コード例 #1
0
        private void DrawClipsUsed()
        {
            EnsureUsedClipsCached();

            usedClipsFoldout.SetTo(EditorGUILayout.Foldout(usedClipsFoldout, "Clips used in the animation player"));
            if (!usedClipsFoldout)
            {
                return;
            }

            EditorGUI.indentLevel++;
            foreach (var clip in animationClipsUsed)
            {
                using (new EditorGUILayout.HorizontalScope())
                {
                    EditorUtilities.ObjectField(clip);
                    clipUsagesFoldedOut[clip] = EditorGUILayout.Foldout(clipUsagesFoldedOut[clip], "");
                }

                if (clipUsagesFoldedOut[clip])
                {
                    using (new EditorGUI.IndentLevelScope())
                    {
                        foreach (var state in clipsUsedInStates[clip])
                        {
                            EditorGUILayout.LabelField("Used in state " + state.Name);
                        }
                    }
                }
            }

            EditorGUI.indentLevel--;
        }
コード例 #2
0
        private static void DrawSelectRandomState(PlayRandomClip state, ref bool markDirty)
        {
            EditorGUILayout.LabelField("Select randomly from:");
            EditorGUI.indentLevel++;
            for (var i = 0; i < state.clips.Count; i++)
            {
                var oldClip = state.clips[i];

                state.clips[i] = EditorUtilities.ObjectField("Clip", oldClip, 150f, 200f);
                if (state.clips[i] != oldClip)
                {
                    state.OnClipAssigned(state.clips[i]);
                    markDirty = true;
                }
            }
            EditorGUI.indentLevel--;

            GUILayout.Space(10f);
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("Add new choice", GUILayout.Width(150f)))
            {
                state.clips.Add(null);
                markDirty = true;
            }

            GUILayout.FlexibleSpace();
            EditorGUILayout.EndHorizontal();
        }
コード例 #3
0
        private void DrawSelectedLayer()
        {
            var layer = animationPlayer.layers[selectedLayer];

            layer.startWeight = EditorGUILayout.Slider($"Layer {selectedLayer} Weight", layer.startWeight, 0f, 1f);
            layer.mask        = EditorUtilities.ObjectField($"Layer {selectedLayer} Mask", layer.mask);
        }
コード例 #4
0
        private static TransitionData DrawTransitionData(TransitionData transitionData)
        {
            transitionData.type = (TransitionType)EditorGUILayout.EnumPopup("Type", transitionData.type);

            if (transitionData.type == TransitionType.Clip)
            {
                EditorGUI.BeginChangeCheck();
                transitionData.clip = EditorUtilities.ObjectField("Clip", transitionData.clip);
                if (EditorGUI.EndChangeCheck())
                {
                    transitionData.duration = transitionData.clip == null ? 0 : transitionData.clip.length;
                }

                return(transitionData);
            }

            transitionData.duration = EditorGUILayout.FloatField("Duration", transitionData.duration);

            if (transitionData.type == TransitionType.Curve)
            {
                transitionData.curve = EditorGUILayout.CurveField(transitionData.curve);
            }

            return(transitionData);
        }
コード例 #5
0
        private static void DrawSingleClipState(SingleClip state, ref bool markDirty, float labelWidth)
        {
            var oldClip = state.clip;

            state.clip = EditorUtilities.ObjectField("Clip", state.clip, labelWidth);
            if (state.clip != oldClip)
            {
                state.OnClipAssigned(state.clip);
                markDirty = true;
            }
        }
コード例 #6
0
        private void DrawReferencedModels()
        {
            usedModelsFoldout.SetTo(EditorGUILayout.Foldout(usedModelsFoldout, "Models used in the animation player"));
            if (!usedModelsFoldout)
            {
                return;
            }

            EditorGUI.indentLevel++;
            foreach (var model in modelsUsed)
            {
                EditorUtilities.ObjectField(model);
            }
            EditorGUI.indentLevel--;
        }
コード例 #7
0
        private void DrawSelectedLayer()
        {
            var layer = animationPlayer.layers[selectedLayer];

            layer.startWeight = EditorGUILayout.Slider($"Layer {selectedLayer} Weight", layer.startWeight, 0f, 1f);
            layer.mask        = EditorUtilities.ObjectField($"Layer {selectedLayer} Mask", layer.mask);

            if (selectedLayer > 0) //Doesn't make any sense for base layer to be additive!
            {
                layer.type = (AnimationLayerType)EditorGUILayout.EnumPopup("Type", layer.type);
            }
            else
            {
                EditorGUILayout.LabelField(string.Empty);
            }
        }
