【Unity】UI自适应-可变形

已于 2022-03-29 20:41:46 修改
阅读量2k 收藏 11
点赞数 1
分类专栏： 工具类 文章标签： unity ui 游戏引擎
于 2022-01-16 19:47:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hg2131/article/details/121770507
版权

文章目录

前言

本文内容为UI控件，水平、垂直方向均变化的自适应处理。即UI与屏幕大小同比例变形。
同时包含：锚点重置、场景备份与还原功能

一、功能代码

1.锚点重置

代码如下：

	private void StandardizedAnchor(Transform parent)
	{
        if (Judge_IfSetAnchor(parent))
        {
            foreach (Transform child in parent)//遍历子物体
            {
                ResetUI(child);

                float x = child.localPosition.x;
                float y = child.localPosition.y;

                float x1 = parent.localPosition.x;
                float y1 = parent.localPosition.y;

                child.localPosition = new Vector2(x + x1, y + y1);

                if (child.childCount > 0)
                {
                    StandardizedAnchor(child);
                }
            }

            if (!parent.GetComponent<Canvas>())//CanvasScaler不进行修改
            {
                parent.GetComponent<RectTransform>().anchorMin = new Vector2(0, 0);
                parent.GetComponent<RectTransform>().anchorMax = new Vector2(1, 1);//锚点

                parent.GetComponent<RectTransform>().offsetMin = new Vector2(0, 0);
                parent.GetComponent<RectTransform>().offsetMax = new Vector2(0, 0);//位置   
            }
        }
	}

	private bool Judge_IfSetAnchor(Transform parent)
	{
        if (parent.GetComponent<Canvas>())//CanvasScaler修改子物体
        {
            return true;
        }
        string[] prefixs = new string[] { };//设置自身及子物体锚点的 判断标准_前缀
        string[] suffixs = new string[] { "_obj" };//设置自身及子物体锚点的 判断标准_后缀		
		bool ifSetAnchor = false;//是否设置自身及子物体锚点的
		
        foreach(string child in prefixs)
        {
            if ((parent.name.Length > child.Length) && (parent.name.Substring(0, child.Length) == child))
            {
                ifSetAnchor = true;
            }
        }

        foreach (string child in suffixs)
        {
            if ((parent.name.Length > child.Length) && (parent.name.Substring(parent.name.Length - child.Length, child.Length) == child))
            {
                ifSetAnchor = true;
            }
        }

        return ifSetAnchor;
	}

    private void ResetUI(Transform obj)
    {
        if (obj.GetComponent<Canvas>())//CanvasScaler不进行修改
        {
            return;
        }

        Vector2 size = new Vector2(obj.GetComponent<RectTransform>().rect.width, obj.GetComponent<RectTransform>().rect.height);
        Vector2 pos = new Vector2(0,0);

        float x1 = 0.5f, y1 = 0.5f , x2 = 0.5f , y2 = 0.5f;
   
        if (obj.GetComponent<RectTransform>().anchorMin.x!=0.5f 
        || obj.GetComponent<RectTransform>().anchorMax.x != 0.5f)
        {
            x1 = obj.GetComponent<RectTransform>().anchorMin.x;
            x2 = obj.GetComponent<RectTransform>().anchorMax.x;
            pos = new Vector2(ScreenSize.x * (x1 + x2 - 1) / 2, pos.y);
        }
        else
        {
            pos = new Vector2(obj.localPosition.x, pos.y);
        }
       
        if (obj.GetComponent<RectTransform>().anchorMin.y!=0.5f 
        || obj.GetComponent<RectTransform>().anchorMax.y != 0.5f)
        {
            y1 = obj.GetComponent<RectTransform>().anchorMin.y;
            y2 = obj.GetComponent<RectTransform>().anchorMax.y;
            pos = new Vector2(pos.x, ScreenSize.y * (y1 + y2 - 1) / 2);
        }
        else
        {
            pos = new Vector2(pos.x, obj.localPosition.y);
        }
      
        obj.GetComponent<RectTransform>().anchorMin = new Vector2(0.5f, 0.5f);
        obj.GetComponent<RectTransform>().anchorMax = new Vector2(0.5f, 0.5f);//锚点
        obj.localPosition = pos;
        obj.GetComponent<RectTransform>().sizeDelta = size;
}

锚点重置处理分为两种：
1、符合Judge_IfSetAnchor()中前后缀的UI，做全屏化处理。
2、全屏化处理UI的子物体，如果不符合1，则将锚点重置为屏幕中心。

2.场景备份

代码如下：

