RenderContext.h

#pragma once
 
#include <Core/ResourceManager/Resource.h>
#include <Foundation/Containers/Map.h>
#include <Foundation/Math/Rect.h>
#include <Foundation/Strings/String.h>
#include <RendererCore/Declarations.h>
#include <RendererCore/Pipeline/ViewData.h>
#include <RendererCore/RenderContext/Implementation/RenderContextStructs.h>
#include <RendererCore/Shader/ConstantBufferStorage.h>
#include <RendererCore/Shader/ShaderStageBinary.h>
#include <RendererCore/ShaderCompiler/PermutationGenerator.h>
#include <RendererCore/Textures/Texture2DResource.h>
#include <RendererCore/Textures/Texture3DResource.h>
#include <RendererCore/Textures/TextureCubeResource.h>
#include <RendererFoundation/CommandEncoder/CommandEncoder.h>
#include <RendererFoundation/Device/Device.h>
#include <RendererFoundation/Shader/Shader.h>
#include <RendererFoundation/Shader/ShaderUtils.h>
 
#include <RendererCore/../../../Data/Base/Shaders/Common/GlobalConstants.h>
 
struct plRenderWorldRenderEvent;
 
// plRenderContext
 
class PL_RENDERERCORE_DLL plRenderContext
{
private:
  plRenderContext(plGALCommandEncoder* pCommandEncoder);
  ~plRenderContext();
  friend class plMemoryUtils;
 
  static plRenderContext* s_pDefaultInstance;
  static plGALCommandEncoder* s_pCommandEncoder;
  static plHybridArray<plRenderContext*, 4> s_Instances;
 
public:
  static plRenderContext* GetDefaultInstance();
  static plRenderContext* CreateInstance(plGALCommandEncoder* pCommandEncoder);
  static void DestroyInstance(plRenderContext* pRenderer);
 
public:
  struct Statistics
  {
    Statistics();
    void Reset();
 
    plUInt32 m_uiFailedDrawcalls;
  };
 
  Statistics GetAndResetStatistics();
 
  void BeginRendering(const plGALRenderingSetup& renderingSetup, const plRectFloat& viewport, const char* szName = "", bool bStereoRendering = false);
  void EndRendering();
 
  void BeginCompute(const char* szName = "");
  void EndCompute();
 
  // Helper class to automatically end rendering or compute on scope exit
  template <int ScopeType>
  class CommandEncoderScope
  {
    PL_DISALLOW_COPY_AND_ASSIGN(CommandEncoderScope);
 
  public:
    PL_ALWAYS_INLINE ~CommandEncoderScope()
    {
      if constexpr (ScopeType == 0)
        m_RenderContext.EndRendering();
      else
        m_RenderContext.EndCompute();
 
      if (m_pCommandsScope != nullptr)
      {
        plGALDevice::GetDefaultDevice()->EndCommands(m_pCommandsScope);
      }
    }
 
    PL_ALWAYS_INLINE plGALCommandEncoder* operator->() { return m_pGALCommandEncoder; }
    PL_ALWAYS_INLINE operator const plGALCommandEncoder*() { return m_pGALCommandEncoder; }
 
  private:
    friend class plRenderContext;
 
    PL_ALWAYS_INLINE CommandEncoderScope(plRenderContext& renderContext, plGALCommandEncoder* pCommandsScope)
      : m_RenderContext(renderContext)
      , m_pCommandsScope(pCommandsScope)
    {
      m_pGALCommandEncoder = renderContext.GetCommandEncoder();
    }
 
    plRenderContext& m_RenderContext;
    plGALCommandEncoder* m_pCommandsScope;
    plGALCommandEncoder* m_pGALCommandEncoder;
  };
 
  using RenderingScope = CommandEncoderScope<0>;
  PL_ALWAYS_INLINE static RenderingScope BeginRenderingScope(const plRenderViewContext& viewContext, const plGALRenderingSetup& renderingSetup, const char* szName = "", bool bStereoRendering = false)
  {
    viewContext.m_pRenderContext->BeginRendering(renderingSetup, viewContext.m_pViewData->m_ViewPortRect, szName, bStereoRendering);
    return RenderingScope(*viewContext.m_pRenderContext, nullptr);
  }
 
  PL_ALWAYS_INLINE static RenderingScope BeginCommandsAndRenderingScope(const plRenderViewContext& viewContext, const plGALRenderingSetup& renderingSetup, const char* szName, bool bStereoRendering = false)
  {
    plGALCommandEncoder* pCommandEncoder = plGALDevice::GetDefaultDevice()->BeginCommands(szName);
    viewContext.m_pRenderContext->BeginRendering(renderingSetup, viewContext.m_pViewData->m_ViewPortRect, "", bStereoRendering);
    return RenderingScope(*viewContext.m_pRenderContext, pCommandEncoder);
  }
 
