【Unity】UI自适应-可变形

已于 2022-03-29 20:41:46 修改
阅读量1.7k 收藏 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

凋零叶子
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Unity3d UI自适应CanvasScaler测试工程
06-10
Unity3d UI自适应CanvasScaler测试工程， 建议先看说明：
Unity中设置UI组件屏幕自适应
qq_59273509的博客
08-17 560
为了适应不同分辨率的场景，要保证UI组件做到在不同分辨率设备上的正常、美观的显示，设置组件参数为屏幕自适应。同时可以将Screen Math Model设置为按照宽和高进行匹配模式。在Canvas的Inspector中选择UI Scale Model。这样可以做到屏幕自适应效果！Match比例设置为0.5。
Unity UI适配规则和对热门游戏适配策略的拆解
最新发布
shaobing32的博客
02-28 1249
本文会介绍一些关于UI适配的基础概念，并且统计了市面上常见的设备的分辨率的情况。同时通过拆解目前市面上较为成功的两款休闲游戏Royal Match和Monopoly GO(两款均为近期游戏付费榜前几的游戏)，大致推断出他们的适配策略，以供学习和参考。
Unity-URP-UI-Blur（2022.2）
05-10
Unity-URP-UI-Blur（2022.2） 效果预览+食用步骤：https://blog.csdn.net/qq_26318597/article/details/130600540
unity-vertex-effects：Unity UI的漂亮文本轮廓
02-06
Unity UI的精美文字轮廓 Unity UIの文字に绮丽な轮郭线を付ける 该存储库包含“效果的改进版本。 他们可以精美地渲染厚文字轮廓。 它们也可以用作柔和的（模糊的）阴影效果。 关键词 Unity uGUI Text Outline Shadow文字縁取り轮郭影 比较方式 注意：带括号的数字是相对于没有轮廓的文本的渲染成本。 注意在哪里使用！ 大纲 内置轮廓效果。 它不能正确渲染粗轮廓。 它在距主文本网格4个稍微倾斜的位置（左上，右上，左下和右下）渲染彩色文本网格。 轮廓8 Outline的略微改进版本。 它在8个位置（上，下，左，右，左上，右上等）渲染文本网格。 等效于（X，Y）=（
【Unity】 UI自适应案例
灵境引路人
05-23 599
案例一：背包自动布局 案例二：文字自适应高度
Unity 实现UI自适应
q1295006114的博客
04-25 935
5.下面的Match是已上门为基础 （建议 如果是横屏已高为主 竖屏相反 方形建议在中间看个人需求）但是在这样设置完后会发现很多的UI的子集部分或者很多UI还是原本大小这样就需要用代码来自适应。在做UI功能的时候都要注意对屏幕的自适应 应为不同的手机设备都拥有不同的分辨率。2.Canvas自带的Canvas Scaler组件。先看看Unity 自带的自适应功能。所以自适应的分辨率是必不可少的。4.是宽和高已上门分辨率为基础。3.选择具体如图所示。也可以封装方法来使用。
unity3d画布/UI自适应屏幕的方式
qq_21315789的博客
06-12 8553
unity3d自带的功能能在不用写代码的情况下使ui适配不同的分辨率。画布的Canvas Scaler选项中的UI Scale Mode有3个选项：恒定像素、随屏幕尺寸缩放、恒定物理大小。
Unity UI自适应
qq_39945752的博客
10-19 1462
unity ui自适应
【UGUI】学会Unity中UGUI中UI元素自适应问题
leoysq的博客
09-19 1686
就像画一幅画，首先我们需要一张什么也没有的白纸贴在画板上（这个画板就是：Canvas）,有了画板以后，我们就可以一层层的铺上画面元素了，这些画面元素就是具体的UI元素（包括：一个图、按钮、滚动条、勾选框、文本框等等）而且，在层级面板的UI名称列表中（大纲列表）排在上面的就会被放在图层下方，后面创建的UI会遮住早先创建的，就像一层层的画画一样，后面刷的颜色肯定是在最前方。但是UI元素的锚点定位好了,我UI元素本身呢，这还不好说吗，就像任何图像在设计软件在都会围绕锚点，并且跟随锚点。UI元素本身也会跟随锚点。
Unity-UI-Extensions.unitypackage
08-25
Unity-UI-Extensions，总有一款效果是你想要的！
Unity3d UGUI 实现底部UI自适应的功能工程
05-19
建议先看说明：...Unity3d UGUI 实现底部UI自适应的功能工程 基于ScrollRect 、 Vertical Layout Group和 Grid Layout Group等组件，实现高度匹配，UI宽度内容动态适配的功能。
unity GUGI 屏幕自适应
qq_37524903的博客
09-09 1325
同理当值为1即处于Height那端时，表示屏幕宽度对于UI大小完全没有任何影响，只有高度会对UI大小产生影响。对于第一步，有3种模式可以选择，默认是第一种像素模式，这也是造成无法自适应屏幕的原因，这里选择Scale with Screen Size模式。第二步调节Screen Match Mode ，这里也有三种模式，选择Match width or Height 模式。当值为0即处于Width那端时，表示屏幕高度对于UI大小完全没有任何影响，只有宽度会对UI大小产生影响。最后 测试 选择不同尺寸。
Unity3d UGUI 实现底部UI自适应的功能（含工程）
qq_33789001的博客
05-19 1372
Unity3d UGUI 实现底部UI自适应的功能（含工程） 前言 UI的自适应常常在项目中使用到，特别手游中，不同比例屏幕的手机，如果能考一套UI自适应显示，能省去不少的开发工作量。这里只是浅浅的讨论一下，这种居中靠底部的UI我们怎么实现自适应。 效果 自由分辨率下，自由拖动的效果： 分辨率1效果： 分辨率2效果： 分辨率3效果： 实现 如下图的UI： 我们首先要思考各个部分的分布，红色部分是一个固定图片/内容显示，中间黄色部分是一个向上滚动的列表，右侧绿色部分是一个上滚动的图片列表；我们暂定的
Unity UI 相关知识（锚点自适应详解）
啪，一个男人出现了，他就是我
08-23 469
Left,Top,Right,Bottom分别表示UI自身相对于自身锚框的距离，Left为UI自身距离左侧锚框的距离，其他同理（Top距离上侧，right距离右侧，bottom距离下侧）——>无论父物体怎么变化，子物体相对于父对象所占的比例不变，也就说子物体会跟随父对象变化。PosX,PosY,PosZ 分别表示UI自身的中心点所距离锚点的X、Y和Z轴的距离。——>无论父物体怎么变化，子物体宽度和高度是恒定不变的。（ 相当于设置的offsetMin和offsetMax的值 ）所有锚框同在一个点时。
UI中级操作（倾斜和雷达效果）
weixin_43754633的博客
08-04 312
Ui操作
【Unity】 Canvas及UI屏幕自适应的基本介绍
灵境引路人
05-23 1565
Canvas画布是UGUI系统最基础的容器类控件，所有的UI控件必须位于Canvas画布控件之内，即必须是Canvas容器的子控件。Canvas的主要功能是提供一个容器来放置和管理UI元素。可以通过设置Canvas的属性来控制UI元素的位置、层级、渲染方式以及与用户输入的交互。Canvas可以通过挂载在场景中的游戏对象上或在代码中动态创建。
Unity基础篇：使UI跟随屏幕分辨率变化自适应。
热门推荐
设计师养成记
09-10 5万+
当我们使用Unity的UGUI设计游戏UI的时候，不得不考虑在不同分辨率机器下UI的缩放以及位置的自适应。今天我们就来讨论一下这个问题。 首先我们来了解一下相机的渲染模式（这个蓝蓝的东西好像可以点唉）和Canvas下的Canvas Scaler 一、Constant Pixel Size： 像素大小始终不变，即一个100*100的图片在任何的分辨率下都占用100*100的像素。简单比较好理解...
unity ui自适应分辨率
08-21
在Unity中实现UI对不同分辨率屏幕的自适应，可以通过使用Canvas Scaler组件来实现。首先，需要将Canvas Scaler的UI Scale Mode属性设置为Constant Pixel Size，这样可以保持UI在不同分辨率屏幕下的像素大小一致。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [（转）Unity 3D手游对不同分辨率屏幕的UI自适应](https://blog.csdn.net/qq_40795166/article/details/113505774)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值