private void CopyScene()//场景备份
         {
              Debug.Log("开始备份");

              Scene OriginalScene;
              string CopyScenePath;

              OriginalScene = SceneManager.GetActiveScene();
              CopyScenePath = Return_TheCopyScenePath(OriginalScene);
              EditorSceneManager.SaveScene(OriginalScene, CopyScenePath, true);

              Debug.Log("备份完成，备份场景路径：" + CopyScenePath);
         }

         private string Return_TheCopyScenePath(UnityEngine.SceneManagement.Scene OriginalScene)
         {
              string CopyScenePath;

              CopyScenePath = OriginalScene.path.Substring(0, OriginalScene.path.Length - 6);
              CopyScenePath = CopyScenePath + "_copy.unity";

              return CopyScenePath;
         }

场景备份说明：
1、备份的场景与原场景在相同路径下
2、两者的判定标准为是否存在_copy后缀

3.场景还原

代码如下：

            private void AutomaticLoad_CopyScene()
			{
                BeginAutomaticRestoreScene = false;//修改 开始自动还原 状态

                Scene originalScene,copyScene;
				string copyScenePath;
                GameObject[] scriptRootChilds;
                bool isChange=false;

                originalScene = SceneManager.GetActiveScene();
                copyScenePath = originalScene.path.Substring(0, originalScene.path.Length - 6);
                copyScenePath = copyScenePath + "_copy.unity";//获取备份场景地址

                copyScene=EditorSceneManager.OpenScene(copyScenePath, OpenSceneMode.Additive);
                scriptRootChilds = copyScene.GetRootGameObjects();
                foreach (GameObject child in scriptRootChilds)
                {
                    if (child.name == MountScript_obj.name)
                    {
                        child.GetComponentInChildren<UI_Scene_Adapter1>().BeginManualRestoreScene = true;
                        isChange = true;
                        break;
                    }
                }//修改备份场景中的BeginRestore状态

                if (isChange)
                {         
                    EditorSceneManager.SaveScene(copyScene, copyScenePath, false);         
                    EditorSceneManager.CloseScene(copyScene, false);       
                    EditorSceneManager.OpenScene(copyScenePath);//打开备份场景
                }
                else
                {
                    Debug.Log("修改备份场景-BeginRestore失败");
                    EditorSceneManager.CloseScene(copyScene, false);
                }
			}

			private void ManualLoad_CopyScene()
			{
                Debug.Log("开始还原");
				Scene copyScene;
				string originalScenePath;
                BeginManualRestoreScene = false;//修改 开始手动还原 状态
                gameObject.GetComponent<UI_Scene_Adapter1>().enabled = false;//禁用脚本

                copyScene = SceneManager.GetActiveScene();
                EditorSceneManager.SaveScene(copyScene);//保存备份场景

                originalScenePath = copyScene.path.Substring(0, copyScene.path.Length - 11);
				originalScenePath = originalScenePath + ".unity";//获取原场景地址
				EditorSceneManager.SaveScene(copyScene, originalScenePath, false);//备份场景替换原场景

                Debug.Log("还原完成");
            }

自动还原与手动还原的区别：
1、手动还原，在备份场景中使用。
选择BeginManualRestoreScene后，自动查找原场景并进行替换。
2、自动还原，在原场景中使用
选择BeginAutomaticRestoreScene后，自动查找备份场景并修改备份场景的BeginManualRestoreScene，之后自动跳转到备份场景并进行手动还原。

