JoltRagdollComponent.h

#pragma once
 
#include <Core/ResourceManager/ResourceHandle.h>
#include <Core/World/ComponentManager.h>
#include <Foundation/Math/Declarations.h>
#include <JoltPlugin/JoltPluginDLL.h>
 
class plJoltUserData;
class plSkeletonJoint;
class plJoltWorldModule;
class plJoltMaterial;
struct plMsgRetrieveBoneState;
struct plMsgAnimationPoseUpdated;
struct plMsgPhysicsAddImpulse;
struct plMsgPhysicsAddForce;
struct plSkeletonResourceGeometry;
 
namespace JPH
{
  class Ragdoll;
  class RagdollSettings;
  class Shape;
} // namespace JPH
 
using plSkeletonResourceHandle = plTypedResourceHandle<class plSkeletonResource>;
using plSurfaceResourceHandle = plTypedResourceHandle<class plSurfaceResource>;
 
class PL_JOLTPLUGIN_DLL plJoltRagdollComponentManager : public plComponentManager<class plJoltRagdollComponent, plBlockStorageType::FreeList>
{
public:
  plJoltRagdollComponentManager(plWorld* pWorld);
  ~plJoltRagdollComponentManager();
 
  virtual void Initialize() override;
 
private:
  friend class plJoltWorldModule;
  friend class plJoltRagdollComponent;
 
  void Update(const plWorldModule::UpdateContext& context);
};
 
struct plJoltRagdollStartMode
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    WithBindPose,        
    WithNextAnimPose,    
    WithCurrentMeshPose, 
    Default = WithBindPose
  };
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_JOLTPLUGIN_DLL, plJoltRagdollStartMode);
 
 
class PL_JOLTPLUGIN_DLL plJoltRagdollComponent : public plComponent
{
  PL_DECLARE_COMPONENT_TYPE(plJoltRagdollComponent, plComponent, plJoltRagdollComponentManager);
 
  // plComponent
 
public:
  virtual void SerializeComponent(plWorldWriter& inout_stream) const override;
  virtual void DeserializeComponent(plWorldReader& inout_stream) override;
 
protected:
  virtual void OnSimulationStarted() override;
  virtual void OnDeactivated() override;
 
  // plJoltRagdollComponent
 
public:
  plJoltRagdollComponent();
  ~plJoltRagdollComponent();
 
  plUInt32 GetObjectFilterID() const { return m_uiObjectFilterID; } // [ scriptable ]
 
  void SetGravityFactor(float fFactor);                       // [ property ]
  float GetGravityFactor() const { return m_fGravityFactor; } // [ property ]
 
  bool m_bSelfCollision = false; // [ property ]
 
  float m_fStiffnessFactor = 1.0f; // [ property ]
 
  float m_fMass = 50.0f; // [ property ]
 
  void SetStartMode(plEnum<plJoltRagdollStartMode> mode);                     // [ property ]
  plEnum<plJoltRagdollStartMode> GetStartMode() const { return m_StartMode; } // [ property ]
 
  void OnMsgPhysicsAddImpulse(plMsgPhysicsAddImpulse& ref_msg); // [ msg handler ]
 
  void OnMsgPhysicsAddForce(plMsgPhysicsAddForce& ref_msg); // [ msg handler ]
 
  void SetInitialImpulse(const plVec3& vPosition, const plVec3& vDirectionAndStrength); // [ scriptable ]
 
  void AddInitialImpulse(const plVec3& vPosition, const plVec3& vDirectionAndStrength); // [ scriptable ]
 
  float m_fOwnerVelocityScale = 1.0f; // [ property ]
 
  float m_fCenterVelocity = 0.0f; // [ property ]
 
  float m_fCenterAngularVelocity = 0.0f; // [ property ]
 
  plVec3 m_vCenterPosition = plVec3::MakeZero(); // [ property ]
 
  void SetJointTypeOverride(plStringView sJointName, plEnum<plSkeletonJointType> type);
 
  void OnAnimationPoseUpdated(plMsgAnimationPoseUpdated& ref_msg); // [ msg handler ]
  void OnRetrieveBoneState(plMsgRetrieveBoneState& ref_msg) const; // [ msg handler ]
 
protected:
  plEnum<plJoltRagdollStartMode> m_StartMode; // [ property ]
  float m_fGravityFactor = 1.0f;              // [ property ]
 
