JoltClothSheetComponent.h

#pragma once
 
#include <Core/World/ComponentManager.h>
#include <GameEngine/Physics/ClothSheetSimulator.h>
#include <JoltPlugin/JoltPluginDLL.h>
#include <RendererCore/Components/RenderComponent.h>
#include <RendererCore/Meshes/MeshBufferResource.h>
#include <RendererCore/Pipeline/RenderData.h>
#include <RendererCore/Pipeline/Renderer.h>
 
using plMaterialResourceHandle = plTypedResourceHandle<class plMaterialResource>;
using plDynamicMeshBufferResourceHandle = plTypedResourceHandle<class plDynamicMeshBufferResource>;
 
 
class PL_JOLTPLUGIN_DLL plJoltClothSheetComponentManager : public plComponentManager<class plJoltClothSheetComponent, plBlockStorageType::FreeList>
{
public:
  plJoltClothSheetComponentManager(plWorld* pWorld);
  ~plJoltClothSheetComponentManager();
 
  virtual void Initialize() override;
 
private:
  void Update(const plWorldModule::UpdateContext& context);
  void UpdateBounds(const plWorldModule::UpdateContext& context);
};
 
 
class PL_JOLTPLUGIN_DLL plJoltClothSheetRenderData final : public plRenderData
{
  PL_ADD_DYNAMIC_REFLECTION(plJoltClothSheetRenderData, plRenderData);
 
public:
  plUInt32 m_uiUniqueID = 0;
  plVec2 m_vTextureScale = plVec2(1.0f);
  plArrayPtr<plVec3> m_Positions;
  plArrayPtr<plUInt16> m_Indices;
  plUInt16 m_uiVerticesX;
  plUInt16 m_uiVerticesY;
  plColor m_Color = plColor::White;
 
  plMaterialResourceHandle m_hMaterial;
};
 
class PL_JOLTPLUGIN_DLL plJoltClothSheetRenderer : public plRenderer
{
  PL_ADD_DYNAMIC_REFLECTION(plJoltClothSheetRenderer, plRenderer);
  PL_DISALLOW_COPY_AND_ASSIGN(plJoltClothSheetRenderer);
 
public:
  plJoltClothSheetRenderer();
  ~plJoltClothSheetRenderer();
 
  virtual void GetSupportedRenderDataCategories(plHybridArray<plRenderData::Category, 8>& ref_categories) const override;
  virtual void GetSupportedRenderDataTypes(plHybridArray<const plRTTI*, 8>& ref_types) const override;
  virtual void RenderBatch(const plRenderViewContext& renderContext, const plRenderPipelinePass* pPass, const plRenderDataBatch& batch) const override;
 
 
protected:
  void CreateVertexBuffer();
 
  plDynamicMeshBufferResourceHandle m_hDynamicMeshBuffer;
};
 
struct PL_JOLTPLUGIN_DLL plJoltClothSheetFlags
{
  using StorageType = plUInt16;
 
  enum Enum
  {
    FixedCornerTopLeft = PL_BIT(0),     
    FixedCornerTopRight = PL_BIT(1),    
    FixedCornerBottomRight = PL_BIT(2), 
    FixedCornerBottomLeft = PL_BIT(3),  
    FixedEdgeTop = PL_BIT(4),           
    FixedEdgeRight = PL_BIT(5),         
    FixedEdgeBottom = PL_BIT(6),        
    FixedEdgeLeft = PL_BIT(7),          
 
    Default = FixedEdgeTop
  };
 
  struct Bits
  {
    StorageType FixedCornerTopLeft : 1;
    StorageType FixedCornerTopRight : 1;
    StorageType FixedCornerBottomRight : 1;
    StorageType FixedCornerBottomLeft : 1;
    StorageType FixedEdgeTop : 1;
    StorageType FixedEdgeRight : 1;
    StorageType FixedEdgeBottom : 1;
    StorageType FixedEdgeLeft : 1;
  };
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_JOLTPLUGIN_DLL, plJoltClothSheetFlags);
 
class PL_JOLTPLUGIN_DLL plJoltClothSheetComponent : public plRenderComponent
{
  PL_DECLARE_COMPONENT_TYPE(plJoltClothSheetComponent, plRenderComponent, plJoltClothSheetComponentManager);
 
  // plComponent
 
public:
  virtual void SerializeComponent(plWorldWriter& inout_stream) const override;
  virtual void DeserializeComponent(plWorldReader& inout_stream) override;
 
protected:
  virtual void OnActivated() override;
  virtual void OnSimulationStarted() override;
  virtual void OnDeactivated() override;
 
  // plRenderComponent
 
public:
  virtual plResult GetLocalBounds(plBoundingBoxSphere& ref_bounds, bool& ref_bAlwaysVisible, plMsgUpdateLocalBounds& ref_msg) override;
 
private:
  void OnMsgExtractRenderData(plMsgExtractRenderData& msg) const;
 
  // plJoltClothSheetComponent
 
public:
  plJoltClothSheetComponent();
  ~plJoltClothSheetComponent();
 
  void SetSize(plVec2 vVal);                 // [ property ]
  plVec2 GetSize() const { return m_vSize; } // [ property ]
 
  void SetSegments(plVec2U32 vVal);                     // [ property ]
  plVec2U32 GetSegments() const { return m_vSegments; } // [ property ]
 
  plUInt8 m_uiCollisionLayer = 0; // [ property ]
 
  float m_fGravityFactor = 1.0f; // [ property ]
 
  float m_fWindInfluence = 0.3f; // [ property ]
 
  float m_fDamping = 0.5f; // [ property ]
 
  float m_fThickness = 0.05f; // [ property ]
 
  plColor m_Color = plColor::White; // [ property ]
 
  void SetFlags(plBitflags<plJoltClothSheetFlags> flags);                // [ property ]
  plBitflags<plJoltClothSheetFlags> GetFlags() const { return m_Flags; } // [ property ]
 
  void SetMaterialFile(const char* szFile); // [ property ]
  const char* GetMaterialFile() const;      // [ property ]
 
  plMaterialResourceHandle m_hMaterial; // [ property ]
 
private:
  void Update();
 
  void ApplyWind();
 
  void SetupCloth();
  void RemoveBody();
  void UpdateBodyBounds();
 
  plVec2 m_vSize = plVec2(1.0f, 1.0f);
  plVec2 m_vTextureScale = plVec2(1.0f);
  plVec2U32 m_vSegments = plVec2U32(16, 16);
  plBitflags<plJoltClothSheetFlags> m_Flags;
  mutable plRenderData::Category m_RenderDataCategory;
  plUInt8 m_uiSleepCounter = 0;
 
  plUInt32 m_uiJoltBodyID = plInvalidIndex;
  plBoundingSphere m_BSphere;
};