4.UI自适应

 private void Start_UIAdapter()
    {
        Debug.Log("开始UI自适应");

        Vector2[] anchorMinAndMax;//锚点坐标
        Vector3[] corners = new Vector3[4];//存储控件四个角的坐标
        string first_control_name = null;//第一个自适应控件的名称
        string last_control_name = null;//最后一个自适应控件的名称
        float beginTime, endTime;//自适应开始时间与结束时间
        int changeNum = 0;//修改的控件数      
        bool isAdapter;//当前控件是否进行UI自适应

        beginTime = Time.realtimeSinceStartup;//初始化开始时间记录	
        Init_UIAdapterNeedData();

        CopyScene();//场景备份
        StandardizedAnchor(RootUI); Debug.Log("标准化UI锚点完成");

        CanvasChilds = RootUI.GetComponentsInChildren<Transform>(true);
        foreach (RectTransform childControl in CanvasChilds)//遍历子物体
        {
            controlNum = controlNum + 1;

            isAdapter = IfAdapterByControl(childControl);
            if (isAdapter)
            {
                corners = AnchorIgnorTheRotate(childControl);
                anchorMinAndMax = ComputeAnchorMinAndMax(corners);
                SetAnchorMinAndMax(childControl, anchorMinAndMax);
       
                changeNum = changeNum + 1;    
            }

            if (controlNum == 1)
            {
                first_control_name = childControl.name;
            }
            else
            {
                last_control_name = childControl.name;
            }
        }

        endTime = Time.realtimeSinceStartup;
        Debug.Log("全部UI自适应已完成");
        Debug.Log("共遍历子控件：" + controlNum + "个，" + "共修改子控件：" + changeNum + "个，" + "开始于" + first_control_name + "控件，结束于" + last_control_name + "控件，耗费时间：" + (endTime - beginTime).ToString("f3") + "s");
    }

    private void Init_UIAdapterNeedData()
    {
        Debug.Log("开始UI自适应");
    
        BeginUIAdapter = false;

        controlNum = -1;//初始化控件数量记录
    }

    private bool IfAdapterByControl(Transform control)
    {	
        string[] prefixs = new string[] { };//是否不执行UI自适应的 判断标准_前缀
        string[] suffixs = new string[] {"_img","_btn","_txt"};//是否执行UI自适应的 判断标准_后缀
        string controlName;//控件名字
        bool ifSetAnchor = false;//是否执行UI自适应

        controlName = control.name;//获取控件名字	

        foreach (string child in suffixs)
        {
            if ((controlName.Length > child.Length) && (controlName.Substring(controlName.Length - child.Length, child.Length) == child))
            {
                ifSetAnchor = true;
            }
        }

		foreach (string child in prefixs)
        {
            if ((controlName.Length > child.Length) && (controlName.Substring(0, child.Length) == child))
            {
                ifSetAnchor = false;
            }
        }

        return ifSetAnchor;
	}
	
	private Vector3[] AnchorIgnorTheRotate(Transform Control)
	{
		#region 变量定义
			Vector3[] ControlCorners = new Vector3[4];
			Vector3[] NewControlCorners = new Vector3[4];
			Vector3 ControlRotation;
			int j = -1;
    #endregion
		ControlRotation = Control.rotation.eulerAngles;//物体旋转角度，四元数转欧拉角
		Control.GetComponent<RectTransform>().GetWorldCorners(ControlCorners);//获取物体四个角的世界坐标（以父物体为世界坐标系）,左下、左上、右上和右下

		#region 控件旋转角度判断 
			if (System.Math.Abs(ControlRotation.z) == 0 || System.Math.Abs(ControlRotation.z) % 360 == 0)//物体不进行旋转
			{
				j = 0;
			}
			else if (System.Math.Abs(ControlRotation.z) % 270 == 0)//物体旋转270度
			{
				j = 3;
			}
			else if (System.Math.Abs(ControlRotation.z) % 180 == 0)//物体旋转180度
			{
				j = 2;
			}
			else if (System.Math.Abs(ControlRotation.z) % 90 == 0)//子物体旋转90度
			{
				j = 1;
			}
		#endregion

		#region 统一控件四个角的坐标
			if (j != -1)
			{
				for (int i = 0; i < 4; i++)
				{
					NewControlCorners[i] = ControlCorners[j];
					j++;
					if (j > 3)
					{
						j = 0;
					}
				}
			}
	#endregion

		return NewControlCorners;
	}

	private Vector2[] ComputeAnchorMinAndMax(Vector3[] ControlCorners)
	{
    	Vector3[] CanvasCorners = new Vector3[4];//最高级父物体四角坐标，Canvas菜单
    	Vector2[] MinAndMaxAnchor = new Vector2[2];//控件锚点坐标
    	float wight, height;
    	float anchorMin_x, anchorMin_y, anchorMax_x, anchorMax_y;//左下角锚点X坐标、左下角锚点Y坐标、右上角锚点X坐标、右上角锚点Y坐标	

    	RootCanvas.GetComponent<RectTransform>().GetWorldCorners(CanvasCorners);     
    	wight = CanvasCorners[2].x * 2;
    	height = CanvasCorners[2].y * 2;
  
    	anchorMin_x = float.Parse(((wight / 2 + ControlCorners[0].x) / wight).ToString("f3"));
    	anchorMin_y = float.Parse(((height / 2 + ControlCorners[0].y) / height).ToString("f3"));
    	anchorMax_x = float.Parse(((wight / 2 + ControlCorners[2].x) / wight).ToString("f3"));
    	anchorMax_y = float.Parse(((height / 2 + ControlCorners[2].y) / height).ToString("f3"));

    	MinAndMaxAnchor[0] = new Vector2(anchorMin_x, anchorMin_y);
    	MinAndMaxAnchor[1] = new Vector2(anchorMax_x, anchorMax_y);
  
    	return MinAndMaxAnchor;
	}

	private void SetAnchorMinAndMax(Transform Control,Vector2[] AnchorMinAndMax)
	{					
		Control.GetComponent<RectTransform>().anchorMin = new Vector2(AnchorMinAndMax[0].x, AnchorMinAndMax[0].y);//设置锚点的anchorMin
	    Control.GetComponent<RectTransform>().anchorMax = new Vector2(AnchorMinAndMax[1].x, AnchorMinAndMax[1].y);//设置锚点的anchorMax

        Control.GetComponent<RectTransform>().offsetMin = new Vector2(0, 0);//设置offsetMin
        Control.GetComponent<RectTransform>().offsetMax = new Vector2(0, 0);//设置offsetMax
        Control.GetComponent<RectTransform>().localScale = new Vector3(1,1,1);		
	}

