private AnimatorState(AssetLayout layout, AssetInfo assetInfo, AnimatorController controller, int stateMachineIndex, int stateIndex, Vector3f position) :
            base(layout)
        {
            AssetInfo       = assetInfo;
            ObjectHideFlags = HideFlags.HideInHierarchy;

            VirtualSerializedFile virtualFile = (VirtualSerializedFile)assetInfo.File;

            IReadOnlyDictionary <uint, string> TOS = controller.TOS;

            if (!TOS.ContainsKey(0))
            {
                Dictionary <uint, string> tos = new Dictionary <uint, string>()
                {
                    { 0, string.Empty }
                };
                tos.AddRange(controller.TOS);
                TOS = tos;
            }
            StateMachineConstant stateMachine = controller.Controller.StateMachineArray[stateMachineIndex].Instance;
            StateConstant        state        = stateMachine.StateConstantArray[stateIndex].Instance;

            Name = TOS[state.NameID];

            Speed       = state.Speed;
            CycleOffset = state.CycleOffset;

            // skip Transitions because not all state exists at this moment

            // exclude StateMachine's behaviours
            int layerIndex = controller.Controller.GetLayerIndexByStateMachineIndex(stateMachineIndex);

            PPtr <MonoBehaviour>[]       machineBehaviours = controller.GetStateBehaviours(layerIndex);
            PPtr <MonoBehaviour>[]       stateBehaviours   = controller.GetStateBehaviours(stateMachineIndex, stateIndex);
            List <PPtr <MonoBehaviour> > behaviours        = new List <PPtr <MonoBehaviour> >(stateBehaviours.Length);

            foreach (PPtr <MonoBehaviour> ptr in stateBehaviours)
            {
#warning TEMP: remove comment when AnimatorStateMachine's child StateMachines has been implemented
                //if (!machineBehaviours.Contains(ptr))
                {
                    behaviours.Add(ptr);
                }
            }
            StateMachineBehaviours = behaviours.ToArray();

            Position                   = position;
            IKOnFeet                   = state.IKOnFeet;
            WriteDefaultValues         = state.GetWriteDefaultValues(controller.File.Version);
            Mirror                     = state.Mirror;
            SpeedParameterActive       = state.SpeedParamID > 0;
            MirrorParameterActive      = state.MirrorParamID > 0;
            CycleOffsetParameterActive = state.CycleOffsetParamID > 0;
            TimeParameterActive        = state.TimeParamID > 0;

            Motion = state.CreateMotion(virtualFile, controller, 0);

            Tag                  = TOS[state.TagID];
            SpeedParameter       = TOS[state.SpeedParamID];
            MirrorParameter      = TOS[state.MirrorParamID];
            CycleOffsetParameter = TOS[state.CycleOffsetParamID];
            TimeParameter        = TOS[state.TimeParamID];
        }
Beispiel #2
0
 public static BlendTree CreateVirtualInstance(VirtualSerializedFile virtualFile, AnimatorController controller, StateConstant state, int nodeIndex)
 {
     return(virtualFile.CreateAsset((assetInfo) => new BlendTree(assetInfo, controller, state, nodeIndex)));
 }