コード例 #8
0
        private void DrawClipsUsed()
        {
            EnsureUsedClipsCached();

            usedClipsFoldout.SetTo(EditorGUILayout.Foldout(usedClipsFoldout, "Clips used in the animation player"));
            if (!usedClipsFoldout)
            {
                return;
            }

            EditorGUI.indentLevel++;
            foreach (var clip in animationClipsUsed)
            {
                EditorUtilities.ObjectField(clip);
            }
            EditorGUI.indentLevel--;
        }
コード例 #9
0
        private static bool DrawBlendTreeEntry(AnimationState state, BlendTreeEntry blendTreeEntry, string blendVarName, string blendVarName2 = null)
        {
            var changedName = false;
            var oldClip     = blendTreeEntry.clip;

            blendTreeEntry.clip = EditorUtilities.ObjectField("Clip", blendTreeEntry.clip, 150f, 200f);
            if (blendTreeEntry.clip != oldClip && blendTreeEntry.clip != null)
            {
                changedName = state.OnClipAssigned(blendTreeEntry.clip);
            }

            var as1D = blendTreeEntry as BlendTreeEntry1D;
            var as2D = blendTreeEntry as BlendTreeEntry2D;

            if (as1D != null)
            {
                DrawThresholdFor1DBlendTree(blendVarName, as1D);
            }
            else if (as2D != null)
            {
                DrawThresholdsFor2DBlendTree(blendVarName, blendVarName2, as2D);
            }
            return(changedName);
        }
コード例 #10
0
        private static void DrawSequence(Sequence state, ref bool markDirty)
        {
            var oldLoopMode = state.loopMode;

            state.loopMode = (SequenceLoopMode)EditorGUILayout.EnumPopup("Loop Mode", state.loopMode);
            if (state.loopMode != oldLoopMode)
            {
                markDirty = true;
            }

            if (state.loopMode == SequenceLoopMode.LoopLastClipIfItLoops)
            {
                EditorGUILayout.HelpBox("The clips in the sequence are played one by one. The final one will loop if it's set to loop.", MessageType.None);
            }
            else
            {
                EditorGUILayout.HelpBox("The clips in the sequence are played one by one, looping after the last one is finished", MessageType.None);
            }

            EditorGUILayout.LabelField("Sequence");
            EditorGUI.indentLevel++;
            var toRemove = -1;
            var old      = EditorGUIUtility.labelWidth;

            EditorGUIUtility.labelWidth = 60f;
            for (var i = 0; i < state.clips.Count; i++)
            {
                var oldClip = state.clips[i];
                using (new EditorGUILayout.HorizontalScope()) {
                    state.clips[i] = EditorUtilities.ObjectField("Clip", oldClip);
                    if (GUILayout.Button("-", GUILayout.Width(20f)))
                    {
                        toRemove = i;
                    }
                }

                if (state.clips[i] != oldClip)
                {
                    state.OnClipAssigned(state.clips[i]);
                    markDirty = true;
                }
            }
            EditorGUIUtility.labelWidth = old;
            EditorGUI.indentLevel--;

            EditorGUI.indentLevel--;

            GUILayout.Space(10f);
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("Add new part", GUILayout.Width(150f)))
            {
                state.clips.Add(null);
                markDirty = true;
            }

            GUILayout.FlexibleSpace();
            EditorGUILayout.EndHorizontal();

            if (toRemove != -1)
            {
                state.clips.RemoveAt(toRemove);
                markDirty = true;
            }
        }
