CommandEncoder.h

 
#pragma once
 
#include <Foundation/Threading/ThreadUtils.h>
#include <RendererFoundation/CommandEncoder/CommandEncoderPlatformInterface.h>
#include <RendererFoundation/CommandEncoder/CommandEncoderState.h>
 
struct plGALRenderingSetup;
 
class PL_RENDERERFOUNDATION_DLL plGALCommandEncoder
{
  PL_DISALLOW_COPY_AND_ASSIGN(plGALCommandEncoder);
 
public:
  plGALCommandEncoder(plGALDevice& ref_device, plGALCommandEncoderCommonPlatformInterface& ref_commonImpl);
  virtual ~plGALCommandEncoder();
 
  // State setting functions
 
  void SetShader(plGALShaderHandle hShader);
 
  void SetConstantBuffer(const plShaderResourceBinding& binding, plGALBufferHandle hBuffer);
  void SetSamplerState(const plShaderResourceBinding& binding, plGALSamplerStateHandle hSamplerState);
  void SetResourceView(const plShaderResourceBinding& binding, plGALTextureResourceViewHandle hResourceView);
  void SetResourceView(const plShaderResourceBinding& binding, plGALBufferResourceViewHandle hResourceView);
  void SetUnorderedAccessView(const plShaderResourceBinding& binding, plGALTextureUnorderedAccessViewHandle hUnorderedAccessView);
  void SetUnorderedAccessView(const plShaderResourceBinding& binding, plGALBufferUnorderedAccessViewHandle hUnorderedAccessView);
  void SetPushConstants(plArrayPtr<const plUInt8> data);
 
  // GPU -> CPU query functions
 
  plGALTimestampHandle InsertTimestamp();
 
  plGALOcclusionHandle BeginOcclusionQuery(plEnum<plGALQueryType> type);
 
  void EndOcclusionQuery(plGALOcclusionHandle hOcclusion);
 
  plGALFenceHandle InsertFence();
 
  // Resource functions
 
  void ClearUnorderedAccessView(plGALTextureUnorderedAccessViewHandle hUnorderedAccessView, plVec4 vClearValues);
  void ClearUnorderedAccessView(plGALBufferUnorderedAccessViewHandle hUnorderedAccessView, plVec4 vClearValues);
 
  void ClearUnorderedAccessView(plGALTextureUnorderedAccessViewHandle hUnorderedAccessView, plVec4U32 vClearValues);
  void ClearUnorderedAccessView(plGALBufferUnorderedAccessViewHandle hUnorderedAccessView, plVec4U32 vClearValues);
 
  void CopyBuffer(plGALBufferHandle hDest, plGALBufferHandle hSource);
  void CopyBufferRegion(plGALBufferHandle hDest, plUInt32 uiDestOffset, plGALBufferHandle hSource, plUInt32 uiSourceOffset, plUInt32 uiByteCount);
  void UpdateBuffer(plGALBufferHandle hDest, plUInt32 uiDestOffset, plArrayPtr<const plUInt8> sourceData, plGALUpdateMode::Enum updateMode = plGALUpdateMode::Discard);
 
  void CopyTexture(plGALTextureHandle hDest, plGALTextureHandle hSource);
  void CopyTextureRegion(plGALTextureHandle hDest, const plGALTextureSubresource& destinationSubResource, const plVec3U32& vDestinationPoint, plGALTextureHandle hSource, const plGALTextureSubresource& sourceSubResource, const plBoundingBoxu32& box);
 
  void UpdateTexture(plGALTextureHandle hDest, const plGALTextureSubresource& destinationSubResource, const plBoundingBoxu32& destinationBox, const plGALSystemMemoryDescription& sourceData);
 
  void ResolveTexture(plGALTextureHandle hDest, const plGALTextureSubresource& destinationSubResource, plGALTextureHandle hSource, const plGALTextureSubresource& sourceSubResource);
 
  void ReadbackTexture(plGALTextureHandle hTexture);
  void CopyTextureReadbackResult(plGALTextureHandle hTexture, plArrayPtr<plGALTextureSubresource> sourceSubResource, plArrayPtr<plGALSystemMemoryDescription> targetData);
 
  void GenerateMipMaps(plGALTextureResourceViewHandle hResourceView);
 
