com.soviby.unity.ui.ugui-toolkit/Assets/Editor/Entity/ImageEntity.cs

#if UNITY_EDITOR
using Sirenix.OdinInspector;
using System;
using UguiToolkit.Editor;
using Unity.Mathematics;
using UnityEditor;
using UnityEngine;
using UnityEngine.UI;

namespace UguiToolkit.Editor
{
    public class ImageEntity : BaseEntity<Image, LayoutInfo.ImageInfo>
    {
        [ShowInInspector]
        private float rotiation;
        [ShowInInspector]
        private float2 scale;
        [ShowInInspector]
        private bool similarityCalc;
        [ShowInInspector]
        private bool needFillTransform;
        [ShowInInspector]
        private Matrix4x4 lastTransformMatrix;


        private Image m_previewImage;

        // <20><><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>
        public void SetTransform(float rotiation, float2 scale, bool similarityCalc)
        {
            this.rotiation = rotiation;
            this.scale = scale;
            this.similarityCalc = similarityCalc;

            this.needFillTransform = true;
        }

        private void LoadImageFromFile(string path)
        {
            if (System.IO.File.Exists(path))
            {
                byte[] fileData = System.IO.File.ReadAllBytes(path);
                Texture2D texture = new Texture2D(2, 2);
                texture.LoadImage(fileData); // <20><><EFBFBD><EFBFBD>ͼƬ<CDBC><C6AC><EFBFBD>ݵ<EFBFBD>Texture2D

                Sprite sprite = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), new Vector2(0.5f, 0.5f));
                m_previewImage.sprite = sprite;
                m_previewImage.color = new Color(1, 1, 1, 0.5f);
                m_previewImage.SetNativeSize();
            }
            else
            {
                Debug.LogError("File not found at path: " + path);
            }
        }

        protected override void OnApplyData(Image ui)
        {
            if (ElementInfo.HaveSlice)
            {
                ui.type = Image.Type.Sliced;
            }
        }

        public override void InitPreview()
        {
            if (ElementInfo == null) return;

            if (!TryGetComponent<Image>(out m_previewImage))
            {
                m_previewImage = gameObject.AddComponent<Image>();
            }

            LoadImageFromFile(ElementInfo.imgPath);
            ApplyTransform(transform);
        }


        protected override void OnApplyTransform(Transform tf)
        {
            var rt = tf as RectTransform;
            if (needFillTransform)
            {
                var pos = ElementInfo.Position;
                var worldPos = StageManager.Instance.PrefabContentsRoot.transform.TransformPoint(new Vector3(pos.x, pos.y, 0));
                var anchorMin = rt.anchorMin;
                var anchorMax = rt.anchorMax;

                var oldPiovt = rt.pivot;
                rt.pivot = new Vector2(0.5f, 0.5f);

                Vector2 size = new Vector2(ElementInfo.w, ElementInfo.h); ;
                Quaternion rotation = Quaternion.identity;

                if (!similarityCalc)
                {
                    if (rt.TryGetComponent<Image>(out var img) && img.sprite && img.sprite.texture)
                    {
                        var texture = img.sprite.texture;
                        if (!string.IsNullOrEmpty(AssetDatabase.GetAssetPath(texture)))
                        {
                            size = new Vector2(texture.width * scale.x, texture.height * scale.y);
                        }
                    }
                    rotation = Quaternion.Euler(0, 0, rotiation * -1);
                }

                // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С
                rt.anchorMin = rt.pivot;
                rt.anchorMax = rt.pivot;
                var oldSizeDelta = rt.sizeDelta;
                rt.sizeDelta = new Vector2(size.x, size.y);
                rt.anchorMin = anchorMin;
                rt.anchorMax = anchorMax;

                // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
                rt.position = worldPos;
                rt.rotation = rotation;

                //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĵ<EFBFBD>
                var oldRect = rt.rect;
                rt.pivot = oldPiovt;
                var offsetRectPos = oldRect.position - rt.rect.position;
                rt.Translate(offsetRectPos);
            }
            else
            {
                var pos = ElementInfo.Position;
                var worldPos = StageManager.Instance.PrefabContentsRoot.transform.TransformPoint(new Vector3(pos.x, pos.y, 0));
                rt.position = worldPos;
            }
        }
    }
}
#endif