UI自适应说明：
1、开始UI自适应后，自动进行场景备份和锚点重置。
2、UI自适应，包含对旋转90、180、270、360图片的处理
3、在IfAdapterByControl()里，通过前后缀，判定是否进行UI自适应处理。

二、代码总览

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;
using UnityEditor.SceneManagement;

[ExecuteInEditMode]
public class UI_Adapter : MonoBehaviour {

	public bool BeginAutomaticRestoreScene = false;//开始自动还原

	public bool BeginManualRestoreScene = false;//开始手动还原

    public bool BeginStandardizedAnchor = false;//开始重置坐标
	public bool BeginCopy = false;//开始备份
	#region UI设置
		public bool BeginUIAdapter = false;//开始UI自适应
        public GameObject MountScript_obj;//当前脚本需挂载到顶级节点的下级节点中
        public Transform RootUI;
        public Vector2 ScreenSize = new Vector2(1920,1080);
        public CanvasScaler RootCanvas;//Canvas菜单，即UI最高父物体

        private Transform[] CanvasChangeChilds=null;//所有子物体的集合
		private Transform[] CanvasChilds = null;//所有子物体的集合
		private int controlNum;//计数-完成自适应的控件数目	

    #endregion
    
    private void Awake()
    {
        BeginAutomaticRestoreScene = false;
        BeginStandardizedAnchor = false;
        BeginCopy = false;
        BeginUIAdapter = false;

        if (BeginManualRestoreScene)
        {     
            ManualLoad_CopyScene();              
        }
        else
        {
            gameObject.GetComponent<UI_Adapter>().enabled = false;//添加脚本后，禁用脚本
        }
    }

	private void Update()
	{
		if(BeginStandardizedAnchor)
		{
			Debug.Log("开始标准化UI锚点");
            StandardizedAnchor(RootUI);
            BeginStandardizedAnchor = false;
			Debug.Log("标准化UI锚点完成");
			gameObject.GetComponent<UI_Adapter>().enabled = false;//位置重置完成后，禁用脚本
		}

		if(BeginUIAdapter)
		{
			Start_UIAdapter();
			gameObject.GetComponent<UI_Adapter>().enabled = false;//UI自适应完成后，禁用脚本
		}

		if(BeginCopy)
		{
            CopyScene();
			gameObject.GetComponent<UI_Adapter>().enabled = false;//场景备份后，禁用脚本
		}

		if(BeginAutomaticRestoreScene)//在原场景中使用
		{
			Debug.Log("开始自动还原");
            AutomaticLoad_CopyScene();
		}

		if(BeginManualRestoreScene)//在备份的场景中使用
		{
			Debug.Log("开始手动还原");
            ManualLoad_CopyScene();
		}

	}

	#region 场景备份与还原代码
		
		#region 场景备份代码
         private void CopyScene()//场景备份
         {
              Debug.Log("开始备份");

              Scene OriginalScene;
              string CopyScenePath;

              OriginalScene = SceneManager.GetActiveScene();
              CopyScenePath = Return_TheCopyScenePath(OriginalScene);
              EditorSceneManager.SaveScene(OriginalScene, CopyScenePath, true);

              Debug.Log("备份完成，备份场景路径：" + CopyScenePath);
         }

         private string Return_TheCopyScenePath(UnityEngine.SceneManagement.Scene OriginalScene)
         {
              string CopyScenePath;

              CopyScenePath = OriginalScene.path.Substring(0, OriginalScene.path.Length - 6);
              CopyScenePath = CopyScenePath + "_copy.unity";

              return CopyScenePath;
         }
        #endregion