  // Misc
  void Flush();
 
  // Debug helper functions
 
  void PushMarker(const char* szMarker);
  void PopMarker();
  void InsertEventMarker(const char* szMarker);
 
  // Dispatch
 
  void BeginCompute(const char* szName = "");
  void EndCompute();
 
  plResult Dispatch(plUInt32 uiThreadGroupCountX, plUInt32 uiThreadGroupCountY, plUInt32 uiThreadGroupCountZ);
  plResult DispatchIndirect(plGALBufferHandle hIndirectArgumentBuffer, plUInt32 uiArgumentOffsetInBytes);
 
  // Draw functions
 
  void BeginRendering(const plGALRenderingSetup& renderingSetup, const char* szName = "");
  void EndRendering();
 
  void Clear(const plColor& clearColor, plUInt32 uiRenderTargetClearMask = 0xFFFFFFFFu, bool bClearDepth = true, bool bClearStencil = true, float fDepthClear = 1.0f, plUInt8 uiStencilClear = 0x0u);
 
  plResult Draw(plUInt32 uiVertexCount, plUInt32 uiStartVertex);
  plResult DrawIndexed(plUInt32 uiIndexCount, plUInt32 uiStartIndex);
  plResult DrawIndexedInstanced(plUInt32 uiIndexCountPerInstance, plUInt32 uiInstanceCount, plUInt32 uiStartIndex);
  plResult DrawIndexedInstancedIndirect(plGALBufferHandle hIndirectArgumentBuffer, plUInt32 uiArgumentOffsetInBytes);
  plResult DrawInstanced(plUInt32 uiVertexCountPerInstance, plUInt32 uiInstanceCount, plUInt32 uiStartVertex);
  plResult DrawInstancedIndirect(plGALBufferHandle hIndirectArgumentBuffer, plUInt32 uiArgumentOffsetInBytes);
 
  // State functions
 
  void SetIndexBuffer(plGALBufferHandle hIndexBuffer);
  void SetVertexBuffer(plUInt32 uiSlot, plGALBufferHandle hVertexBuffer);
  void SetVertexDeclaration(plGALVertexDeclarationHandle hVertexDeclaration);
 
  plGALPrimitiveTopology::Enum GetPrimitiveTopology() const { return m_State.m_Topology; }
  void SetPrimitiveTopology(plGALPrimitiveTopology::Enum topology);
 
  void SetBlendState(plGALBlendStateHandle hBlendState, const plColor& blendFactor = plColor::White, plUInt32 uiSampleMask = 0xFFFFFFFFu);
  void SetDepthStencilState(plGALDepthStencilStateHandle hDepthStencilState, plUInt8 uiStencilRefValue = 0xFFu);
  void SetRasterizerState(plGALRasterizerStateHandle hRasterizerState);
 
  void SetViewport(const plRectFloat& rect, float fMinDepth = 0.0f, float fMaxDepth = 1.0f);
  void SetScissorRect(const plRectU32& rect);
 
  // Internal
 
  PL_ALWAYS_INLINE plGALDevice& GetDevice() { return m_Device; }
  // Don't use light hearted ;)
  void InvalidateState();
 
protected:
  friend class plGALDevice;
 
  void AssertRenderingThread()
  {
    PL_ASSERT_DEV(plThreadUtils::IsMainThread(), "This function can only be executed on the main thread.");
  }
 
private:
  void ClearStatisticsCounters();
  void CountDispatchCall() { m_uiDispatchCalls++; }
  void CountDrawCall() { m_uiDrawCalls++; }
 
private:
  friend class plMemoryUtils;
 
  // Statistic variables
  plUInt32 m_uiDispatchCalls = 0;
  plUInt32 m_uiDrawCalls = 0;
 
  enum class CommandEncoderType
  {
    Invalid,
    Render,
    Compute
  };
 
  CommandEncoderType m_CurrentCommandEncoderType = CommandEncoderType::Invalid;
  bool m_bMarker = false;
 
  // Parent Device
  plGALDevice& m_Device;
  plGALCommandEncoderRenderState m_State;
  plGALCommandEncoderCommonPlatformInterface& m_CommonImpl;
 
  plGALOcclusionHandle m_hPendingOcclusionQuery = {};
};