.. _program_listing_file_Source_Azura_RenderSystem_Inc_Generic_GenericTypes.h:

Program Listing for File GenericTypes.h
=======================================

|exhale_lsh| :ref:`Return to documentation for file <file_Source_Azura_RenderSystem_Inc_Generic_GenericTypes.h>` (``Source\Azura\RenderSystem\Inc\Generic\GenericTypes.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   #include "Containers/Vector.h"
   #include "Generic/Constants.h"
   #include "Types.h"
   #include "Core/RawStorageFormat.h"
   #include "Utils/Hash.h"
   #include "Core/AssetLocation.h"
   
   #include <boost/container/small_vector.hpp>
   #include <boost/detail/bitmask.hpp>
   
   namespace Azura {
   template <typename T, SizeType N>
   using SmallVector = boost::container::small_vector<T, N>;
   
   const U32 PRESENT_TARGET = 100;
   
   enum class RawStorageFormat;
   
   enum class RS {
     Success = 0,
     UnknownError,
   };
   
   enum class ColorSpace {
     SRGB,
     HDR10
   };
   
   enum class PresentModes {
     Immediate,
     Mailbox,
     FIFO,
     FIFORelaxed,
     SharedDemandRefresh,
     SharedContinuous
   };
   
   enum class PipelineType
   {
     Graphics,
     Compute
   };
   
   enum class RenderPassType
   {
     Graphics,
     Compute
   };
   
   enum class ShaderStage : U32 {
     All = 0x00001111,
     Vertex = 0x00000001,
     Pixel = 0x00000010,
     Compute = 0x00000100,
     Geometry = 0x00001000
   };
   
   BOOST_BITMASK(ShaderStage);
   
   enum class BufferUsage {
     Vertex,
     Index,
   };
   
   enum class BufferUsageRate {
     PerVertex,
     PerInstance
   };
   
   enum class BlendFactor {
     Zero,
     One,
     SrcColor,
     OneMinusSrcColor,
     DstColor,
     OneMinusDstColor,
     SrcAlpha,
     OneMinusSrcAlpha,
     DstAlpha,
     OneMinusDstAlpha,
     ConstantColor,
     OneMinusConstantColor,
     ConstantAlpha,
     OneMinusConstantAlpha,
     SrcAlphaSaturate,
     Src1Color,
     OneMinusSrc1Color,
     Src1Alpha,
     OneMinusSrc1Alpha
   };
   
   enum class BlendOp {
     Add,
     Subtract,
     ReverseSubtract,
     Min,
     Max
   };
   
   struct BlendingEq {
     BlendFactor m_srcFactor{};
     BlendFactor m_dstFactor{};
     BlendOp m_op{};
   };
   
   struct BlendState {
     bool m_enable{false};
     BlendingEq m_color{};
     BlendingEq m_alpha{};
   };
   
   enum class PrimitiveTopology {
     PointList,
     LineList,
     LineStrip,
     TriangleList,
     TriangleStrip,
     TriangleFan,
     LineListWithAdjacency,
     LineStripWithAdjacency,
     TriangleListWithAdjacency,
     TriangleStripWithAdjacency,
     PatchList
   };
   
   enum class CullMode {
     None,
     FrontBit,
     BackBit,
     FrontAndBack
   };
   
   enum class FrontFace {
     CounterClockwise,
     Clockwise
   };
   
   enum class DrawType {
     InstancedIndexed,
     InstancedIndexedIndirect
   };
   
   enum class ImageType {
     Image1D,
     Image2D,
     Image3D
   };
   
   enum class ImageViewType {
     ImageView1D,
     ImageView1DArray,
     ImageView2D,
     ImageView2DArray,
     ImageView3D,
     ImageViewCubeMap,
     ImageViewCubeMapArray,
   };
   
   enum class SamplerType {
     Sampler1D,
     Sampler2D,
     Sampler3D
   };
   
   enum class DescriptorType {
     UniformBuffer,
     Sampler,
     SampledImage,
     CombinedImageSampler,
     PushConstant,
     UnorderedView
   };
   
   enum class BufferSource {
     Normal,
     StructuredBuffer
   };
   
   const U32 MAX_DESCRIPTOR_TYPE_COUNT = 5;
   
   struct Bounds3D {
     U32 m_width{1};
     U32 m_height{1};
     U32 m_depth{1};
   
     Bounds3D(U32 width, U32 height, U32 depth)
       : m_width(width),
         m_height(height),
         m_depth(depth) {
   
     }
   
     U32 GetSize() const {
       return m_width * m_height * m_depth;
     }
   };
   
   struct Bounds2D {
     U32 m_width{0};
     U32 m_height{0};
   
     Bounds2D(U32 width, U32 height)
       : m_width(width),
         m_height(height) {
   
     }
   };
   
   struct ShaderStageInfo {
     ShaderStage m_stage;
     String m_entryPoint;
     String m_filePath;
     bool m_isCompiled;
   };
   
   struct ViewportDimensions {
     float m_x;
     float m_y;
     float m_width;
     float m_height;
     float m_minDepth;
     float m_maxDepth;
   };
   
   using SlotID = U32;
   
   struct SlotSemantic {
     const char* m_name;
     RawStorageFormat m_format;
     U32 m_id{0};
   };
   
   struct VertexSlot {
     BufferUsageRate m_rate;
     SmallVector<SlotSemantic, 10> m_stride;
     U32 m_strideSize{0};
     BufferSource m_bufferSource{BufferSource::Normal};
   };
   
   struct DescriptorSlotCreateInfo {
     DescriptorType m_type{DescriptorType::UniformBuffer};
     ShaderStage m_stages{ShaderStage::All};
   };
   
   struct DescriptorSlot {
     U32 m_key{0};
     DescriptorType m_type{DescriptorType::UniformBuffer};
     ShaderStage m_stages{ShaderStage::All};
     U32 m_setIdx{0};
     U32 m_bindIdx{0};
   };
   
   struct TextureDesc {
     Bounds3D m_bounds{1, 1, 1};
     U32 m_size{0};
     U32 m_mipLevels{1};
     U32 m_arrayLayers{1};
     ImageType m_type{ImageType::Image2D};
     RawStorageFormat m_format{RawStorageFormat::R8G8B8A8_UNORM};
   };
   
   enum class TextureAddressMode {
     Wrap,
     Mirror,
     Clamp,
     Border,
     MirrorOnce
   };
   
   enum class TextureFilter {
     MinMagMipPoint,
     MinMagPoint_MipLinear,
     MinPoint_MagLinear_MipPoint,
     MinPoint_MagMipLinear,
     MinLinear_MagMipPoint,
     MinLinear_MagPoint_MipLinear,
     MinMagLinear_MipPoint,
     MinMagMipLinear,
     Anisotropic,
   };
   
   struct SamplerDesc {
     TextureAddressMode m_addressModeU{TextureAddressMode::Wrap};
     TextureAddressMode m_addressModeV{TextureAddressMode::Wrap};
     TextureAddressMode m_addressModeW{TextureAddressMode::Wrap};
   
     TextureFilter m_filter{TextureFilter::MinMagMipLinear};
   };
   
   struct BufferInfo {
     U32 m_offset;
     U32 m_byteSize;
     U32 m_maxByteSize;
     U32 m_binding;
     U32 m_sourceBufferId;
   
     BufferInfo()
       : m_offset(0),
         m_byteSize(0),
         m_maxByteSize(0),
         m_binding(0),
         m_sourceBufferId(0) {
     }
   };
   
   enum class BufferUpdateType {
     UniformBuffer,
     Sampler,
     SampledImage,
     CombinedImageSampler,
     PushConstant,
     UnorderedView,
     Vertex,
     Instance
   };
   
   struct BufferUpdate
   {
     BufferUpdateType m_type;
   
     U32 m_idx;
     U32 m_gpuOffset;
     U32 m_gpuByteSize;
   
     U32 m_updateOffset;
     U32 m_updateByteSize;
   };
   
   struct TextureBufferInfo final : public BufferInfo {
     TextureDesc m_desc;
     U32 m_set{0};
   };
   
   struct SamplerInfo {
     U32 m_set{0};
     U32 m_binding{0};
     SamplerDesc m_desc{};
   };
   
   struct UniformBufferInfo final : public BufferInfo {
     U32 m_set{0};
   };
   
   struct BufferTargetInfo final : public BufferInfo {
     U32 m_set{0};
   };
   
   
   struct LayerSubresource {
     U32 m_layerCount{1};
     U32 m_baseLayer{0};
   };
   
   struct TextureSubresource {
     LayerSubresource m_layerInfo{};
     U32 m_mipLevel{0};
   };
   
   struct TextureRequirements {
     U32 m_maxCount{0};
     U32 m_poolSize{0};
   };
   
   struct DeviceRequirements {
     bool m_discreteGPU{true};
     bool m_transferQueue{false};
     bool m_float64{false};
     bool m_int64{false};
   };
   
   struct ApplicationInfo {
     std::string m_name;
     Version m_version;
   };
   
   constexpr U32 DEFAULT_FRAMES_IN_FLIGHT = 2;
   constexpr U32 MAX_RENDER_PASS_INPUTS   = 10;
   constexpr U32 MAX_RENDER_PASS_OUTPUTS  = 10;
   constexpr U32 MAX_RENDER_PASS_SETS     = 10;
   constexpr U32 MAX_RENDER_PASS_SHADERS  = 10;
   
   struct MemoryRequirements {
     U32 m_stagingBufferSize{0x4000000};
   };
   
   struct ApplicationRequirements {
     MemoryRequirements m_renderer;
   };
   
   struct SwapChainRequirements {
     RawStorageFormat m_format{};
     RawStorageFormat m_depthFormat{};
     Bounds2D m_extent{0u, 0u};
     ColorSpace m_colorSpace{};
     U32 m_framesInFlight{DEFAULT_FRAMES_IN_FLIGHT};
   };
   
   struct ShaderCreateInfo {
     ShaderStage m_stage;
     String m_shaderFileName;
     AssetLocation location;
   };
   
   struct RenderTargetCreateInfo {
     RawStorageFormat m_format{RawStorageFormat::UNKNOWN};
     int m_width{-1};
     int m_height{-1};
     int m_depth{1};
   };
   
   struct StructuredBufferCreateInfo {
     U32 m_size;
     U32 m_stride;
   };
   
   struct PipelinePassInput {
     U32 m_id;
     ShaderStage m_stages;
   };
   
   struct ClearData {
     float m_color[4]{0.0f, 0.0f, 0.0f, 1.0f};
     float m_depth{1.0f};
     U8 m_stencil{0};
   };
   
   struct PipelinePassCreateInfo {
     using Shaders = SmallVector<U32, MAX_RENDER_PASS_SHADERS>;
     using OutputTargets = SmallVector<U32, MAX_RENDER_PASS_OUTPUTS>;
     using OutputBuffers = SmallVector<U32, MAX_RENDER_PASS_OUTPUTS>;
     using InputTargets = SmallVector<PipelinePassInput, MAX_RENDER_PASS_INPUTS>;
     using InputBuffers = SmallVector<PipelinePassInput, MAX_RENDER_PASS_INPUTS>;
     using DescriptorSets = SmallVector<U32, MAX_RENDER_PASS_SETS>;
   
     Shaders m_shaders{};
   
     InputTargets m_inputTargets{};
     InputBuffers m_inputBuffers{};
     OutputTargets m_outputTargets{};
     OutputBuffers m_outputBuffers{};
     DescriptorSets m_descriptorSets{};
   
     ClearData m_clearData{};
     BlendState m_blendState{};
     RenderPassType m_type{RenderPassType::Graphics};
   };
   
   struct DescriptorRequirements {
     DescriptorRequirements(U32 numDescriptors, U32 numSets, Memory::Allocator& alloc);
     U32 AddDescriptor(const DescriptorSlotCreateInfo& info);
     U32 AddSet(const std::initializer_list<U32>& sets);
   
     Containers::Vector<DescriptorSlotCreateInfo> m_descriptorSlots;
     Containers::Vector<Containers::Vector<U32>> m_descriptorSets;
   
   private:
     std::reference_wrapper<Memory::Allocator> m_allocator;
   };
   
   struct ShaderRequirements {
     ShaderRequirements(U32 numShaders, Memory::Allocator& allocator);
     U32 AddShader(const ShaderCreateInfo& info);
   
     Containers::Vector<ShaderCreateInfo> m_shaders;
   };
   
   struct RenderPassRequirements {
     RenderPassRequirements(U32 numRenderTargets, U32 numPasses, U32 numBuffers, Memory::Allocator& alloc);
     U32 AddTarget(const RenderTargetCreateInfo& info);
     U32 AddBuffer(const StructuredBufferCreateInfo& info);
     U32 AddPass(const PipelinePassCreateInfo& info);
   
     Containers::Vector<StructuredBufferCreateInfo> m_buffers;
     Containers::Vector<RenderTargetCreateInfo> m_targets;
     Containers::Vector<PipelinePassCreateInfo> m_passSequence;
   
     U32 m_maxPools{1};
   };
   
   struct DescriptorCount {
     U32 m_numUniformSlots{0};
     U32 m_numSamplerSlots{0};
     U32 m_numCombinedSamplerSlots{0};
     U32 m_numSampledImageSlots{0};
     U32 m_numPushConstantsSlots{0};
     U32 m_numUnorderedViewSlots{0};
   };
   
   struct ThreadGroupDimensions
   {
     U32 m_x{1};
     U32 m_y{1};
     U32 m_z{1};
   };
   
   struct DescriptorTableEntry {
     int m_count{1};
     int m_cumulativeCount{0};
     DescriptorType m_type;
   };
   
   } // namespace Azura