        #region 场景还原代码
            private void AutomaticLoad_CopyScene()
			{
                BeginAutomaticRestoreScene = false;//修改 开始自动还原 状态

                Scene originalScene,copyScene;
				string copyScenePath;
                GameObject[] scriptRootChilds;
                bool isChange=false;

                originalScene = SceneManager.GetActiveScene();
                copyScenePath = originalScene.path.Substring(0, originalScene.path.Length - 6);
                copyScenePath = copyScenePath + "_copy.unity";//获取备份场景地址
       
                copyScene=EditorSceneManager.OpenScene(copyScenePath, OpenSceneMode.Additive);
                scriptRootChilds = copyScene.GetRootGameObjects();
                foreach (GameObject child in scriptRootChilds)
                {
                    if (child.name == MountScript_obj.name)
                    {
                        child.GetComponentInChildren<UI_Adapter>().BeginManualRestoreScene = true;
                        isChange = true;
                        break;
                    }
                }//修改备份场景中的BeginRestore状态

                if (isChange)
                {         
                    EditorSceneManager.SaveScene(copyScene, copyScenePath, false);         
                    EditorSceneManager.CloseScene(copyScene, false);       
                    EditorSceneManager.OpenScene(copyScenePath);//打开备份场景
                }
                else
                {
                    Debug.Log("修改备份场景-BeginRestore失败");
                    EditorSceneManager.CloseScene(copyScene, false);
                }
			}

			private void ManualLoad_CopyScene()
			{
                Debug.Log("开始还原");
				Scene copyScene;
				string originalScenePath;
                BeginManualRestoreScene = false;//修改 开始手动还原 状态
                gameObject.GetComponent<UI_Adapter>().enabled = false;//禁用脚本

                copyScene = SceneManager.GetActiveScene();
                EditorSceneManager.SaveScene(copyScene);//保存备份场景

                originalScenePath = copyScene.path.Substring(0, copyScene.path.Length - 11);
				originalScenePath = originalScenePath + ".unity";//获取原场景地址
				EditorSceneManager.SaveScene(copyScene, originalScenePath, false);//备份场景替换原场景

                Debug.Log("还原完成");
            }
		#endregion

	#endregion
	
	#region 标准化-锚点
		private void StandardizedAnchor(Transform parent)
		{
            if (Judge_IfSetAnchor(parent))
            {
                foreach (Transform child in parent)//遍历子物体
                {

                    ResetUI(child);

                    float x = child.localPosition.x;
                    float y = child.localPosition.y;

                    float x1 = Parent.localPosition.x;
                    float y1 = Parent.localPosition.y;

                    child.localPosition = new Vector2(x + x1, y + y1);

                    if (child.childCount > 0)
                    {
                        StandardizedAnchor(child);
                    }
                }
                if (!parent.GetComponent<Canvas>())//CanvasScaler不进行修改
                {
                	parent.GetComponent<RectTransform>().anchorMin = new Vector2(0, 0);
                	parent.GetComponent<RectTransform>().anchorMax = new Vector2(1, 1);//锚点

                	parent.GetComponent<RectTransform>().offsetMin = new Vector2(0, 0);
                	parent.GetComponent<RectTransform>().offsetMax = new Vector2(0, 0);//位置     
                }
            }
		}

		private bool Judge_IfSetAnchor(Transform parent)
		{		
		 	if (parent.GetComponent<Canvas>())//CanvasScaler修改子物体
            {
                return true;
            }
		    string[] prefixs = new string[] { };//设置自身及子物体锚点的 判断标准_前缀
            string[] suffixs = new string[] { "_obj" };//设置自身及子物体锚点的 判断标准_后缀		
			bool ifSetAnchor = false;//是否设置自身及子物体锚点的
			
            foreach(string child in prefixs)
            {
                if ((parent.name.Length > child.Length) && (parent.name.Substring(0, child.Length) == child))
                {
                    ifSetAnchor = true;
                }
            }

            foreach (string child in suffixs)
            {
                if ((parent.name.Length > child.Length) && (parent.name.Substring(parent.name.Length - child.Length, child.Length) == child))
                {
                    ifSetAnchor = true;
                }
            }

            return ifSetAnchor;
		}

        private bool ResetUI(Transform obj)
        {
            if (obj.GetComponent<Canvas>())//CanvasScaler不进行修改
            {
                return false;
            }

            Vector2 size = new Vector2(obj.GetComponent<RectTransform>().rect.width, obj.GetComponent<RectTransform>().rect.height);
            Vector2 pos = new Vector2(0,0);

            float x1 = 0.5f, y1 = 0.5f , x2 = 0.5f , y2 = 0.5f;
       
            if (obj.GetComponent<RectTransform>().anchorMin.x!=0.5f 
            || obj.GetComponent<RectTransform>().anchorMax.x != 0.5f)
            {
                x1 = obj.GetComponent<RectTransform>().anchorMin.x;
                x2 = obj.GetComponent<RectTransform>().anchorMax.x;
                pos = new Vector2(ScreenSize.x * (x1 + x2 - 1) / 2, pos.y);
            }
            else
            {
                pos = new Vector2(obj.localPosition.x, pos.y);
            }
           
            if (obj.GetComponent<RectTransform>().anchorMin.y!=0.5f 
            || obj.GetComponent<RectTransform>().anchorMax.y != 0.5f)
            {
                y1 = obj.GetComponent<RectTransform>().anchorMin.y;
                y2 = obj.GetComponent<RectTransform>().anchorMax.y;
                pos = new Vector2(pos.x, ScreenSize.y * (y1 + y2 - 1) / 2);
            }
            else
            {
                pos = new Vector2(pos.x, obj.localPosition.y);
            }
          
            obj.GetComponent<RectTransform>().anchorMin = new Vector2(0.5f, 0.5f);
            obj.GetComponent<RectTransform>().anchorMax = new Vector2(0.5f, 0.5f);//锚点
            obj.localPosition = pos;
            obj.GetComponent<RectTransform>().sizeDelta = size;

        return true;
    }
    #endregion