  using ComputeScope = CommandEncoderScope<1>;
  PL_ALWAYS_INLINE static ComputeScope BeginComputeScope(const plRenderViewContext& viewContext, const char* szName = "")
  {
    viewContext.m_pRenderContext->BeginCompute(szName);
    return ComputeScope(*viewContext.m_pRenderContext, nullptr);
  }
 
  PL_ALWAYS_INLINE static ComputeScope BeginCommandsAndComputeScope(const plRenderViewContext& viewContext, const char* szName)
  {
    plGALCommandEncoder* pCommandEncoder = plGALDevice::GetDefaultDevice()->BeginCommands(szName);
 
    viewContext.m_pRenderContext->BeginCompute();
    return ComputeScope(*viewContext.m_pRenderContext, pCommandEncoder);
  }
 
  PL_ALWAYS_INLINE plGALCommandEncoder* GetCommandEncoder()
  {
    PL_ASSERT_DEBUG(m_pGALCommandEncoder != nullptr, "Outside of BeginCommands / EndCommands scope of the device");
    return m_pGALCommandEncoder;
  }
 
  // Member Functions
  void SetShaderPermutationVariable(const char* szName, const plTempHashedString& sValue);
  void SetShaderPermutationVariable(const plHashedString& sName, const plHashedString& sValue);
 
  void BindMaterial(const plMaterialResourceHandle& hMaterial);
 
  void BindTexture2D(const plTempHashedString& sSlotName, const plTexture2DResourceHandle& hTexture, plResourceAcquireMode acquireMode = plResourceAcquireMode::AllowLoadingFallback);
  void BindTexture3D(const plTempHashedString& sSlotName, const plTexture3DResourceHandle& hTexture, plResourceAcquireMode acquireMode = plResourceAcquireMode::AllowLoadingFallback);
  void BindTextureCube(const plTempHashedString& sSlotName, const plTextureCubeResourceHandle& hTexture, plResourceAcquireMode acquireMode = plResourceAcquireMode::AllowLoadingFallback);
 
  void BindTexture2D(const plTempHashedString& sSlotName, plGALTextureResourceViewHandle hResourceView);
  void BindTexture3D(const plTempHashedString& sSlotName, plGALTextureResourceViewHandle hResourceView);
  void BindTextureCube(const plTempHashedString& sSlotName, plGALTextureResourceViewHandle hResourceView);
 
  void BindUAV(const plTempHashedString& sSlotName, plGALTextureUnorderedAccessViewHandle hUnorderedAccessViewHandle);
  void BindUAV(const plTempHashedString& sSlotName, plGALBufferUnorderedAccessViewHandle hUnorderedAccessViewHandle);
 
  void BindSamplerState(const plTempHashedString& sSlotName, plGALSamplerStateHandle hSamplerSate);
 
  void BindBuffer(const plTempHashedString& sSlotName, plGALBufferResourceViewHandle hResourceView);
 
  void BindConstantBuffer(const plTempHashedString& sSlotName, plGALBufferHandle hConstantBuffer);
  void BindConstantBuffer(const plTempHashedString& sSlotName, plConstantBufferStorageHandle hConstantBufferStorage);
 
  void SetPushConstants(const plTempHashedString& sSlotName, plArrayPtr<const plUInt8> data);
 
  template <typename T>
  PL_ALWAYS_INLINE void SetPushConstants(const plTempHashedString& sSlotName, const T& constants)
  {
    SetPushConstants(sSlotName, plArrayPtr<const plUInt8>(reinterpret_cast<const plUInt8*>(&constants), sizeof(T)));
  }
 
  void BindShader(const plShaderResourceHandle& hShader, plBitflags<plShaderBindFlags> flags = plShaderBindFlags::Default);
 
  void BindMeshBuffer(const plDynamicMeshBufferResourceHandle& hDynamicMeshBuffer);
  void BindMeshBuffer(const plMeshBufferResourceHandle& hMeshBuffer);
  void BindMeshBuffer(plGALBufferHandle hVertexBuffer, plGALBufferHandle hIndexBuffer, const plVertexDeclarationInfo* pVertexDeclarationInfo, plGALPrimitiveTopology::Enum topology, plUInt32 uiPrimitiveCount, plGALBufferHandle hVertexBuffer2 = {}, plGALBufferHandle hVertexBuffer3 = {}, plGALBufferHandle hVertexBuffer4 = {});
  PL_ALWAYS_INLINE void BindNullMeshBuffer(plGALPrimitiveTopology::Enum topology, plUInt32 uiPrimitiveCount)
  {
    BindMeshBuffer(plGALBufferHandle(), plGALBufferHandle(), nullptr, topology, uiPrimitiveCount);
  }
 
