StateMachineBaseNodeOperator.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/AgentBehaviourNetwork.h>
#include <mutex>
 
namespace Atoms
{
    
    class ATOMS_EXPORT StateMachineBaseNodeOperator : public Operator
    {
    public: 
 
        StateMachineBaseNodeOperator();
 
        virtual ~StateMachineBaseNodeOperator();
 
        void reset();
        void setFps(double fps);
 
        void setDoNotAdvanceClips(const bool value) { m_doNotAdvanceClips = value; };
 
        AgentBehaviourNetwork& network() { return m_network; };
 
        virtual void resetTime() { m_resetTime = true; };
        virtual bool isReadyToTransition(double frameRate = 1.0, bool checkTransitionFrames = true, bool checkForceTransition = true) = 0;
        virtual void advanceSingleClip(double timeStep, double frameStep, bool randomClip = false) = 0;
        virtual double computeBlendInOffset(double frameRate, bool checkTransitionFrames = true) = 0;
        virtual void computeBlendInOffsetInPlace(double frameRate, bool checkTransitionFrames = true) = 0;
        virtual double getBlendInOffset() = 0;
        virtual void prepareForBlendIn(double offset, double timeStep) = 0;
        virtual bool isBlendInStage(double offset, unsigned int blend) = 0;
        virtual bool isBlendOutStage(double& frameDifference, unsigned int blend) = 0;
        virtual double computeBlendInWeight(double offset, unsigned int blend) = 0;
        virtual double computeBlendOutWeight(unsigned int blend) = 0;
        virtual void setUpBlendOutFrame(double offset, double timeStep) = 0;
        virtual bool isBlendOutFinished(unsigned int blend) = 0;
        virtual void initSubState(double frame) = 0;
        virtual bool hasClips() = 0;
 
        virtual void buildNetwork(const AtomsPtr<Atoms::StateMachine>& stateMachine, const Atoms::AnimationState& state, std::map<std::string, std::string>& clipToAgentTypeNames, std::mutex& mutex, const double timeOffset, AtomsCore::Rand32* idRandom) = 0;
 
        unsigned int blendIn() { return m_blendIn; };
        unsigned int blendOut() { return m_blendOut; };
        bool isOneShot() { return m_oneShot; };
        bool needLockDirectionForTurning() { return m_needLockDirectionForTurning; };
 
    protected: 
 
        AgentBehaviourNetwork m_network;
 
        AtomsGraph::DoublePort* m_timePort;
 
        AtomsGraph::DoublePort* m_fpsPort;
 
        AtomsGraph::LongPort* m_frameOffset;
 
        unsigned int m_blendIn;
        unsigned int m_blendOut;
 
        bool m_doNotAdvanceClips;
        bool m_needLockDirectionForTurning;
        bool m_oneShot;
        bool m_resetTime;
        bool m_first;
 
    };
}