Beispiel #3
0
        private AnimatorStateMachine(AssetInfo assetInfo, AnimatorController controller, int stateMachineIndex) :
            base(assetInfo, HideFlags.HideInHierarchy)
        {
            VirtualSerializedFile virtualFile = (VirtualSerializedFile)assetInfo.File;

            LayerConstant layer = controller.Controller.GetLayerByStateMachineIndex(stateMachineIndex);

            Name = controller.TOS[layer.Binding];

            StateMachineConstant stateMachine = controller.Controller.StateMachineArray[stateMachineIndex].Instance;

            int stateCount        = stateMachine.StateConstantArray.Count;
            int stateMachineCount = 0;
            int count             = stateCount + stateMachineCount;
            int side = (int)Math.Ceiling(Math.Sqrt(count));

            List <AnimatorState> states = new List <AnimatorState>();

            m_childStates = new ChildAnimatorState[stateCount];
            for (int y = 0, stateIndex = 0; y < side && stateIndex < stateCount; y++)
            {
                for (int x = 0; x < side && stateIndex < stateCount; x++, stateIndex++)
                {
                    Vector3f           position   = new Vector3f(x * StateOffset, y * StateOffset, 0.0f);
                    AnimatorState      state      = AnimatorState.CreateVirtualInstance(virtualFile, controller, stateMachineIndex, stateIndex, position);
                    ChildAnimatorState childState = new ChildAnimatorState(state, position);
                    m_childStates[stateIndex] = childState;
                    states.Add(state);
                }
            }
#warning TODO: child StateMachines
            m_childStateMachines = new ChildAnimatorStateMachine[stateMachineCount];

            // set destination state for transitions here because all states has become valid only now
            for (int i = 0; i < stateMachine.StateConstantArray.Count; i++)
            {
                AnimatorState state         = states[i];
                StateConstant stateConstant = stateMachine.StateConstantArray[i].Instance;
                PPtr <AnimatorStateTransition>[] transitions = new PPtr <AnimatorStateTransition> [stateConstant.TransitionConstantArray.Count];
                for (int j = 0; j < stateConstant.TransitionConstantArray.Count; j++)
                {
                    TransitionConstant transitionConstant         = stateConstant.TransitionConstantArray[j].Instance;
                    AnimatorStateTransition.Parameters parameters = new AnimatorStateTransition.Parameters
                    {
                        StateMachine = stateMachine,
                        States       = states,
                        TOS          = controller.TOS,
                        Transition   = transitionConstant,
                        Version      = controller.File.Version,
                    };
                    AnimatorStateTransition transition = AnimatorStateTransition.CreateVirtualInstance(virtualFile, parameters);
                    transitions[j] = transition.File.CreatePPtr(transition);
                }
                state.Transitions = transitions;
            }

            m_anyStateTransitions = new PPtr <AnimatorStateTransition> [stateMachine.AnyStateTransitionConstantArray.Count];
            for (int i = 0; i < stateMachine.AnyStateTransitionConstantArray.Count; i++)
            {
                TransitionConstant transitionConstant         = stateMachine.AnyStateTransitionConstantArray[i].Instance;
                AnimatorStateTransition.Parameters parameters = new AnimatorStateTransition.Parameters
                {
                    StateMachine = stateMachine,
                    States       = states,
                    TOS          = controller.TOS,
                    Transition   = transitionConstant,
                    Version      = controller.File.Version,
                };
                AnimatorStateTransition transition = AnimatorStateTransition.CreateVirtualInstance(virtualFile, parameters);
                m_anyStateTransitions[i] = transition.File.CreatePPtr(transition);
            }

            StateMachineConstant.Parameters stateParameters = new StateMachineConstant.Parameters
            {
                ID      = layer.Binding,
                States  = states,
                TOS     = controller.TOS,
                Version = controller.File.Version,
            };
            m_entryTransitions       = stateMachine.CreateEntryTransitions(virtualFile, stateParameters);
            m_stateMachineBehaviours = Array.Empty <PPtr <MonoBehaviour> >();

            AnyStatePosition           = new Vector3f(0.0f, -StateOffset, 0.0f);
            EntryPosition              = new Vector3f(StateOffset, -StateOffset, 0.0f);
            ExitPosition               = new Vector3f(2.0f * StateOffset, -StateOffset, 0.0f);
            ParentStateMachinePosition = new Vector3f(0.0f, -2.0f * StateOffset, 0.0f);

            DefaultState = ChildStates.Count > 0 ? ChildStates[stateMachine.DefaultState].State : default;
        }