    #region UI自适应代码
        private void Start_UIAdapter()
        {
            Debug.Log("开始UI自适应");
    
            Vector2[] anchorMinAndMax;//锚点坐标
            Vector3[] corners = new Vector3[4];//存储控件四个角的坐标
            string first_control_name = null;//第一个自适应控件的名称
            string last_control_name = null;//最后一个自适应控件的名称
            float beginTime, endTime;//自适应开始时间与结束时间
            int changeNum = 0;//修改的控件数      
            bool isAdapter;//当前控件是否进行UI自适应

            beginTime = Time.realtimeSinceStartup;//初始化开始时间记录	
            Init_UIAdapterNeedData();

            CopyScene();//场景备份
            StandardizedAnchor(RootUI); Debug.Log("标准化UI锚点完成");

            CanvasChilds = RootUI.GetComponentsInChildren<Transform>(true);
            foreach (RectTransform childControl in CanvasChilds)//遍历子物体
            {
                controlNum = controlNum + 1;

                isAdapter = IfAdapterByControl(childControl);
                if (isAdapter)
                {
                    corners = AnchorIgnorTheRotate(childControl);
                    anchorMinAndMax = ComputeAnchorMinAndMax(corners);
                    SetAnchorMinAndMax(childControl, anchorMinAndMax);
           
                    changeNum = changeNum + 1;    
                }

                if (controlNum == 1)
                {
                    first_control_name = childControl.name;
                }
                else
                {
                    last_control_name = childControl.name;
                }
            }

            endTime = Time.realtimeSinceStartup;
            Debug.Log("全部UI自适应已完成");
            Debug.Log("共遍历子控件：" + controlNum + "个，" + "共修改子控件：" + changeNum + "个，" + "开始于" + first_control_name + "控件，结束于" + last_control_name + "控件，耗费时间：" + (endTime - beginTime).ToString("f3") + "s");
        }

        private void Init_UIAdapterNeedData()
        {
            Debug.Log("开始UI自适应");
        
            BeginUIAdapter = false;

            controlNum = -1;//初始化控件数量记录
        }

        private bool IfAdapterByControl(Transform control)
	    {	
            string[] prefixs = new string[] { };//是否不执行UI自适应的 判断标准_前缀
            string[] suffixs = new string[] {"_img","_btn","_txt"};//是否执行UI自适应的 判断标准_后缀
            string controlName;//控件名字
            bool ifSetAnchor = false;//是否执行UI自适应

            controlName = control.name;//获取控件名字	

            foreach (string child in suffixs)
            {
                if ((controlName.Length > child.Length) && (controlName.Substring(controlName.Length - child.Length, child.Length) == child))
                {
                    ifSetAnchor = true;
                }
            }

			foreach (string child in prefixs)
            {
                if ((controlName.Length > child.Length) && (controlName.Substring(0, child.Length) == child))
                {
                    ifSetAnchor = false;
                }
            }

            return ifSetAnchor;
		}
	
		private Vector3[] AnchorIgnorTheRotate(Transform Control)
		{
			#region 变量定义
				Vector3[] ControlCorners = new Vector3[4];
				Vector3[] NewControlCorners = new Vector3[4];
				Vector3 ControlRotation;
				int j = -1;
        	#endregion
			ControlRotation = Control.rotation.eulerAngles;//物体旋转角度，四元数转欧拉角
			Control.GetComponent<RectTransform>().GetWorldCorners(ControlCorners);//获取物体四个角的世界坐标（以父物体为世界坐标系）,左下、左上、右上和右下

			#region 控件旋转角度判断 
				if (System.Math.Abs(ControlRotation.z) == 0 || System.Math.Abs(ControlRotation.z) % 360 == 0)//物体不进行旋转
				{
					j = 0;
				}
				else if (System.Math.Abs(ControlRotation.z) % 270 == 0)//物体旋转270度
				{
					j = 3;
				}
				else if (System.Math.Abs(ControlRotation.z) % 180 == 0)//物体旋转180度
				{
					j = 2;
				}
				else if (System.Math.Abs(ControlRotation.z) % 90 == 0)//子物体旋转90度
				{
					j = 1;
				}
			#endregion

			#region 统一控件四个角的坐标
				if (j != -1)
				{
					for (int i = 0; i < 4; i++)
					{
						NewControlCorners[i] = ControlCorners[j];
						j++;
						if (j > 3)
						{
							j = 0;
						}
					}
				}
			#endregion

			return NewControlCorners;
		}
		
