JoltCharacterControllerComponent.h

#pragma once
 
#include <Core/World/World.h>
#include <JoltPlugin/JoltPluginDLL.h>
#include <JoltPlugin/System/JoltCollisionFiltering.h>
#include <GameEngine/Physics/CharacterControllerComponent.h>
 
struct plMsgMoveCharacterController;
struct plMsgUpdateLocalBounds;
 
namespace JPH
{
  class CharacterVirtual;
  class TempAllocator;
} // namespace JPH
 
PL_DECLARE_FLAGS(plUInt32, plJoltCharacterDebugFlags, PrintState, VisShape, VisContacts, VisCasts, VisGroundContact, VisFootCheck);
PL_DECLARE_REFLECTABLE_TYPE(PL_JOLTPLUGIN_DLL, plJoltCharacterDebugFlags);
 
class PL_JOLTPLUGIN_DLL plJoltCharacterControllerComponent : public plCharacterControllerComponent
{
  PL_DECLARE_ABSTRACT_COMPONENT_TYPE(plJoltCharacterControllerComponent, plCharacterControllerComponent);
 
  // 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;
 
  // plJoltCharacterControllerComponent
 
public:
  plJoltCharacterControllerComponent();
  ~plJoltCharacterControllerComponent();
 
  struct ContactPoint
  {
    float m_fCastFraction = 0.0f;
    plVec3 m_vPosition;
    plVec3 m_vSurfaceNormal;
    plVec3 m_vContactNormal;
    JPH::BodyID m_BodyID;
    JPH::SubShapeID m_SubShapeID;
  };
 
  void SetObjectToIgnore(plUInt32 uiObjectFilterID);
 
  void ClearObjectToIgnore();
 
public:
  plUInt8 m_uiCollisionLayer = 0; // [ property ]
 
  plUInt8 m_uiPresenceCollisionLayer = 0; // [ property ]
 
  plBitflags<plJoltCharacterDebugFlags> m_DebugFlags; // [ property ]
 
  void SetMaxClimbingSlope(plAngle slope);                           // [ property ]
  plAngle GetMaxClimbingSlope() const { return m_MaxClimbingSlope; } // [ property ]
 
  void SetMass(float fMass);                // [ property ]
  float GetMass() const { return m_fMass; } // [ property ]
 
  void SetStrength(float fStrength);                // [ property ]
  float GetStrength() const { return m_fStrength; } // [ property ]
 
  virtual void RawMove(const plVec3& vMoveDeltaGlobal) override{}; // [ scriptable ]
 
  virtual void MoveCharacter(plMsgMoveCharacterController& msg) override{}; // [ msg handler ]
 
  virtual void TeleportCharacter(const plVec3& vGlobalFootPos) override{}; // [ scriptable ]
 
  virtual bool IsDestinationUnobstructed(const plVec3& vGlobalFootPos, float fCharacterHeight) override { return false; }; // [ scriptable ]
 
  virtual bool IsTouchingGround() override { return true; }; // [ scriptable ]
 
  virtual bool IsCrouching() override { return false; }; // [ scriptable ]
 
private:
  plAngle m_MaxClimbingSlope = plAngle::MakeFromDegree(45); // [ property ]
  float m_fMass = 70.0f;                                    // [ property ]
  float m_fStrength = 500.0f;                               // [ property ]
 
protected:
  PL_ALWAYS_INLINE float GetUpdateTimeDelta() const { return m_fUpdateTimeDelta; }
 
  PL_ALWAYS_INLINE float GetInverseUpdateTimeDelta() const { return m_fInverseUpdateTimeDelta; }
 
  virtual JPH::Ref<JPH::Shape> MakeNextCharacterShape() = 0;
 
  virtual float GetShapeRadius() const = 0;
 
  virtual void UpdateCharacter() = 0;
 
  JPH::CharacterVirtual* GetJoltCharacter() { return m_pCharacter; }
  const JPH::CharacterVirtual* GetJoltCharacter() const { return m_pCharacter; }
 
  plResult TryChangeShape(JPH::Shape* pNewShape);
 
  void RawMoveWithVelocity(const plVec3& vVelocity, float fMaxStairStepUp, float fMaxStepDown);
 
  void RawMoveIntoDirection(const plVec3& vDirection);
 
  void RawMoveToPosition(const plVec3& vTargetPosition);
 
  void TeleportToPosition(const plVec3& vGlobalFootPos);
 
  bool StickToGround(float fMaxDist);
 
  void CollectCastContacts(plDynamicArray<ContactPoint>& out_Contacts, const JPH::Shape* pShape, const plVec3& vQueryPosition, const plQuat& qQueryRotation, const plVec3& vSweepDir) const;
 
  void CollectContacts(plDynamicArray<ContactPoint>& out_Contacts, const JPH::Shape* pShape, const plVec3& vQueryPosition, const plQuat& qQueryRotation, float fCollisionTolerance) const;
 
  plVec3 GetContactVelocityAndPushAway(const ContactPoint& contact, float fPushForce);
 
  void SpawnContactInteraction(const ContactPoint& contact, const plHashedString& sSurfaceInteraction, plSurfaceResourceHandle hFallbackSurface, const plVec3& vInteractionNormal = plVec3(0, 0, 1));
 
  void VisualizeContact(const ContactPoint& contact, const plColor& color) const;
 
  void VisualizeContacts(const plDynamicArray<ContactPoint>& contacts, const plColor& color) const;
 
private:
  friend class plJoltWorldModule;
 
  void Update(plTime deltaTime);
 
  float m_fUpdateTimeDelta = 0.1f;
  float m_fInverseUpdateTimeDelta = 1.0f;
  JPH::CharacterVirtual* m_pCharacter = nullptr;
 
  void CreatePresenceBody();
  void RemovePresenceBody();
  void MovePresenceBody(plTime deltaTime);
 
  plUInt32 m_uiPresenceBodyID = plInvalidIndex;
  plUInt32 m_uiPresenceBodyAddCounter = 0;
 
  plJoltBodyFilter m_BodyFilter;
  plUInt32 m_uiUserDataIndex = plInvalidIndex;
};