Beispiel #4
0
        public ChildMotion(VirtualSerializedFile file, AnimatorController controller, StateConstant state, int nodeIndex, int childIndex)
        {
            BlendTreeConstant     treeConstant = state.GetBlendTree();
            BlendTreeNodeConstant node         = treeConstant.NodeArray[nodeIndex].Instance;
            int childNodeIndex = (int)node.ChildIndices[childIndex];

            Motion = state.CreateMotion(file, controller, childNodeIndex);

            Threshold   = node.GetThreshold(controller.File.Version, childIndex);
            Position    = default;
            TimeScale   = 1.0f;
            CycleOffset = node.CycleOffset;

            uint directID = node.GetDirectBlendParameter(controller.File.Version, childIndex);

            DirectBlendParameter = controller.TOS[directID];

            Mirror = node.Mirror;
        }
Beispiel #5
0
        public AnimatorStateMachine(VirtualSerializedFile file, AnimatorController controller, int stateMachineIndex) :
            base(file.CreateAssetInfo(ClassIDType.AnimatorStateMachine))
        {
            ObjectHideFlags = 1;

            LayerConstant layer = controller.Controller.GetLayerByStateMachineIndex(stateMachineIndex);

            Name = controller.TOS[layer.Binding];

            StateMachineConstant stateMachine = controller.Controller.StateMachineArray[stateMachineIndex].Instance;

            int stateCount        = stateMachine.StateConstantArray.Count;
            int stateMachineCount = 0;
            int count             = stateCount + stateMachineCount;
            int side = (int)Math.Ceiling(Math.Sqrt(count));

            List <AnimatorState> states = new List <AnimatorState>();

            m_childStates = new ChildAnimatorState[stateCount];
            for (int y = 0, stateIndex = 0; y < side && stateIndex < stateCount; y++)
            {
                for (int x = 0; x < side && stateIndex < stateCount; x++, stateIndex++)
                {
                    Vector3f           position   = new Vector3f(x * StateOffset, y * StateOffset, 0.0f);
                    AnimatorState      state      = new AnimatorState(file, controller, stateMachineIndex, stateIndex, position);
                    ChildAnimatorState childState = new ChildAnimatorState(state, position);
                    m_childStates[stateIndex] = childState;
                    states.Add(state);
                }
            }
            m_childStateMachines = new ChildAnimatorStateMachine[stateMachineCount];

            // set destination state for transitions here because all states has become valid only now
            for (int i = 0; i < stateMachine.StateConstantArray.Count; i++)
            {
                AnimatorState state         = states[i];
                StateConstant stateConstant = stateMachine.StateConstantArray[i].Instance;
                for (int j = 0; j < stateConstant.TransitionConstantArray.Count; j++)
                {
                    long stateTransitionPath                   = state.Transitions[j].PathID;
                    AnimatorStateTransition transition         = (AnimatorStateTransition)file.GetAsset(stateTransitionPath);
                    TransitionConstant      transitionConstant = stateConstant.TransitionConstantArray[j].Instance;
                    if (!transitionConstant.IsExit)
                    {
                        AnimatorState destState = states[transitionConstant.DestinationState];
                        transition.DstState = PPtr <AnimatorState> .CreateVirtualPointer(destState);
                    }
                }
            }

            m_anyStateTransitions = new PPtr <AnimatorStateTransition> [stateMachine.AnyStateTransitionConstantArray.Count];
            for (int i = 0; i < stateMachine.AnyStateTransitionConstantArray.Count; i++)
            {
                TransitionConstant      transitionConstant = stateMachine.AnyStateTransitionConstantArray[i].Instance;
                AnimatorStateTransition transition         = new AnimatorStateTransition(file, controller, transitionConstant, states);
                m_anyStateTransitions[i] = PPtr <AnimatorStateTransition> .CreateVirtualPointer(transition);
            }

            m_entryTransitions       = stateMachine.GetEntryTransitions(file, controller, layer.Binding, states);
            m_stateMachineBehaviours = new PPtr <MonoBehaviour> [0];

            AnyStatePosition           = new Vector3f(0.0f, -StateOffset, 0.0f);
            EntryPosition              = new Vector3f(StateOffset, -StateOffset, 0.0f);
            ExitPosition               = new Vector3f(2.0f * StateOffset, -StateOffset, 0.0f);
            ParentStateMachinePosition = new Vector3f(0.0f, -2.0f * StateOffset, 0.0f);

            DefaultState = ChildStates.Count > 0 ? ChildStates[stateMachine.DefaultState].State : default;

            file.AddAsset(this);
        }
