AnimationStateOperator.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 <unordered_map>
#include <list>
#include <Atoms/Graph/Operators/StateMachineBaseNodeOperator.h>
#include <mutex>
 
namespace Atoms
{
    
    class ATOMS_EXPORT AnimationStateOperator : public StateMachineBaseNodeOperator
    {
    public: 
 
        class MotionType
        {
        public:
            MotionType() :
                currentRandomClip(0),
                allRandom(false)
            {}
            
            std::vector<unsigned int> clips;
            int currentRandomClip;
            bool allRandom;
        };
 
        class SubState
        {
        public:
            SubState() : offset(0.0), hash(-1), isTurning(false), transitionStarted(false), bypass(false) {}
            std::vector<unsigned> ids;
            double offset;
            int hash;
            bool isTurning;
            bool transitionStarted;
            bool bypass;
        };
 
        class AdditiveClipData
        {
        public:
            AdditiveClipData() :
                clipPtr(nullptr),
                start(0.0),
                end(0.0),
                frame(0.0),
                fps(30.0),
                hasLoop(false),
                timePort1(nullptr),
                timePort2(nullptr)
            {}
 
            AnimationClipPtr clipPtr;
            double start;
            double end;
            //double blend;
            double frame;
            double fps;
            bool hasLoop;
 
            AtomsGraph::DoublePort* timePort1;
            AtomsGraph::DoublePort* timePort2;
            AtomsGraph::LongPort* frameOffsetPort1;
            AtomsGraph::LongPort* frameOffsetPort2;
        };
 
        class ClipData
        {
        public:
            ClipData() :
                clipPtr(nullptr),
                tag(""),
                start(0.0),
                end(0.0),
                //blend(0.0),
                frame(0.0),
                weight(0.0),
                fps(30.0),
                framesBlendInOffset(0),
                resetTime(0.0),
                mergeType(0),
                motionType(0),
                angle(0.0),
                blendAngle(0.0),
                maxTurnAngle(0.0),
                previousAngle(0.0),
                randomWeight(1.0),
                numBlendFrames(1),
                hasLoop(false),
                synced(false),
                useClipDirection(false),
                timePort(nullptr),
                weightPort(nullptr),
                activePort(nullptr),
                frameOffsetPort(nullptr)
            {}
 
            AnimationClipPtr clipPtr;
            std::string tag;
            double start;
            double end;
            //double blend;
            double frame;
            double weight;
            double fps;
            double framesBlendInOffset;
            double resetTime;
            unsigned int mergeType;
            unsigned int motionType;
            double angle;
            double blendAngle;
            double maxTurnAngle;
            double previousAngle;
            double randomWeight;
            unsigned int numBlendFrames;
            bool hasLoop;
            bool synced;
            bool useClipDirection;
 
            AtomsGraph::DoublePort* timePort;
            AtomsGraph::DoublePort* weightPort;
            AtomsGraph::BooleanPort* activePort;
            AtomsGraph::LongPort* frameOffsetPort;
        };
 
        NODE_STANDARD_MEMBERS
 
        AnimationStateOperator();
 
        virtual ~AnimationStateOperator();
 
        bool    compute(const AtomsGraph::ComputeData* computeData);
 
        void reset();
 
        void updateTurningData(
            AtomsCore::Vector3& direction,
            AtomsCore::Vector3& upDirVec,
            AtomsCore::Vector3& projDir,
            AtomsCore::Vector3& agentTurnAngle,
            bool behave3d, 
            bool isFirst);
 
        void initializeFirstFrame(
            AtomsCore::Vector3& direction,
            AtomsCore::Vector3& upDirVec,
            AtomsCore::Vector3& projDir);
 
        void advanceSingleClip(double timeStep, double frameStep, bool randomClip = false);
 
        int pickNewRandomClipId(AnimationStateOperator::MotionType& motionType);
 
        double getMergeWeight(const AnimationStateOperator::ClipData& clipData);
 
        double updateTurnWeights(MotionType& motionType, double turnAngled, double& straight_weight, double maxWeight);
 
        void computeTurnWeights(double maxWeight);
 
        std::pair<int, int> getUnsyncedClipId();
 
        int getUnsyncedClip(MotionType& motionData, double turnAngled);
 
        void buildNetwork(const AtomsPtr<Atoms::StateMachine>& stateMachine, const Atoms::AnimationState &state, std::map<std::string, std::string>& clipToAgentTypeNames, std::mutex& mutex, const double starFrame, AtomsCore::Rand32* idRandom);
 
        bool isReadyToTransition(double frameRate = 1.0, bool checkTransitionFrames = true, bool checkForceTransition = true);
        double computeBlendInOffset(double frameRate, bool checkTransitionFrames = true);
        void computeBlendInOffsetInPlace(double frameRate, bool checkTransitionFrames = true);
        double getBlendInOffset();
        double getBlendInOffset(int clipId);
        void prepareForBlendIn(double offset, double timeStep);
        void prepareClipForBlendIn(int clipId, double offset);
        int getActiveClipId();
        bool isBlendInStage(double offset, unsigned int blend);
        bool isBlendInStage(int clipId, double offset, unsigned int blend);
        bool isBlendOutStage(double& frameDifference, unsigned int blend);
        double computeBlendInWeight(double offset, unsigned int blend);
        double computeBlendInWeight(int clipId, double offset, unsigned int blend);
        double computeBlendOutWeight(unsigned int blend);
        double computeBlendOutWeight(int clipId, unsigned int blend);
        void setUpBlendOutFrame(double offset, double timeStep);
        bool isBlendOutFinished(unsigned int blend);
        void setClipFrameAndWeights();
        void initSubState(double frame);
 
        bool hasClips() { return m_clips.size() > 0; };
 
    protected:
 
        std::vector<double> m_frames;
 
        std::vector<MotionType> m_motionInfo;
 
        std::vector<ClipData> m_clips;
 
        std::vector<AdditiveClipData> m_additiveClips;
 
        std::vector<std::string> m_clipNames;
 
        std::list<SubState> m_subStateQueue;    
 
        AtomsCore::Rand32* m_idRandom;      
    
        AtomsCore::Vector3 m_previousDirection;
        AtomsCore::Vector3 m_cacheUpVector;
        AtomsCore::Vector3 m_cacheDirectionVector;
 
        AtomsCore::Vector3 m_turnAngle;
        AtomsCore::Vector3 m_prevTurnAngle;
        AtomsCore::Vector3 m_maxTurnAngle;
        
        double m_previousTime;
        
        int m_currentState;
 
        unsigned int m_postRandClipId;
        
    
        bool m_transitionStarted;
        bool m_skipCycle;
        bool m_randomLoop;
        bool m_needLockDirectionForTurning;
 
    };
}