GraphicsTypes.h

Go to the documentation of this file.

/*
 *  Copyright 2019-2021 Diligent Graphics LLC
 *  Copyright 2015-2019 Egor Yusov
 *  
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *  
 *      http://www.apache.org/licenses/LICENSE-2.0
 *  
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *  In no event and under no legal theory, whether in tort (including negligence), 
 *  contract, or otherwise, unless required by applicable law (such as deliberate 
 *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
 *  liable for any damages, including any direct, indirect, special, incidental, 
 *  or consequential damages of any character arising as a result of this License or 
 *  out of the use or inability to use the software (including but not limited to damages 
 *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and 
 *  all other commercial damages or losses), even if such Contributor has been advised 
 *  of the possibility of such damages.
 */
 
#pragma once
 
// clang-format off
 
 
#include "../../../Primitives/interface/BasicTypes.h"
#include "../../../Primitives/interface/DebugOutput.h"
#include "../../../Primitives/interface/FlagEnum.h"
#include "../../../Platforms/interface/NativeWindow.h"
#include "APIInfo.h"
 
DILIGENT_BEGIN_NAMESPACE(Diligent)
 
 
DILIGENT_TYPED_ENUM(VALUE_TYPE, Uint8)
{
    VT_UNDEFINED = 0, 
    VT_INT8,          
    VT_INT16,         
    VT_INT32,         
    VT_UINT8,         
    VT_UINT16,        
    VT_UINT32,        
    VT_FLOAT16,       
    VT_FLOAT32,       
    VT_NUM_TYPES      
};
 
 
DILIGENT_TYPED_ENUM(SHADER_TYPE, Uint32)
{
    SHADER_TYPE_UNKNOWN          = 0x0000, 
    SHADER_TYPE_VERTEX           = 0x0001, 
    SHADER_TYPE_PIXEL            = 0x0002, 
    SHADER_TYPE_GEOMETRY         = 0x0004, 
    SHADER_TYPE_HULL             = 0x0008, 
    SHADER_TYPE_DOMAIN           = 0x0010, 
    SHADER_TYPE_COMPUTE          = 0x0020, 
    SHADER_TYPE_AMPLIFICATION    = 0x0040, 
    SHADER_TYPE_MESH             = 0x0080, 
    SHADER_TYPE_RAY_GEN          = 0x0100, 
    SHADER_TYPE_RAY_MISS         = 0x0200, 
    SHADER_TYPE_RAY_CLOSEST_HIT  = 0x0400, 
    SHADER_TYPE_RAY_ANY_HIT      = 0x0800, 
    SHADER_TYPE_RAY_INTERSECTION = 0x1000, 
    SHADER_TYPE_CALLABLE         = 0x2000, 
    SHADER_TYPE_LAST             = SHADER_TYPE_CALLABLE,
 
    SHADER_TYPE_ALL_GRAPHICS    = SHADER_TYPE_VERTEX   |
                                  SHADER_TYPE_PIXEL    |
                                  SHADER_TYPE_GEOMETRY | 
                                  SHADER_TYPE_HULL     | 
                                  SHADER_TYPE_DOMAIN,
 
    SHADER_TYPE_ALL_MESH        = SHADER_TYPE_AMPLIFICATION |
                                  SHADER_TYPE_MESH |
                                  SHADER_TYPE_PIXEL,
 
    SHADER_TYPE_ALL_RAY_TRACING    = SHADER_TYPE_RAY_GEN          |
                                     SHADER_TYPE_RAY_MISS         |
                                     SHADER_TYPE_RAY_CLOSEST_HIT  |
                                     SHADER_TYPE_RAY_ANY_HIT      |
                                     SHADER_TYPE_RAY_INTERSECTION |
                                     SHADER_TYPE_CALLABLE
};
DEFINE_FLAG_ENUM_OPERATORS(SHADER_TYPE);
 
 
 