    	private Vector2[] ComputeAnchorMinAndMax(Vector3[] ControlCorners)
    	{
        	Vector3[] CanvasCorners = new Vector3[4];//最高级父物体四角坐标，Canvas菜单
        	Vector2[] MinAndMaxAnchor = new Vector2[2];//控件锚点坐标
        	float wight, height;
        	float anchorMin_x, anchorMin_y, anchorMax_x, anchorMax_y;//左下角锚点X坐标、左下角锚点Y坐标、右上角锚点X坐标、右上角锚点Y坐标	

        	RootCanvas.GetComponent<RectTransform>().GetWorldCorners(CanvasCorners);     
        	wight = CanvasCorners[2].x * 2;
        	height = CanvasCorners[2].y * 2;
      
        	anchorMin_x = float.Parse(((wight / 2 + ControlCorners[0].x) / wight).ToString("f3"));
        	anchorMin_y = float.Parse(((height / 2 + ControlCorners[0].y) / height).ToString("f3"));
        	anchorMax_x = float.Parse(((wight / 2 + ControlCorners[2].x) / wight).ToString("f3"));
        	anchorMax_y = float.Parse(((height / 2 + ControlCorners[2].y) / height).ToString("f3"));

        	MinAndMaxAnchor[0] = new Vector2(anchorMin_x, anchorMin_y);
        	MinAndMaxAnchor[1] = new Vector2(anchorMax_x, anchorMax_y);
      
        	return MinAndMaxAnchor;
    	}
    	
		private void SetAnchorMinAndMax(Transform Control,Vector2[] AnchorMinAndMax)
		{					
			Control.GetComponent<RectTransform>().anchorMin = new Vector2(AnchorMinAndMax[0].x, AnchorMinAndMax[0].y);//设置锚点的anchorMin
		    Control.GetComponent<RectTransform>().anchorMax = new Vector2(AnchorMinAndMax[1].x, AnchorMinAndMax[1].y);//设置锚点的anchorMax

            Control.GetComponent<RectTransform>().offsetMin = new Vector2(0, 0);//设置offsetMin
            Control.GetComponent<RectTransform>().offsetMax = new Vector2(0, 0);//设置offsetMax
            Control.GetComponent<RectTransform>().localScale = new Vector3(1,1,1);		
		}
	#endregion
	}

三、知识点

1.anchorMin 与 anchorMax

2.offsetMin 与 offsetMax

3.localPosition

4.sizeDelta

5.rect

6.GetWorldCorners()

四、知识点说明文章链接

https://www.cnblogs.com/w-wfy/p/7800757.html
https://blog.csdn.net/jmu201521121014/article/details/105725175