  struct Limb
  {
    plUInt16 m_uiPartIndex = plInvalidJointIndex;
  };
 
  struct LimbConstructionInfo
  {
    plTransform m_GlobalTransform;
    plUInt16 m_uiJoltPartIndex = plInvalidJointIndex;
  };
 
  void Update(bool bForce);
  plResult EnsureSkeletonIsKnown();
  void CreateLimbsFromBindPose();
  void CreateLimbsFromCurrentMeshPose();
  void DestroyAllLimbs();
  void CreateLimbsFromPose(const plMsgAnimationPoseUpdated& pose);
  bool HasCreatedLimbs() const;
  plTransform GetRagdollRootTransform() const;
  void UpdateOwnerPosition();
  void RetrieveRagdollPose();
  void SendAnimationPoseMsg();
  void ConfigureRagdollPart(void* pRagdollSettingsPart, const plTransform& globalTransform, plUInt8 uiCollisionLayer, plJoltWorldModule& worldModule);
  void CreateAllLimbs(const plSkeletonResource& skeletonResource, const plMsgAnimationPoseUpdated& pose, plJoltWorldModule& worldModule, float fObjectScale);
  void ComputeLimbModelSpaceTransform(plTransform& transform, const plMsgAnimationPoseUpdated& pose, plUInt32 uiPoseJointIndex);
  void ComputeLimbGlobalTransform(plTransform& transform, const plMsgAnimationPoseUpdated& pose, plUInt32 uiPoseJointIndex);
  void CreateLimb(const plSkeletonResource& skeletonResource, plMap<plUInt16, LimbConstructionInfo>& limbConstructionInfos, plArrayPtr<const plSkeletonResourceGeometry*> geometries, const plMsgAnimationPoseUpdated& pose, plJoltWorldModule& worldModule, float fObjectScale);
  JPH::Shape* CreateLimbGeoShape(const LimbConstructionInfo& limbConstructionInfo, const plSkeletonResourceGeometry& geo, const plJoltMaterial* pJoltMaterial, const plQuat& qBoneDirAdjustment, const plTransform& skeletonRootTransform, plTransform& out_shapeTransform, float fObjectScale);
  void CreateAllLimbGeoShapes(const LimbConstructionInfo& limbConstructionInfo, plArrayPtr<const plSkeletonResourceGeometry*> geometries, const plSkeletonJoint& thisLimbJoint, const plSkeletonResource& skeletonResource, float fObjectScale);
  virtual void ApplyPartInitialVelocity();
  void ApplyBodyMass();
  void ApplyInitialImpulse(plJoltWorldModule& worldModule, float fMaxImpulse);
 
  plSkeletonResourceHandle m_hSkeleton;
  plDynamicArray<plMat4> m_CurrentLimbTransforms;
 
  plUInt32 m_uiObjectFilterID = plInvalidIndex;
  plUInt32 m_uiJoltUserDataIndex = plInvalidIndex;
  plJoltUserData* m_pJoltUserData = nullptr;
 
  JPH::Ragdoll* m_pRagdoll = nullptr;
  JPH::RagdollSettings* m_pRagdollSettings = nullptr;
  plDynamicArray<Limb> m_Limbs;
  plTransform m_RootBodyLocalTransform;
  plTime m_ElapsedTimeSinceUpdate = plTime::MakeZero();
 
  plVec3 m_vInitialImpulsePosition = plVec3::MakeZero();
  plVec3 m_vInitialImpulseDirection = plVec3::MakeZero();
  plUInt8 m_uiNumInitialImpulses = 0;
 
  struct JointOverride
  {
    plTempHashedString m_sJointName;
    bool m_bOverrideType = false;
    plEnum<plSkeletonJointType> m_JointType;
  };
 
  plDynamicArray<JointOverride> m_JointOverrides;
 
 
  void SetupLimbJoints(const plSkeletonResource* pSkeleton);
  void CreateLimbJoint(const plSkeletonJoint& thisJoint, void* pParentBodyDesc, void* pThisBodyDesc);
};