DILIGENT_TYPED_ENUM(BIND_FLAGS, Uint32)
{
    BIND_NONE                = 0x0,   
    BIND_VERTEX_BUFFER       = 0x1,   
    BIND_INDEX_BUFFER        = 0x2,   
    BIND_UNIFORM_BUFFER      = 0x4,   
    BIND_SHADER_RESOURCE     = 0x8,   
    BIND_STREAM_OUTPUT       = 0x10,  
    BIND_RENDER_TARGET       = 0x20,  
    BIND_DEPTH_STENCIL       = 0x40,  
    BIND_UNORDERED_ACCESS    = 0x80,  
    BIND_INDIRECT_DRAW_ARGS  = 0x100, 
    BIND_INPUT_ATTACHMENT    = 0x200, 
    BIND_RAY_TRACING         = 0x400, 
    BIND_FLAGS_LAST          = 0x400
};
DEFINE_FLAG_ENUM_OPERATORS(BIND_FLAGS)
 
 
DILIGENT_TYPED_ENUM(USAGE, Uint8)
{
    USAGE_IMMUTABLE = 0, 
 
    USAGE_DEFAULT,
 
    USAGE_DYNAMIC,
 
    USAGE_STAGING,
 
    USAGE_UNIFIED,
 
    USAGE_NUM_USAGES
};
 
    
DILIGENT_TYPED_ENUM(CPU_ACCESS_FLAGS, Uint8)
{
    CPU_ACCESS_NONE  = 0x00, 
    CPU_ACCESS_READ  = 0x01, 
    CPU_ACCESS_WRITE = 0x02  
};
DEFINE_FLAG_ENUM_OPERATORS(CPU_ACCESS_FLAGS)
 
 
DILIGENT_TYPED_ENUM(MAP_TYPE, Uint8)
{
    MAP_READ = 0x01,       
 
    MAP_WRITE = 0x02,          
 
    MAP_READ_WRITE = 0x03
};
 
 
DILIGENT_TYPED_ENUM(MAP_FLAGS, Uint8)
{
    MAP_FLAG_NONE         = 0x000,
 
    MAP_FLAG_DO_NOT_WAIT  = 0x001,
 
    MAP_FLAG_DISCARD      = 0x002,
 
    MAP_FLAG_NO_OVERWRITE = 0x004
};
DEFINE_FLAG_ENUM_OPERATORS(MAP_FLAGS)
 
 
DILIGENT_TYPED_ENUM(RESOURCE_DIMENSION, Uint8)
{
    RESOURCE_DIM_UNDEFINED = 0,  
    RESOURCE_DIM_BUFFER,         
    RESOURCE_DIM_TEX_1D,         
    RESOURCE_DIM_TEX_1D_ARRAY,   
    RESOURCE_DIM_TEX_2D,         
    RESOURCE_DIM_TEX_2D_ARRAY,   
    RESOURCE_DIM_TEX_3D,         
    RESOURCE_DIM_TEX_CUBE,       
    RESOURCE_DIM_TEX_CUBE_ARRAY, 
    RESOURCE_DIM_NUM_DIMENSIONS  
};
 
 
DILIGENT_TYPED_ENUM(TEXTURE_VIEW_TYPE, Uint8)
{
    TEXTURE_VIEW_UNDEFINED = 0,
 
    TEXTURE_VIEW_SHADER_RESOURCE,
 
    TEXTURE_VIEW_RENDER_TARGET,
 
    TEXTURE_VIEW_DEPTH_STENCIL,
 
    TEXTURE_VIEW_UNORDERED_ACCESS,
 
    TEXTURE_VIEW_NUM_VIEWS
};
 
 
DILIGENT_TYPED_ENUM(BUFFER_VIEW_TYPE, Uint8)
{
    BUFFER_VIEW_UNDEFINED = 0,
 
    BUFFER_VIEW_SHADER_RESOURCE,
 
    BUFFER_VIEW_UNORDERED_ACCESS,
 
    BUFFER_VIEW_NUM_VIEWS
};
 
 
DILIGENT_TYPED_ENUM(TEXTURE_FORMAT, Uint16)
{
    TEX_FORMAT_UNKNOWN = 0,
 
    TEX_FORMAT_RGBA32_TYPELESS,
 
    TEX_FORMAT_RGBA32_FLOAT,  
 
    TEX_FORMAT_RGBA32_UINT,
 
    TEX_FORMAT_RGBA32_SINT,  
 
    TEX_FORMAT_RGB32_TYPELESS,  
 
    TEX_FORMAT_RGB32_FLOAT,  
 
    TEX_FORMAT_RGB32_UINT,  
 
    TEX_FORMAT_RGB32_SINT,  
 
    TEX_FORMAT_RGBA16_TYPELESS,  
 
    TEX_FORMAT_RGBA16_FLOAT, 
 
    TEX_FORMAT_RGBA16_UNORM, 
 
    TEX_FORMAT_RGBA16_UINT, 
 
    TEX_FORMAT_RGBA16_SNORM, 
 
    TEX_FORMAT_RGBA16_SINT, 
 
    TEX_FORMAT_RG32_TYPELESS, 
 
    TEX_FORMAT_RG32_FLOAT, 
 
    TEX_FORMAT_RG32_UINT, 
 
    TEX_FORMAT_RG32_SINT, 
 
    TEX_FORMAT_R32G8X24_TYPELESS, 
 
    TEX_FORMAT_D32_FLOAT_S8X24_UINT, 
 
    TEX_FORMAT_R32_FLOAT_X8X24_TYPELESS, 
 
    TEX_FORMAT_X32_TYPELESS_G8X24_UINT, 
 
    TEX_FORMAT_RGB10A2_TYPELESS, 
 
    TEX_FORMAT_RGB10A2_UNORM, 
 
    TEX_FORMAT_RGB10A2_UINT, 
 
    TEX_FORMAT_R11G11B10_FLOAT, 
 
    TEX_FORMAT_RGBA8_TYPELESS, 
 
    TEX_FORMAT_RGBA8_UNORM,
 
    TEX_FORMAT_RGBA8_UNORM_SRGB, 
 
    TEX_FORMAT_RGBA8_UINT, 
 
    TEX_FORMAT_RGBA8_SNORM, 
 
    TEX_FORMAT_RGBA8_SINT, 
 
    TEX_FORMAT_RG16_TYPELESS, 
 
    TEX_FORMAT_RG16_FLOAT, 
 
    TEX_FORMAT_RG16_UNORM, 
 
    TEX_FORMAT_RG16_UINT, 
 
    TEX_FORMAT_RG16_SNORM, 
 
    TEX_FORMAT_RG16_SINT, 
 
    TEX_FORMAT_R32_TYPELESS, 
 
    TEX_FORMAT_D32_FLOAT, 
 
    TEX_FORMAT_R32_FLOAT, 
 
    TEX_FORMAT_R32_UINT, 
 
    TEX_FORMAT_R32_SINT, 
 
    TEX_FORMAT_R24G8_TYPELESS, 
 
    TEX_FORMAT_D24_UNORM_S8_UINT, 
 
    TEX_FORMAT_R24_UNORM_X8_TYPELESS, 
 
    TEX_FORMAT_X24_TYPELESS_G8_UINT, 
 
    TEX_FORMAT_RG8_TYPELESS, 
 
    TEX_FORMAT_RG8_UNORM, 
 
    TEX_FORMAT_RG8_UINT, 
 
    TEX_FORMAT_RG8_SNORM, 
 
    TEX_FORMAT_RG8_SINT, 
 
    TEX_FORMAT_R16_TYPELESS, 
 
    TEX_FORMAT_R16_FLOAT, 
 
    TEX_FORMAT_D16_UNORM, 
 
    TEX_FORMAT_R16_UNORM, 
 
    TEX_FORMAT_R16_UINT, 
 
    TEX_FORMAT_R16_SNORM, 
 
    TEX_FORMAT_R16_SINT, 
 
    TEX_FORMAT_R8_TYPELESS, 
 
    TEX_FORMAT_R8_UNORM, 
 
    TEX_FORMAT_R8_UINT, 
 
    TEX_FORMAT_R8_SNORM, 
 
    TEX_FORMAT_R8_SINT, 
 
    TEX_FORMAT_A8_UNORM, 
 
    TEX_FORMAT_R1_UNORM, 
 
    TEX_FORMAT_RGB9E5_SHAREDEXP, 
 
    TEX_FORMAT_RG8_B8G8_UNORM, 
 
    TEX_FORMAT_G8R8_G8B8_UNORM, 
 
    TEX_FORMAT_BC1_TYPELESS, 
 
    TEX_FORMAT_BC1_UNORM,
 
    TEX_FORMAT_BC1_UNORM_SRGB,
 
    TEX_FORMAT_BC2_TYPELESS, 
 
    TEX_FORMAT_BC2_UNORM,
 
    TEX_FORMAT_BC2_UNORM_SRGB,
 
    TEX_FORMAT_BC3_TYPELESS, 
 
    TEX_FORMAT_BC3_UNORM,
 
    TEX_FORMAT_BC3_UNORM_SRGB,
 
    TEX_FORMAT_BC4_TYPELESS, 
 
    TEX_FORMAT_BC4_UNORM,
 
    TEX_FORMAT_BC4_SNORM,
 
    TEX_FORMAT_BC5_TYPELESS,
 
    TEX_FORMAT_BC5_UNORM,
 
    TEX_FORMAT_BC5_SNORM,
 
    TEX_FORMAT_B5G6R5_UNORM,
 
    TEX_FORMAT_B5G5R5A1_UNORM, 
 
    TEX_FORMAT_BGRA8_UNORM,
 
    TEX_FORMAT_BGRX8_UNORM,
 
    TEX_FORMAT_R10G10B10_XR_BIAS_A2_UNORM,
 
    TEX_FORMAT_BGRA8_TYPELESS,
 
    TEX_FORMAT_BGRA8_UNORM_SRGB,
 
    TEX_FORMAT_BGRX8_TYPELESS,
 
    TEX_FORMAT_BGRX8_UNORM_SRGB,
 
    TEX_FORMAT_BC6H_TYPELESS,
 
    TEX_FORMAT_BC6H_UF16,
 
    TEX_FORMAT_BC6H_SF16,
 
    TEX_FORMAT_BC7_TYPELESS,
 
    TEX_FORMAT_BC7_UNORM,
 
    TEX_FORMAT_BC7_UNORM_SRGB,
 
    TEX_FORMAT_NUM_FORMATS
};
 
 
DILIGENT_TYPED_ENUM(FILTER_TYPE, Uint8)
{
    FILTER_TYPE_UNKNOWN  = 0,           
    FILTER_TYPE_POINT,                  
    FILTER_TYPE_LINEAR,                 
    FILTER_TYPE_ANISOTROPIC,            
    FILTER_TYPE_COMPARISON_POINT,       
    FILTER_TYPE_COMPARISON_LINEAR,      
    FILTER_TYPE_COMPARISON_ANISOTROPIC, 
    FILTER_TYPE_MINIMUM_POINT,          
    FILTER_TYPE_MINIMUM_LINEAR,         
    FILTER_TYPE_MINIMUM_ANISOTROPIC,    
    FILTER_TYPE_MAXIMUM_POINT,          
    FILTER_TYPE_MAXIMUM_LINEAR,         
    FILTER_TYPE_MAXIMUM_ANISOTROPIC,    
    FILTER_TYPE_NUM_FILTERS             
};
 
 
DILIGENT_TYPED_ENUM(TEXTURE_ADDRESS_MODE, Uint8)
{
    TEXTURE_ADDRESS_UNKNOWN = 0,
 
    TEXTURE_ADDRESS_WRAP    = 1,
 
    TEXTURE_ADDRESS_MIRROR  = 2,
 
    TEXTURE_ADDRESS_CLAMP   = 3,
 
    TEXTURE_ADDRESS_BORDER  = 4,
 
    TEXTURE_ADDRESS_MIRROR_ONCE = 5,
 
    TEXTURE_ADDRESS_NUM_MODES
};
 
 
DILIGENT_TYPED_ENUM(COMPARISON_FUNCTION, Uint8)
{
    COMPARISON_FUNC_UNKNOWN = 0,
 
    COMPARISON_FUNC_NEVER,
 
    COMPARISON_FUNC_LESS,
 
    COMPARISON_FUNC_EQUAL,
 
    COMPARISON_FUNC_LESS_EQUAL,
 
    COMPARISON_FUNC_GREATER,
 
    COMPARISON_FUNC_NOT_EQUAL,
 
    COMPARISON_FUNC_GREATER_EQUAL,
 
    COMPARISON_FUNC_ALWAYS,
 
    COMPARISON_FUNC_NUM_FUNCTIONS
};
 
 
DILIGENT_TYPED_ENUM(MISC_TEXTURE_FLAGS, Uint8)
{
    MISC_TEXTURE_FLAG_NONE          = 0x00,
 
 
    MISC_TEXTURE_FLAG_GENERATE_MIPS = 0x01
};
DEFINE_FLAG_ENUM_OPERATORS(MISC_TEXTURE_FLAGS)
 
 
DILIGENT_TYPED_ENUM(PRIMITIVE_TOPOLOGY, Uint8)
{
    PRIMITIVE_TOPOLOGY_UNDEFINED = 0,
 
    PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
 
    PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
 
    PRIMITIVE_TOPOLOGY_POINT_LIST,
 
    PRIMITIVE_TOPOLOGY_LINE_LIST,
 
    PRIMITIVE_TOPOLOGY_LINE_STRIP,
 
    PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST,
 
    PRIMITIVE_TOPOLOGY_NUM_TOPOLOGIES
};
 
 
struct DepthStencilClearValue
{
    Float32 Depth   DEFAULT_INITIALIZER(1.f);
    Uint8 Stencil   DEFAULT_INITIALIZER(0);
 
#if DILIGENT_CPP_INTERFACE
    DepthStencilClearValue()noexcept{}
 
