PhysicsWorldModule.h

#pragma once
 
#include <Core/Messages/EventMessage.h>
#include <Core/ResourceManager/ResourceHandle.h>
#include <Core/World/WorldModule.h>
#include <Foundation/Communication/Message.h>
 
struct plGameObjectHandle;
struct plSkeletonResourceDescriptor;
 
using plSurfaceResourceHandle = plTypedResourceHandle<class plSurfaceResource>;
 
enum class plPhysicsHitType : int8_t
{
  Undefined = -1,        
  TriangleFrontFace = 0, 
  TriangleBackFace = 1,  
};
 
struct plPhysicsCastResult
{
  plVec3 m_vPosition;
  plVec3 m_vNormal;
  float m_fDistance;
 
  plGameObjectHandle m_hShapeObject;                        
  plGameObjectHandle m_hActorObject;                        
  plSurfaceResourceHandle m_hSurface;                       
  plUInt32 m_uiObjectFilterID = plInvalidIndex;             
  plPhysicsHitType m_hitType = plPhysicsHitType::Undefined; 
 
  // Physics-engine specific information, may be available or not.
  void* m_pInternalPhysicsShape = nullptr;
  void* m_pInternalPhysicsActor = nullptr;
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plPhysicsCastResult);
 
 
struct plPhysicsCastResultArray
{
  plHybridArray<plPhysicsCastResult, 16> m_Results;
};
 
struct plPhysicsOverlapResult
{
  PL_DECLARE_POD_TYPE();
 
  plGameObjectHandle m_hShapeObject;            
  plGameObjectHandle m_hActorObject;            
  plUInt32 m_uiObjectFilterID = plInvalidIndex; 
  plVec3 m_vCenterPosition;                     
 
  // Physics-engine specific information, may be available or not.
  void* m_pInternalPhysicsShape = nullptr;
  void* m_pInternalPhysicsActor = nullptr;
};
 
struct plPhysicsOverlapResultArray
{
  plHybridArray<plPhysicsOverlapResult, 16> m_Results;
};
 
PL_DECLARE_FLAGS_WITH_DEFAULT(plUInt32, plPhysicsShapeType, 0xFFFFFFFF,
  Static,    
  Dynamic,   
  Query,     
  Trigger,   
  Character, 
  Ragdoll,   
  Rope,      
  Cloth      
);
 
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plPhysicsShapeType);
 
struct plPhysicsQueryParameters
{
  plPhysicsQueryParameters() = default;
  explicit plPhysicsQueryParameters(plUInt32 uiCollisionLayer,
    plBitflags<plPhysicsShapeType> shapeTypes = plPhysicsShapeType::Default, plUInt32 uiIgnoreObjectFilterID = plInvalidIndex)
    : m_uiCollisionLayer(uiCollisionLayer)
    , m_ShapeTypes(shapeTypes)
    , m_uiIgnoreObjectFilterID(uiIgnoreObjectFilterID)
  {
  }
 
  plUInt32 m_uiCollisionLayer = 0;
  plBitflags<plPhysicsShapeType> m_ShapeTypes = plPhysicsShapeType::Default;
  plUInt32 m_uiIgnoreObjectFilterID = plInvalidIndex;
  bool m_bIgnoreInitialOverlap = false;
};
 
enum class plPhysicsHitCollection
{
  Closest,
  Any
};
 
class PL_CORE_DLL plPhysicsWorldModuleInterface : public plWorldModule
{
  PL_ADD_DYNAMIC_REFLECTION(plPhysicsWorldModuleInterface, plWorldModule);
 
protected:
  plPhysicsWorldModuleInterface(plWorld* pWorld)
    : plWorldModule(pWorld)
  {
  }
 
public:
  virtual plUInt32 GetCollisionLayerByName(plStringView sName) const = 0;
 
  virtual bool Raycast(plPhysicsCastResult& out_result, const plVec3& vStart, const plVec3& vDir, float fDistance, const plPhysicsQueryParameters& params, plPhysicsHitCollection collection = plPhysicsHitCollection::Closest) const = 0;
 
  virtual bool RaycastAll(plPhysicsCastResultArray& out_results, const plVec3& vStart, const plVec3& vDir, float fDistance, const plPhysicsQueryParameters& params) const = 0;
 
  virtual bool SweepTestSphere(plPhysicsCastResult& out_result, float fSphereRadius, const plVec3& vStart, const plVec3& vDir, float fDistance, const plPhysicsQueryParameters& params, plPhysicsHitCollection collection = plPhysicsHitCollection::Closest) const = 0;
 
  virtual bool SweepTestBox(plPhysicsCastResult& out_result, plVec3 vBoxExtends, const plTransform& transform, const plVec3& vDir, float fDistance, const plPhysicsQueryParameters& params, plPhysicsHitCollection collection = plPhysicsHitCollection::Closest) const = 0;
 
  virtual bool SweepTestCapsule(plPhysicsCastResult& out_result, float fCapsuleRadius, float fCapsuleHeight, const plTransform& transform, const plVec3& vDir, float fDistance, const plPhysicsQueryParameters& params, plPhysicsHitCollection collection = plPhysicsHitCollection::Closest) const = 0;
 