  plResult DrawMeshBuffer(plUInt32 uiPrimitiveCount = 0xFFFFFFFF, plUInt32 uiFirstPrimitive = 0, plUInt32 uiInstanceCount = 1);
 
  plResult Dispatch(plUInt32 uiThreadGroupCountX, plUInt32 uiThreadGroupCountY = 1, plUInt32 uiThreadGroupCountZ = 1);
  plResult DispatchIndirect(plGALBufferHandle hIndirectArgumentBuffer, plUInt32 uiArgumentOffsetInBytes);
 
  plResult ApplyContextStates(bool bForce = false);
  void ResetContextState();
 
  plGlobalConstants& WriteGlobalConstants();
  const plGlobalConstants& ReadGlobalConstants() const;
 
  void SetDefaultTextureFilter(plTextureFilterSetting::Enum filter);
 
  plTextureFilterSetting::Enum GetDefaultTextureFilter() const { return m_DefaultTextureFilter; }
 
  plTextureFilterSetting::Enum GetSpecificTextureFilter(plTextureFilterSetting::Enum configuration) const;
 
  void SetAllowAsyncShaderLoading(bool bAllow);
 
  bool GetAllowAsyncShaderLoading();
 
 
  // Static Functions
public:
  // Constant buffer storage handling
  template <typename T>
  PL_ALWAYS_INLINE static plConstantBufferStorageHandle CreateConstantBufferStorage()
  {
    return CreateConstantBufferStorage(sizeof(T));
  }
 
  template <typename T>
  PL_FORCE_INLINE static plConstantBufferStorageHandle CreateConstantBufferStorage(plConstantBufferStorage<T>*& out_pStorage)
  {
    plConstantBufferStorageBase* pStorage;
    plConstantBufferStorageHandle hStorage = CreateConstantBufferStorage(sizeof(T), pStorage);
    out_pStorage = static_cast<plConstantBufferStorage<T>*>(pStorage);
    return hStorage;
  }
 
  PL_FORCE_INLINE static plConstantBufferStorageHandle CreateConstantBufferStorage(plUInt32 uiSizeInBytes)
  {
    plConstantBufferStorageBase* pStorage;
    return CreateConstantBufferStorage(uiSizeInBytes, pStorage);
  }
 
  static plConstantBufferStorageHandle CreateConstantBufferStorage(plUInt32 uiSizeInBytes, plConstantBufferStorageBase*& out_pStorage);
  static void DeleteConstantBufferStorage(plConstantBufferStorageHandle hStorage);
 
  template <typename T>
  PL_FORCE_INLINE static bool TryGetConstantBufferStorage(plConstantBufferStorageHandle hStorage, plConstantBufferStorage<T>*& out_pStorage)
  {
    plConstantBufferStorageBase* pStorage = nullptr;
    bool bResult = TryGetConstantBufferStorage(hStorage, pStorage);
    out_pStorage = static_cast<plConstantBufferStorage<T>*>(pStorage);
    return bResult;
  }
 
  static bool TryGetConstantBufferStorage(plConstantBufferStorageHandle hStorage, plConstantBufferStorageBase*& out_pStorage);
 
  template <typename T>
  PL_FORCE_INLINE static T* GetConstantBufferData(plConstantBufferStorageHandle hStorage)
  {
    plConstantBufferStorage<T>* pStorage = nullptr;
    if (TryGetConstantBufferStorage(hStorage, pStorage))
    {
      return &(pStorage->GetDataForWriting());
    }
 
    return nullptr;
  }
 
  // Default sampler state
  static plGALSamplerStateCreationDescription GetDefaultSamplerState(plBitflags<plDefaultSamplerFlags> flags);
 
private:
  PL_MAKE_SUBSYSTEM_STARTUP_FRIEND(RendererCore, RendererContext);
 
  static void LoadBuiltinShader(plShaderUtils::plBuiltinShaderType type, plShaderUtils::plBuiltinShader& out_shader);
  static void RegisterImmutableSamplers();
  static void OnEngineStartup();
  static void OnEngineShutdown();
  static void GALStaticDeviceEventHandler(const plGALDeviceEvent& e);
 
private:
  Statistics m_Statistics;
  plBitflags<plRenderContextFlags> m_StateFlags;
  plShaderResourceHandle m_hActiveShader;
  plGALShaderHandle m_hActiveGALShader;
 
  plHashTable<plHashedString, plHashedString> m_PermutationVariables;
  plMaterialResourceHandle m_hNewMaterial;
  plMaterialResourceHandle m_hMaterial;
 
