Descriptors.h

 
#pragma once
 
#include <Foundation/Algorithm/HashableStruct.h>
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/Containers/StaticArray.h>
#include <Foundation/Math/Color.h>
#include <Foundation/Types/SharedPtr.h>
#include <RendererFoundation/Descriptors/Enumerations.h>
#include <RendererFoundation/RendererFoundationDLL.h>
#include <RendererFoundation/Resources/ResourceFormats.h>
#include <RendererFoundation/Shader/ShaderByteCode.h>
#include <Texture/Image/ImageEnums.h>
 
class plWindowBase;
 
 
 
struct plGALWindowSwapChainCreationDescription : public plHashableStruct<plGALWindowSwapChainCreationDescription>
{
  plWindowBase* m_pWindow = nullptr;
 
  // Describes the format that should be used for the backbuffer.
  // Note however, that different platforms may enforce restrictions on this.
  plGALMSAASampleCount::Enum m_SampleCount = plGALMSAASampleCount::None;
  plGALResourceFormat::Enum m_BackBufferFormat = plGALResourceFormat::RGBAUByteNormalizedsRGB;
  plEnum<plGALPresentMode> m_InitialPresentMode = plGALPresentMode::VSync;
 
  bool m_bDoubleBuffered = true;
  bool m_bAllowScreenshots = false;
};
 
struct plGALSwapChainCreationDescription : public plHashableStruct<plGALSwapChainCreationDescription>
{
  const plRTTI* m_pSwapChainType = nullptr;
};
 
struct plGALDeviceCreationDescription
{
  bool m_bDebugDevice = false;
};
 
struct plGALShaderCreationDescription : public plHashableStruct<plGALShaderCreationDescription>
{
  plGALShaderCreationDescription();
  ~plGALShaderCreationDescription();
 
  bool HasByteCodeForStage(plGALShaderStage::Enum stage) const;
 
  plSharedPtr<plGALShaderByteCode> m_ByteCodes[plGALShaderStage::ENUM_COUNT];
};
 
struct plGALRenderTargetBlendDescription : public plHashableStruct<plGALRenderTargetBlendDescription>
{
  plEnum<plGALBlend> m_SourceBlend = plGALBlend::One;
  plEnum<plGALBlend> m_DestBlend = plGALBlend::One;
  plEnum<plGALBlendOp> m_BlendOp = plGALBlendOp::Add;
 
  plEnum<plGALBlend> m_SourceBlendAlpha = plGALBlend::One;
  plEnum<plGALBlend> m_DestBlendAlpha = plGALBlend::One;
  plEnum<plGALBlendOp> m_BlendOpAlpha = plGALBlendOp::Add;
 
  plUInt8 m_uiWriteMask = 0xFF;    
  bool m_bBlendingEnabled = false; 
};
 
struct plGALBlendStateCreationDescription : public plHashableStruct<plGALBlendStateCreationDescription>
{
  plGALRenderTargetBlendDescription m_RenderTargetBlendDescriptions[PL_GAL_MAX_RENDERTARGET_COUNT];
 
  bool m_bAlphaToCoverage = false;  
  bool m_bIndependentBlend = false; 
};
 
struct plGALStencilOpDescription : public plHashableStruct<plGALStencilOpDescription>
{
  plEnum<plGALStencilOp> m_FailOp = plGALStencilOp::Keep;
  plEnum<plGALStencilOp> m_DepthFailOp = plGALStencilOp::Keep;
  plEnum<plGALStencilOp> m_PassOp = plGALStencilOp::Keep;
 
  plEnum<plGALCompareFunc> m_StencilFunc = plGALCompareFunc::Always;
};
 
struct plGALDepthStencilStateCreationDescription : public plHashableStruct<plGALDepthStencilStateCreationDescription>
{
  plGALStencilOpDescription m_FrontFaceStencilOp;
  plGALStencilOpDescription m_BackFaceStencilOp;
 
  plEnum<plGALCompareFunc> m_DepthTestFunc = plGALCompareFunc::Less;
 
  bool m_bSeparateFrontAndBack = false; 
  bool m_bDepthTest = true;
  bool m_bDepthWrite = true;
  bool m_bStencilTest = false;
  plUInt8 m_uiStencilReadMask = 0xFF;
  plUInt8 m_uiStencilWriteMask = 0xFF;
};
 
