ReflectionProbeMapping.h

#pragma once
 
#include <RendererCore/RendererCorePCH.h>
 
#include <RendererCore/Lights/Implementation/ReflectionProbeData.h>
#include <RendererFoundation/RendererFoundationDLL.h>
 
struct plReflectionProbeMappingEvent
{
  enum class Type
  {
    ProbeMapped,          
    ProbeUnmapped,        
    ProbeUpdateRequested, 
  };
 
  plReflectionProbeId m_Id;
  Type m_Type;
};
 
class plReflectionProbeMapping
{
public:
  plReflectionProbeMapping(plUInt32 uiAtlasSize);
  ~plReflectionProbeMapping();
 
 
  void AddProbe(plReflectionProbeId probe, plBitflags<plProbeFlags> flags);
 
  void UpdateProbe(plReflectionProbeId probe, plBitflags<plProbeFlags> flags);
 
  void ProbeUpdateFinished(plReflectionProbeId probe);
 
  void RemoveProbe(plReflectionProbeId probe);
 
 
  plInt32 GetReflectionIndex(plReflectionProbeId probe, bool bForExtraction = false) const;
 
  plGALTextureHandle GetTexture() const { return m_hReflectionSpecularTexture; }
 
 
  void PreExtraction();
 
  void AddWeight(plReflectionProbeId probe, float fPriority);
 
  void PostExtraction();
 
 
public:
  plEvent<const plReflectionProbeMappingEvent&> m_Events;
 
private:
  struct plProbeMappingFlags
  {
    using StorageType = plUInt8;
 
    enum Enum
    {
      SkyLight = plProbeFlags::SkyLight,
      HasCustomCubeMap = plProbeFlags::HasCustomCubeMap,
      Sphere = plProbeFlags::Sphere,
      Box = plProbeFlags::Box,
      Dynamic = plProbeFlags::Dynamic,
      Dirty = PL_BIT(5),
      Usable = PL_BIT(6),
      Default = 0
    };
 
    struct Bits
    {
      StorageType SkyLight : 1;
      StorageType HasCustomCubeMap : 1;
      StorageType Sphere : 1;
      StorageType Box : 1;
      StorageType Dynamic : 1;
      StorageType Dirty : 1;
      StorageType Usable : 1;
    };
  };
 
  //PL_DECLARE_FLAGS_OPERATORS(plProbeMappingFlags);
 
  struct SortedProbes
  {
    PL_DECLARE_POD_TYPE();
 
    PL_ALWAYS_INLINE bool operator<(const SortedProbes& other) const
    {
      if (m_fPriority > other.m_fPriority) // we want to sort descending (higher priority first)
        return true;
 
      return m_uiIndex < other.m_uiIndex;
    }
 
    plReflectionProbeId m_uiIndex;
    float m_fPriority = 0.0f;
  };
 
  struct ProbeDataInternal
  {
    plBitflags<plProbeMappingFlags> m_Flags;
    plInt32 m_uiReflectionIndex = -1;
    float m_fPriority = 0.0f;
    plReflectionProbeId m_id;
  };
 
private:
  void MapProbe(plReflectionProbeId id, plInt32 iReflectionIndex);
  void UnmapProbe(plReflectionProbeId id);
 
private:
  plDynamicArray<ProbeDataInternal> m_RegisteredProbes;
  plReflectionProbeId m_SkyLight;
 
  plUInt32 m_uiAtlasSize = 32;
  plDynamicArray<plReflectionProbeId> m_MappedCubes;
 
  // GPU Data
  plGALTextureHandle m_hReflectionSpecularTexture;
 
  // Cleared every frame:
  plDynamicArray<SortedProbes> m_SortedProbes; // All probes exiting in the scene, sorted by priority.
  plDynamicArray<SortedProbes> m_ActiveProbes; // Probes that are currently mapped in the atlas.
  plDynamicArray<plInt32> m_UnusedProbeSlots;  // Probe slots are are currently unused in the atlas.
  plDynamicArray<SortedProbes> m_AddProbes;    // Probes that should be added to the atlas
};