  plShaderPermutationResourceHandle m_hActiveShaderPermutation;
 
  plBitflags<plShaderBindFlags> m_ShaderBindFlags;
 
  plGALBufferHandle m_hVertexBuffers[4];
  plGALBufferHandle m_hIndexBuffer;
  const plVertexDeclarationInfo* m_pVertexDeclarationInfo;
  plGALPrimitiveTopology::Enum m_Topology;
  plUInt32 m_uiMeshBufferPrimitiveCount;
  plEnum<plTextureFilterSetting> m_DefaultTextureFilter;
  bool m_bAllowAsyncShaderLoading;
  bool m_bStereoRendering = false;
 
  plHashTable<plUInt64, plGALTextureResourceViewHandle> m_BoundTextures2D;
  plHashTable<plUInt64, plGALTextureResourceViewHandle> m_BoundTextures3D;
  plHashTable<plUInt64, plGALTextureResourceViewHandle> m_BoundTexturesCube;
  plHashTable<plUInt64, plGALTextureUnorderedAccessViewHandle> m_BoundTextureUAVs;
 
  plHashTable<plUInt64, plGALSamplerStateHandle> m_BoundSamplers;
 
  plHashTable<plUInt64, plGALBufferResourceViewHandle> m_BoundBuffer;
  plHashTable<plUInt64, plGALBufferUnorderedAccessViewHandle> m_BoundBufferUAVs;
  plGALSamplerStateHandle m_hFallbackSampler;
 
  struct BoundConstantBuffer
  {
    PL_DECLARE_POD_TYPE();
 
    BoundConstantBuffer() = default;
    BoundConstantBuffer(plGALBufferHandle hConstantBuffer)
      : m_hConstantBuffer(hConstantBuffer)
    {
    }
    BoundConstantBuffer(plConstantBufferStorageHandle hConstantBufferStorage)
      : m_hConstantBufferStorage(hConstantBufferStorage)
    {
    }
 
    plGALBufferHandle m_hConstantBuffer;
    plConstantBufferStorageHandle m_hConstantBufferStorage;
  };
 
  plHashTable<plUInt64, BoundConstantBuffer> m_BoundConstantBuffers;
 
  plConstantBufferStorageHandle m_hGlobalConstantBufferStorage;
  plConstantBufferStorageHandle m_hPushConstantsStorage;
 
  struct ShaderVertexDecl
  {
    plGALShaderHandle m_hShader;
    plUInt32 m_uiVertexDeclarationHash;
 
    PL_FORCE_INLINE bool operator<(const ShaderVertexDecl& rhs) const
    {
      if (m_hShader < rhs.m_hShader)
        return true;
      if (rhs.m_hShader < m_hShader)
        return false;
      return m_uiVertexDeclarationHash < rhs.m_uiVertexDeclarationHash;
    }
 
    PL_FORCE_INLINE bool operator==(const ShaderVertexDecl& rhs) const
    {
      return (m_hShader == rhs.m_hShader && m_uiVertexDeclarationHash == rhs.m_uiVertexDeclarationHash);
    }
  };
 
  static plResult BuildVertexDeclaration(plGALShaderHandle hShader, const plVertexDeclarationInfo& decl, plGALVertexDeclarationHandle& out_Declaration);
 
  static plMap<ShaderVertexDecl, plGALVertexDeclarationHandle> s_GALVertexDeclarations;
 
  static plMutex s_ConstantBufferStorageMutex;
  static plIdTable<plConstantBufferStorageId, plConstantBufferStorageBase*> s_ConstantBufferStorageTable;
  static plMap<plUInt32, plDynamicArray<plConstantBufferStorageBase*>> s_FreeConstantBufferStorage;
 
private: // Per Renderer States
  plGALCommandEncoder* m_pGALCommandEncoder = nullptr;
  plEventSubscriptionID m_GALdeviceEventsId = 0;
  bool m_bRendering = false;
  bool m_bCompute = false;
 
  // Member Functions
  void UploadConstants();
 
  void SetShaderPermutationVariableInternal(const plHashedString& sName, const plHashedString& sValue);
  void BindShaderInternal(const plShaderResourceHandle& hShader, plBitflags<plShaderBindFlags> flags);
  plShaderPermutationResource* ApplyShaderState();
  plMaterialResource* ApplyMaterialState();
  void ApplyConstantBufferBindings(const plGALShader* pShader);
  void ApplyTextureBindings(const plGALShader* pShader);
  void ApplyUAVBindings(const plGALShader* pShader);
  void ApplySamplerBindings(const plGALShader* pShader);
  void ApplyBufferBindings(const plGALShader* pShader);
};