Device.h

 
#pragma once
 
#include <Foundation/Containers/HashTable.h>
#include <Foundation/Containers/IdTable.h>
#include <Foundation/Memory/CommonAllocators.h>
#include <Foundation/Strings/HashedString.h>
#include <RendererFoundation/Descriptors/Descriptors.h>
#include <RendererFoundation/Device/DeviceCapabilities.h>
#include <RendererFoundation/RendererFoundationDLL.h>
 
class plColor;
 
class PL_RENDERERFOUNDATION_DLL plGALDevice
{
public:
  static plEvent<const plGALDeviceEvent&> s_Events;
 
  // Init & shutdown functions
 
  plResult Init();
  plResult Shutdown();
  plStringView GetRenderer();
 
  // Commands functions
 
  plGALCommandEncoder* BeginCommands(const char* szName);
  void EndCommands(plGALCommandEncoder* pCommandEncoder);
 
  // State creation functions
 
  plGALBlendStateHandle CreateBlendState(const plGALBlendStateCreationDescription& description);
  void DestroyBlendState(plGALBlendStateHandle hBlendState);
 
  plGALDepthStencilStateHandle CreateDepthStencilState(const plGALDepthStencilStateCreationDescription& description);
  void DestroyDepthStencilState(plGALDepthStencilStateHandle hDepthStencilState);
 
  plGALRasterizerStateHandle CreateRasterizerState(const plGALRasterizerStateCreationDescription& description);
  void DestroyRasterizerState(plGALRasterizerStateHandle hRasterizerState);
 
  plGALSamplerStateHandle CreateSamplerState(const plGALSamplerStateCreationDescription& description);
  void DestroySamplerState(plGALSamplerStateHandle hSamplerState);
 
  // Resource creation functions
 
  plGALShaderHandle CreateShader(const plGALShaderCreationDescription& description);
  void DestroyShader(plGALShaderHandle hShader);
 
  plGALBufferHandle CreateBuffer(const plGALBufferCreationDescription& description, plArrayPtr<const plUInt8> initialData = plArrayPtr<const plUInt8>());
  void DestroyBuffer(plGALBufferHandle hBuffer);
 
  // Helper functions for buffers (for common, simple use cases)
 
  plGALBufferHandle CreateVertexBuffer(plUInt32 uiVertexSize, plUInt32 uiVertexCount, plArrayPtr<const plUInt8> initialData = plArrayPtr<const plUInt8>(), bool bDataIsMutable = false);
  plGALBufferHandle CreateIndexBuffer(plGALIndexType::Enum indexType, plUInt32 uiIndexCount, plArrayPtr<const plUInt8> initialData = plArrayPtr<const plUInt8>(), bool bDataIsMutable = false);
  plGALBufferHandle CreateConstantBuffer(plUInt32 uiBufferSize);
 
  plGALTextureHandle CreateTexture(const plGALTextureCreationDescription& description, plArrayPtr<plGALSystemMemoryDescription> initialData = plArrayPtr<plGALSystemMemoryDescription>());
  void DestroyTexture(plGALTextureHandle hTexture);
 
  plGALTextureHandle CreateProxyTexture(plGALTextureHandle hParentTexture, plUInt32 uiSlice);
  void DestroyProxyTexture(plGALTextureHandle hProxyTexture);
 
  plGALTextureHandle CreateSharedTexture(const plGALTextureCreationDescription& description, plArrayPtr<plGALSystemMemoryDescription> initialData = {});
  plGALTextureHandle OpenSharedTexture(const plGALTextureCreationDescription& description, plGALPlatformSharedHandle hSharedHandle);
  void DestroySharedTexture(plGALTextureHandle hTexture);
 
  // Resource views
  plGALTextureResourceViewHandle GetDefaultResourceView(plGALTextureHandle hTexture);
  plGALBufferResourceViewHandle GetDefaultResourceView(plGALBufferHandle hBuffer);
 
  plGALTextureResourceViewHandle CreateResourceView(const plGALTextureResourceViewCreationDescription& description);
  void DestroyResourceView(plGALTextureResourceViewHandle hResourceView);
 
  plGALBufferResourceViewHandle CreateResourceView(const plGALBufferResourceViewCreationDescription& description);
  void DestroyResourceView(plGALBufferResourceViewHandle hResourceView);
 
