Exemplo n.º 1
0
 /// <summary>
 /// Initializes a new instance of the InternalUiTweenerEditorCanvasItem.
 /// </summary>
 /// <param name="target">Target UiTweener.TimelineItem</param>
 public InternalUiAnimationEditorCanvasItem(UiAnimationClipSegment target)
 {
     Target = target;
 }
Exemplo n.º 2
0
        public static void Update()
        {
            if (DragAndDropQueue != null)
            {
                for (int i = 0; i < DragAndDropQueue.Count; i++)
                {
                    UiAnimationClipSegment tween = new UiAnimationClipSegment();
                    tween.GameObject = DragAndDropQueue[i] as GameObject;
                    tween.Delay      = GetTimeByMousePosition(InternalUiAnimationEditor.MousePosition.x);
                    tween.Layer      = GetLayerByMousePosition(InternalUiAnimationEditor.MousePosition.y);

                    RectTransform rectTransform = tween.GameObject.GetComponent <RectTransform>();

                    if (rectTransform != null)
                    {
                        tween.PositionFrom = new Vector2(rectTransform.anchoredPosition.x, rectTransform.anchoredPosition.y);
                        tween.PositionTo   = new Vector2(rectTransform.anchoredPosition.x, rectTransform.anchoredPosition.y);

                        tween.RotationFrom = rectTransform.localRotation.eulerAngles.z;
                        tween.RotationTo   = rectTransform.localRotation.eulerAngles.z;

                        tween.ScaleFrom = new Vector2(rectTransform.localScale.x, rectTransform.localScale.y);
                        tween.ScaleTo   = new Vector2(rectTransform.localScale.x, rectTransform.localScale.y);
                    }

                    if (InternalUiAnimationEditorSelection.TargetAnimationClip != null)
                    {
                        InternalUiAnimationEditorSelection.TargetAnimationClip.Items.Add(tween);
                        InternalUiAnimationEditorSelection.TargetAnimationClip.Items.Sort((a, b) => (a.Delay.CompareTo(b.Delay)));

                        justAddedTween = tween;
                    }
                }

                DragAndDropQueue = null;
            }

            if (InternalUiAnimationEditorSelection.CanvasItemToEdit == null)
            {
                Items = new List <InternalUiAnimationEditorCanvasItem>();

                for (int i = 0; i < InternalUiAnimationEditorSelection.TargetAnimationClip.Items.Count; i++)
                {
                    InternalUiAnimationEditorCanvasItem canvasItem = new InternalUiAnimationEditorCanvasItem
                                                                     (
                        InternalUiAnimationEditorSelection.TargetAnimationClip.Items[i]
                                                                     );

                    Items.Add(canvasItem);

                    if (canvasItem.Target == justAddedTween)
                    {
                        InternalUiAnimationEditorSelection.SetCanvasItemToEdit(canvasItem);
                        justAddedTween = null;
                    }
                }
            }

            if (InternalUiAnimationEditorSelection.CanvasItemToEdit != null)
            {
                Items.Remove(InternalUiAnimationEditorSelection.CanvasItemToEdit);
                Items.Add(InternalUiAnimationEditorSelection.CanvasItemToEdit);
            }

            if (InternalUiAnimationEditorSelection.CanvasItemToDrag != null)
            {
                UpdateDrag(InternalUiAnimationEditorSelection.CanvasItemToDrag);
            }

            if (InternalUiAnimationEditorSelection.CanvasItemToResize != null)
            {
                UpdateResize(InternalUiAnimationEditorSelection.CanvasItemToResize);
            }

            for (int i = 0; i < Items.Count; i++)
            {
                Items[i].IsCollided = false;

                for (int j = 0; j < Items.Count; j++)
                {
                    if (i == j)
                    {
                        continue;
                    }

                    if (Items[i].Target.GameObject != Items[j].Target.GameObject)
                    {
                        continue;
                    }

                    if (Items[i].Target.ItemType != Items[j].Target.ItemType)
                    {
                        continue;
                    }

                    if (Items[i].HitTest(Items[j].X, Items[i].Y) || Items[j].HitTest(Items[i].X, Items[j].Y))
                    {
                        Items[i].IsCollided = true;
                        break;
                    }
                }
            }
        }
        private static void RenderAnimationClipSegment(UiAnimationClipSegment segment)
        {
            if (segment.GameObject == null)
            {
                EditorGUILayout.HelpBox("Game object is missed! Setup another game object or delete this segment.", MessageType.Error);
            }

            segment.GameObject = InternalUiAnimationEditorGUI.InspectorObjectField
                                 (
                "Game Object",
                segment.GameObject
                                 );

            if (segment.GameObject != null)
            {
                segment.ItemType = (UiAnimationClipSegmentType)InternalUiAnimationEditorGUI.InspectorEnumPopup
                                   (
                    "Type",
                    segment.ItemType,
                    () =>
                {
                    RectTransform rectTransform = segment.GameObject.GetComponent <RectTransform>();

                    if (rectTransform != null)
                    {
                        segment.PositionFrom = new Vector2(rectTransform.anchoredPosition.x, rectTransform.anchoredPosition.y);
                        segment.PositionTo   = new Vector2(rectTransform.anchoredPosition.x, rectTransform.anchoredPosition.y);

                        segment.RotationFrom = rectTransform.localRotation.eulerAngles.z;
                        segment.RotationTo   = rectTransform.localRotation.eulerAngles.z;

                        segment.ScaleFrom = new Vector2(rectTransform.localScale.x, rectTransform.localScale.y);
                        segment.ScaleTo   = new Vector2(rectTransform.localScale.x, rectTransform.localScale.y);
                    }
                }
                                   );

                segment.EasingType = (EasingType)InternalUiAnimationEditorGUI.InspectorEnumPopup
                                     (
                    "Easing type",
                    segment.EasingType
                                     );

                switch (segment.ItemType)
                {
                case UiAnimationClipSegmentType.Alpha:
                    segment.AlphaFrom = InternalUiAnimationEditorGUI.InspectorFloatField("Alpha From", segment.AlphaFrom);
                    segment.AlphaTo   = InternalUiAnimationEditorGUI.InspectorFloatField("Alpha To", segment.AlphaTo);
                    break;

                case UiAnimationClipSegmentType.Color:
                    segment.ColorFrom = InternalUiAnimationEditorGUI.InspectorColorField("Color From", segment.ColorFrom);
                    segment.ColorTo   = InternalUiAnimationEditorGUI.InspectorColorField("Color To", segment.ColorTo);
                    break;

                case UiAnimationClipSegmentType.Position:
                    segment.PositionFrom = InternalUiAnimationEditorGUI.InspectorVector2Field("Position From XY", segment.PositionFrom);
                    segment.PositionTo   = InternalUiAnimationEditorGUI.InspectorVector2Field("Position To XY", segment.PositionTo);
                    break;

                case UiAnimationClipSegmentType.Rotation:
                    segment.RotationFrom = InternalUiAnimationEditorGUI.InspectorFloatField("Rotation From", segment.RotationFrom);
                    segment.RotationTo   = InternalUiAnimationEditorGUI.InspectorFloatField("Rotation To", segment.RotationTo);
                    break;

                case UiAnimationClipSegmentType.Scale:
                    segment.ScaleFrom = InternalUiAnimationEditorGUI.InspectorVector2Field("Scale From XY", segment.ScaleFrom);
                    segment.ScaleTo   = InternalUiAnimationEditorGUI.InspectorVector2Field("Scale To XY", segment.ScaleTo);
                    break;
                }

                segment.Predefined = InternalUiAnimationEditorGUI.InspectorBooleanField
                                     (
                    new GUIContent("Predefined", "Use From value as predefined value for " + segment.GameObject.name),
                    segment.Predefined
                                     );

                /*
                 * UtilityReflection.SetMemberValue
                 * (
                 *  segment, "Predefined",
                 *  segment.Predefined = InternalUiAnimationEditorGUI.InspectorBooleanField
                 *  (
                 *      new GUIContent("Predefined", "Use From value as predefined value for " + segment.GameObject.name),
                 *      (bool)UtilityReflection.GetMemberValue(segment, "Predefined")
                 *  )
                 * );
                 */
            }

            GUIStyle buttonStyle = new GUIStyle(GUI.skin.GetStyle("Button"));

            buttonStyle.margin.left = 138;
            buttonStyle.margin.top  = 5;

            EditorGUI.BeginChangeCheck();
            GUILayout.Button("Delete segment", buttonStyle);
            if (EditorGUI.EndChangeCheck())
            {
                InternalUiAnimationEditorSelection.TargetAnimationClip.Items.Remove(segment);
                InternalUiAnimationEditorSelection.TargetAnimationClip.Items.Sort((a, b) => (a.Delay.CompareTo(b.Delay)));
                InternalUiAnimationEditorSelection.SetCanvasItemToEdit(null);
            }
        }