    DepthStencilClearValue(Float32 _Depth,
                           Uint8   _Stencil)noexcept : 
        Depth   {_Depth  },
        Stencil {_Stencil}
    {}
#endif
};
typedef struct DepthStencilClearValue DepthStencilClearValue;
 
struct OptimizedClearValue
{
    TEXTURE_FORMAT Format       DEFAULT_INITIALIZER(TEX_FORMAT_UNKNOWN);
 
    Float32        Color[4]     DEFAULT_INITIALIZER({});
 
    DepthStencilClearValue DepthStencil;
 
#if DILIGENT_CPP_INTERFACE
    bool operator == (const OptimizedClearValue& rhs)const
    {
        return Format == rhs.Format &&
               Color[0] == rhs.Color[0] &&
               Color[1] == rhs.Color[1] &&
               Color[2] == rhs.Color[2] &&
               Color[3] == rhs.Color[3] &&
               DepthStencil.Depth   == rhs.DepthStencil.Depth &&
               DepthStencil.Stencil == rhs.DepthStencil.Stencil;
    }
#endif
};
typedef struct OptimizedClearValue OptimizedClearValue;
 
 
struct DeviceObjectAttribs
{
    const Char* Name DEFAULT_INITIALIZER(nullptr);
 
    // We have to explicitly define constructors because otherwise Apple's clang fails to compile the following legitimate code:
    //     DeviceObjectAttribs{"Name"}
 
#if DILIGENT_CPP_INTERFACE
    DeviceObjectAttribs()noexcept{}
 
    explicit DeviceObjectAttribs(const Char* _Name) : 
        Name{_Name}
    {}
#endif
};
typedef struct DeviceObjectAttribs DeviceObjectAttribs;
    
DILIGENT_TYPED_ENUM(ADAPTER_TYPE, Uint8)
{
    ADAPTER_TYPE_UNKNOWN = 0,
 
    ADAPTER_TYPE_SOFTWARE,
 
    ADAPTER_TYPE_HARDWARE
};
 
 
enum SCALING_MODE
{
    SCALING_MODE_UNSPECIFIED = 0,
 
    SCALING_MODE_CENTERED = 1,
 
    SCALING_MODE_STRETCHED = 2
};
 
 
enum SCANLINE_ORDER
{
    SCANLINE_ORDER_UNSPECIFIED = 0,
 
    SCANLINE_ORDER_PROGRESSIVE = 1,
 
    SCANLINE_ORDER_UPPER_FIELD_FIRST = 2,
 
    SCANLINE_ORDER_LOWER_FIELD_FIRST = 3
};
 
struct DisplayModeAttribs
{
    Uint32 Width                    DEFAULT_INITIALIZER(0);
 
    Uint32 Height                   DEFAULT_INITIALIZER(0);
 
    TEXTURE_FORMAT Format           DEFAULT_INITIALIZER(TEX_FORMAT_UNKNOWN);
 
    Uint32 RefreshRateNumerator     DEFAULT_INITIALIZER(0);
 
    Uint32 RefreshRateDenominator   DEFAULT_INITIALIZER(0);
 
    enum SCALING_MODE Scaling           DEFAULT_INITIALIZER(SCALING_MODE_UNSPECIFIED);
 
    enum SCANLINE_ORDER ScanlineOrder   DEFAULT_INITIALIZER(SCANLINE_ORDER_UNSPECIFIED);
};
typedef struct DisplayModeAttribs DisplayModeAttribs;
 
DILIGENT_TYPED_ENUM(SWAP_CHAIN_USAGE_FLAGS, Uint32)
{
    SWAP_CHAIN_USAGE_NONE             = 0x00L,
        
    SWAP_CHAIN_USAGE_RENDER_TARGET    = 0x01L,
 
    SWAP_CHAIN_USAGE_SHADER_INPUT     = 0x02L,
 
    SWAP_CHAIN_USAGE_COPY_SOURCE      = 0x04L,
 
    SWAP_CHAIN_USAGE_LAST             = SWAP_CHAIN_USAGE_COPY_SOURCE,
};
DEFINE_FLAG_ENUM_OPERATORS(SWAP_CHAIN_USAGE_FLAGS)
 
 
DILIGENT_TYPED_ENUM(SURFACE_TRANSFORM, Uint32)
{
    SURFACE_TRANSFORM_OPTIMAL = 0,
 
    SURFACE_TRANSFORM_IDENTITY,
 
    SURFACE_TRANSFORM_ROTATE_90,
 
    SURFACE_TRANSFORM_ROTATE_180,
 
    SURFACE_TRANSFORM_ROTATE_270,
 
    SURFACE_TRANSFORM_HORIZONTAL_MIRROR,
 
    SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90,
 
    SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180,
 
    SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270
};
 
 
struct SwapChainDesc
{
    Uint32 Width                        DEFAULT_INITIALIZER(0);
 
    Uint32 Height                       DEFAULT_INITIALIZER(0);
        
    TEXTURE_FORMAT ColorBufferFormat    DEFAULT_INITIALIZER(TEX_FORMAT_RGBA8_UNORM_SRGB);
        
    TEXTURE_FORMAT DepthBufferFormat    DEFAULT_INITIALIZER(TEX_FORMAT_D32_FLOAT);
 
    SWAP_CHAIN_USAGE_FLAGS Usage        DEFAULT_INITIALIZER(SWAP_CHAIN_USAGE_RENDER_TARGET);
 
    SURFACE_TRANSFORM PreTransform      DEFAULT_INITIALIZER(SURFACE_TRANSFORM_OPTIMAL);
 
    Uint32 BufferCount                  DEFAULT_INITIALIZER(2);
    
    Float32 DefaultDepthValue           DEFAULT_INITIALIZER(1.f);
 
    Uint8 DefaultStencilValue           DEFAULT_INITIALIZER(0);
 
    bool  IsPrimary                     DEFAULT_INITIALIZER(true);
 
#if DILIGENT_CPP_INTERFACE
    SwapChainDesc() noexcept
    {
#if PLATFORM_ANDROID || PLATFORM_IOS
        // Use 3 buffers by default on mobile platforms
        BufferCount = 3;
#endif
    }
 