  // Render target views
  plGALRenderTargetViewHandle GetDefaultRenderTargetView(plGALTextureHandle hTexture);
 
  plGALRenderTargetViewHandle CreateRenderTargetView(const plGALRenderTargetViewCreationDescription& description);
  void DestroyRenderTargetView(plGALRenderTargetViewHandle hRenderTargetView);
 
  // Unordered access views
  plGALTextureUnorderedAccessViewHandle CreateUnorderedAccessView(const plGALTextureUnorderedAccessViewCreationDescription& description);
  void DestroyUnorderedAccessView(plGALTextureUnorderedAccessViewHandle hUnorderedAccessView);
 
  plGALBufferUnorderedAccessViewHandle CreateUnorderedAccessView(const plGALBufferUnorderedAccessViewCreationDescription& description);
  void DestroyUnorderedAccessView(plGALBufferUnorderedAccessViewHandle hUnorderedAccessView);
 
  // Other rendering creation functions
 
  using SwapChainFactoryFunction = plDelegate<plGALSwapChain*(plAllocator*)>;
  plGALSwapChainHandle CreateSwapChain(const SwapChainFactoryFunction& func);
  plResult UpdateSwapChain(plGALSwapChainHandle hSwapChain, plEnum<plGALPresentMode> newPresentMode);
  void DestroySwapChain(plGALSwapChainHandle hSwapChain);
 
  plGALVertexDeclarationHandle CreateVertexDeclaration(const plGALVertexDeclarationCreationDescription& description);
  void DestroyVertexDeclaration(plGALVertexDeclarationHandle hVertexDeclaration);
 
  // GPU -> CPU query functions
 
  plEnum<plGALAsyncResult> GetTimestampResult(plGALTimestampHandle hTimestamp, plTime& out_result);
 
  plEnum<plGALAsyncResult> GetOcclusionQueryResult(plGALOcclusionHandle hOcclusion, plUInt64& out_uiResult);
 
  plEnum<plGALAsyncResult> GetFenceResult(plGALFenceHandle hFence, plTime timeout = plTime::MakeZero());
 
 
  // Swap chain functions
 
  plGALTextureHandle GetBackBufferTextureFromSwapChain(plGALSwapChainHandle hSwapChain);
 
 
  // Misc functions
 
  void EnqueueFrameSwapChain(plGALSwapChainHandle hSwapChain);
 
  void BeginFrame(const plUInt64 uiAppFrame = 0);
 
  void EndFrame();
 
  plUInt64 GetCurrentFrame() const;
  plUInt64 GetSafeFrame() const;
 
 
  const plGALDeviceCreationDescription* GetDescription() const;
 
  const plGALSwapChain* GetSwapChain(plGALSwapChainHandle hSwapChain) const;
  template <typename T>
  const T* GetSwapChain(plGALSwapChainHandle hSwapChain) const
  {
    return static_cast<const T*>(GetSwapChainInternal(hSwapChain, plGetStaticRTTI<T>()));
  }
 
  const plGALShader* GetShader(plGALShaderHandle hShader) const;
  const plGALTexture* GetTexture(plGALTextureHandle hTexture) const;
  virtual const plGALSharedTexture* GetSharedTexture(plGALTextureHandle hTexture) const = 0;
  const plGALBuffer* GetBuffer(plGALBufferHandle hBuffer) const;
  const plGALDepthStencilState* GetDepthStencilState(plGALDepthStencilStateHandle hDepthStencilState) const;
  const plGALBlendState* GetBlendState(plGALBlendStateHandle hBlendState) const;
  const plGALRasterizerState* GetRasterizerState(plGALRasterizerStateHandle hRasterizerState) const;
  const plGALVertexDeclaration* GetVertexDeclaration(plGALVertexDeclarationHandle hVertexDeclaration) const;
  const plGALSamplerState* GetSamplerState(plGALSamplerStateHandle hSamplerState) const;
  const plGALTextureResourceView* GetResourceView(plGALTextureResourceViewHandle hResourceView) const;
  const plGALBufferResourceView* GetResourceView(plGALBufferResourceViewHandle hResourceView) const;
  const plGALRenderTargetView* GetRenderTargetView(plGALRenderTargetViewHandle hRenderTargetView) const;
  const plGALTextureUnorderedAccessView* GetUnorderedAccessView(plGALTextureUnorderedAccessViewHandle hUnorderedAccessView) const;
  const plGALBufferUnorderedAccessView* GetUnorderedAccessView(plGALBufferUnorderedAccessViewHandle hUnorderedAccessView) const;
 