Beispiel #6
0
        private void TryInitialize(ProjectAssetContainer container)
        {
            if (m_initialized)
            {
                return;
            }

            AnimatorController asset      = (AnimatorController)Asset;
            ControllerConstant controller = asset.Controller;
            IReadOnlyList <OffsetPtr <StateMachineConstant> > stateMachinesConst = controller.StateMachineArray;

            m_stateMachines = new AnimatorStateMachine[stateMachinesConst.Count];
            for (int i = 0; i < stateMachinesConst.Count; i++)
            {
                StateMachineConstant stateMachineConstant = stateMachinesConst[i].Instance;
                AnimatorStateMachine stateMachine         = new AnimatorStateMachine(container.VirtualFile, asset, i);
                m_stateMachines[i] = stateMachine;
            }

            for (int i = 0; i < StateMachines.Count; i++)
            {
                AnimatorStateMachine stateMachine         = StateMachines[i];
                StateMachineConstant stateMachineConstant = asset.Controller.StateMachineArray[i].Instance;
                AddAsset(stateMachine);

                foreach (PPtr <AnimatorStateTransition> transitionPtr in stateMachine.AnyStateTransitions)
                {
                    AnimatorStateTransition transition = transitionPtr.GetAsset(container.VirtualFile);
                    AddAsset(transition);
                }
                foreach (PPtr <AnimatorTransition> transitionPtr in stateMachine.EntryTransitions)
                {
                    AnimatorTransition transition = transitionPtr.GetAsset(container.VirtualFile);
                    AddAsset(transition);
                }

                for (int j = 0; j < stateMachine.ChildStates.Count; j++)
                {
                    PPtr <AnimatorState> statePtr      = stateMachine.ChildStates[j].State;
                    AnimatorState        state         = statePtr.GetAsset(container.VirtualFile);
                    StateConstant        stateConstant = stateMachineConstant.StateConstantArray[j].Instance;
                    AddAsset(state);

                    if (state.Motion.IsVirtual)
                    {
                        AddBlendTree(container.VirtualFile, state.Motion.CastTo <BlendTree>());
                    }

                    for (int k = 0; k < state.Transitions.Count; k++)
                    {
                        PPtr <AnimatorStateTransition> transitionPtr      = state.Transitions[k];
                        AnimatorStateTransition        transition         = transitionPtr.GetAsset(container.VirtualFile);
                        TransitionConstant             transitionConstant = stateConstant.TransitionConstantArray[k].Instance;

                        AddAsset(transition);
                    }
                }
            }

            m_initialized = true;
        }
Beispiel #7
0
        private BlendTree(AssetLayout layout, AssetInfo assetInfo, AnimatorController controller, StateConstant state, int nodeIndex) :
            base(layout)
        {
            AssetInfo       = assetInfo;
            ObjectHideFlags = HideFlags.HideInHierarchy;

            VirtualSerializedFile virtualFile = (VirtualSerializedFile)assetInfo.File;
            BlendTreeNodeConstant node        = state.GetBlendTree().NodeArray[nodeIndex].Instance;

            Name = nameof(BlendTree);

            Childs = new ChildMotion[node.ChildIndices.Length];
            for (int i = 0; i < node.ChildIndices.Length; i++)
            {
                Childs[i] = new ChildMotion(virtualFile, controller, state, nodeIndex, i);
            }

            BlendParameter         = node.BlendEventID == uint.MaxValue ? string.Empty : controller.TOS[node.BlendEventID];
            BlendParameterY        = node.BlendEventYID == uint.MaxValue ? string.Empty : controller.TOS[node.BlendEventYID];
            MinThreshold           = node.GetMinThreshold(controller.File.Version);
            MaxThreshold           = node.GetMaxThreshold(controller.File.Version);
            UseAutomaticThresholds = false;
            NormalizedBlendValues  = node.BlendDirectData.Instance.NormalizedBlendValues;
            BlendType = node.BlendType;
        }