WindVolumeComponent.h

#pragma once
 
#include <Core/Interfaces/WindWorldModule.h>
#include <Core/World/Component.h>
#include <Core/World/Declarations.h>
#include <Core/World/World.h>
#include <GameEngine/GameEngineDLL.h>
 
struct plMsgUpdateLocalBounds;
struct plMsgComponentInternalTrigger;
struct plMsgDeleteGameObject;
 
class PL_GAMEENGINE_DLL plWindVolumeComponent : public plComponent
{
  PL_DECLARE_ABSTRACT_COMPONENT_TYPE(plWindVolumeComponent, plComponent);
 
  // plComponent
 
public:
  virtual void SerializeComponent(plWorldWriter& inout_stream) const override;
  virtual void DeserializeComponent(plWorldReader& inout_stream) override;
 
protected:
  virtual void OnActivated() override;
  virtual void OnDeactivated() override;
  virtual void OnSimulationStarted() override;
 
  // plWindVolumeComponent
 
public:
  plWindVolumeComponent();
  ~plWindVolumeComponent();
 
  static plSpatialData::Category SpatialDataCategory;
 
  plTime m_BurstDuration; // [ property ]
 
  plEnum<plWindStrength> m_Strength; // [ property ]
 
  float m_fStrengthFactor = 1.0f;
 
  plSimdVec4f ComputeForceAtGlobalPosition(const plSimdVec4f& vGlobalPos) const;
 
  virtual plSimdVec4f ComputeForceAtLocalPosition(const plSimdVec4f& vLocalPos) const = 0;
 
  plEnum<plOnComponentFinishedAction> m_OnFinishedAction; // [ property ]
 
protected:
  void OnTriggered(plMsgComponentInternalTrigger& msg);
  void OnMsgDeleteGameObject(plMsgDeleteGameObject& msg);
 
  float GetWindInMetersPerSecond() const;
};
 
 
using plWindVolumeSphereComponentManager = plComponentManager<class plWindVolumeSphereComponent, plBlockStorageType::Compact>;
 
class PL_GAMEENGINE_DLL plWindVolumeSphereComponent : public plWindVolumeComponent
{
  PL_DECLARE_COMPONENT_TYPE(plWindVolumeSphereComponent, plWindVolumeComponent, plWindVolumeSphereComponentManager);
 
  // plComponent
 
public:
  virtual void SerializeComponent(plWorldWriter& inout_stream) const override;
  virtual void DeserializeComponent(plWorldReader& inout_stream) override;
 
  // plWindVolumeSphereComponent
 
public:
  plWindVolumeSphereComponent();
  ~plWindVolumeSphereComponent();
 
  virtual plSimdVec4f ComputeForceAtLocalPosition(const plSimdVec4f& vLocalPos) const override;
 
  float GetRadius() const { return m_fRadius; } // [ property ]
  void SetRadius(float fVal);                   // [ property ]
 
private:
  void OnUpdateLocalBounds(plMsgUpdateLocalBounds& msg);
 
  float m_fRadius = 1.0f;
  plSimdFloat m_fOneDivRadius;
};
 
 
struct plWindVolumeCylinderMode
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    Directional, 
    Vortex,      
 
    Default = Directional
  };
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_GAMEENGINE_DLL, plWindVolumeCylinderMode);
 
using plWindVolumeCylinderComponentManager = plComponentManager<class plWindVolumeCylinderComponent, plBlockStorageType::Compact>;
 
class PL_GAMEENGINE_DLL plWindVolumeCylinderComponent : public plWindVolumeComponent
{
  PL_DECLARE_COMPONENT_TYPE(plWindVolumeCylinderComponent, plWindVolumeComponent, plWindVolumeCylinderComponentManager);
 
  // plComponent
 
public:
  virtual void SerializeComponent(plWorldWriter& inout_stream) const override;
  virtual void DeserializeComponent(plWorldReader& inout_stream) override;
 
  // plWindVolumeCylinderComponent
 
public:
  plWindVolumeCylinderComponent();
  ~plWindVolumeCylinderComponent();
 
  virtual plSimdVec4f ComputeForceAtLocalPosition(const plSimdVec4f& vLocalPos) const override;
 
  float GetRadius() const { return m_fRadius; }                   // [ property ]
  void SetRadius(float fVal);                                     // [ property ]
 
  float GetRadiusFalloff() const { return m_fRadiusFalloff; }     // [ property ]
  void SetRadiusFalloff(float fVal);                              // [ property ]
 
  float GetLength() const { return m_fLength; }                   // [ property ]
  void SetLength(float fVal);                                     // [ property ]
 
  float GetPositiveFalloff() const { return m_fPositiveFalloff; } // [ property ]
  void SetPositiveFalloff(float fVal);                            // [ property ]
 
  float GetNegativeFalloff() const { return m_fNegativeFalloff; } // [ property ]
  void SetNegativeFalloff(float fVal);                            // [ property ]
 
  plEnum<plWindVolumeCylinderMode> m_Mode;                        // [ property ]
 
private:
  void OnUpdateLocalBounds(plMsgUpdateLocalBounds& msg);
 
  void ComputeScaleBiasValues();
 
  float m_fRadius = 1.0f;
  float m_fRadiusFalloff = 0.0f;
  float m_fLength = 5.0f;
  float m_fPositiveFalloff = 0.0f;
  float m_fNegativeFalloff = 0.0f;
 
  plSimdVec4f m_vScaleValues;
  plSimdVec4f m_vBiasValues;
};
 
 
using plWindVolumeConeComponentManager = plComponentManager<class plWindVolumeConeComponent, plBlockStorageType::Compact>;
 
class PL_GAMEENGINE_DLL plWindVolumeConeComponent : public plWindVolumeComponent
{
  PL_DECLARE_COMPONENT_TYPE(plWindVolumeConeComponent, plWindVolumeComponent, plWindVolumeConeComponentManager);
 
  // plComponent
 
public:
  virtual void SerializeComponent(plWorldWriter& inout_stream) const override;
  virtual void DeserializeComponent(plWorldReader& inout_stream) override;
 
  // plWindVolumeCylinderComponent
 
public:
  plWindVolumeConeComponent();
  ~plWindVolumeConeComponent();
 
  virtual plSimdVec4f ComputeForceAtLocalPosition(const plSimdVec4f& vLocalPos) const override;
 
  float GetLength() const { return m_fLength; } // [ property ]
  void SetLength(float fVal);                   // [ property ]
 
  plAngle GetAngle() const { return m_Angle; }  // [ property ]
  void SetAngle(plAngle val);                   // [ property ]
 
private:
  void OnUpdateLocalBounds(plMsgUpdateLocalBounds& msg);
 
  float m_fLength = 1.0f;
  plAngle m_Angle = plAngle::MakeFromDegree(45);
};