  const plGALDeviceCapabilities& GetCapabilities() const;
 
  virtual plUInt64 GetMemoryConsumptionForTexture(const plGALTextureCreationDescription& description) const;
  virtual plUInt64 GetMemoryConsumptionForBuffer(const plGALBufferCreationDescription& description) const;
 
  static void SetDefaultDevice(plGALDevice* pDefaultDevice);
  static plGALDevice* GetDefaultDevice();
  static bool HasDefaultDevice();
 
  // \brief Sends the queued up commands to the GPU.
  // Same as plCommandEncoder:Flush.
  void Flush();
 
  void WaitIdle();
 
  // public in case someone external needs to lock multiple operations
  mutable plMutex m_Mutex;
 
  plAllocator* GetAllocator();
 
private:
  static plGALDevice* s_pDefaultDevice;
 
protected:
  plGALDevice(const plGALDeviceCreationDescription& Description);
 
  virtual ~plGALDevice();
 
  template <typename IdTableType, typename ReturnType>
  ReturnType* Get(typename IdTableType::TypeOfId hHandle, const IdTableType& IdTable) const;
 
  void DestroyViews(plGALTexture* pResource);
  void DestroyViews(plGALBuffer* pResource);
 
  template <typename HandleType>
  void AddDeadObject(plUInt32 uiType, HandleType handle);
 
  template <typename HandleType>
  void ReviveDeadObject(plUInt32 uiType, HandleType handle);
 
  void DestroyDeadObjects();
 
  void VerifyMultithreadedAccess() const;
 
  const plGALSwapChain* GetSwapChainInternal(plGALSwapChainHandle hSwapChain, const plRTTI* pRequestedType) const;
 
  plGALTextureHandle FinalizeTextureInternal(const plGALTextureCreationDescription& desc, plGALTexture* pTexture);
  plGALBufferHandle FinalizeBufferInternal(const plGALBufferCreationDescription& desc, plGALBuffer* pBuffer);
 
  plProxyAllocator m_Allocator;
  plLocalAllocatorWrapper m_AllocatorWrapper;
 
  using ShaderTable = plIdTable<plGALShaderHandle::IdType, plGALShader*, plLocalAllocatorWrapper>;
  using BlendStateTable = plIdTable<plGALBlendStateHandle::IdType, plGALBlendState*, plLocalAllocatorWrapper>;
  using DepthStencilStateTable = plIdTable<plGALDepthStencilStateHandle::IdType, plGALDepthStencilState*, plLocalAllocatorWrapper>;
  using RasterizerStateTable = plIdTable<plGALRasterizerStateHandle::IdType, plGALRasterizerState*, plLocalAllocatorWrapper>;
  using BufferTable = plIdTable<plGALBufferHandle::IdType, plGALBuffer*, plLocalAllocatorWrapper>;
  using TextureTable = plIdTable<plGALTextureHandle::IdType, plGALTexture*, plLocalAllocatorWrapper>;
  using TextureResourceViewTable = plIdTable<plGALTextureResourceViewHandle::IdType, plGALTextureResourceView*, plLocalAllocatorWrapper>;
  using BufferResourceViewTable = plIdTable<plGALBufferResourceViewHandle::IdType, plGALBufferResourceView*, plLocalAllocatorWrapper>;
  using SamplerStateTable = plIdTable<plGALSamplerStateHandle::IdType, plGALSamplerState*, plLocalAllocatorWrapper>;
  using RenderTargetViewTable = plIdTable<plGALRenderTargetViewHandle::IdType, plGALRenderTargetView*, plLocalAllocatorWrapper>;
  using TextureUnorderedAccessViewTable = plIdTable<plGALTextureUnorderedAccessViewHandle::IdType, plGALTextureUnorderedAccessView*, plLocalAllocatorWrapper>;
  using BufferUnorderedAccessViewTable = plIdTable<plGALBufferUnorderedAccessViewHandle::IdType, plGALBufferUnorderedAccessView*, plLocalAllocatorWrapper>;
  using SwapChainTable = plIdTable<plGALSwapChainHandle::IdType, plGALSwapChain*, plLocalAllocatorWrapper>;
  using VertexDeclarationTable = plIdTable<plGALVertexDeclarationHandle::IdType, plGALVertexDeclaration*, plLocalAllocatorWrapper>;
 
