RagdollOperator.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.
// ===========================================================================
#ifndef ATOMS_UNREAL
#include <AtomsGraph/Ports.h>
 
#include <Atoms/Globals.h>
#include <Atoms/Graph/Operator.h>
#include <AtomsCore/Joint.h>
#include <AtomsUtils/Utils.h>
#include <Atoms/Physx/RigidBodyConstraint.h>
#include <Atoms/HeightField.h>
 
namespace Atoms
{
    class AtomsPhysx;
    class RigidBody;
    class RigidBodyConstraint;
 
    class ATOMS_EXPORT RagdollOperator : public Operator
    {
    public:
 
        enum Mode
        {
            kNone = 0,
            kStatic,
            kKinematic,
            kRagdoll,
            kPartialRagdoll,
            kMotorRagdoll,
            kPartialMotorRagdoll
        };
 
        class ConstraintData
        {
        public:
            ConstraintData() : constraint(nullptr) {}
            RigidBodyConstraint* constraint;
            AtomsCore::Matrix matrix;
            AtomsCore::Matrix drivePose;
            RigidBodyConstraintAttributes::Drive drives[6];
        };
 
        class JointData
        {
        public:
            JointData(): 
                rigidBody(nullptr),
                scale(1.0, 1.0, 1.0)
            {
            }
            RigidBody* rigidBody;
            AtomsCore::Matrix jointOffset;
            AtomsCore::Matrix jointOffsetInverse;
            std::map<size_t, ConstraintData> constraints;
            AtomsCore::Vector3 scale;
        };
 
        NODE_STANDARD_MEMBERS
 
            RagdollOperator();
 
        virtual ~RagdollOperator();
 
        bool compute(const AtomsGraph::ComputeData* computeData);
 
        void updateDynamics();
 
        void reset();
 
        inline void setPhysics(AtomsPhysx* physx) { m_physx = physx; }
 
        inline const std::map<size_t, JointData>& rbs() const { return m_rbs; }
        inline std::map<size_t, JointData>& rbs() { return m_rbs; }
 
        inline void setRagdollSetup(const std::string& value) { m_ragdollSetup = value; }
 
        inline void setPartialRagdollFilter(const std::string& value)
        { 
            auto clearString = AtomsUtils::eraseFromString(value, ' ');
            AtomsUtils::splitString(clearString, ',', m_partialRagdollFilter);
        }
 
        inline void setDynamicOnCollision(int value) { m_dynamicOnCollision = value; }
 
        inline void setCollisionForceThreshold(double value) { m_collisionForceThreshold = value; }
 
        inline void setMotorRagdollDamping(double value) { m_motorRagdollDamping = value; }
 
        inline void setMotorRagdollStiffness(double value) { m_motorRagdollStiffness = value; }
 
        inline void setBreakable(int value) { m_breakable = value; }
 
        inline void setBreakableFilter(const std::string& value) 
        { 
            auto clearString = AtomsUtils::eraseFromString(value, ' ');
            AtomsUtils::splitString(clearString, ',', m_breakableFilter);
        }
 
        inline void setAnimationBlending(double value) { m_animationBlending = value; }
 
        inline void setStuckOnCollision(bool value) { m_stuckOnCollision = value; }
 
        inline void setPartialRagdollSkipChildren(bool value) { m_partialRagdollSkipChildren = value; }
 
        inline void setMotorRagdollAcceleration(short value) { m_motorRagdollAcceleration = value; }
 
        inline void setMotorRagdollMaxForce(double value) { m_motorRagdollMaxForce = value; }
 
        inline void setBreakForce(const AtomsCore::Vector2& value) { m_breakForce = value; }
 
        inline void setSelfCollision(bool value) { m_selfCollision = value; }
 
        inline void setMode(short value) { m_mode = value; }
        
        void updateKinematic(double value);
 
        void setDynamicSwitchOnChildren(const AtomsCore::Joint* joint);
 
        inline void setHeightField(const std::string& value) { m_heightField = value; }
        
        inline void setGravityField(const std::string& value) { m_gravityField = value; }
 
        inline void setStuckOnCollisionBreakForce(const AtomsCore::Vector2& value) { m_stuckOnCollisionBreakForce = value; }
 
        inline const std::vector<size_t>& rbsOrder() const { return m_rbsOrder; }
 
        inline void setDynamicOnCollisionFilter(const std::string& value)
        {
            auto clearString = AtomsUtils::eraseFromString(value, ' ');
            AtomsUtils::splitString(clearString, ',', m_dynamicOnCollisionFilter);
        }
 
        inline void setStuckOnCollisionImpulse(double value) { m_stuckOnCollisionImpulse = value; }
 
        inline void setCollisionPool(int value) { m_collisionPool = value; }
 
        inline void setDynamicOnCollisionPool(int value) { m_dynamicOnCollisionPool = value; }
 
        inline void setStuckOnCollisionPool(int value) { m_stuckOnCollisionPool = value; }
 
        inline void setAddContactData(bool value) { m_addContactData = value; }
 
    private:
 
        AtomsGraph::PosePort* m_inPose;
 
        AtomsPhysx* m_physx;
 
        bool m_init;
 
        std::map<size_t, JointData> m_rbs;
 
        std::vector<size_t> m_rbsOrder;
 
        AtomsCore::Pose pose;
 
        short m_prevMode;
 
        short m_mode;
 
        short m_currentMode;
 
        std::string m_ragdollSetup;
 
        std::vector<std::string> m_partialRagdollFilter;
 
        std::map<size_t, size_t> m_partialRagdollSetup;
 
        int m_dynamicOnCollision;
 
        std::vector<std::string> m_dynamicOnCollisionFilter;
 
        double m_collisionForceThreshold;
 
        double m_motorRagdollDamping;
 
        double m_motorRagdollStiffness;
 
        short m_motorRagdollAcceleration;
 
        double m_motorRagdollMaxForce;
 
        AtomsCore::Vector2 m_breakForce;
 
        int m_breakable;
 
        std::vector<std::string> m_breakableFilter;
 
        double m_animationBlending;
 
        bool m_stuckOnCollision;
 
        double m_stuckOnCollisionImpulse;
 
        AtomsCore::Vector2 m_stuckOnCollisionBreakForce;
 
        bool m_partialRagdollSkipChildren;
 
        bool m_inRestPose;
 
        bool m_selfCollision;
 
        std::string m_heightField;
 
        std::string m_gravityField;
 
        Atoms::HeightField* hfPtr;
        Atoms::HeightField* gfPtr;
 
        int m_collisionPool;
 
        int m_dynamicOnCollisionPool;
 
        int m_stuckOnCollisionPool;
 
        bool m_addContactData;
    };
}
#endif