【Unity 实用工具篇】 | UIEffect 实现一系列UGUI特效，颜色渐变特效
努力前行，总会成为自己心中的那道光
05-08 2万+
在Unity中 UGUI 的使用几乎是必不可少的，虽然也有NGUI、FGUI等可以使用，但使用UGUI的还是占多数。 而在使用UGUI的过程中，除了一些基础的UI交互页面及逻辑，学习一些UGUI特效的使用也是很有必要的。 接下来会分享一些UGUI中比较简单且实用的特效，供有需要的小伙伴学习使用。
Unity 实现UI自适应
slf_tragon的博客
05-29 747
5.下面的Match是已上门为基础 （建议 如果是横屏已高为主 竖屏相反 方形建议在中间看个人需求）但是在这样设置完后会发现很多的UI的子集部分或者很多UI还是原本大小这样就需要用代码来自适应。在做UI功能的时候都要注意对屏幕的自适应 应为不同的手机设备都拥有不同的分辨率。2.Canvas自带的Canvas Scaler组件。先看看Unity 自带的自适应功能。所以自适应的分辨率是必不可少的。4.是宽和高已上门分辨率为基础。3.选择具体如图所示。也可以封装方法来使用。
Unity UI自适应
qq_43511290的博客
04-19 1951
Unity UI自适应一级目录 一级目录 Canves的设置 左上角的UI设置 左下角的UI设置 右上角的UI设置 有下角的UI设置
一、制作UI自适应
最新发布
akjhgi的博客
10-10 435
UI自适应
UI自适应 Unity
a_leaf_的博客
01-05 558
最近学习遇到了一个UI自适应的问题 如下图: 1335*750 当切换到free aspect下 经验条因为没有设置两边对齐就会出现间隙问题 这几个小格子我是用的grid layout Group 来调整的，所以在自适应的时候，随着屏幕变化，只需要更改这个组件下的cellSize即可。 首先看第一张图 因为除经验条外其他的宽度都是固定大小的可以在其UI的rect transform组件下计算出其总宽度，然后再加上这十个经验条的总宽度就==屏幕的总宽度。然后就是小学生解方程就可以得出每个经验条的cell
[UnityUI]UGUI自适应
热门推荐
宏哥的博客
03-12 2万+
参考链接： http://www.jianshu.com/p/96fd1fbe8409 http://blog.sina.com.cn/s/blog_4148e8630102vji9.html http://www.xuanyusong.com/archives/3278 关键点： 0.自适应的测试：通过设置多种的屏幕大小进行测试，测试时最好要打开Maximize o
unity UGUI自适应问题
qq_41839772的博客
11-12 772
初入程序深似海呀！在做项目UI时必须经历的一个问题就是UI自适应问题，啥也不懂的时候，难以避免的就是稍微一调整屏幕分辨率，UI就变了，就变了！！！这就很难受。 那么下面来稍微了解一下UI自适应。 官方文档：https://docs.unity3d.com/Manual/script-CanvasScaler.html UI Scale Mode：确定如何缩放画布中的UI元素。 Constan...
曲面UI插件 Curved UI
07-19
Curved UI插件正是为了解决这个问题而设计的，它扩展了Unity的Canvas组件，让UI元素可以根据场景中的视角和几何形状进行动态弯曲和变形。 在Curved UI - VR Ready Solution To Bend Warp Your Canvas _2.2.unity...
Unity DOTS纯ECS的UI分辨率适配（写一个ECS的CanvasScaler）
ALonWol的博客
05-09 910
UnityECS UI分辨率适配组件CanvasScaler
Unity形变插件（Mega-Fiers 3.36）
05-25
MegaFiers 是一个Unity3d专用的物体变形与动画解决方案，仅供大家下载学习使用。
Unity入门-UGUI详解-画布
买烤麸烤饼儿的博客
06-15 1789
快速导航 UI组件 画布 图片 文本 按钮 单选框 滑动条 滚动条 下拉菜单 输入框 视频播放 控制组件 矩形变换组件 布局元素组件 布局控制组件 UI事件 图集 渲染顺序 1. 画布 1.1 简介 画布组件是UI渲染最主要的组件。 我们可以将画布组件理解成一个容器，其他UI元素都必须填充到该容器中，最终形成我们看到的一个UI界面。 如果场景中没有画布，那么我们创建任何一个UI元素，都会自动创建画布，并且将新元素置于其下。 因此可以游戏
unity3d中UI自适应
oyang_mrong的博客
09-12 1544
unity3d中针对UI界面的自适应问题，其内嵌了自己的算法，如何使用它的算法呢？ 很简单！！！ 找到Canvas的属性界面中的Canvas Scaler 其中将UI Scale Mode设置为：Scale With Screen Size，将Reference Resolution中x，y设置为主流分辨率（如1920*1080）（Reference Resolution的作用为：当buil...
Unity实现Ui自适应屏幕
qq_62893047的博客
06-01 1169
实现Ui自适应屏幕：无论屏幕如何缩放，对应的UI总是始终保持在相对屏幕的位置。
Unity3d UGUI 实现底部UI自适应的功能（含工程）
qq_33789001的博客
05-19 1555
Unity3d UGUI 实现底部UI自适应的功能（含工程） 前言 UI的自适应常常在项目中使用到，特别手游中，不同比例屏幕的手机，如果能考一套UI自适应显示，能省去不少的开发工作量。这里只是浅浅的讨论一下，这种居中靠底部的UI我们怎么实现自适应。 效果 自由分辨率下，自由拖动的效果： 分辨率1效果： 分辨率2效果： 分辨率3效果： 实现 如下图的UI： 我们首先要思考各个部分的分布，红色部分是一个固定图片/内容显示，中间黄色部分是一个向上滚动的列表，右侧绿色部分是一个上滚动的图片列表；我们暂定的
【Unity】 UI自适应案例
灵境引路人
05-23 887
案例一：背包自动布局 案例二：文字自适应高度
unity中设置UI自适应的方法
m0_52801429的博客
05-23 699
unityUI自适应
unity ui自适应分辨率
08-21
在Unity中实现UI对不同分辨率屏幕的自适应，可以通过使用Canvas Scaler组件来实现。首先，需要将Canvas Scaler的UI Scale Mode属性设置为Constant Pixel Size，这样可以保持UI在不同分辨率屏幕下的像素大小一致。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值