  ShaderTable m_Shaders;
  BlendStateTable m_BlendStates;
  DepthStencilStateTable m_DepthStencilStates;
  RasterizerStateTable m_RasterizerStates;
  BufferTable m_Buffers;
  TextureTable m_Textures;
  TextureResourceViewTable m_TextureResourceViews;
  BufferResourceViewTable m_BufferResourceViews;
  SamplerStateTable m_SamplerStates;
  RenderTargetViewTable m_RenderTargetViews;
  TextureUnorderedAccessViewTable m_TextureUnorderedAccessViews;
  BufferUnorderedAccessViewTable m_BufferUnorderedAccessViews;
  SwapChainTable m_SwapChains;
  VertexDeclarationTable m_VertexDeclarations;
 
 
  // Hash tables used to prevent state object duplication
  plHashTable<plUInt32, plGALBlendStateHandle, plHashHelper<plUInt32>, plLocalAllocatorWrapper> m_BlendStateTable;
  plHashTable<plUInt32, plGALDepthStencilStateHandle, plHashHelper<plUInt32>, plLocalAllocatorWrapper> m_DepthStencilStateTable;
  plHashTable<plUInt32, plGALRasterizerStateHandle, plHashHelper<plUInt32>, plLocalAllocatorWrapper> m_RasterizerStateTable;
  plHashTable<plUInt32, plGALSamplerStateHandle, plHashHelper<plUInt32>, plLocalAllocatorWrapper> m_SamplerStateTable;
  plHashTable<plUInt32, plGALVertexDeclarationHandle, plHashHelper<plUInt32>, plLocalAllocatorWrapper> m_VertexDeclarationTable;
 
  struct DeadObject
  {
    PL_DECLARE_POD_TYPE();
 
    plUInt32 m_uiType;
    plUInt32 m_uiHandle;
  };
 
  plDynamicArray<DeadObject, plLocalAllocatorWrapper> m_DeadObjects;
 
  plGALDeviceCreationDescription m_Description;
 
  plGALDeviceCapabilities m_Capabilities;
 
  // Deactivate Doxygen document generation for the following block. (API abstraction only)
 
  // These functions need to be implemented by a render API abstraction
protected:
  friend class plMemoryUtils;
 
  // Init & shutdown functions
 
  virtual plResult InitPlatform() = 0;
  virtual plResult ShutdownPlatform() = 0;
  virtual plStringView GetRendererPlatform() = 0;
 
  // Pipeline & Pass functions
 
 
 
  // Command Encoder
 
  virtual plGALCommandEncoder* BeginCommandsPlatform(const char* szName) = 0;
  virtual void EndCommandsPlatform(plGALCommandEncoder* pPass) = 0;
 
  // State creation functions
 
  virtual plGALBlendState* CreateBlendStatePlatform(const plGALBlendStateCreationDescription& Description) = 0;
  virtual void DestroyBlendStatePlatform(plGALBlendState* pBlendState) = 0;
 
  virtual plGALDepthStencilState* CreateDepthStencilStatePlatform(const plGALDepthStencilStateCreationDescription& Description) = 0;
  virtual void DestroyDepthStencilStatePlatform(plGALDepthStencilState* pDepthStencilState) = 0;
 
  virtual plGALRasterizerState* CreateRasterizerStatePlatform(const plGALRasterizerStateCreationDescription& Description) = 0;
  virtual void DestroyRasterizerStatePlatform(plGALRasterizerState* pRasterizerState) = 0;
 
  virtual plGALSamplerState* CreateSamplerStatePlatform(const plGALSamplerStateCreationDescription& Description) = 0;
  virtual void DestroySamplerStatePlatform(plGALSamplerState* pSamplerState) = 0;
 
  // Resource creation functions
 
  virtual plGALShader* CreateShaderPlatform(const plGALShaderCreationDescription& Description) = 0;
  virtual void DestroyShaderPlatform(plGALShader* pShader) = 0;
 
