ClipReaderOperator.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/AnimationClipLooper.h>
#include <AtomsCore/Metadata/Vector3Metadata.h>
#include <AtomsCore/JointChain.h>
#include <Atoms/AgentType.h>
 
namespace Atoms
{
    class ATOMS_EXPORT ClipReaderOperator : public Operator
    {
    public:
 
        struct BindData
        {
            AtomsCore::Matrix rotation;
            AtomsCore::Matrix matrix;
            AtomsCore::Matrix inverseMatrix;
        };
 
        NODE_STANDARD_MEMBERS
 
        ClipReaderOperator();
        
        virtual ~ClipReaderOperator();
        
        bool    compute(const AtomsGraph::ComputeData* computeData);
 
        void reset();
 
        void setupDefaultPose();
 
        void fillSkeletonClipIdMap(AnimationClipCPtr& clip, const AtomsCore::Skeleton& skeleton);
 
        double setPoseFromLooper(AnimationClipCPtr& clip, const AtomsCore::Skeleton& skeleton, AtomsCore::Pose& pose, double time, bool isAtomsClip, bool isParentSpace, const AtomsCore::SkeletonLod* skeletonLod, const long frameOffset);
        void setPoseFromClip(AnimationClipCPtr& clip, const AtomsCore::Skeleton& skeleton, AtomsCore::Pose& pose, int clampedFrame, double weight, bool isAtomsClip, bool isParentSpace, const AtomsCore::SkeletonLod* skeletonLod);
        
        AtomsCore::Vector3 getPelvisVelocityFromClip(AnimationClipCPtr& clip, const AtomsCore::Skeleton& skeleton, AtomsCore::Pose& pose, int frame, double reminder, const AtomsCore::SkeletonLod* skeletonLod, const int newFrame, const double newReminder);
        AtomsCore::Vector3 getPelvisVelocityFromLooper(AnimationClipCPtr& clip, const AtomsCore::Skeleton& skeleton, AtomsCore::Pose& pose, int frame, double reminder, const AtomsCore::SkeletonLod* skeletonLod, const int newFrame, const double newReminder, const long frameOffset);
 
        AtomsCore::Vector3 getDirectionAtFrame(AtomsCore::Poser& poser, AnimationClipCPtr& clip, const AtomsCore::Skeleton& skeleton, AtomsCore::Pose& pose, const AtomsCore::Vector3& velocity, const unsigned int frame, const unsigned int nextFrame, const double reminder, const int rootPelvisIndex);
 
        void removeFootLock(const AtomsCore::Skeleton& skeleton, AtomsCore::Pose& pose);
        void scaleMetadata(const AtomsCore::Skeleton& skeleton, AtomsCore::Pose& pose, double agentScale, double retargetingFactor);
        void scaleDetachedJoints(const AtomsCore::Skeleton& skeleton, AtomsCore::Pose& pose, double agentScale, double retargetingFactor);
        void setLocalDirectionAndVelocity(AtomsCore::Poser& poser,
            AnimationClipCPtr& clip,
            const AtomsCore::Skeleton& skeleton,
            AtomsCore::Pose& pose,
            const AtomsCore::Vector3& velocity,
            double retargetingFactor,
            bool syncede,
            const AtomsCore::Vector3 &rootOffset,
            double clipFrame,
            double startTime,
            double endTime,
            const long frameOffset);
 
 
        bool getPoleVector(
            bool useBind,
            const AtomsCore::JointChain* chain,
            const std::vector<AtomsCore::Vector3>& allPositions,
            const AtomsCore::Vector3 &startPos,
            const AtomsCore::Vector3 &endPos,
            AtomsCore::Vector3 &midPos,
            AtomsCore::Vector3 &poleVector,
            double threshold = 0.9999);
 
        AtomsCore::Vector3 getTargetPoint(
            const AtomsCore::Vector3 sStartPos,
            const AtomsCore::Vector3 sEndPos,
            const AtomsCore::Vector3 tStartPos,
            const AtomsCore::Vector3 offset,
            double factor);
 
        void resetJointPoses(const AtomsCore::Skeleton& skeleton, AtomsCore::Pose& pose);
 
        void refreshTargetMatrix(
            const AtomsCore::Skeleton& tSkeleton,
            AtomsCore::Pose& tPose,
            unsigned short jointId);
 
        void computeRetarget(
            const Atoms::AgentTypeCPtr tAgentType,
            const Atoms::AgentTypeCPtr sAgentType,
            const AtomsCore::Skeleton& tSkeleton,
            const AtomsCore::Skeleton& sSkeleton,
            AtomsCore::Pose& tPose,
            AtomsCore::Pose& sPose,
            std::map<unsigned short, AtomsCore::MapMetadata> &sMetadata,
            const double agentScale);
 
        inline void useLocomotion(bool value) { m_isLocomotion = value; }
 
        void setTimeAndPreviousTime(double time, double prevTime);
 
        void resetPreviousDirection() { m_resetPreviousDirection = true; }
 
    private:
 
        double getIkBlend(
            const AtomsCore::JointChain* sChain,
            std::map<unsigned short, AtomsCore::MapMetadata>& sMetadata
        );
 