struct plGALRasterizerStateCreationDescription : public plHashableStruct<plGALRasterizerStateCreationDescription>
{
  plEnum<plGALCullMode> m_CullMode = plGALCullMode::Back; 
  plInt32 m_iDepthBias = 0;                               
  float m_fDepthBiasClamp = 0.0f;                         
  float m_fSlopeScaledDepthBias = 0.0f;                   
  bool m_bWireFrame = false;                              
  bool m_bFrontCounterClockwise = false;                  
  bool m_bScissorTest = false;
  bool m_bConservativeRasterization = false;              
};
 
struct plGALSamplerStateCreationDescription : public plHashableStruct<plGALSamplerStateCreationDescription>
{
  plEnum<plGALTextureFilterMode> m_MinFilter;
  plEnum<plGALTextureFilterMode> m_MagFilter;
  plEnum<plGALTextureFilterMode> m_MipFilter;
 
  plEnum<plImageAddressMode> m_AddressU;
  plEnum<plImageAddressMode> m_AddressV;
  plEnum<plImageAddressMode> m_AddressW;
 
  plEnum<plGALCompareFunc> m_SampleCompareFunc;
 
  plColor m_BorderColor = plColor::Black;
 
  float m_fMipLodBias = 0.0f;
  float m_fMinMip = -1.0f;
  float m_fMaxMip = 42000.0f;
 
  plUInt32 m_uiMaxAnisotropy = 4;
};
 
struct PL_RENDERERFOUNDATION_DLL plGALVertexAttribute
{
  plGALVertexAttribute() = default;
 
  plGALVertexAttribute(plGALVertexAttributeSemantic::Enum semantic, plGALResourceFormat::Enum format, plUInt16 uiOffset, plUInt8 uiVertexBufferSlot,
    bool bInstanceData);
 
  plGALVertexAttributeSemantic::Enum m_eSemantic = plGALVertexAttributeSemantic::Position;
  plGALResourceFormat::Enum m_eFormat = plGALResourceFormat::XYZFloat;
  plUInt16 m_uiOffset = 0;
  plUInt8 m_uiVertexBufferSlot = 0;
  bool m_bInstanceData = false;
};
 
struct PL_RENDERERFOUNDATION_DLL plGALVertexDeclarationCreationDescription : public plHashableStruct<plGALVertexDeclarationCreationDescription>
{
  plGALShaderHandle m_hShader;
  plStaticArray<plGALVertexAttribute, 16> m_VertexAttributes;
};
 
// Need to add: immutable (GPU only), default(GPU only, but allows CopyToTempStorage updates), transient (allows plGALUpdateMode::Discard), staging: read(back), staging: write (constantly mapped), unified memory (mobile, onboard GPU, allows all ops)
// Or use VmaMemoryUsage  + read write flags?
struct plGALResourceAccess
{
  PL_ALWAYS_INLINE bool IsImmutable() const { return m_bImmutable; }
 
  bool m_bReadBack = false;
  bool m_bImmutable = true;
};
 
struct plGALBufferCreationDescription : public plHashableStruct<plGALBufferCreationDescription>
{
  plUInt32 m_uiTotalSize = 0;
  plUInt32 m_uiStructSize = 0; // Struct or texel size
  plBitflags<plGALBufferUsageFlags> m_BufferFlags;
  plGALResourceAccess m_ResourceAccess;
};
 
struct plGALTextureCreationDescription : public plHashableStruct<plGALTextureCreationDescription>
{
  void SetAsRenderTarget(plUInt32 uiWidth, plUInt32 uiHeight, plGALResourceFormat::Enum format, plGALMSAASampleCount::Enum sampleCount = plGALMSAASampleCount::None);
 
  plUInt32 m_uiWidth = 0;
  plUInt32 m_uiHeight = 0;
  plUInt32 m_uiDepth = 1;
  plUInt32 m_uiMipLevelCount = 1;
  plUInt32 m_uiArraySize = 1;
 