  virtual bool OverlapTestSphere(float fSphereRadius, const plVec3& vPosition, const plPhysicsQueryParameters& params) const = 0;
 
  virtual bool OverlapTestCapsule(float fCapsuleRadius, float fCapsuleHeight, const plTransform& transform, const plPhysicsQueryParameters& params) const = 0;
 
  virtual void QueryShapesInSphere(plPhysicsOverlapResultArray& out_results, float fSphereRadius, const plVec3& vPosition, const plPhysicsQueryParameters& params) const = 0;
 
  virtual plVec3 GetGravity() const = 0;
 
  // ABSTRACTION HELPERS
  //
  // These functions are used to be able to use certain physics functionality, without having a direct dependency on the exact implementation (Jolt / PhysX).
  // If no physics module is available, they simply do nothing.
  // Add functions on demand.
 
  virtual void AddStaticCollisionBox(plGameObject* pOwner, plVec3 vBoxSize) {}
 
  struct JointConfig
  {
    plGameObjectHandle m_hActorA;
    plGameObjectHandle m_hActorB;
    plTransform m_LocalFrameA = plTransform::MakeIdentity();
    plTransform m_LocalFrameB = plTransform::MakeIdentity();
  };
 
  struct FixedJointConfig : JointConfig
  {
  };
 
  virtual void AddFixedJointComponent(plGameObject* pOwner, const plPhysicsWorldModuleInterface::FixedJointConfig& cfg) {}
 
  virtual plBoundingBoxSphere GetWorldSpaceBounds(plGameObject* pOwner, plUInt32 uiCollisionLayer, plBitflags<plPhysicsShapeType> shapeTypes, bool bIncludeChildObjects) const { return plBoundingBoxSphere::MakeInvalid(); }
};
 
 
class PL_CORE_DLL plScriptExtensionClass_Physics
{
public:
  static plPhysicsCastResult* Raycast(const plWorld* pWorld, const plVec3& vStart, const plVec3& vDir, float fDistance, plUInt32 uiCollisionLayer, plBitflags<plPhysicsShapeType> shapeTypes, plUInt32 uiIgnoreObjectFilterID);
};
 
 
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plScriptExtensionClass_Physics);
 
struct PL_CORE_DLL plMsgPhysicsAddImpulse : public plMessage
{
  PL_DECLARE_MESSAGE_TYPE(plMsgPhysicsAddImpulse, plMessage);
 
  plVec3 m_vGlobalPosition;
  plVec3 m_vImpulse;
  plUInt32 m_uiObjectFilterID = plInvalidIndex;
 
  // Physics-engine specific information, may be available or not.
  void* m_pInternalPhysicsShape = nullptr;
  void* m_pInternalPhysicsActor = nullptr;
};
 
struct PL_CORE_DLL plMsgPhysicsAddForce : public plMessage
{
  PL_DECLARE_MESSAGE_TYPE(plMsgPhysicsAddForce, plMessage);
 
  plVec3 m_vGlobalPosition;
  plVec3 m_vForce;
 
  // Physics-engine specific information, may be available or not.
  void* m_pInternalPhysicsShape = nullptr;
  void* m_pInternalPhysicsActor = nullptr;
};
 
struct PL_CORE_DLL plMsgPhysicsJointBroke : public plEventMessage
{
  PL_DECLARE_MESSAGE_TYPE(plMsgPhysicsJointBroke, plEventMessage);
 
  plGameObjectHandle m_hJointObject;
};
 
struct PL_CORE_DLL plMsgObjectGrabbed : public plMessage
{
  PL_DECLARE_MESSAGE_TYPE(plMsgObjectGrabbed, plMessage);
 
  plGameObjectHandle m_hGrabbedBy;
  bool m_bGotGrabbed = true;
};
 
struct PL_CORE_DLL plMsgReleaseObjectGrab : public plMessage
{
  PL_DECLARE_MESSAGE_TYPE(plMsgReleaseObjectGrab, plMessage);
 
  plGameObjectHandle m_hGrabbedObjectToRelease;
};
 
 
struct PL_CORE_DLL plSmcTriangle
{
  PL_DECLARE_POD_TYPE();
 
  plUInt32 m_uiVertexIndices[3];
};
 
struct PL_CORE_DLL plSmcSubMesh
{
  PL_DECLARE_POD_TYPE();
 
  plUInt32 m_uiFirstTriangle = 0;
  plUInt32 m_uiNumTriangles = 0;
  plUInt16 m_uiSurfaceIndex = 0;
};
 
struct PL_CORE_DLL plSmcDescription
{
  plDeque<plVec3> m_Vertices;
  plDeque<plSmcTriangle> m_Triangles;
  plDeque<plSmcSubMesh> m_SubMeshes;
  plDeque<plString> m_Surfaces;
};
 
struct PL_CORE_DLL plMsgBuildStaticMesh : public plMessage
{
  PL_DECLARE_MESSAGE_TYPE(plMsgBuildStaticMesh, plMessage);
 
  plSmcDescription* m_pStaticMeshDescription = nullptr;
};