コード例 #11
0
        private static void Draw2DBlendTree(BlendTree2D state, ref bool markDirty)
        {
            state.blendVariable  = EditorUtilities.TextField("First blend variable", state.blendVariable, 120f);
            state.blendVariable2 = EditorUtilities.TextField("Second blend variable", state.blendVariable2, 120f);
            EditorGUI.indentLevel++;

            if (state.blendTree == null)
            {
                state.blendTree = new System.Collections.Generic.List <BlendTreeEntry2D>();
            }

            int swapIndex = -1;

            for (var i = 0; i < state.blendTree.Count; i++)
            {
                var blendTreeEntry = state.blendTree[i];

                var oldClip = blendTreeEntry.clip;
                blendTreeEntry.clip = EditorUtilities.ObjectField("Clip", blendTreeEntry.clip, 150f, 200f);
                if (blendTreeEntry.clip != oldClip && blendTreeEntry.clip != null)
                {
                    markDirty |= state.OnClipAssigned(blendTreeEntry.clip);
                }

                EditorGUILayout.BeginHorizontal();
                {
                    blendTreeEntry.threshold1 = EditorUtilities.FloatField($"When '{state.blendVariable}' =", blendTreeEntry.threshold1, 150f, 200f);
                    EditorGUI.BeginDisabledGroup(i == 0);
                    if (GUILayout.Button("\u2191", upDownButtonStyle, upDownButtonOptions))
                    {
                        swapIndex = i;
                    }
                    EditorGUI.EndDisabledGroup();
                }
                EditorGUILayout.EndHorizontal();

                EditorGUILayout.BeginHorizontal();
                {
                    blendTreeEntry.threshold2 = EditorUtilities.FloatField($"When '{state.blendVariable2}' =", blendTreeEntry.threshold2, 150f, 200f);

                    EditorGUI.BeginDisabledGroup(i == state.blendTree.Count - 1);
                    if (GUILayout.Button("\u2193", upDownButtonStyle, upDownButtonOptions))
                    {
                        swapIndex = i + 1;
                    }
                    EditorGUI.EndDisabledGroup();

                    // Remove 2D blend tree entry
                    if (GUILayout.Button("Remove", GUILayout.Width(70f)))
                    {
                        state.blendTree.RemoveAt(i);
                    }
                }
                EditorGUILayout.EndHorizontal();

                if (i != state.blendTree.Count - 1)
                {
                    EditorUtilities.Splitter(width: 350f);
                }
            }

            if (swapIndex != -1)
            {
                markDirty = true;
                state.blendTree.Swap(swapIndex, swapIndex - 1);
            }

            EditorGUI.indentLevel--;

            GUILayout.Space(10f);
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("Add blend tree entry", GUILayout.Width(150f)))
            {
                state.blendTree.Add(new BlendTreeEntry2D());
                markDirty = true;
            }

            GUILayout.FlexibleSpace();
            EditorGUILayout.EndHorizontal();
        }
コード例 #12
0
        private static void Draw1DBlendTree(BlendTree1D state, ref bool markDirty)
        {
            state.blendVariable = EditorUtilities.TextField("Blend with variable", state.blendVariable, 130f);
            EditorGUI.indentLevel++;

            int swapIndex = -1;

            if (state.blendTree == null)
            {
                state.blendTree = new System.Collections.Generic.List <BlendTreeEntry1D>();
            }
            for (var i = 0; i < state.blendTree.Count; i++)
            {
                var blendTreeEntry = state.blendTree[i];

                var whenLabel = $"When '{state.blendVariable}' =";
                var whenLabelRequiredWidth = GUI.skin.label.CalcSize(new GUIContent(whenLabel)).x;

                var remainingAfterClipLabel = Screen.width - 30f - 70f - 25f - 100f;
                var remainingAfterWhenLabel = Screen.width - whenLabelRequiredWidth - 70f - 25f - 100f;

                EditorGUILayout.BeginHorizontal();
                {
                    var oldClip = blendTreeEntry.clip;
                    blendTreeEntry.clip = EditorUtilities.ObjectField("Clip", blendTreeEntry.clip, 30f, remainingAfterClipLabel);
                    if (blendTreeEntry.clip != oldClip)
                    {
                        if (blendTreeEntry.clip != null)
                        {
                            state.OnClipAssigned(blendTreeEntry.clip);
                        }
                        markDirty = true;
                    }

                    EditorGUI.BeginDisabledGroup(i == 0);
                    if (GUILayout.Button("\u2191", upDownButtonStyle, upDownButtonOptions))
                    {
                        swapIndex = i;
                    }
                    EditorGUI.EndDisabledGroup();
                }
                EditorGUILayout.EndHorizontal();

                EditorGUILayout.BeginHorizontal();
                {
                    blendTreeEntry.threshold = EditorUtilities.FloatField(whenLabel, blendTreeEntry.threshold, whenLabelRequiredWidth, remainingAfterWhenLabel);

                    EditorGUI.BeginDisabledGroup(i == state.blendTree.Count - 1);
                    if (GUILayout.Button("\u2193", upDownButtonStyle, upDownButtonOptions))
                    {
                        swapIndex = i + 1;
                    }
                    EditorGUI.EndDisabledGroup();

                    // Remove 1D blend tree entry
                    if (GUILayout.Button("Remove", GUILayout.Width(70f)))
                    {
                        state.blendTree.RemoveAt(i);
                    }
                }
                EditorGUILayout.EndHorizontal();

                if (i != state.blendTree.Count - 1)
                {
                    EditorUtilities.Splitter(width: Screen.width - 100f);
                }
            }

            if (swapIndex != -1)
            {
                markDirty = true;
                state.blendTree.Swap(swapIndex, swapIndex - 1);
            }

            EditorGUI.indentLevel--;

            GUILayout.Space(10f);
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("Add blend tree entry", GUILayout.Width(150f)))
            {
                state.blendTree.Add(new BlendTreeEntry1D());
                markDirty = true;
            }

            GUILayout.FlexibleSpace();
            EditorGUILayout.EndHorizontal();
        }