    SwapChainDesc(Uint32         _Width,
                  Uint32         _Height,
                  TEXTURE_FORMAT _ColorBufferFormat,
                  TEXTURE_FORMAT _DepthBufferFormat,
                  Uint32         _BufferCount         = SwapChainDesc{}.BufferCount,
                  Float32        _DefaultDepthValue   = SwapChainDesc{}.DefaultDepthValue,
                  Uint8          _DefaultStencilValue = SwapChainDesc{}.DefaultStencilValue,
                  bool           _IsPrimary           = SwapChainDesc{}.IsPrimary) :
        Width               {_Width              },
        Height              {_Height             },
        ColorBufferFormat   {_ColorBufferFormat  },
        DepthBufferFormat   {_DepthBufferFormat  },
        BufferCount         {_BufferCount        },
        DefaultDepthValue   {_DefaultDepthValue  },
        DefaultStencilValue {_DefaultStencilValue},
        IsPrimary           {_IsPrimary          }
    {
    }
#endif
};
typedef struct SwapChainDesc SwapChainDesc;
 
struct FullScreenModeDesc
{
    Bool Fullscreen                 DEFAULT_INITIALIZER(False);
 
    Uint32 RefreshRateNumerator     DEFAULT_INITIALIZER(0);
 
    Uint32 RefreshRateDenominator   DEFAULT_INITIALIZER(0);
 
    enum SCALING_MODE    Scaling         DEFAULT_INITIALIZER(SCALING_MODE_UNSPECIFIED);
 
    enum SCANLINE_ORDER  ScanlineOrder   DEFAULT_INITIALIZER(SCANLINE_ORDER_UNSPECIFIED);
};
typedef struct FullScreenModeDesc FullScreenModeDesc;
 
 
enum QUERY_TYPE
{
    QUERY_TYPE_UNDEFINED = 0,
 
    QUERY_TYPE_OCCLUSION,
 
    QUERY_TYPE_BINARY_OCCLUSION,
 
    QUERY_TYPE_TIMESTAMP,
 
    QUERY_TYPE_PIPELINE_STATISTICS,
 
    QUERY_TYPE_DURATION,
 
    QUERY_TYPE_NUM_TYPES
};
 
 
 
enum RENDER_DEVICE_TYPE
{
    RENDER_DEVICE_TYPE_UNDEFINED = 0,  
    RENDER_DEVICE_TYPE_D3D11,          
    RENDER_DEVICE_TYPE_D3D12,          
    RENDER_DEVICE_TYPE_GL,             
    RENDER_DEVICE_TYPE_GLES,           
    RENDER_DEVICE_TYPE_VULKAN,         
    RENDER_DEVICE_TYPE_METAL           
};
 
 
struct SamplerCaps
{
    Bool BorderSamplingModeSupported   DEFAULT_INITIALIZER(False);
 
    Bool AnisotropicFilteringSupported DEFAULT_INITIALIZER(False);
 
    Bool LODBiasSupported              DEFAULT_INITIALIZER(False);
};
typedef struct SamplerCaps SamplerCaps;
 
 
struct TextureCaps
{
    Uint32 MaxTexture1DDimension   DEFAULT_INITIALIZER(0);
 
    Uint32 MaxTexture1DArraySlices DEFAULT_INITIALIZER(0);
 
    Uint32 MaxTexture2DDimension   DEFAULT_INITIALIZER(0);
 
    Uint32 MaxTexture2DArraySlices DEFAULT_INITIALIZER(0);
 
    Uint32 MaxTexture3DDimension   DEFAULT_INITIALIZER(0);
 
    Uint32 MaxTextureCubeDimension DEFAULT_INITIALIZER(0);
 
    Bool Texture2DMSSupported      DEFAULT_INITIALIZER(False);
 
    Bool Texture2DMSArraySupported DEFAULT_INITIALIZER(False);
 
    Bool TextureViewSupported      DEFAULT_INITIALIZER(False);
 
    Bool CubemapArraysSupported    DEFAULT_INITIALIZER(False);
};
typedef struct TextureCaps TextureCaps;
    
 
DILIGENT_TYPED_ENUM(DEVICE_FEATURE_STATE, Uint8)
{
    DEVICE_FEATURE_STATE_DISABLED = 0,
 
 
    DEVICE_FEATURE_STATE_ENABLED = 1,
 
 
    DEVICE_FEATURE_STATE_OPTIONAL = 2
};
 
 
struct DeviceFeatures
{
 
    DEVICE_FEATURE_STATE SeparablePrograms             DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
 
    DEVICE_FEATURE_STATE ShaderResourceQueries         DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE IndirectRendering             DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE WireframeFill                 DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE MultithreadedResourceCreation DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE ComputeShaders                DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE GeometryShaders               DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE Tessellation                  DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE MeshShaders                   DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE RayTracing                    DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE RayTracing2                   DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE BindlessResources             DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE OcclusionQueries              DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE BinaryOcclusionQueries        DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE TimestampQueries              DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE PipelineStatisticsQueries     DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE DurationQueries               DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE DepthBiasClamp                DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE DepthClamp                    DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE IndependentBlend              DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE DualSourceBlend               DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE MultiViewport                 DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE TextureCompressionBC          DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE VertexPipelineUAVWritesAndAtomics DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE PixelUAVWritesAndAtomics          DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE TextureUAVExtendedFormats         DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE ShaderFloat16                     DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE ResourceBuffer16BitAccess         DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE UniformBuffer16BitAccess          DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE ShaderInputOutput16               DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE ShaderInt8                        DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE ResourceBuffer8BitAccess         DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE UniformBuffer8BitAccess          DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE ShaderResourceRuntimeArray       DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
    DEVICE_FEATURE_STATE WaveOp                           DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
#if DILIGENT_CPP_INTERFACE
    DeviceFeatures() noexcept {}
 
    explicit DeviceFeatures(DEVICE_FEATURE_STATE State) noexcept :
        SeparablePrograms                 {State},
        ShaderResourceQueries             {State},
        IndirectRendering                 {State},
        WireframeFill                     {State},
        MultithreadedResourceCreation     {State},
        ComputeShaders                    {State},
        GeometryShaders                   {State},
        Tessellation                      {State},
        MeshShaders                       {State},
        RayTracing                        {State},
        RayTracing2                       {State},
        BindlessResources                 {State},
        OcclusionQueries                  {State},
        BinaryOcclusionQueries            {State},
        TimestampQueries                  {State},
        PipelineStatisticsQueries         {State},
        DurationQueries                   {State},
        DepthBiasClamp                    {State},
        DepthClamp                        {State},
        IndependentBlend                  {State},
        DualSourceBlend                   {State},
        MultiViewport                     {State},
        TextureCompressionBC              {State},
        VertexPipelineUAVWritesAndAtomics {State},
        PixelUAVWritesAndAtomics          {State},
        TextureUAVExtendedFormats         {State},
        ShaderFloat16                     {State},
        ResourceBuffer16BitAccess         {State},
        UniformBuffer16BitAccess          {State},
        ShaderInputOutput16               {State},
        ShaderInt8                        {State},
        ResourceBuffer8BitAccess          {State},
        UniformBuffer8BitAccess           {State},
        ShaderResourceRuntimeArray        {State},
        WaveOp                            {State}
    {
#   if defined(_MSC_VER) && defined(_WIN64)
        static_assert(sizeof(*this) == 35, "Did you add a new feature to DeviceFeatures? Please handle its status above.");
#   endif
    }
#endif
};
typedef struct DeviceFeatures DeviceFeatures;
 
 
DILIGENT_TYPED_ENUM(ADAPTER_VENDOR, Uint8)
{
    ADAPTER_VENDOR_UNKNOWN = 0,
 
    ADAPTER_VENDOR_NVIDIA,
 
    ADAPTER_VENDOR_AMD,
 
    ADAPTER_VENDOR_INTEL,
 
    ADAPTER_VENDOR_ARM,
 
    ADAPTER_VENDOR_QUALCOMM,
 
    ADAPTER_VENDOR_IMGTECH,
 
    ADAPTER_VENDOR_MSFT
};
 