        AtomsMath::Vector3 computeIkBlendRelativeTarget(
            const AtomsCore::JointChain* tChain,
            const AtomsCore::JointChain* sChain,
            const double agentScale,
            const AtomsMath::Vector3& agentPlaneNormal
        );
 
        AtomsMath::Vector3 computeIkBlendRelativeTarget(
            const Atoms::AgentType::RetargetJointChainData& retarget,
            const Atoms::AgentTypeCPtr tAgentType,
            const Atoms::AgentTypeCPtr sAgentType,
            AtomsCore::Pose& tPose,
            const AtomsMath::Vector3& agentPlaneNormal,
            const AtomsCore::Vector3& sStartPos,
            const AtomsCore::Vector3& sEndPos,
            const AtomsCore::Vector3& tStartPos,
            const double agentScale
        );
 
        AtomsMath::Vector3 computeTargetPos(
            std::map<unsigned short, AtomsCore::MapMetadata>& sMetadata,
            const Atoms::AgentType::RetargetJointChainData& retarget,
            const Atoms::AgentTypeCPtr tAgentType,
            const Atoms::AgentTypeCPtr sAgentType,
            AtomsCore::Pose& tPose,
            const AtomsMath::Vector3& agentPlaneNormal,
            const AtomsCore::Vector3& sStartPos,
            const AtomsCore::Vector3& sEndPos,
            const AtomsCore::Vector3& tStartPos,
            const double agentScale);
 
        void computeThreeJointChain(
            const Atoms::AgentType::RetargetJointChainData& retarget,
            const Atoms::AgentTypeCPtr tAgentType,
            const Atoms::AgentTypeCPtr sAgentType,
            AtomsCore::Pose& tPose,
            const AtomsMath::Vector3& targetPos,
            const AtomsCore::Vector3& sStartPos,
            const AtomsCore::Vector3& sEndPos,
            const AtomsCore::Vector3& tStartPos,
            const double agentScale,
            const std::pair<AtomsMath::Vector3, AtomsMath::Vector3>& localPoleVector);
 
        void computeFARBIKChain(
            const Atoms::AgentType::RetargetJointChainData& retarget,
            const Atoms::AgentTypeCPtr tAgentType,
            const Atoms::AgentTypeCPtr sAgentType,
            AtomsCore::Pose& tPose,
            const AtomsMath::Vector3& targetPos,
            const AtomsCore::Vector3& sStartPos,
            const AtomsCore::Vector3& sEndPos,
            const AtomsCore::Vector3& tStartPos);
 
        AtomsCore::Matrix getClipJointMatrix(AnimationClipCPtr& clip,
            const AtomsCore::Skeleton& skeleton,
            int clampedFrame, double weight,
            AtomsCore::JointCPtr pelvisJoint);
 
    private:
 
        AtomsCore::Vector3 m_prevDirection;
 
        AtomsGraph::StringPort* m_clipNamePort;
 
        AtomsGraph::DoublePort* m_timePort;
 
        AtomsGraph::DoublePort* m_startFramePort;
 
        AtomsGraph::DoublePort* m_endFramePort;
 
        AtomsGraph::DoublePort* m_frameRate;
 
        AtomsGraph::DoublePort* m_outframePort;
 
        AtomsGraph::BooleanPort* m_overrideSimDirectionPort;
 
        AtomsGraph::BooleanPort* m_disableDirectionBlendingPort;
 
        AtomsGraph::DoublePort* m_overrideSimDirectionMaxTurnAnglePort;
 
        AtomsGraph::LongPort* m_frameOffset;
 
        Atoms::AnimationClipLooper *m_clipLooper;
 
        unsigned int m_currentLoop;
 
        std::vector<int> m_skeletonClipJointId;
 
        std::vector<BindData> m_bindData;
 
        std::string frameRateOverrideName;
 
        AnimationClipCPtr m_clip;
 
        double m_retargetingFactor;
        double m_retargetingIKFactor;
        
        Atoms::AgentTypeCPtr m_agentTypeCPtr;
 
        AtomsCore::Pose m_sourcePose;
 
        std::map<std::string, AtomsCore::Vector3> m_poleVectorInBindMap;
 
        std::vector<AtomsCore::Matrix> m_sAllMatrix;
        std::vector<AtomsCore::Matrix> m_tAllMatrix;
        std::vector<AtomsCore::Vector3> m_sAllPositions;
        std::vector<AtomsCore::Vector3> m_tAllPositions;
        std::vector<bool> m_tAllMatrixDirty;
        std::vector<std::pair<AtomsMath::Vector3, AtomsMath::Vector3>> m_localPoleVectors;
        AtomsCore::Quaternion rotationOffset;
 
        double m_prevTime;
 
        double m_agentTypeScaleMultiplier;
 
        bool m_isAtomsClip;
        bool m_isLoop;
        bool m_first;
        bool m_retarget;
        bool m_isParentSpace;
        bool m_isLocomotion;
        bool m_loopBlending;
        bool m_resetPreviousDirection;
    };
}