AlicizaX/com.alicizax.unity.ui.extension
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
95fc6ee2a2
com.alicizax.unity.ui.exten.../Editor/UX/UXImageEditor.cs

837 lines
37 KiB
C#
Raw Normal View History

modify
2025-07-28 19:42:29 +08:00
using System;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;
using System.IO;
using UnityEditorInternal;
using System.Linq;
using UnityEditor.AnimatedValues;
namespace UnityEngine.UI
{
[CustomEditor(typeof(UXImage), true)]
[CanEditMultipleObjects]
modify
2025-07-28 20:52:34 +08:00
internal class UXImageEditor : Editor
modify
2025-07-28 19:42:29 +08:00
{
private GameObject go;
private SerializedProperty m_Color;
private SerializedProperty m_RaycastTarget;
protected SerializedProperty m_RaycastPadding;
private SerializedProperty m_MaskAble;
private SerializedProperty m_Sprite;
private SerializedProperty m_Type;
private SerializedProperty m_Material;
private SerializedProperty m_sourceImage;
private SerializedProperty m_ColorType;
private SerializedProperty m_Direction;
SerializedProperty m_UseSpriteMesh;
SerializedProperty m_PreserveAspect;
SerializedProperty m_FillCenter;
SerializedProperty m_PixelsPerUnitMultiplier;
SerializedProperty m_FillMethod;
SerializedProperty m_FillOrigin;
SerializedProperty m_FillAmount;
SerializedProperty m_FillClockwise;
SerializedProperty m_FlipMode;
SerializedProperty m_FlipWithCopy;
SerializedProperty m_FlipEdgeHorizontal;
SerializedProperty m_FlipEdgeVertical;
SerializedProperty m_FlipFillCenter;
SerializedProperty m_GradientColor;
GUIContent m_ClockwiseContent;
GUIContent m_SpriteFlipContent;
GUIContent m_FlipModeContent;
GUIContent m_FlipEdgeContent;
GUIContent m_FlipFillContent;
private UXImage m_targetObject;
private GameObject m_CloneObj;
private string m_Origin_name;
private bool m_InitialHide;
#if UNITY_2021_1_OR_NEWER
private bool m_bIsDriven;
#endif
GUIContent m_SpriteContent;
GUIContent m_PaddingContent;
GUIContent m_LeftContent;
GUIContent m_RightContent;
GUIContent m_TopContent;
GUIContent m_BottomContent;
private GUIContent m_CorrectButtonContent;
GUIContent m_SpriteTypeContent;
AnimBool m_ShowType;
protected AnimBool m_ShowNativeSize;
AnimBool m_ShowSlicedOrTiled;
AnimBool m_ShowSliced;
AnimBool m_ShowTiled;
AnimBool m_ShowFilled;
static private bool m_ShowPadding = false;
private class Styles
{
public static GUIContent text = EditorGUIUtility.TrTextContent("Fill Origin");
public static GUIContent[] OriginHorizontalStyle =
{
EditorGUIUtility.TrTextContent("Left"),
EditorGUIUtility.TrTextContent("Right")
};
public static GUIContent[] OriginVerticalStyle =
{
EditorGUIUtility.TrTextContent("Bottom"),
EditorGUIUtility.TrTextContent("Top")
};
public static GUIContent[] Origin90Style =
{
EditorGUIUtility.TrTextContent("BottomLeft"),
EditorGUIUtility.TrTextContent("TopLeft"),
EditorGUIUtility.TrTextContent("TopRight"),
EditorGUIUtility.TrTextContent("BottomRight")
};
public static GUIContent[] Origin180Style =
{
EditorGUIUtility.TrTextContent("Bottom"),
EditorGUIUtility.TrTextContent("Left"),
EditorGUIUtility.TrTextContent("Top"),
EditorGUIUtility.TrTextContent("Right")
};
public static GUIContent[] Origin360Style =
{
EditorGUIUtility.TrTextContent("Bottom"),
EditorGUIUtility.TrTextContent("Right"),
EditorGUIUtility.TrTextContent("Top"),
EditorGUIUtility.TrTextContent("Left")
};
}
private void OnEnable()
{
Image image = target as Image;
go = image.gameObject;
UIEffectWrapDrawer.InitInspectorString();
m_Color = serializedObject.FindProperty("m_Color");
m_Sprite = serializedObject.FindProperty("m_Sprite");
m_Type = serializedObject.FindProperty("m_Type");
m_Material = serializedObject.FindProperty("m_Material");
m_RaycastTarget = serializedObject.FindProperty("m_RaycastTarget");
m_RaycastPadding = serializedObject.FindProperty("m_RaycastPadding");
m_sourceImage = serializedObject.FindProperty("m_Sprite");
m_MaskAble = serializedObject.FindProperty("m_Maskable");
//spriteContent = new GUIContent("Source Image");
m_targetObject = serializedObject.targetObject as UXImage;
m_Origin_name = m_Sprite.objectReferenceValue?.name;
m_ColorType = serializedObject.FindProperty("m_ColorType");
m_GradientColor = serializedObject.FindProperty("m_GradientColor");
m_Direction = serializedObject.FindProperty("m_Direction");
m_UseSpriteMesh = serializedObject.FindProperty("m_UseSpriteMesh");
m_PreserveAspect = serializedObject.FindProperty("m_PreserveAspect");
m_FillCenter = serializedObject.FindProperty("m_FillCenter");
m_PixelsPerUnitMultiplier = serializedObject.FindProperty("m_PixelsPerUnitMultiplier");
m_FillMethod = serializedObject.FindProperty("m_FillMethod");
m_FillOrigin = serializedObject.FindProperty("m_FillOrigin");
m_FillClockwise = serializedObject.FindProperty("m_FillClockwise");
m_FillAmount = serializedObject.FindProperty("m_FillAmount");
m_FlipModeContent = new GUIContent("FlipMode");
m_FlipEdgeContent = new GUIContent("FlipEdge");
m_FlipFillContent = new GUIContent("FlipFill");
m_FlipMode = serializedObject.FindProperty("m_FlipMode");
m_FlipWithCopy = serializedObject.FindProperty("m_FlipWithCopy");
m_FlipEdgeHorizontal = serializedObject.FindProperty("m_FlipEdgeHorizontal");
m_FlipEdgeVertical = serializedObject.FindProperty("m_FlipEdgeVertical");
m_FlipFillCenter = serializedObject.FindProperty("m_FlipFillCenter");
#if UNITY_2021_1_OR_NEWER
m_bIsDriven = false;
#endif
m_PaddingContent = EditorGUIUtility.TrTextContent("Raycast Padding");
m_LeftContent = EditorGUIUtility.TrTextContent("Left");
m_RightContent = EditorGUIUtility.TrTextContent("Right");
m_TopContent = EditorGUIUtility.TrTextContent("Top");
m_BottomContent = EditorGUIUtility.TrTextContent("Bottom");
m_CorrectButtonContent = EditorGUIUtility.TrTextContent("Set Native Size", "Sets the size to match the content.");
m_SpriteTypeContent = EditorGUIUtility.TrTextContent("Image Type");
m_ClockwiseContent = EditorGUIUtility.TrTextContent("Clockwise");
m_SpriteContent = EditorGUIUtility.TrTextContent("Source Image");
m_ShowType = new AnimBool(m_Sprite.objectReferenceValue != null);
m_ShowType.valueChanged.AddListener(Repaint);
m_ShowNativeSize = new AnimBool(false);
m_ShowNativeSize.valueChanged.AddListener(Repaint);
var typeEnum = (Image.Type)m_Type.enumValueIndex;
m_ShowSlicedOrTiled = new AnimBool(!m_Type.hasMultipleDifferentValues && typeEnum == Image.Type.Sliced);
m_ShowSliced = new AnimBool(!m_Type.hasMultipleDifferentValues && typeEnum == Image.Type.Sliced);
m_ShowTiled = new AnimBool(!m_Type.hasMultipleDifferentValues && typeEnum == Image.Type.Tiled);
m_ShowFilled = new AnimBool(!m_Type.hasMultipleDifferentValues && typeEnum == Image.Type.Filled);
m_ShowSlicedOrTiled.valueChanged.AddListener(Repaint);
m_ShowSliced.valueChanged.AddListener(Repaint);
m_ShowTiled.valueChanged.AddListener(Repaint);
m_ShowFilled.valueChanged.AddListener(Repaint);
}
private void OnDisable()
{
if (m_CloneObj != null)
{
DestroyImmediate(m_CloneObj);
}
m_ShowType.valueChanged.RemoveListener(Repaint);
m_ShowNativeSize.valueChanged.RemoveListener(Repaint);
m_ShowSlicedOrTiled.valueChanged.RemoveListener(Repaint);
m_ShowSliced.valueChanged.RemoveListener(Repaint);
m_ShowTiled.valueChanged.RemoveListener(Repaint);
m_ShowFilled.valueChanged.RemoveListener(Repaint);
}
public override void OnInspectorGUI()
{
EditorGUI.BeginChangeCheck();
serializedObject.Update();
serializedObject.ApplyModifiedProperties();
//base.OnInspectorGUI();
//CustomEditorGUILayout.PropertyField(sourceImage);
//CustomEditorGUILayout.PropertyField(color);
//CustomEditorGUILayout.PropertyField(material);
//CustomEditorGUILayout.PropertyField(raycastTarget);
//CustomEditorGUILayout.PropertyField(maskAble);
serializedObject.Update();
Image image = target as Image;
RectTransform rect = image.GetComponent<RectTransform>();
#if UNITY_2021_1_OR_NEWER
m_bIsDriven = (rect.drivenByObject as Slider)?.fillRect == rect;
#endif
SpriteGUI();
AppearanceControlsGUI();
RaycastControlsGUI();
MaskableControlsGUI();
//m_ShowType.target = m_Sprite.objectReferenceValue != null;
//if (EditorGUILayout.BeginFadeGroup(m_ShowType.faded))
TypeGUI();
//EditorGUILayout.EndFadeGroup();
SetShowNativeSize(false);
if (EditorGUILayout.BeginFadeGroup(m_ShowNativeSize.faded))
{
EditorGUI.indentLevel++;
if ((Image.Type)m_Type.enumValueIndex == Image.Type.Simple)
EditorGUILayout.PropertyField(m_UseSpriteMesh);
EditorGUILayout.PropertyField(m_PreserveAspect);
EditorGUI.indentLevel--;
}
EditorGUILayout.EndFadeGroup();
NativeSizeButtonGUI();
FlipGUI();
serializedObject.ApplyModifiedProperties();
Rect effectWarpRect = EditorGUILayout.GetControlRect();
UIEffectWrapDrawer.Draw(effectWarpRect, go);
}
protected void SpriteGUI()
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(m_Sprite, m_SpriteContent);
if (EditorGUI.EndChangeCheck())
{
var newSprite = m_Sprite.objectReferenceValue as Sprite;
if (newSprite)
{
UXImage.Type oldType = (UXImage.Type)m_Type.enumValueIndex;
if (newSprite.border.SqrMagnitude() > 0)
{
m_Type.enumValueIndex = (int)UXImage.Type.Sliced;
}
else if (oldType == UXImage.Type.Sliced)
{
m_Type.enumValueIndex = (int)UXImage.Type.Simple;
}
}
}
}
protected void MaskableControlsGUI()
{
EditorGUILayout.PropertyField(m_MaskAble);
}
protected void AppearanceControlsGUI()
{
EditorGUI.BeginChangeCheck();
modify
2025-07-28 20:52:34 +08:00
string[] labels = { "Solid_Color", "Gradient_Color" };
modify
2025-07-28 19:42:29 +08:00
var type = (UXImage.ColorType)EnumPopupLayoutEx("ColorType", typeof(UXImage.ColorType), m_ColorType.intValue, labels);
// EditorGUILayout.EnumPopup(EditorLocalization.GetLocalization("UXImage", "m_ColorType"), (UXImage.ColorType)m_ColorType.intValue);
if (EditorGUI.EndChangeCheck())
{
m_ColorType.intValue = (int)type;
if ((int)type == 1 && m_Type.intValue != 0)
{
m_Type.intValue = 0;
}
if ((int)type == 1 && m_FlipMode.intValue != 0)
{
m_FlipMode.intValue = 0;
}
}
GUILayout.BeginHorizontal();
GUILayout.Space(EditorGUIUtility.labelWidth);
if (GUILayout.Button("UseUIColorConfig", EditorStyles.miniButton))
{
//弹窗
if (type == UXImage.ColorType.Solid_Color)
{
// ColorChooseWindow.OpenWindow();
// ColorChooseWindow.r_window.target = (UXImage)target;
}
if (type == UXImage.ColorType.Gradient_Color)
{
// GradientChooseWindow.OpenWindow();
// GradientChooseWindow.r_window.target = (UXImage)target;
}
//m_Color.colorValue = UIColorChooseWindow.r_window.usecolor;
//m_GradientColor.
}
GUILayout.EndHorizontal();
if (type == UXImage.ColorType.Solid_Color)
{
EditorGUILayout.PropertyField(m_Color);
}
else if (type == UXImage.ColorType.Gradient_Color)
{
EditorGUI.BeginChangeCheck();
modify
2025-07-28 20:52:34 +08:00
string[] labels2 = { "Vertical", "Horizontal" };
modify
2025-07-28 19:42:29 +08:00
var direction = (UXImage.GradientDirection)EnumPopupLayoutEx("m_Direction", typeof(UXImage.GradientDirection), m_Direction.intValue, labels2);
if (EditorGUI.EndChangeCheck())
{
m_Direction.intValue = (int)direction;
}
//EditorGUILayout.ColorField(m_Color);
EditorGUILayout.PropertyField(m_GradientColor, new GUIContent("Gradient_Color"));
}
EditorGUILayout.PropertyField(m_Material);
}
protected void RaycastControlsGUI()
{
EditorGUILayout.PropertyField(m_RaycastTarget);
float height = EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
if (m_ShowPadding)
height += (EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing) * 4;
var rect = EditorGUILayout.GetControlRect(true, height);
if (m_RaycastPadding != null)
{
EditorGUI.BeginProperty(rect, m_PaddingContent, m_RaycastPadding);
rect.height = EditorGUIUtility.singleLineHeight;
using (var check = new EditorGUI.ChangeCheckScope())
{
m_ShowPadding = EditorGUI.Foldout(rect, m_ShowPadding, m_PaddingContent, true);
if (check.changed)
{
SceneView.RepaintAll();
}
}
if (m_ShowPadding)
{
using (var check = new EditorGUI.ChangeCheckScope())
{
EditorGUI.indentLevel++;
Vector4 newPadding = m_RaycastPadding.vector4Value;
rect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
newPadding.x = EditorGUI.FloatField(rect, m_LeftContent, newPadding.x);
rect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
newPadding.y = EditorGUI.FloatField(rect, m_BottomContent, newPadding.y);
rect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
newPadding.z = EditorGUI.FloatField(rect, m_RightContent, newPadding.z);
rect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
newPadding.w = EditorGUI.FloatField(rect, m_TopContent, newPadding.w);
if (check.changed)
{
m_RaycastPadding.vector4Value = newPadding;
}
EditorGUI.indentLevel--;
}
}
EditorGUI.EndProperty();
}
}
protected void TypeGUI()
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(m_Type, m_SpriteTypeContent);
if (EditorGUI.EndChangeCheck())
{
if (m_Type.intValue != 0 && m_ColorType.intValue == 1)
{
m_ColorType.intValue = 0;
}
}
++EditorGUI.indentLevel;
{
Image.Type typeEnum = (Image.Type)m_Type.enumValueIndex;
bool showSlicedOrTiled = (!m_Type.hasMultipleDifferentValues && (typeEnum == Image.Type.Sliced || typeEnum == Image.Type.Tiled));
if (showSlicedOrTiled && targets.Length > 1)
showSlicedOrTiled = targets.Select(obj => obj as Image).All(img => img.hasBorder);
m_ShowSlicedOrTiled.target = showSlicedOrTiled;
m_ShowSliced.target = (showSlicedOrTiled && !m_Type.hasMultipleDifferentValues && typeEnum == Image.Type.Sliced);
m_ShowTiled.target = (showSlicedOrTiled && !m_Type.hasMultipleDifferentValues && typeEnum == Image.Type.Tiled);
m_ShowFilled.target = (!m_Type.hasMultipleDifferentValues && typeEnum == Image.Type.Filled);
Image image = target as Image;
if (EditorGUILayout.BeginFadeGroup(m_ShowSlicedOrTiled.faded))
{
if (image.hasBorder)
EditorGUILayout.PropertyField(m_FillCenter);
EditorGUILayout.PropertyField(m_PixelsPerUnitMultiplier);
}
EditorGUILayout.EndFadeGroup();
if (EditorGUILayout.BeginFadeGroup(m_ShowSliced.faded))
{
if (image.sprite != null && !image.hasBorder)
EditorGUILayout.HelpBox("This Image doesn't have a border.", MessageType.Warning);
}
EditorGUILayout.EndFadeGroup();
if (EditorGUILayout.BeginFadeGroup(m_ShowTiled.faded))
{
if (image.sprite != null && !image.hasBorder && (image.sprite.texture.wrapMode != TextureWrapMode.Repeat || image.sprite.packed))
EditorGUILayout.HelpBox("It looks like you want to tile a sprite with no border. It would be more efficient to modify the Sprite properties, clear the Packing tag and set the Wrap mode to Repeat.", MessageType.Warning);
}
EditorGUILayout.EndFadeGroup();
if (EditorGUILayout.BeginFadeGroup(m_ShowFilled.faded))
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(m_FillMethod);
if (EditorGUI.EndChangeCheck())
{
m_FillOrigin.intValue = 0;
}
var shapeRect = EditorGUILayout.GetControlRect(true);
switch ((Image.FillMethod)m_FillMethod.enumValueIndex)
{
case Image.FillMethod.Horizontal:
m_FillOrigin.intValue = EditorGUI.Popup(shapeRect, Styles.text, m_FillOrigin.intValue, Styles.OriginHorizontalStyle);
break;
case Image.FillMethod.Vertical:
m_FillOrigin.intValue = EditorGUI.Popup(shapeRect, Styles.text, m_FillOrigin.intValue, Styles.OriginVerticalStyle);
break;
case Image.FillMethod.Radial90:
m_FillOrigin.intValue = EditorGUI.Popup(shapeRect, Styles.text, m_FillOrigin.intValue, Styles.Origin90Style);
break;
case Image.FillMethod.Radial180:
m_FillOrigin.intValue = EditorGUI.Popup(shapeRect, Styles.text, m_FillOrigin.intValue, Styles.Origin180Style);
break;
case Image.FillMethod.Radial360:
m_FillOrigin.intValue = EditorGUI.Popup(shapeRect, Styles.text, m_FillOrigin.intValue, Styles.Origin360Style);
break;
}
#if UNITY_2021_1_OR_NEWER
if (m_bIsDriven)
EditorGUILayout.HelpBox("The Fill amount property is driven by Slider.", MessageType.None);
using (new EditorGUI.DisabledScope(m_bIsDriven))
{
EditorGUILayout.PropertyField(m_FillAmount);
}
#else
EditorGUILayout.PropertyField(m_FillAmount);
#endif
if ((Image.FillMethod)m_FillMethod.enumValueIndex > Image.FillMethod.Vertical)
{
EditorGUILayout.PropertyField(m_FillClockwise, m_ClockwiseContent);
}
}
EditorGUILayout.EndFadeGroup();
}
--EditorGUI.indentLevel;
}
private void FlipGUI()
{
EditorGUI.BeginChangeCheck();
//EditorGUILayout.PropertyField(m_gradientMode, m_SpriteGradientContent);
UXImage.FlipMode flipmodeEnumOld = (UXImage.FlipMode)m_FlipMode.enumValueIndex;
bool flipWithCopyOld = m_FlipWithCopy.boolValue;
#if UNITY_2021_2_OR_NEWER
UXImage.FlipEdgeVertical edgeVerticalOld = (UXImage.FlipEdgeVertical)(m_FlipEdgeVertical.enumValueFlag);
#else
UXImage.FlipEdgeVertical edgeVerticalOld = (UXImage.FlipEdgeVertical)(m_FlipEdgeVertical.enumValueIndex + 3);
#endif
UXImage.FlipEdgeHorizontal edgeHorizontalOld = (UXImage.FlipEdgeHorizontal)m_FlipEdgeHorizontal.enumValueIndex;
string[] labels =
{
"None", "Horizontal",
modify
2025-07-28 20:52:34 +08:00
"Vertical", "FourCorner"
modify
2025-07-28 19:42:29 +08:00
};
EditorGUI.BeginChangeCheck();
m_FlipMode.intValue = EnumPopupLayoutEx(m_FlipModeContent.text, typeof(UXImage.FlipMode), m_FlipMode.intValue, labels);
if (EditorGUI.EndChangeCheck())
{
if (m_FlipMode.intValue != 0 && m_ColorType.intValue == 1)
{
m_ColorType.intValue = 0;
}
}
//EditorGUILayout.PropertyField(m_FlipMode, m_FlipModeContent);
UXImage.FlipMode flipmodeEnum = (UXImage.FlipMode)m_FlipMode.enumValueIndex;
switch (flipmodeEnum)
{
case UXImage.FlipMode.Horziontal:
++EditorGUI.indentLevel;
bool iscopy1 = m_FlipWithCopy.boolValue;
m_FlipWithCopy.boolValue = EditorGUILayout.Toggle("Copy", m_FlipWithCopy.boolValue);
if (iscopy1 == true && m_FlipWithCopy.boolValue == false)
{
if (m_FlipEdgeHorizontal.intValue == 0)
{
go.transform.Translate(Vector3.right * go.GetComponent<RectTransform>().rect.width / 4);
}
else if (m_FlipEdgeHorizontal.intValue == 2)
{
go.transform.Translate(Vector3.left * go.GetComponent<RectTransform>().rect.width / 4);
}
}
if (m_FlipWithCopy.boolValue)
{
int last = m_FlipEdgeHorizontal.intValue;
if (iscopy1 == false)
{
if (last == 0)
{
go.transform.Translate(Vector3.left * go.GetComponent<RectTransform>().rect.width / 2);
}
else if (last == 2)
{
go.transform.Translate(Vector3.right * go.GetComponent<RectTransform>().rect.width / 2);
}
}
string[] labels2 =
{
"Left", "Middle",
"Right"
};
m_FlipEdgeHorizontal.intValue = EnumPopupLayoutEx(m_FlipEdgeContent.text, typeof(UXImage.FlipEdgeHorizontal), m_FlipEdgeHorizontal.intValue, labels2);
//EditorGUILayout.PropertyField(m_FlipEdgeHorizontal, m_FlipEdgeContent);
int now = m_FlipEdgeHorizontal.intValue;
if (last != now)
{
if ((last == 0 && now == 1))
{
go.transform.Translate(Vector3.right * go.GetComponent<RectTransform>().rect.width / 4);
}
else if ((last == 2 && now == 1))
{
go.transform.Translate(Vector3.left * go.GetComponent<RectTransform>().rect.width / 4);
}
else if (last == 0 && now == 2 || (last == 1 && now == 2))
{
go.transform.Translate(Vector3.right * go.GetComponent<RectTransform>().rect.width / 2);
}
else if ((last == 1 && now == 0) || (last == 2 && now == 0))
{
go.transform.Translate(Vector3.left * go.GetComponent<RectTransform>().rect.width / 2);
}
}
}
--EditorGUI.indentLevel;
break;
case UXImage.FlipMode.Vertical:
++EditorGUI.indentLevel;
bool iscopy = m_FlipWithCopy.boolValue;
m_FlipWithCopy.boolValue = EditorGUILayout.Toggle("Copy", m_FlipWithCopy.boolValue);
if (iscopy == true && m_FlipWithCopy.boolValue == false)
{
if (m_FlipEdgeVertical.intValue == 3)
{
go.transform.Translate(Vector3.down * go.GetComponent<RectTransform>().rect.height / 4);
}
else if (m_FlipEdgeVertical.intValue == 5)
{
go.transform.Translate(Vector3.up * go.GetComponent<RectTransform>().rect.height / 4);
}
}
if (m_FlipWithCopy.boolValue)
{
int last = m_FlipEdgeVertical.intValue;
if (iscopy == false)
{
if (last == 3)
{
go.transform.Translate(Vector3.up * go.GetComponent<RectTransform>().rect.height / 2);
}
else if (last == 5)
{
go.transform.Translate(Vector3.down * go.GetComponent<RectTransform>().rect.height / 2);
}
}
string[] labels2 =
{
"Up", "Middle",
"Down"
};
m_FlipEdgeVertical.intValue = EnumPopupLayoutEx(m_FlipEdgeContent.text, typeof(UXImage.FlipEdgeVertical), m_FlipEdgeVertical.intValue, labels2);
//EditorGUILayout.PropertyField(m_FlipEdgeVertical, m_FlipEdgeContent);
int now = m_FlipEdgeVertical.intValue;
if (last != now)
{
if ((last == 3 && now == 4))
{
go.transform.Translate(Vector3.down * go.GetComponent<RectTransform>().rect.height / 4);
}
else if ((last == 5 && now == 4))
{
go.transform.Translate(Vector3.up * go.GetComponent<RectTransform>().rect.height / 4);
}
else if (last == 3 && now == 5 || (last == 4 && now == 5))
{
go.transform.Translate(Vector3.down * go.GetComponent<RectTransform>().rect.height / 2);
}
else if ((last == 4 && now == 3) || last == 5 && now == 3)
{
go.transform.Translate(Vector3.up * go.GetComponent<RectTransform>().rect.height / 2);
}
}
}
--EditorGUI.indentLevel;
break;
case UXImage.FlipMode.FourCorner:
++EditorGUI.indentLevel;
int lastC = m_FlipFillCenter.intValue;
string[] labels3 = { "LeftTop", "RightTop", "RightBottom", "LeftBottom" };
m_FlipFillCenter.intValue = EnumPopupLayoutEx(m_FlipFillContent.text, typeof(UXImage.FlipFillCenter), m_FlipFillCenter.intValue, labels3);
//EditorGUILayout.PropertyField(m_FlipFillCenter, m_FlipFillContent);
int nowC = m_FlipFillCenter.intValue;
// if (lastC != nowC)
// {
// if(lastC==0&&nowC==1||(lastC==3&&nowC==2)){
// go.transform.Translate(Vector3.right * go.GetComponent<RectTransform>().rect.width / 2);
// }
// else if(lastC==0&& nowC==2){
// go.transform.Translate(Vector3.right * go.GetComponent<RectTransform>().rect.width / 2);
// go.transform.Translate(Vector3.down * go.GetComponent<RectTransform>().rect.height / 2);
// }
// else if(lastC==0&& nowC==3 || (lastC==1&&nowC==2)){
// go.transform.Translate(Vector3.down * go.GetComponent<RectTransform>().rect.height / 2);
// }
// else if(lastC==1&&nowC==0||(lastC==2&&nowC==3)){
// go.transform.Translate(Vector3.left * go.GetComponent<RectTransform>().rect.width / 2);
// }
// else if(lastC==1&&nowC==3){
// go.transform.Translate(Vector3.left * go.GetComponent<RectTransform>().rect.width / 2);
// go.transform.Translate(Vector3.down * go.GetComponent<RectTransform>().rect.height / 2);
// }
// else if(lastC==2&&nowC==1||(lastC==3&&nowC==0)){
// go.transform.Translate(Vector3.up * go.GetComponent<RectTransform>().rect.height / 2);
// }
// else if(lastC==2&&nowC==0){
// go.transform.Translate(Vector3.left * go.GetComponent<RectTransform>().rect.width / 2);
// go.transform.Translate(Vector3.up * go.GetComponent<RectTransform>().rect.height / 2);
// }
// else if(lastC==3&&nowC==1){
// go.transform.Translate(Vector3.right * go.GetComponent<RectTransform>().rect.width / 2);
// go.transform.Translate(Vector3.up * go.GetComponent<RectTransform>().rect.height / 2);
// }
// }
--EditorGUI.indentLevel;
break;
default:
break;
}
if (EditorGUI.EndChangeCheck())
{
int OldWidthScaler = 1;
int OldHeightScaler = 1;
int NewWidthScaler = 1;
int NewHeightScaler = 1;
if (flipmodeEnumOld != flipmodeEnum)
{
m_FlipWithCopy.boolValue = false;
}
if (flipmodeEnumOld == UXImage.FlipMode.Horziontal)
{
GetSizeScaler(flipmodeEnumOld, flipWithCopyOld, (UXImage.FlipEdge)(int)edgeHorizontalOld, ref OldWidthScaler, ref OldHeightScaler);
}
if (flipmodeEnumOld == UXImage.FlipMode.Vertical)
{
GetSizeScaler(flipmodeEnumOld, flipWithCopyOld, (UXImage.FlipEdge)(int)edgeVerticalOld, ref OldWidthScaler, ref OldHeightScaler);
}
if (flipmodeEnumOld == UXImage.FlipMode.FourCorner)
{
GetSizeScaler(flipmodeEnumOld, flipWithCopyOld, UXImage.FlipEdge.None, ref OldWidthScaler, ref OldHeightScaler);
}
if (flipmodeEnum == UXImage.FlipMode.Horziontal)
{
#if UNITY_2021_2_OR_NEWER
GetSizeScaler(flipmodeEnum, m_FlipWithCopy.boolValue, (UXImage.FlipEdge)(int)m_FlipEdgeHorizontal.enumValueFlag, ref NewWidthScaler, ref NewHeightScaler);
#else
GetSizeScaler(flipmodeEnum, m_FlipWithCopy.boolValue, (UXImage.FlipEdge)(int)m_FlipEdgeHorizontal.enumValueIndex, ref NewWidthScaler, ref NewHeightScaler);
#endif
}
if (flipmodeEnum == UXImage.FlipMode.Vertical)
{
#if UNITY_2021_2_OR_NEWER
GetSizeScaler(flipmodeEnum, m_FlipWithCopy.boolValue, (UXImage.FlipEdge)(int)m_FlipEdgeVertical.enumValueFlag, ref NewWidthScaler, ref NewHeightScaler);
#else
GetSizeScaler(flipmodeEnum, m_FlipWithCopy.boolValue, (UXImage.FlipEdge)(int)(m_FlipEdgeVertical.enumValueIndex + 3), ref NewWidthScaler, ref NewHeightScaler);
#endif
}
if (flipmodeEnum == UXImage.FlipMode.FourCorner)
{
GetSizeScaler(flipmodeEnum, m_FlipWithCopy.boolValue, UXImage.FlipEdge.None, ref NewWidthScaler, ref NewHeightScaler);
}
UXImage image = target as UXImage;
float width = image.rectTransform.rect.width * ((float)NewWidthScaler / OldWidthScaler);
float height = image.rectTransform.rect.height * ((float)NewHeightScaler / OldHeightScaler);
image.rectTransform.sizeDelta = new Vector2(width, height);
serializedObject.ApplyModifiedProperties();
}
}
void GetSizeScaler(UXImage.FlipMode flipMode, bool flipWithCopy, UXImage.FlipEdge flipEdge, ref int widthScaler, ref int heightScaler)
{
if (flipMode == UXImage.FlipMode.FourCorner)
{
widthScaler = 2;
heightScaler = 2;
}
if (flipMode == UXImage.FlipMode.Vertical)
{
if (flipWithCopy && flipEdge != UXImage.FlipEdge.VertMiddle)
{
widthScaler = 1;
heightScaler = 2;
}
}
if (flipMode == UXImage.FlipMode.Horziontal)
{
if (flipWithCopy && flipEdge != UXImage.FlipEdge.HorzMiddle)
{
widthScaler = 2;
heightScaler = 1;
}
}
}
void SetShowNativeSize(bool instant)
{
Image.Type type = (Image.Type)m_Type.enumValueIndex;
bool showNativeSize = (type == Image.Type.Simple || type == Image.Type.Filled) && m_Sprite.objectReferenceValue != null;
if (instant)
m_ShowNativeSize.value = showNativeSize;
else
m_ShowNativeSize.target = showNativeSize;
}
protected void NativeSizeButtonGUI()
{
if (EditorGUILayout.BeginFadeGroup(m_ShowNativeSize.faded))
{
EditorGUILayout.BeginHorizontal();
{
GUILayout.Space(EditorGUIUtility.labelWidth);
if (GUILayout.Button(m_CorrectButtonContent, EditorStyles.miniButton))
{
foreach (Graphic graphic in targets.Select(obj => obj as Graphic))
{
Undo.RecordObject(graphic.rectTransform, "Set Native Size");
graphic.SetNativeSize();
EditorUtility.SetDirty(graphic);
}
}
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndFadeGroup();
}
public int EnumPopupLayoutEx(string label, Type type, int enumValueIndex, string[] labels)
{
int[] ints = (int[])Enum.GetValues(type);
string[] strings = Enum.GetNames(type);
if (labels.Length != ints.Length)
{
return EditorGUILayout.IntPopup(label, enumValueIndex, strings, ints);
}
else
{
return EditorGUILayout.IntPopup(label, enumValueIndex, labels, ints);
}
}
}
}
Reference in New Issue Copy Permalink