BlendSpaceOperator.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/Operators/StateMachineBaseNodeOperator.h>
#include <Atoms/Graph/Operators/ClipReaderOperator.h>
#include <Atoms/AnimationClip.h>
#include <Atoms/Graph/AgentBehaviourNetwork.h>
#include <Atoms/Locomotion.h>
 
#include <deque>
 
namespace Atoms
{
 
    class ATOMS_EXPORT BlendSpaceOperator : public StateMachineBaseNodeOperator
    {
    public:
 
        enum WaitingState
        {
            kNone = 0,
            kIn,
            kOut,
            kWaitingForIn,
            kWaitingForOut
        };
 
        struct OutputData
        {
            AtomsGraph::DoublePort* frameRatePort;
            AtomsGraph::DoublePort* timePort;
            AtomsGraph::DoublePort* weightPort;
            AtomsGraph::BooleanPort* activePort;
            Atoms::ClipReaderOperator* clipReaderOp;
            AnimationClipPtr clip;
            AtomsMath::Vector2 position;
            double time;
            double length;
            double fps;
            int start;
            int end;
            bool active;
            bool hasLoop;
            bool unsynced;
            int blendIn;
            int blendOut;
            int waitFrames;
            std::string name;
        };
 
        NODE_STANDARD_MEMBERS
 
            BlendSpaceOperator();
 
        virtual ~BlendSpaceOperator();
 
        bool compute(const AtomsGraph::ComputeData* computeData);
 
        void reset();
 
        void resetTime();
 
        inline OutputData& outputPortData(size_t index) { return m_outPortData[index]; }
 
        inline size_t numOutputPorts() const { return m_outPortData.size(); }
 
        void setLocomotionTriangles(const std::vector<AtomsUtils::Triangle2>& triangles) { m_locomotionTriangles = triangles; };
 
        void setSkipTriangles(const std::set<int>& skipTriangles) { m_skipTriangles = skipTriangles; };
 
        inline void setMaxAngularAcceleration(const double value) { m_maxAngularAcceleration = value; };
 
        inline void setMaxLinearAcceleration(const double value) { m_maxLinearAcceleration = value; };
 
        inline void setLinearAverageNumFrames(const int value) { m_linearAverageNumFrames = value; };
 
        inline void setAngularAverageNumFrames(const int value) { m_angularAverageNumFrames = value; };
 
        inline void setForcedUnsyncedClips(const bool value) { m_forceUnsyncedClips = value; };
 
        bool isReadyToTransition(const OutputData& clipData, double frameStep);
 
        // methods from the AnimationStateOperator
        bool isReadyToTransition(double frameRate = 1.0, bool checkTransitionFrames = true, bool checkForceTransition = true);
        void advanceSingleClip(double timeStep, double frameStep, bool randomClip = false);
        double computeBlendInOffset(double frameRate, bool checkTransitionFrames = true);
        void computeBlendInOffsetInPlace(double frameRate, bool checkTransitionFrames = true);
        double getBlendInOffset();
        void prepareForBlendIn(double offset, double timeStep);
        bool isBlendInStage(double offset, unsigned int blend);
        bool isBlendOutStage(double& frameDifference, unsigned int blend);
        double computeBlendInWeight(double offset, unsigned int blend);
        double computeBlendOutWeight(unsigned int blend);
        void setUpBlendOutFrame(double offset, double timeStep);
        bool isBlendOutFinished(unsigned int blend);
        void initSubState(double frame);
        bool hasClips() { return false; };
        void checkAndPlayUnsynced(const int syncedMajorId, const double deltaTime, double& useClipDirection);
 
        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);
 
        void buildNetwork(const Atoms::LocomotionCPtr& loco, const double timeOffset);
 
        WaitingState waitingState() { return m_waitingState; };
        const AtomsCore::Vector2f &currentPosition() { return m_cachedPosition; };
        const AtomsCore::Vector2f &getInputPosition() { return m_inputPosition; };
        const AtomsCore::Vector2f &getUnsyncPosition() { return m_unsyncPosition; };
        const AtomsCore::Vector3f &barycentricCoordinates() { return m_prevBarycentricCoordinates; };
        const AtomsUtils::Triangle2 &currentTriangle() { return m_prevTriangle; };
        const int unsyncedClipId() { return m_unsyncedId; };
        const bool forceUnsyncedClips() { return m_forceUnsyncedClips; };
 
    private:
 
        bool updateInputPosition();
        bool shouldCheckNextUnsyncWaitFrames(const OutputData& clipData, double frameStep, const int waitFrames);
        void setClipWeights(const std::vector<BlendSpaceOperator::OutputData>& datas, const AtomsCore::Vector3f& weights, const AtomsUtils::Triangle2& triangle, const double multiplier = 1.0);
        void cacheBarycentricCoordinatesAndTriangle(const AtomsCore::Vector3f& barycentricCoords, const AtomsUtils::Triangle2& triangle);
        bool computeBarycentricCoordinatesAndTriangle(AtomsMath::Vector3f& barycentricCoords, AtomsUtils::Triangle2& outTriangle, const bool cacheOnly = false);
 
        std::vector<OutputData> m_outPortData;
 
        std::vector<AtomsUtils::Triangle2> m_locomotionTriangles;
        std::set<int> m_skipTriangles;
        
        std::deque<float> m_angularVelocities;
 
        std::deque<float> m_linearVelocities;
 
        AtomsCore::Vector3f m_prevBarycentricCoordinates;
        AtomsCore::Vector3f m_cachedWeights;
        AtomsUtils::Triangle2 m_prevTriangle;
        AtomsUtils::Triangle2 m_cachedTriangle;
 
        AtomsCore::Vector2f m_inputPosition;
        AtomsCore::Vector2f m_cachedPosition;
        AtomsCore::Vector2f m_unsyncPosition;
        
        double m_time;
 
        double m_previousTime;
 
        double m_previousUseClipDirection;
 
        double m_maxAngularAcceleration;
        
        double m_maxLinearAcceleration;
 
        int m_currentUnsyncedStep;
 
        int m_previousUnsyncedMajorId;
 
        int m_currentMajorId;
 
        int m_majorId;
        
        int m_unsyncedId;
 
        int m_nextUnsyncedId;
 
        int m_numWaitFrames;
 
        int m_totNumWaitFrames;
 
        int m_angularAverageNumFrames;
 
        int m_linearAverageNumFrames;
 
        WaitingState m_waitingState;
        
        bool m_forceUnsyncedClips;
 
        bool m_playingUnsynced;
 
    };
}