StateMachineOperator.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
 
#include <AtomsGraph/Ports.h>
#include <Atoms/Globals.h>
#include <Atoms/Graph/Operator.h>
#include <Atoms/AnimationClip.h>
#include <Atoms/AnimationState.h>
#include <Atoms/StateMachine.h>
#include <Atoms/Graph/AgentBehaviourNetwork.h>
#include <Atoms/Graph/Operators/StateMachineBaseNodeOperator.h>
#include <mutex>
 
namespace Atoms
{
    
    class ATOMS_EXPORT StateMachineOperator : public Operator
    {
    public:
 
        class AnimationStateData
        {
        public:
            AnimationStateData() :
                op(nullptr),
                weightPort(nullptr),
                timePort(nullptr),
                activePort(nullptr),
                weight(0),
                frame(0),
                forceActive(false)
            {}
 
            StateMachineBaseNodeOperator *op;
            AtomsGraph::DoublePort* weightPort;
            AtomsGraph::DoublePort* timePort;
            AtomsGraph::BooleanPort* activePort;
            AtomsGraph::LongPort* frameOffsetPort;
 
            double weight;
            double frame;
            bool forceActive;
        };
 
        class TransitionNoClipData
        {
        public:
            int blendIn;
            int blendOut;
        };
 
        NODE_STANDARD_MEMBERS
 
        StateMachineOperator();
 
        virtual ~StateMachineOperator();
 
        bool    compute(const AtomsGraph::ComputeData* computeData);
 
        void reset();
 
        void setFps(double fps);
 
        void initRandom(int value);
 
        void advanceTime(const AtomsGraph::ComputeData* computeData, const double frameStep, const bool incrementFrame = true);
 
        void linearBlendStates(const std::pair<int, int>& transition,
            int stateIndex,
            double frameStep,
            double timeStep,
            unsigned int blendInTransition,
            const AtomsGraph::ComputeData* computeData);
 
        bool isStateInQueue(int state);
 
        void buildNetwork(const AtomsPtr<Atoms::StateMachine> &stateMachine, std::map<std::string, std::string>& clipToAgentTypeNames, std::mutex& mutex, const double timeOffset, const bool forceUnsyncedClips, const int frameOffset);
 
        AgentBehaviourNetwork& network() { return m_network; };
 
        void advanceSingleState(int stateIndex, double timeStep, double frameStep);
 
        const std::list<unsigned int>& getStateQueue() const { return m_stateQueue; };
 
        const bool isInTransition() const { return m_isInTransition; }
 
    private:
 
        AgentBehaviourNetwork m_network;
 
        AtomsGraph::DoublePort* m_timePort;
 
        AtomsGraph::DoublePort* m_fpsPort;
 
        AtomsGraph::LongPort*   m_statePort;
        
        AtomsGraph::BooleanPort* m_allowPathSearch;
 
        std::map<int, AnimationStateData> m_states;
 
        std::unordered_map<int, int> m_statePortIndex;
 
        std::map<std::pair<int, int>, int> m_transitionPortIndex;
 
        std::map < std::pair<int, int>, TransitionNoClipData> m_transitionNoClipsData;
 
        std::list<unsigned int> m_stateQueue;
 
        AtomsCore::Vector3 m_previousDirection;
 
        AtomsCore::Vector3 m_cacheUpVector;
 
        AtomsCore::Vector3 m_cacheDirectionVector;
 
        AtomsCore::Rand32 m_idRandom;
 
        double m_framesBlendInOffset;
 
        double m_previousTime;
 
        //double m_prevTurnAngle;
 
        int m_currentState;
 
        int m_previousState;
 
        int m_prevFromOneShot;
 
        bool m_first;
 
        bool m_isInTransition;
 
        bool m_transitionStarted;
 
        bool m_transitionIsEnded;
    };
}