ParticleEffectInstance.h

#pragma once
 
#include <Foundation/Math/Transform.h>
#include <Foundation/SimdMath/SimdVec4i.h>
#include <Foundation/Threading/TaskSystem.h>
#include <Foundation/Types/SharedPtr.h>
#include <ParticlePlugin/System/ParticleSystemInstance.h>
 
class plParticleEffectInstance;
 
class plParticleEffectUpdateTask final : public plTask
{
public:
  plParticleEffectUpdateTask(plParticleEffectInstance* pEffect);
 
  plTime m_UpdateDiff;
 
private:
  virtual void Execute() override;
 
  plParticleEffectInstance* m_pEffect;
};
 
class PL_PARTICLEPLUGIN_DLL plParticleEffectInstance
{
  friend class plParticleWorldModule;
  friend class plParticleEffectUpdateTask;
 
public:
  plParticleEffectInstance();
  ~plParticleEffectInstance();
 
  void Construct(plParticleEffectHandle hEffectHandle, const plParticleEffectResourceHandle& hResource, plWorld* pWorld, plParticleWorldModule* pOwnerModule, plUInt64 uiRandomSeed, bool bIsShared, plArrayPtr<plParticleEffectFloatParam> floatParams, plArrayPtr<plParticleEffectColorParam> colorParams);
  void Destruct();
 
  void Interrupt();
 
  const plParticleEffectHandle& GetHandle() const { return m_hEffectHandle; }
 
  void SetEmitterEnabled(bool bEnable);
  bool GetEmitterEnabled() const { return m_bEmitterEnabled; }
 
  bool HasActiveParticles() const;
 
  void ClearParticleSystems();
  void ClearEventReactions();
 
  bool IsContinuous() const;
 
  plWorld* GetWorld() const { return m_pWorld; }
  plParticleWorldModule* GetOwnerWorldModule() const { return m_pOwnerModule; }
 
  const plParticleEffectResourceHandle& GetResource() const { return m_hResource; }
 
  const plHybridArray<plParticleSystemInstance*, 4>& GetParticleSystems() const { return m_ParticleSystems; }
 
  void AddParticleEvent(const plParticleEvent& pe);
 
  plRandom& GetRNG() { return m_Random; }
 
  plUInt64 GetRandomSeed() const { return m_uiRandomSeed; }
 
  void RequestWindSamples();
  void UpdateWindSamples(plTime diff);
 
  plUInt64 GetNumActiveParticles() const;
 
public:
  bool IsSimulatedInLocalSpace() const { return m_bSimulateInLocalSpace; }
 
  void SetTransform(const plTransform& transform, const plVec3& vParticleStartVelocity);
 
  void SetTransformForNextFrame(const plTransform& transform, const plVec3& vParticleStartVelocity);
 
  const plTransform& GetTransform() const { return m_Transform; }
 
  bool NeedsToApplyTransform() const { return m_bSimulateInLocalSpace || m_bIsSharedEffect; }
 
  plSimdVec4f GetWindAt(const plSimdVec4f& vPosition) const;
 
private:
  void PassTransformToSystems();
 
  plTransform m_Transform;
  plTransform m_TransformForNextFrame;
 
  plVec3 m_vVelocity;
  plVec3 m_vVelocityForNextFrame;
 
  struct WindSampleGrid
  {
    plSimdVec4f m_vMinPos;
    plSimdVec4f m_vMaxPos;
    plSimdVec4f m_vInvCellSize;
    plSmallArray<plSimdVec4f, 16, plAlignedAllocatorWrapper> m_Samples;
  };
 
  plVec4I32 m_vNumWindSamples; // not unsigned so it can be loaded directly to a SIMD register, w contains total num samples
  mutable plUniquePtr<WindSampleGrid> m_WindSampleGrids[2];
 
 
public:
  bool Update(const plTime& diff);
 
  plTime GetTotalEffectLifeTime() const { return m_TotalEffectLifeTime; }
 
private: // friend plParticleWorldModule
  bool ShouldBeUpdated() const;
 