struct GraphicsAdapterInfo
{
    char Description[128]   DEFAULT_INITIALIZER({});
 
    ADAPTER_TYPE   Type     DEFAULT_INITIALIZER(ADAPTER_TYPE_UNKNOWN);
 
    ADAPTER_VENDOR Vendor   DEFAULT_INITIALIZER(ADAPTER_VENDOR_UNKNOWN);
 
    Uint32 VendorId         DEFAULT_INITIALIZER(0);
 
    Uint32 DeviceId         DEFAULT_INITIALIZER(0);
 
    Uint32 NumOutputs       DEFAULT_INITIALIZER(0);
 
 
    Uint64  DeviceLocalMemory   DEFAULT_INITIALIZER(0);
 
 
 
    Uint64  HostVisibileMemory  DEFAULT_INITIALIZER(0);
 
 
 
    Uint64  UnifiedMemory       DEFAULT_INITIALIZER(0);
 
    CPU_ACCESS_FLAGS UnifiedMemoryCPUAccess DEFAULT_INITIALIZER(CPU_ACCESS_NONE);
};
typedef struct GraphicsAdapterInfo GraphicsAdapterInfo;
 
 
struct DeviceCaps
{
    enum RENDER_DEVICE_TYPE DevType DEFAULT_INITIALIZER(RENDER_DEVICE_TYPE_UNDEFINED);
 
    Int32 MajorVersion DEFAULT_INITIALIZER(0);
 
    Int32 MinorVersion DEFAULT_INITIALIZER(0);
 
    GraphicsAdapterInfo AdapterInfo;
 
    SamplerCaps SamCaps;
 
    TextureCaps TexCaps;
 
 
    DeviceFeatures Features;
 
#if DILIGENT_CPP_INTERFACE
    bool IsGLDevice()const
    {
        return DevType == RENDER_DEVICE_TYPE_GL || DevType == RENDER_DEVICE_TYPE_GLES;
    }
    bool IsD3DDevice()const
    {
        return DevType == RENDER_DEVICE_TYPE_D3D11 || DevType == RENDER_DEVICE_TYPE_D3D12;
    }
    bool IsVulkanDevice()const
    {
        return DevType == RENDER_DEVICE_TYPE_VULKAN;
    }
    bool IsMetalDevice()const
    {
        return DevType == RENDER_DEVICE_TYPE_METAL;
    }
 
    struct NDCAttribs
    {
        const float MinZ;          // Minimum z value of normalized device coordinate space
        const float ZtoDepthScale; // NDC z to depth scale
        const float YtoVScale;     // Scale to transform NDC y coordinate to texture V coordinate
 
        float GetZtoDepthBias() const
        {
            // Returns ZtoDepthBias such that given NDC z coordinate, depth value can be
            // computed as follows:
            // d = z * ZtoDepthScale + ZtoDepthBias
            return -MinZ * ZtoDepthScale;
        }
    };
 
    const NDCAttribs& GetNDCAttribs()const
    {
        if (IsVulkanDevice())
        {
            // Note that Vulkan itself does not invert Y coordinate when transforming
            // normalized device Y to window space. However, we use negative viewport
            // height which achieves the same effect as in D3D, thererfore we need to
            // invert y (see comments in DeviceContextVkImpl::CommitViewports() for details)
            static constexpr const NDCAttribs NDCAttribsVk {0.0f, 1.0f, -0.5f};
            return NDCAttribsVk;
        }
        else if (IsD3DDevice())
        {
            static constexpr const NDCAttribs NDCAttribsD3D {0.0f, 1.0f, -0.5f};
            return NDCAttribsD3D;
        }
        else if (IsGLDevice())
        {
            static constexpr const NDCAttribs NDCAttribsGL {-1.0f, 0.5f, 0.5f};
            return NDCAttribsGL;
        }
        else
        {
            static constexpr const NDCAttribs NDCAttribsDefault {0.0f, 1.0f, 0.5f};
            return NDCAttribsDefault;
        }
    }
#endif
};
typedef struct DeviceCaps DeviceCaps;
 
 
DILIGENT_TYPED_ENUM(WAVE_FEATURE, Uint32)
{
    WAVE_FEATURE_UNKNOWN          = 0x00,
    WAVE_FEATURE_BASIC            = 0x01,
    WAVE_FEATURE_VOTE             = 0x02,
    WAVE_FEATURE_ARITHMETIC       = 0x04,
    WAVE_FEATURE_BALLOUT          = 0x08,
    WAVE_FEATURE_SHUFFLE          = 0x10,
    WAVE_FEATURE_SHUFFLE_RELATIVE = 0x20,
    WAVE_FEATURE_CLUSTERED        = 0x40,
    WAVE_FEATURE_QUAD             = 0x80,
    WAVE_FEATURE_LAST             = WAVE_FEATURE_QUAD
};
DEFINE_FLAG_ENUM_OPERATORS(WAVE_FEATURE);
 
 
struct WaveOpProperties
{
    Uint32       MinSize         DEFAULT_INITIALIZER(0);
 
    Uint32       MaxSize         DEFAULT_INITIALIZER(0);
 
    SHADER_TYPE  SupportedStages DEFAULT_INITIALIZER(SHADER_TYPE_UNKNOWN);
 
    WAVE_FEATURE Features        DEFAULT_INITIALIZER(WAVE_FEATURE_UNKNOWN);
};
typedef struct WaveOpProperties WaveOpProperties;
 
 
struct DeviceProperties
{
    Uint32  MaxRayTracingRecursionDepth  DEFAULT_INITIALIZER(0);
 
    WaveOpProperties WaveOp  DEFAULT_INITIALIZER({});
};
typedef struct DeviceProperties DeviceProperties;
 
 
struct EngineCreateInfo
{
    Int32                    APIVersion             DEFAULT_INITIALIZER(DILIGENT_API_VERSION);
 
    Uint32                   NumDeferredContexts    DEFAULT_INITIALIZER(0);
 
 
    DeviceFeatures Features;
 
    struct IMemoryAllocator* pRawMemAllocator       DEFAULT_INITIALIZER(nullptr);
 
    DebugMessageCallbackType DebugMessageCallback   DEFAULT_INITIALIZER(nullptr);
};
typedef struct EngineCreateInfo EngineCreateInfo;
 
struct EngineGLCreateInfo DILIGENT_DERIVE(EngineCreateInfo)
 
    NativeWindow Window;
 
 
    bool CreateDebugContext     DEFAULT_INITIALIZER(false);
 
 
    bool ForceNonSeparablePrograms DEFAULT_INITIALIZER(false);
};
typedef struct EngineGLCreateInfo EngineGLCreateInfo;
 
 
DILIGENT_TYPED_ENUM(D3D11_DEBUG_FLAGS, Uint32)
{
    D3D11_DEBUG_FLAG_NONE                                = 0x00,
 
    D3D11_DEBUG_FLAG_CREATE_DEBUG_DEVICE                 = 0x01,
 
    D3D11_DEBUG_FLAG_VERIFY_COMMITTED_SHADER_RESOURCES   = 0x02,
 
    D3D11_DEBUG_FLAG_VERIFY_COMMITTED_RESOURCE_RELEVANCE = 0x04
};
DEFINE_FLAG_ENUM_OPERATORS(D3D11_DEBUG_FLAGS)
 
DILIGENT_TYPED_ENUM(DIRECT3D_FEATURE_LEVEL, Uint8)
{
    DIRECT3D_FEATURE_LEVEL_10_0,
 
    DIRECT3D_FEATURE_LEVEL_10_1,
 
    DIRECT3D_FEATURE_LEVEL_11_0,
 
    DIRECT3D_FEATURE_LEVEL_11_1,
 
    DIRECT3D_FEATURE_LEVEL_12_0,
 
    DIRECT3D_FEATURE_LEVEL_12_1
};
 