  plEnum<plGALResourceFormat> m_Format = plGALResourceFormat::Invalid;
  plEnum<plGALMSAASampleCount> m_SampleCount = plGALMSAASampleCount::None;
  plEnum<plGALTextureType> m_Type = plGALTextureType::Texture2D;
 
  bool m_bAllowShaderResourceView = true;
  bool m_bAllowUAV = false;
  bool m_bCreateRenderTarget = false;
  bool m_bAllowDynamicMipGeneration = false;
 
  plGALResourceAccess m_ResourceAccess;
 
  void* m_pExisitingNativeObject = nullptr; 
};
 
struct plGALTextureResourceViewCreationDescription : public plHashableStruct<plGALTextureResourceViewCreationDescription>
{
  plGALTextureHandle m_hTexture;
  plEnum<plGALResourceFormat> m_OverrideViewFormat = plGALResourceFormat::Invalid;
  plUInt32 m_uiMostDetailedMipLevel = 0;
  plUInt32 m_uiMipLevelsToUse = 0xFFFFFFFFu;
  plUInt32 m_uiFirstArraySlice = 0; // For cubemap array: index of first 2d slice to start with
  plUInt32 m_uiArraySize = 1;       // For cubemap array: number of cubemaps
};
 
struct plGALBufferResourceViewCreationDescription : public plHashableStruct<plGALBufferResourceViewCreationDescription>
{
  plGALBufferHandle m_hBuffer;
  plEnum<plGALResourceFormat> m_OverrideViewFormat = plGALResourceFormat::Invalid;
  plUInt32 m_uiFirstElement = 0;
  plUInt32 m_uiNumElements = 0;
  bool m_bRawView = false;
};
 
struct plGALRenderTargetViewCreationDescription : public plHashableStruct<plGALRenderTargetViewCreationDescription>
{
  plGALTextureHandle m_hTexture;
 
  plEnum<plGALResourceFormat> m_OverrideViewFormat = plGALResourceFormat::Invalid;
 
  plUInt32 m_uiMipLevel = 0;
 
  plUInt32 m_uiFirstSlice = 0;
  plUInt32 m_uiSliceCount = 1;
 
  bool m_bReadOnly = false; 
};
 
struct plGALTextureUnorderedAccessViewCreationDescription : public plHashableStruct<plGALTextureUnorderedAccessViewCreationDescription>
{
  plGALTextureHandle m_hTexture;
  plUInt32 m_uiFirstArraySlice = 0; 
  plUInt32 m_uiArraySize = 1;       
  plUInt16 m_uiMipLevelToUse = 0;   
  plEnum<plGALResourceFormat> m_OverrideViewFormat = plGALResourceFormat::Invalid;
};
 
struct plGALBufferUnorderedAccessViewCreationDescription : public plHashableStruct<plGALBufferUnorderedAccessViewCreationDescription>
{
  plGALBufferHandle m_hBuffer;
  plUInt32 m_uiFirstElement = 0;
  plUInt32 m_uiNumElements = 0;
  plEnum<plGALResourceFormat> m_OverrideViewFormat = plGALResourceFormat::Invalid;
  bool m_bRawView = false;
};
 
struct plGALDeviceEvent
{
  enum Type
  {
    AfterInit,
    BeforeShutdown,
    BeforeBeginFrame,
    AfterBeginFrame,
    BeforeEndFrame,
    AfterEndFrame,
    BeforeBeginCommands,
    AfterBeginCommands,
    BeforeEndCommands,
    AfterEndCommands,
    // could add resource creation/destruction events, if this would be useful
  };
 
  Type m_Type;
  class plGALDevice* m_pDevice = nullptr;
  plGALCommandEncoder* m_pCommandEncoder = nullptr;
};
 
// Opaque platform specific handle
// Typically holds a platform specific handle for the texture and it's synchronization primitive
struct plGALPlatformSharedHandle : public plHashableStruct<plGALPlatformSharedHandle>
{
  plUInt64 m_hSharedTexture = 0;
  plUInt64 m_hSemaphore = 0;
  plUInt32 m_uiProcessId = 0;
  plUInt32 m_uiMemoryTypeIndex = 0;
  plUInt64 m_uiSize = 0;
};
 
#include <RendererFoundation/Descriptors/Implementation/Descriptors_inl.h>