  const plSharedPtr<plTask>& GetUpdateTask() { return m_pTask; }
 
private: // friend plParticleEffectUpdateTask
  friend class plParticleEffectController;
  void PreSimulate();
 
  bool StepSimulation(const plTime& tDiff);
 
private:
  plTime m_TotalEffectLifeTime = plTime::MakeZero();
  plTime m_ElapsedTimeSinceUpdate = plTime::MakeZero();
 
 
public:
  bool IsSharedEffect() const { return m_bIsSharedEffect; }
 
private: // friend plParticleWorldModule
  void AddSharedInstance(const void* pSharedInstanceOwner);
  void RemoveSharedInstance(const void* pSharedInstanceOwner);
 
private:
  bool m_bIsSharedEffect = false;
 
public:
  void SetIsVisible() const;
 
  void SetVisibleIf(plParticleEffectInstance* pOtherVisible);
 
  bool IsVisible() const;
 
  void GetBoundingVolume(plBoundingBoxSphere& ref_volume) const;
 
private:
  void CombineSystemBoundingVolumes();
 
  plBoundingBoxSphere m_BoundingVolume;
  mutable plTime m_EffectIsVisible;
  plParticleEffectInstance* m_pVisibleIf = nullptr;
  plEnum<plEffectInvisibleUpdateRate> m_InvisibleUpdateRate;
  plUInt64 m_uiRandomSeed = 0;
 
public:
  void SetParameter(const plTempHashedString& sName, float value);
  void SetParameter(const plTempHashedString& sName, const plColor& value);
 
  plInt32 FindFloatParameter(const plTempHashedString& sName) const;
  float GetFloatParameter(const plTempHashedString& sName, float fDefaultValue) const;
  float GetFloatParameter(plUInt32 uiIdx) const { return m_FloatParameters[uiIdx].m_fValue; }
 
  plInt32 FindColorParameter(const plTempHashedString& sName) const;
  const plColor& GetColorParameter(const plTempHashedString& sName, const plColor& defaultValue) const;
  const plColor& GetColorParameter(plUInt32 uiIdx) const { return m_ColorParameters[uiIdx].m_Value; }
 
 
private:
  struct FloatParameter
  {
    PL_DECLARE_POD_TYPE();
    plUInt64 m_uiNameHash;
    float m_fValue;
  };
 
  struct ColorParameter
  {
    PL_DECLARE_POD_TYPE();
    plUInt64 m_uiNameHash;
    plColor m_Value;
  };
 
  plHybridArray<FloatParameter, 2> m_FloatParameters;
  plHybridArray<ColorParameter, 2> m_ColorParameters;
 
 
 
private:
  void Reconfigure(bool bFirstTime, plArrayPtr<plParticleEffectFloatParam> floatParams, plArrayPtr<plParticleEffectColorParam> colorParams);
  void ClearParticleSystem(plUInt32 index);
  void ProcessEventQueues();
 
  // for deterministic randomness
  plRandom m_Random;
 
  plHashSet<const void*> m_SharedInstances;
  plParticleEffectHandle m_hEffectHandle;
  bool m_bEmitterEnabled = true;
  bool m_bSimulateInLocalSpace = false;
  bool m_bIsFinishing = false;
  plUInt8 m_uiReviveTimeout = 3;
  plInt8 m_iMinSimStepsToDo = 0;
  float m_fApplyInstanceVelocity = 0;
  plTime m_PreSimulateDuration;
  plParticleEffectResourceHandle m_hResource;
 
  plParticleWorldModule* m_pOwnerModule = nullptr;
  plWorld* m_pWorld = nullptr;
  plHybridArray<plParticleSystemInstance*, 4> m_ParticleSystems;
  plHybridArray<plParticleEventReaction*, 4> m_EventReactions;
 
  plSharedPtr<plTask> m_pTask;
 
  plStaticArray<plParticleEvent, 16> m_EventQueue;
};