static const Uint32 DEFAULT_ADAPTER_ID = 0xFFFFFFFFU;
 
struct EngineD3D11CreateInfo DILIGENT_DERIVE(EngineCreateInfo)
           
    Uint32                 AdapterId           DEFAULT_INITIALIZER(DEFAULT_ADAPTER_ID);
 
    DIRECT3D_FEATURE_LEVEL MinimumFeatureLevel DEFAULT_INITIALIZER(DIRECT3D_FEATURE_LEVEL_11_0);
 
    D3D11_DEBUG_FLAGS      DebugFlags          DEFAULT_INITIALIZER(D3D11_DEBUG_FLAG_NONE);
};
typedef struct EngineD3D11CreateInfo EngineD3D11CreateInfo;
 
 
struct EngineD3D12CreateInfo DILIGENT_DERIVE(EngineCreateInfo)
 
    const char* D3D12DllName       DEFAULT_INITIALIZER("d3d12.dll");
 
    Uint32      AdapterId          DEFAULT_INITIALIZER(DEFAULT_ADAPTER_ID);
 
    DIRECT3D_FEATURE_LEVEL MinimumFeatureLevel DEFAULT_INITIALIZER(DIRECT3D_FEATURE_LEVEL_11_0);
 
    bool EnableDebugLayer           DEFAULT_INITIALIZER(false);
 
    bool EnableGPUBasedValidation   DEFAULT_INITIALIZER(false);
 
    bool BreakOnError               DEFAULT_INITIALIZER(false);
 
    bool BreakOnCorruption          DEFAULT_INITIALIZER(true);
 
    Uint32 CPUDescriptorHeapAllocationSize[4]
#if DILIGENT_CPP_INTERFACE
        {
            8192,  // D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV
            2048,  // D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER
            1024,  // D3D12_DESCRIPTOR_HEAP_TYPE_RTV
            1024   // D3D12_DESCRIPTOR_HEAP_TYPE_DSV
        }
#endif
    ;
 
    Uint32 GPUDescriptorHeapSize[2]
#if DILIGENT_CPP_INTERFACE
        {
            16384, // D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV
            1024   // D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER
        }
#endif
    ;
 
    Uint32 GPUDescriptorHeapDynamicSize[2]
#if DILIGENT_CPP_INTERFACE
        {
            8192,  // D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV
            1024   // D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER
        }
#endif
    ;
 
    Uint32 DynamicDescriptorAllocationChunkSize[2]
#if DILIGENT_CPP_INTERFACE
        {
            256,  // D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV
            32    // D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER
        }
#endif
    ;
 
    Uint32 DynamicHeapPageSize       DEFAULT_INITIALIZER(1 << 20);
 
    Uint32 NumDynamicHeapPagesToReserve DEFAULT_INITIALIZER(1);
 
    Uint32 QueryPoolSizes[QUERY_TYPE_NUM_TYPES]
#if DILIGENT_CPP_INTERFACE
        {
            0,   // Ignored
            128, // QUERY_TYPE_OCCLUSION
            128, // QUERY_TYPE_BINARY_OCCLUSION
            512, // QUERY_TYPE_TIMESTAMP
            128, // QUERY_TYPE_PIPELINE_STATISTICS
            256, // QUERY_TYPE_DURATION
        }
#endif
    ;
 
    const char* pDxCompilerPath DEFAULT_INITIALIZER(nullptr);
};
typedef struct EngineD3D12CreateInfo EngineD3D12CreateInfo;
 
 
struct VulkanDescriptorPoolSize
{
    Uint32 MaxDescriptorSets                DEFAULT_INITIALIZER(0);
    Uint32 NumSeparateSamplerDescriptors    DEFAULT_INITIALIZER(0);
    Uint32 NumCombinedSamplerDescriptors    DEFAULT_INITIALIZER(0);
    Uint32 NumSampledImageDescriptors       DEFAULT_INITIALIZER(0);
    Uint32 NumStorageImageDescriptors       DEFAULT_INITIALIZER(0);
    Uint32 NumUniformBufferDescriptors      DEFAULT_INITIALIZER(0);
    Uint32 NumStorageBufferDescriptors      DEFAULT_INITIALIZER(0);
    Uint32 NumUniformTexelBufferDescriptors DEFAULT_INITIALIZER(0);
    Uint32 NumStorageTexelBufferDescriptors DEFAULT_INITIALIZER(0);
    Uint32 NumInputAttachmentDescriptors    DEFAULT_INITIALIZER(0);
    Uint32 NumAccelStructDescriptors        DEFAULT_INITIALIZER(0);
 
#if DILIGENT_CPP_INTERFACE
    VulkanDescriptorPoolSize()noexcept {}
 
    VulkanDescriptorPoolSize(Uint32 _MaxDescriptorSets,
                             Uint32 _NumSeparateSamplerDescriptors,
                             Uint32 _NumCombinedSamplerDescriptors,
                             Uint32 _NumSampledImageDescriptors,
                             Uint32 _NumStorageImageDescriptors,
                             Uint32 _NumUniformBufferDescriptors,
                             Uint32 _NumStorageBufferDescriptors,
                             Uint32 _NumUniformTexelBufferDescriptors,
                             Uint32 _NumStorageTexelBufferDescriptors,
                             Uint32 _NumInputAttachmentDescriptors,
                             Uint32 _NumAccelStructDescriptors)noexcept :
        MaxDescriptorSets               {_MaxDescriptorSets               },
        NumSeparateSamplerDescriptors   {_NumSeparateSamplerDescriptors   },
        NumCombinedSamplerDescriptors   {_NumCombinedSamplerDescriptors   },
        NumSampledImageDescriptors      {_NumSampledImageDescriptors      },
        NumStorageImageDescriptors      {_NumStorageImageDescriptors      },
        NumUniformBufferDescriptors     {_NumUniformBufferDescriptors     },
        NumStorageBufferDescriptors     {_NumStorageBufferDescriptors     },
        NumUniformTexelBufferDescriptors{_NumUniformTexelBufferDescriptors},
        NumStorageTexelBufferDescriptors{_NumStorageTexelBufferDescriptors},
        NumInputAttachmentDescriptors   {_NumInputAttachmentDescriptors   },
        NumAccelStructDescriptors       {_NumAccelStructDescriptors       }
    {
        // On clang aggregate initialization fails to compile if 
        // structure members have default initializers
    }
#endif
};
typedef struct VulkanDescriptorPoolSize VulkanDescriptorPoolSize;
 
 
struct EngineVkCreateInfo DILIGENT_DERIVE(EngineCreateInfo)
    
    Uint32             AdapterId                DEFAULT_INITIALIZER(DEFAULT_ADAPTER_ID);
 
    bool               EnableValidation         DEFAULT_INITIALIZER(false);
        
    Uint32             GlobalExtensionCount     DEFAULT_INITIALIZER(0);
 
    const char* const* ppGlobalExtensionNames   DEFAULT_INITIALIZER(nullptr);
 
    void* pVkAllocator                          DEFAULT_INITIALIZER(nullptr);
 
    VulkanDescriptorPoolSize MainDescriptorPoolSize
#if DILIGENT_CPP_INTERFACE
        //Max  SepSm  CmbSm  SmpImg StrImg   UB     SB    UTxB   StTxB  InptAtt  AccelSt
        {8192,  1024,  8192,  8192,  1024,  4096,  4096,  1024,  1024,   256,     256}
#endif
    ;
 
    
    VulkanDescriptorPoolSize DynamicDescriptorPoolSize
#if DILIGENT_CPP_INTERFACE
        //Max  SepSm  CmbSm  SmpImg StrImg   UB     SB    UTxB   StTxB  InptAtt  AccelSt
        {2048,   256,  2048,  2048,   256,  1024,  1024,   256,   256,    64,      64}