コード例 #13
0
        private static void DrawStateData(AnimationState state, ref bool updateStateNames)
        {
            const float labelWidth = 55f;

            var old = state.Name;

            state.Name = EditorUtilities.TextField("Name", state.Name, labelWidth);
            if (old != state.Name)
            {
                updateStateNames = true;
            }

            state.speed = EditorUtilities.DoubleField("Speed", state.speed, labelWidth);

            //@TODO: Use pattern matching when C# 7
            var type = state.GetType();

            if (type == typeof(SingleClipState))
            {
                var singleClipState = (SingleClipState)state;
                var oldClip         = singleClipState.clip;
                singleClipState.clip = EditorUtilities.ObjectField("Clip", singleClipState.clip, labelWidth);
                if (singleClipState.clip != null && singleClipState.clip != oldClip)
                {
                    updateStateNames |= singleClipState.OnClipAssigned(singleClipState.clip);
                }
            }
            else if (type == typeof(BlendTree1D))
            {
                var blendTree = (BlendTree1D)state;
                blendTree.blendVariable = EditorUtilities.TextField("Blend with variable", blendTree.blendVariable, 120f);
                EditorGUI.indentLevel++;
                foreach (var blendTreeEntry in blendTree.blendTree)
                {
                    updateStateNames |= DrawBlendTreeEntry(state, blendTreeEntry, blendTree.blendVariable);
                }

                EditorGUI.indentLevel--;

                GUILayout.Space(10f);
                EditorGUILayout.BeginHorizontal();
                if (GUILayout.Button("Add blend tree entry", GUILayout.Width(150f)))
                {
                    blendTree.blendTree.Add(new BlendTreeEntry1D());
                }
                GUILayout.FlexibleSpace();
                EditorGUILayout.EndHorizontal();
            }

            else if (type == typeof(BlendTree2D))
            {
                var blendTree2D = (BlendTree2D)state;
                blendTree2D.blendVariable  = EditorUtilities.TextField("First blend variable", blendTree2D.blendVariable, 120f);
                blendTree2D.blendVariable2 = EditorUtilities.TextField("Second blend variable", blendTree2D.blendVariable2, 120f);
                EditorGUI.indentLevel++;
                foreach (var blendTreeEntry in blendTree2D.blendTree)
                {
                    updateStateNames |= DrawBlendTreeEntry(state, blendTreeEntry, blendTree2D.blendVariable, blendTree2D.blendVariable2);
                }

                EditorGUI.indentLevel--;

                GUILayout.Space(10f);
                EditorGUILayout.BeginHorizontal();
                if (GUILayout.Button("Add blend tree entry", GUILayout.Width(150f)))
                {
                    blendTree2D.blendTree.Add(new BlendTreeEntry2D());
                }
                GUILayout.FlexibleSpace();
                EditorGUILayout.EndHorizontal();
            }
            else
            {
                EditorGUILayout.LabelField($"Unknown animation state type: {type.Name}");
            }
        }