  virtual plGALBuffer* CreateBufferPlatform(const plGALBufferCreationDescription& Description, plArrayPtr<const plUInt8> pInitialData) = 0;
  virtual void DestroyBufferPlatform(plGALBuffer* pBuffer) = 0;
 
  virtual plGALTexture* CreateTexturePlatform(const plGALTextureCreationDescription& Description, plArrayPtr<plGALSystemMemoryDescription> pInitialData) = 0;
  virtual void DestroyTexturePlatform(plGALTexture* pTexture) = 0;
 
  virtual plGALTexture* CreateSharedTexturePlatform(const plGALTextureCreationDescription& Description, plArrayPtr<plGALSystemMemoryDescription> pInitialData, plEnum<plGALSharedTextureType> sharedType, plGALPlatformSharedHandle handle) = 0;
  virtual void DestroySharedTexturePlatform(plGALTexture* pTexture) = 0;
 
  virtual plGALTextureResourceView* CreateResourceViewPlatform(plGALTexture* pResource, const plGALTextureResourceViewCreationDescription& Description) = 0;
  virtual void DestroyResourceViewPlatform(plGALTextureResourceView* pResourceView) = 0;
 
  virtual plGALBufferResourceView* CreateResourceViewPlatform(plGALBuffer* pResource, const plGALBufferResourceViewCreationDescription& Description) = 0;
  virtual void DestroyResourceViewPlatform(plGALBufferResourceView* pResourceView) = 0;
 
  virtual plGALRenderTargetView* CreateRenderTargetViewPlatform(plGALTexture* pTexture, const plGALRenderTargetViewCreationDescription& Description) = 0;
  virtual void DestroyRenderTargetViewPlatform(plGALRenderTargetView* pRenderTargetView) = 0;
 
  virtual plGALTextureUnorderedAccessView* CreateUnorderedAccessViewPlatform(plGALTexture* pResource, const plGALTextureUnorderedAccessViewCreationDescription& Description) = 0;
  virtual void DestroyUnorderedAccessViewPlatform(plGALTextureUnorderedAccessView* pUnorderedAccessView) = 0;
 
  virtual plGALBufferUnorderedAccessView* CreateUnorderedAccessViewPlatform(plGALBuffer* pResource, const plGALBufferUnorderedAccessViewCreationDescription& Description) = 0;
  virtual void DestroyUnorderedAccessViewPlatform(plGALBufferUnorderedAccessView* pUnorderedAccessView) = 0;
 
  // Other rendering creation functions
 
  virtual plGALVertexDeclaration* CreateVertexDeclarationPlatform(const plGALVertexDeclarationCreationDescription& Description) = 0;
  virtual void DestroyVertexDeclarationPlatform(plGALVertexDeclaration* pVertexDeclaration) = 0;
 
  // GPU -> CPU query functions
 
  virtual plEnum<plGALAsyncResult> GetTimestampResultPlatform(plGALTimestampHandle hTimestamp, plTime& out_result) = 0;
  virtual plEnum<plGALAsyncResult> GetOcclusionResultPlatform(plGALOcclusionHandle hOcclusion, plUInt64& out_uiResult) = 0;
  virtual plEnum<plGALAsyncResult> GetFenceResultPlatform(plGALFenceHandle hFence, plTime timeout) = 0;
 
  // Misc functions
 
  virtual void BeginFramePlatform(plArrayPtr<plGALSwapChain*> swapchains, const plUInt64 uiAppFrame) = 0;
  virtual void EndFramePlatform(plArrayPtr<plGALSwapChain*> swapchains) = 0;
 
  virtual plUInt64 GetCurrentFramePlatform() const = 0;
  virtual plUInt64 GetSafeFramePlatform() const = 0;
 
  virtual void FillCapabilitiesPlatform() = 0;
 
  virtual void FlushPlatform() = 0;
  virtual void WaitIdlePlatform() = 0;
 
 
 
private:
  bool m_bBeginFrameCalled = false;
  plHybridArray<plGALSwapChain*, 8> m_FrameSwapChains;
  bool m_bBeginPipelineCalled = false;
  bool m_bBeginCommandsCalled = false;
};
 
#include <RendererFoundation/Device/Implementation/Device_inl.h>