#endif
    ;
 
    Uint32 DeviceLocalMemoryPageSize        DEFAULT_INITIALIZER(16 << 20);
 
    Uint32 HostVisibleMemoryPageSize        DEFAULT_INITIALIZER(16 << 20);
 
    Uint32 DeviceLocalMemoryReserveSize     DEFAULT_INITIALIZER(256 << 20);
 
    Uint32 HostVisibleMemoryReserveSize     DEFAULT_INITIALIZER(256 << 20);
 
    Uint32 UploadHeapPageSize               DEFAULT_INITIALIZER(1 << 20);
 
    Uint32 DynamicHeapSize                  DEFAULT_INITIALIZER(8 << 20);
 
    Uint32 DynamicHeapPageSize              DEFAULT_INITIALIZER(256 << 10);
 
    Uint32 QueryPoolSizes[QUERY_TYPE_NUM_TYPES]
#if DILIGENT_CPP_INTERFACE
    {
        0,   // Ignored
        128, // QUERY_TYPE_OCCLUSION
        128, // QUERY_TYPE_BINARY_OCCLUSION
        512, // QUERY_TYPE_TIMESTAMP
        128, // QUERY_TYPE_PIPELINE_STATISTICS
        256  // QUERY_TYPE_DURATION
    }
#endif
    ;
 
    const char* pDxCompilerPath DEFAULT_INITIALIZER(nullptr);
};
typedef struct EngineVkCreateInfo EngineVkCreateInfo;
 
 
struct EngineMtlCreateInfo DILIGENT_DERIVE(EngineCreateInfo)
 
    Uint32 DynamicHeapPageSize       DEFAULT_INITIALIZER(4 << 20);
 
 
 
    bool UseAutoreleasePoolsInContexts  DEFAULT_INITIALIZER(true);
};
typedef struct EngineMtlCreateInfo EngineMtlCreateInfo;
 
 
struct Box
{
    Uint32 MinX DEFAULT_INITIALIZER(0); 
    Uint32 MaxX DEFAULT_INITIALIZER(0); 
    Uint32 MinY DEFAULT_INITIALIZER(0); 
    Uint32 MaxY DEFAULT_INITIALIZER(0); 
    Uint32 MinZ DEFAULT_INITIALIZER(0); 
    Uint32 MaxZ DEFAULT_INITIALIZER(1); 
 
#if DILIGENT_CPP_INTERFACE
    Box(Uint32 _MinX, Uint32 _MaxX, 
        Uint32 _MinY, Uint32 _MaxY, 
        Uint32 _MinZ, Uint32 _MaxZ) noexcept:   
        MinX {_MinX},
        MaxX {_MaxX},
        MinY {_MinY},
        MaxY {_MaxY},
        MinZ {_MinZ},
        MaxZ {_MaxZ}    
    {}
 
    Box(Uint32 _MinX, Uint32 _MaxX, 
        Uint32 _MinY, Uint32 _MaxY) noexcept:
        Box{_MinX, _MaxX, _MinY, _MaxY, 0, 1}
    {}
 
    Box(Uint32 _MinX, Uint32 _MaxX) noexcept:
        Box{_MinX, _MaxX, 0, 0, 0, 1}
    {}
 
    Box() noexcept {}
#endif
};
typedef struct Box Box;
 
 
DILIGENT_TYPED_ENUM(COMPONENT_TYPE, Uint8)
{
    COMPONENT_TYPE_UNDEFINED,
 
    COMPONENT_TYPE_FLOAT,
 
    COMPONENT_TYPE_SNORM,
 
    COMPONENT_TYPE_UNORM,
 
    COMPONENT_TYPE_UNORM_SRGB,
 
    COMPONENT_TYPE_SINT,
 
    COMPONENT_TYPE_UINT,
 
    COMPONENT_TYPE_DEPTH,
 
    COMPONENT_TYPE_DEPTH_STENCIL,
 
    COMPONENT_TYPE_COMPOUND,
 
    COMPONENT_TYPE_COMPRESSED,
};
 
struct TextureFormatAttribs
{
    const Char* Name             DEFAULT_INITIALIZER("TEX_FORMAT_UNKNOWN");
 
    TEXTURE_FORMAT Format        DEFAULT_INITIALIZER(TEX_FORMAT_UNKNOWN);
 
    Uint8 ComponentSize          DEFAULT_INITIALIZER(0);
 
    Uint8 NumComponents          DEFAULT_INITIALIZER(0);
 
    COMPONENT_TYPE ComponentType DEFAULT_INITIALIZER(COMPONENT_TYPE_UNDEFINED);
 
    bool IsTypeless              DEFAULT_INITIALIZER(false);
 
    Uint8 BlockWidth             DEFAULT_INITIALIZER(0);
 
    Uint8 BlockHeight            DEFAULT_INITIALIZER(0);
 
#if DILIGENT_CPP_INTERFACE
    Uint32 GetElementSize() const
    {
        return Uint32{ComponentSize} * (ComponentType != COMPONENT_TYPE_COMPRESSED ? Uint32{NumComponents} : Uint32{1});
    }
 
    TextureFormatAttribs( const Char*    _Name,
                            TEXTURE_FORMAT _Format, 
                            Uint8          _ComponentSize,
                            Uint8          _NumComponents,
                            COMPONENT_TYPE _ComponentType,
                            bool           _IsTypeless,
                            Uint8          _BlockWidth,
                            Uint8          _BlockHeight)noexcept : 
        Name         {_Name         },
        Format       {_Format       },
        ComponentSize{_ComponentSize},
        NumComponents{_NumComponents},
        ComponentType{_ComponentType},
        IsTypeless   {_IsTypeless   },
        BlockWidth   {_BlockWidth   },
        BlockHeight  {_BlockHeight  }
    {
    }
 
    TextureFormatAttribs()noexcept {}
#endif
};
typedef struct TextureFormatAttribs TextureFormatAttribs;
 
 
 
struct TextureFormatInfo DILIGENT_DERIVE(TextureFormatAttribs)
 
    bool Supported  DEFAULT_INITIALIZER(false);
 
    // Explicitly pad the structure to 8-byte boundary
    bool Padding[7];
};
typedef struct TextureFormatInfo TextureFormatInfo;
 
 
DILIGENT_TYPED_ENUM(RESOURCE_DIMENSION_SUPPORT, Uint32)
{
    RESOURCE_DIMENSION_SUPPORT_NONE           = 0,
 
    RESOURCE_DIMENSION_SUPPORT_BUFFER         = 1 << RESOURCE_DIM_BUFFER,
 
    RESOURCE_DIMENSION_SUPPORT_TEX_1D         = 1 << RESOURCE_DIM_TEX_1D,
 
    RESOURCE_DIMENSION_SUPPORT_TEX_1D_ARRAY   = 1 << RESOURCE_DIM_TEX_1D_ARRAY,
 
    RESOURCE_DIMENSION_SUPPORT_TEX_2D         = 1 << RESOURCE_DIM_TEX_2D,
 
    RESOURCE_DIMENSION_SUPPORT_TEX_2D_ARRAY   = 1 << RESOURCE_DIM_TEX_2D_ARRAY,
 
    RESOURCE_DIMENSION_SUPPORT_TEX_3D         = 1 << RESOURCE_DIM_TEX_3D,
 
    RESOURCE_DIMENSION_SUPPORT_TEX_CUBE       = 1 << RESOURCE_DIM_TEX_CUBE,
 
    RESOURCE_DIMENSION_SUPPORT_TEX_CUBE_ARRAY = 1 << RESOURCE_DIM_TEX_CUBE_ARRAY
};
DEFINE_FLAG_ENUM_OPERATORS(RESOURCE_DIMENSION_SUPPORT);
 
 
 
struct TextureFormatInfoExt DILIGENT_DERIVE(TextureFormatInfo)
 
    BIND_FLAGS BindFlags    DEFAULT_INITIALIZER(BIND_NONE);
 
 
    RESOURCE_DIMENSION_SUPPORT Dimensions DEFAULT_INITIALIZER(RESOURCE_DIMENSION_SUPPORT_NONE);
 
    Uint32     SampleCounts DEFAULT_INITIALIZER(0);
 
    Bool       Filterable   DEFAULT_INITIALIZER(false);
};
typedef struct TextureFormatInfoExt TextureFormatInfoExt;
 
 
 
DILIGENT_TYPED_ENUM(PIPELINE_STAGE_FLAGS, Uint32)
{
    PIPELINE_STAGE_FLAG_UNDEFINED                    = 0x00000000,
 
    PIPELINE_STAGE_FLAG_TOP_OF_PIPE                  = 0x00000001,
 
    PIPELINE_STAGE_FLAG_DRAW_INDIRECT                = 0x00000002,
 
    PIPELINE_STAGE_FLAG_VERTEX_INPUT                 = 0x00000004,
 
    PIPELINE_STAGE_FLAG_VERTEX_SHADER                = 0x00000008,
    
    PIPELINE_STAGE_FLAG_HULL_SHADER                  = 0x00000010,
    
    PIPELINE_STAGE_FLAG_DOMAIN_SHADER                = 0x00000020,
    
    PIPELINE_STAGE_FLAG_GEOMETRY_SHADER              = 0x00000040,
    
    PIPELINE_STAGE_FLAG_PIXEL_SHADER                 = 0x00000080,
    
    PIPELINE_STAGE_FLAG_EARLY_FRAGMENT_TESTS         = 0x00000100,
    
    PIPELINE_STAGE_FLAG_LATE_FRAGMENT_TESTS          = 0x00000200,
    
    PIPELINE_STAGE_FLAG_RENDER_TARGET                = 0x00000400,
    
    PIPELINE_STAGE_FLAG_COMPUTE_SHADER               = 0x00000800,
    
    PIPELINE_STAGE_FLAG_TRANSFER                     = 0x00001000,
    
    PIPELINE_STAGE_FLAG_BOTTOM_OF_PIPE               = 0x00002000,
    
    PIPELINE_STAGE_FLAG_HOST                         = 0x00004000,
    
    PIPELINE_STAGE_FLAG_CONDITIONAL_RENDERING        = 0x00040000,
 
    PIPELINE_STAGE_FLAG_SHADING_RATE_TEXTURE         = 0x00400000,
    
    PIPELINE_STAGE_FLAG_RAY_TRACING_SHADER           = 0x00200000,
    
    PIPELINE_STAGE_FLAG_ACCELERATION_STRUCTURE_BUILD = 0x02000000,
    
    PIPELINE_STAGE_FLAG_TASK_SHADER                  = 0x00080000,
    
    PIPELINE_STAGE_FLAG_MESH_SHADER                  = 0x00100000,
    
    PIPELINE_STAGE_FLAG_FRAGMENT_DENSITY_PROCESS     = 0x00800000,
    
    PIPELINE_STAGE_FLAG_DEFAULT                      = 0x80000000
};
DEFINE_FLAG_ENUM_OPERATORS(PIPELINE_STAGE_FLAGS)
 
 
 
DILIGENT_TYPED_ENUM(ACCESS_FLAGS, Uint32)
{
    ACCESS_FLAG_NONE                         = 0x00000000,
 
    ACCESS_FLAG_INDIRECT_COMMAND_READ        = 0x00000001,
 
    ACCESS_FLAG_INDEX_READ                   = 0x00000002,
 
    ACCESS_FLAG_VERTEX_READ                  = 0x00000004,
 
    ACCESS_FLAG_UNIFORM_READ                 = 0x00000008,
 
    ACCESS_FLAG_INPUT_ATTACHMENT_READ        = 0x00000010,
 
    ACCESS_FLAG_SHADER_READ                  = 0x00000020,
 
    ACCESS_FLAG_SHADER_WRITE                 = 0x00000040,
 
    ACCESS_FLAG_RENDER_TARGET_READ           = 0x00000080,
    
    ACCESS_FLAG_RENDER_TARGET_WRITE          = 0x00000100,
 
    ACCESS_FLAG_DEPTH_STENCIL_READ           = 0x00000200,
 
    ACCESS_FLAG_DEPTH_STENCIL_WRITE          = 0x00000400,
 
    ACCESS_FLAG_COPY_SRC                     = 0x00000800,
 
    ACCESS_FLAG_COPY_DST                     = 0x00001000,
 
    ACCESS_FLAG_HOST_READ                    = 0x00002000,
 
    ACCESS_FLAG_HOST_WRITE                   = 0x00004000,
 
    ACCESS_FLAG_MEMORY_READ                  = 0x00008000,
 
    // flags that are valid where it is used.
    ACCESS_FLAG_MEMORY_WRITE                 = 0x00010000,
 
    ACCESS_FLAG_CONDITIONAL_RENDERING_READ   = 0x00100000,
 
    ACCESS_FLAG_SHADING_RATE_TEXTURE_READ    = 0x00800000,
 
    ACCESS_FLAG_ACCELERATION_STRUCTURE_READ  = 0x00200000,
 
    ACCESS_FLAG_ACCELERATION_STRUCTURE_WRITE = 0x00400000,
 
    ACCESS_FLAG_FRAGMENT_DENSITY_MAP_READ    = 0x01000000,
 
    ACCESS_FLAG_DEFAULT                      = 0x80000000
};
DEFINE_FLAG_ENUM_OPERATORS(ACCESS_FLAGS)
 
 
DILIGENT_TYPED_ENUM(RESOURCE_STATE, Uint32)
{
    RESOURCE_STATE_UNKNOWN              = 0x00000,
 
    RESOURCE_STATE_UNDEFINED            = 0x00001,
 
    RESOURCE_STATE_VERTEX_BUFFER        = 0x00002,
 
    RESOURCE_STATE_CONSTANT_BUFFER      = 0x00004,
 
    RESOURCE_STATE_INDEX_BUFFER         = 0x00008,
 
    RESOURCE_STATE_RENDER_TARGET        = 0x00010,
        
    RESOURCE_STATE_UNORDERED_ACCESS     = 0x00020,
 
    RESOURCE_STATE_DEPTH_WRITE          = 0x00040,
 
    RESOURCE_STATE_DEPTH_READ           = 0x00080,
 
    RESOURCE_STATE_SHADER_RESOURCE      = 0x00100,
        
    RESOURCE_STATE_STREAM_OUT           = 0x00200,
 
    RESOURCE_STATE_INDIRECT_ARGUMENT    = 0x00400,
 
    RESOURCE_STATE_COPY_DEST            = 0x00800,
 
    RESOURCE_STATE_COPY_SOURCE          = 0x01000,
        
    RESOURCE_STATE_RESOLVE_DEST         = 0x02000,
        
    RESOURCE_STATE_RESOLVE_SOURCE       = 0x04000,
 
    RESOURCE_STATE_INPUT_ATTACHMENT     = 0x08000,
 
    RESOURCE_STATE_PRESENT              = 0x10000,
 
    RESOURCE_STATE_BUILD_AS_READ        = 0x20000,
 
    RESOURCE_STATE_BUILD_AS_WRITE       = 0x40000,
 
    RESOURCE_STATE_RAY_TRACING          = 0x80000,
 
    RESOURCE_STATE_MAX_BIT              = RESOURCE_STATE_RAY_TRACING,
 
    RESOURCE_STATE_GENERIC_READ         = RESOURCE_STATE_VERTEX_BUFFER     |
                                          RESOURCE_STATE_CONSTANT_BUFFER   |
                                          RESOURCE_STATE_INDEX_BUFFER      |
                                          RESOURCE_STATE_SHADER_RESOURCE   |
                                          RESOURCE_STATE_INDIRECT_ARGUMENT |
                                          RESOURCE_STATE_COPY_SOURCE
};
DEFINE_FLAG_ENUM_OPERATORS(RESOURCE_STATE);
 
DILIGENT_TYPED_ENUM(STATE_TRANSITION_TYPE, Uint8)
{
    STATE_TRANSITION_TYPE_IMMEDIATE = 0,
 
    STATE_TRANSITION_TYPE_BEGIN,
 
    STATE_TRANSITION_TYPE_END
};
 
DILIGENT_END_NAMESPACE // namespace Diligent