Testing code for InlineConstants, based on Tutorial02_Cube

[hzqst]

#include "Tutorial02_Cube.hpp"
#include "MapHelper.hpp"
#include "GraphicsUtilities.h"
#include "ColorConversion.h"

#define USE_INLINE_CONSTANTS        1 //Use inline constants instead of ordinary uniform buffer
#define USE_STATIC_INLINE_CONSTANTS 0 //Inline constants are static, no data update on the fly
#define USE_VULKAN_PUSH_CONSTANT    0 //Use Vulkan Push Constant under the hood. emulated dynamic buffer will be used if go without USE_VULKAN_PUSH_CONSTANT on Vulkan
#define USE_PRS_TEST                0 //Use PipelineResourceSignature instead legacy ResourceLayout

namespace Diligent
{

SampleBase* CreateSample()
{
    return new Tutorial02_Cube();
}

void Tutorial02_Cube::CreatePipelineState()
{
    // Pipeline state object encompasses configuration of all GPU stages

    GraphicsPipelineStateCreateInfo PSOCreateInfo;

    // Pipeline state name is used by the engine to report issues.
    // It is always a good idea to give objects descriptive names.
    PSOCreateInfo.PSODesc.Name = "Cube PSO";

    // This is a graphics pipeline
    PSOCreateInfo.PSODesc.PipelineType = PIPELINE_TYPE_GRAPHICS;

    // clang-format off
    // This tutorial will render to a single render target
    PSOCreateInfo.GraphicsPipeline.NumRenderTargets             = 1;
    // Set render target format which is the format of the swap chain's color buffer
    PSOCreateInfo.GraphicsPipeline.RTVFormats[0]                = m_pSwapChain->GetDesc().ColorBufferFormat;
    // Set depth buffer format which is the format of the swap chain's back buffer
    PSOCreateInfo.GraphicsPipeline.DSVFormat                    = m_pSwapChain->GetDesc().DepthBufferFormat;
    // Primitive topology defines what kind of primitives will be rendered by this pipeline state
    PSOCreateInfo.GraphicsPipeline.PrimitiveTopology            = PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
    // Cull back faces
    PSOCreateInfo.GraphicsPipeline.RasterizerDesc.CullMode      = CULL_MODE_BACK;
    // Enable depth testing
    PSOCreateInfo.GraphicsPipeline.DepthStencilDesc.DepthEnable = True;
    // clang-format on

    ShaderCreateInfo ShaderCI;
    // Tell the system that the shader source code is in HLSL.
    // For OpenGL, the engine will convert this into GLSL under the hood.
    ShaderCI.SourceLanguage = SHADER_SOURCE_LANGUAGE_HLSL;

    // OpenGL backend requires emulated combined HLSL texture samplers (g_Texture + g_Texture_sampler combination)
    ShaderCI.Desc.UseCombinedTextureSamplers = true;

    // Pack matrices in row-major order
    ShaderCI.CompileFlags = SHADER_COMPILE_FLAG_PACK_MATRIX_ROW_MAJOR;

    // Presentation engine always expects input in gamma space. Normally, pixel shader output is
    // converted from linear to gamma space by the GPU. However, some platforms (e.g. Android in GLES mode,
    // or Emscripten in WebGL mode) do not support gamma-correction. In this case the application
    // has to do the conversion manually.
    ShaderMacro Macros[] = {
        {"CONVERT_PS_OUTPUT_TO_GAMMA", m_ConvertPSOutputToGamma ? "1" : "0"},
#if USE_VULKAN_PUSH_CONSTANT
        {"USE_VULKAN_PUSH_CONSTANT", "1" },
#endif
    };

    ShaderCI.Macros      = {Macros, _countof(Macros)};

    // In this tutorial, we will load shaders from file. To be able to do that,
    // we need to create a shader source stream factory
    RefCntAutoPtr<IShaderSourceInputStreamFactory> pShaderSourceFactory;
    m_pEngineFactory->CreateDefaultShaderSourceStreamFactory(nullptr, &pShaderSourceFactory);
    ShaderCI.pShaderSourceStreamFactory = pShaderSourceFactory;
    // Create a vertex shader
    RefCntAutoPtr<IShader> pVS;
    {
        ShaderCI.Desc.ShaderType = SHADER_TYPE_VERTEX;
        ShaderCI.EntryPoint      = "main";
        ShaderCI.Desc.Name       = "Cube VS";
        ShaderCI.FilePath        = "cube.vsh";
#if USE_INLINE_CONSTANTS

        if (m_pDevice->GetDeviceInfo().Type == RENDER_DEVICE_TYPE_D3D12)
            ShaderCI.ShaderCompiler = Diligent::SHADER_COMPILER_DXC;

#endif
        m_pDevice->CreateShader(ShaderCI, &pVS);
        // Create dynamic uniform buffer that will store our transformation matrix
        // Dynamic buffers can be frequently updated by the CPU
        BufferDesc CBDesc;
        CBDesc.Name           = "VS constants CB";
        CBDesc.Size           = sizeof(float4x4);
        CBDesc.Usage          = USAGE_DYNAMIC;
        CBDesc.BindFlags      = BIND_UNIFORM_BUFFER;
        CBDesc.CPUAccessFlags = CPU_ACCESS_WRITE;
        m_pDevice->CreateBuffer(CBDesc, nullptr, &m_VSConstants);
    }

    // Create a pixel shader
    RefCntAutoPtr<IShader> pPS;
    {
        ShaderCI.Desc.ShaderType = SHADER_TYPE_PIXEL;
        ShaderCI.EntryPoint      = "main";
        ShaderCI.Desc.Name       = "Cube PS";
        ShaderCI.FilePath        = "cube.psh";
        m_pDevice->CreateShader(ShaderCI, &pPS);
    }

    // clang-format off
    // Define vertex shader input layout
    LayoutElement LayoutElems[] =
    {
        // Attribute 0 - vertex position
        LayoutElement{0, 0, 3, VT_FLOAT32, False},
        // Attribute 1 - vertex color
        LayoutElement{1, 0, 4, VT_FLOAT32, False}
    };
    // clang-format on
    PSOCreateInfo.GraphicsPipeline.InputLayout.LayoutElements = LayoutElems;
    PSOCreateInfo.GraphicsPipeline.InputLayout.NumElements    = _countof(LayoutElems);

    PSOCreateInfo.pVS = pVS;
    PSOCreateInfo.pPS = pPS;

#if USE_INLINE_CONSTANTS

#    if USE_PRS_TEST
    const PipelineResourceDesc PipelineResources[] = {
        {
            SHADER_TYPE_VERTEX,
            "Constants",
            sizeof(float4x4) / 4,
            SHADER_RESOURCE_TYPE_CONSTANT_BUFFER,

#        if USE_STATIC_INLINE_CONSTANTS
            SHADER_RESOURCE_VARIABLE_TYPE_STATIC,
#        else //USE_STATIC_INLINE_CONSTANTS
            SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC,
#        endif

            PIPELINE_RESOURCE_FLAG_INLINE_CONSTANTS

        #if USE_VULKAN_PUSH_CONSTANT
            | PIPELINE_RESOURCE_FLAG_VULKAN_PUSH_CONSTANT
        #endif
            ,
        },
    };
    Diligent::PipelineResourceSignatureDesc PRSDesc;
    PRSDesc.UseCombinedTextureSamplers = true;
    PRSDesc.Resources                  = PipelineResources;
    PRSDesc.NumResources               = _countof(PipelineResources);

    m_pDevice->CreatePipelineResourceSignature(PRSDesc, &m_pPRS);

    IPipelineResourceSignature* ppSignatures[]{m_pPRS};

    PSOCreateInfo.ppResourceSignatures    = ppSignatures;
    PSOCreateInfo.ResourceSignaturesCount = _countof(ppSignatures);

#    else //USE_PRS_TEST

    ShaderResourceVariableDesc Variables[] = {
        {SHADER_TYPE_VERTEX, "Constants",

#        if USE_STATIC_INLINE_CONSTANTS
         SHADER_RESOURCE_VARIABLE_TYPE_STATIC,
#        else //USE_STATIC_INLINE_CONSTANTS
         SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC,
#        endif

         SHADER_VARIABLE_FLAG_INLINE_CONSTANTS
        },
    };
    PSOCreateInfo.PSODesc.ResourceLayout.Variables    = Variables;
    PSOCreateInfo.PSODesc.ResourceLayout.NumVariables = _countof(Variables);
#    endif

#else //USE_INLINE_CONSTANTS

    // Define variable type that will be used by default
    PSOCreateInfo.PSODesc.ResourceLayout.DefaultVariableType = SHADER_RESOURCE_VARIABLE_TYPE_STATIC;

#endif

    m_pDevice->CreateGraphicsPipelineState(PSOCreateInfo, &m_pPSO);

#if USE_INLINE_CONSTANTS && USE_STATIC_INLINE_CONSTANTS
#    if USE_PRS_TEST
    m_pPRS->GetStaticVariableByName(SHADER_TYPE_VERTEX, "Constants")->SetInlineConstants(m_WorldViewProjMatrix.Data(), 0, sizeof(float4x4) / 4);
#    else
    m_pPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "Constants")->SetInlineConstants(m_WorldViewProjMatrix.Data(), 0, sizeof(float4x4) / 4);
#    endif

#endif

#if !(USE_INLINE_CONSTANTS)

    // Since we did not explicitly specify the type for 'Constants' variable, default
    // type (SHADER_RESOURCE_VARIABLE_TYPE_STATIC) will be used. Static variables never
    // change and are bound directly through the pipeline state object.
    m_pPSO->GetStaticVariableByName(SHADER_TYPE_VERTEX, "Constants")->Set(m_VSConstants);

#endif

    // Create a shader resource binding object and bind all static resources in it
#if USE_PRS_TEST
        m_pPRS->CreateShaderResourceBinding(&m_pSRB, true);
#else
        m_pPSO->CreateShaderResourceBinding(&m_pSRB, true);
#endif
}

void Tutorial02_Cube::CreateVertexBuffer()
{
    // Layout of this structure matches the one we defined in the pipeline state
    struct Vertex
    {
        float3 pos;
        float4 color;
    };

    // Cube vertices

    //      (-1,+1,+1)________________(+1,+1,+1)
    //               /|              /|
    //              / |             / |
    //             /  |            /  |
    //            /   |           /   |
    //(-1,-1,+1) /____|__________/(+1,-1,+1)
    //           |    |__________|____|
    //           |   /(-1,+1,-1) |    /(+1,+1,-1)
    //           |  /            |   /
    //           | /             |  /
    //           |/              | /
    //           /_______________|/
    //        (-1,-1,-1)       (+1,-1,-1)
    //

    constexpr Vertex CubeVerts[8] =
        {
            {float3{-1, -1, -1}, float4{1, 0, 0, 1}},
            {float3{-1, +1, -1}, float4{0, 1, 0, 1}},
            {float3{+1, +1, -1}, float4{0, 0, 1, 1}},
            {float3{+1, -1, -1}, float4{1, 1, 1, 1}},

            {float3{-1, -1, +1}, float4{1, 1, 0, 1}},
            {float3{-1, +1, +1}, float4{0, 1, 1, 1}},
            {float3{+1, +1, +1}, float4{1, 0, 1, 1}},
            {float3{+1, -1, +1}, float4{0.2f, 0.2f, 0.2f, 1.f}},
        };

    // Create a vertex buffer that stores cube vertices
    BufferDesc VertBuffDesc;
    VertBuffDesc.Name      = "Cube vertex buffer";
    VertBuffDesc.Usage     = USAGE_IMMUTABLE;
    VertBuffDesc.BindFlags = BIND_VERTEX_BUFFER;
    VertBuffDesc.Size      = sizeof(CubeVerts);
    BufferData VBData;
    VBData.pData    = CubeVerts;
    VBData.DataSize = sizeof(CubeVerts);
    m_pDevice->CreateBuffer(VertBuffDesc, &VBData, &m_CubeVertexBuffer);
}

void Tutorial02_Cube::CreateIndexBuffer()
{
    // clang-format off
    constexpr Uint32 Indices[] =
    {
        2,0,1, 2,3,0,
        4,6,5, 4,7,6,
        0,7,4, 0,3,7,
        1,0,4, 1,4,5,
        1,5,2, 5,6,2,
        3,6,7, 3,2,6
    };
    // clang-format on

    BufferDesc IndBuffDesc;
    IndBuffDesc.Name      = "Cube index buffer";
    IndBuffDesc.Usage     = USAGE_IMMUTABLE;
    IndBuffDesc.BindFlags = BIND_INDEX_BUFFER;
    IndBuffDesc.Size      = sizeof(Indices);
    BufferData IBData;
    IBData.pData    = Indices;
    IBData.DataSize = sizeof(Indices);
    m_pDevice->CreateBuffer(IndBuffDesc, &IBData, &m_CubeIndexBuffer);
}

void Tutorial02_Cube::Initialize(const SampleInitInfo& InitInfo)
{
    SampleBase::Initialize(InitInfo);

    //Initialize matrix
    Update(0, 0, false);

    CreatePipelineState();
    CreateVertexBuffer();
    CreateIndexBuffer();
}

// Render a frame
void Tutorial02_Cube::Render()
{
    ITextureView* pRTV = m_pSwapChain->GetCurrentBackBufferRTV();
    ITextureView* pDSV = m_pSwapChain->GetDepthBufferDSV();
    // Clear the back buffer
    float4 ClearColor = {0.350f, 0.350f, 0.350f, 1.0f};
    if (m_ConvertPSOutputToGamma)
    {
        // If manual gamma correction is required, we need to clear the render target with sRGB color
        ClearColor = LinearToSRGB(ClearColor);
    }
    m_pImmediateContext->ClearRenderTarget(pRTV, ClearColor.Data(), RESOURCE_STATE_TRANSITION_MODE_TRANSITION);
    m_pImmediateContext->ClearDepthStencil(pDSV, CLEAR_DEPTH_FLAG, 1.f, 0, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);

#if !(USE_INLINE_CONSTANTS)
    {
        // Map the buffer and write current world-view-projection matrix
        MapHelper<float4x4> CBConstants(m_pImmediateContext, m_VSConstants, MAP_WRITE, MAP_FLAG_DISCARD);
        *CBConstants = m_WorldViewProjMatrix;
    }
#endif

#if USE_INLINE_CONSTANTS && !(USE_STATIC_INLINE_CONSTANTS)
    {
#    if USE_PRS_TEST
        m_pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "Constants")->SetInlineConstants(m_WorldViewProjMatrix.Data(), 0, sizeof(float4x4) / 4);
#    else
        m_pSRB->GetVariableByName(SHADER_TYPE_VERTEX, "Constants")->SetInlineConstants(m_WorldViewProjMatrix.Data(), 0, sizeof(float4x4) / 4);
#    endif
    }
#endif

    // Bind vertex and index buffers
    const Uint64 offset   = 0;
    IBuffer*     pBuffs[] = {m_CubeVertexBuffer};
    m_pImmediateContext->SetVertexBuffers(0, 1, pBuffs, &offset, RESOURCE_STATE_TRANSITION_MODE_TRANSITION, SET_VERTEX_BUFFERS_FLAG_RESET);
    m_pImmediateContext->SetIndexBuffer(m_CubeIndexBuffer, 0, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);

    // Set the pipeline state
    m_pImmediateContext->SetPipelineState(m_pPSO);

    // Commit shader resources. RESOURCE_STATE_TRANSITION_MODE_TRANSITION mode
    // makes sure that resources are transitioned to required states.
    m_pImmediateContext->CommitShaderResources(m_pSRB, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);

    DrawIndexedAttribs DrawAttrs;     // This is an indexed draw call
    DrawAttrs.IndexType  = VT_UINT32; // Index type
    DrawAttrs.NumIndices = 36;
    // Verify the state of vertex and index buffers
    DrawAttrs.Flags = DRAW_FLAG_VERIFY_ALL;
    m_pImmediateContext->DrawIndexed(DrawAttrs);
}

void Tutorial02_Cube::Update(double CurrTime, double ElapsedTime, bool DoUpdateUI)
{
    SampleBase::Update(CurrTime, ElapsedTime, DoUpdateUI);

    // Apply rotation
    float4x4 CubeModelTransform = float4x4::RotationY(static_cast<float>(CurrTime) * 1.0f) * float4x4::RotationX(-PI_F * 0.1f);

    // Camera is at (0, 0, -5) looking along the Z axis
    float4x4 View = float4x4::Translation(0.f, 0.0f, 5.0f);

    // Get pretransform matrix that rotates the scene according the surface orientation
    float4x4 SrfPreTransform = GetSurfacePretransformMatrix(float3{0, 0, 1});

    // Get projection matrix adjusted to the current screen orientation
    float4x4 Proj = GetAdjustedProjectionMatrix(PI_F / 4.0f, 0.1f, 100.f);

    // Compute world-view-projection matrix
    m_WorldViewProjMatrix = CubeModelTransform * View * SrfPreTransform * Proj;
}

} // namespace Diligent

#if USE_VULKAN_PUSH_CONSTANT && VULKAN
[[vk::push_constant]]
cbuffer Constants
{
    float4x4 g_WorldViewProj;
};
#else
cbuffer Constants
{
    float4x4 g_WorldViewProj;
};
#endif

// Vertex shader takes two inputs: vertex position and color.
// By convention, Diligent Engine expects vertex shader inputs to be 
// labeled 'ATTRIBn', where n is the attribute number.
struct VSInput
{
    float3 Pos   : ATTRIB0;
    float4 Color : ATTRIB1;
};

struct PSInput 
{
    float4 Pos   : SV_POSITION;
    float4 Color : COLOR0; 
};

// Note that if separate shader objects are not supported (this is only the case for old GLES3.0 devices), vertex
// shader output variable name must match exactly the name of the pixel shader input variable.
// If the variable has structure type (like in this example), the structure declarations must also be identical.
void main(in  VSInput VSIn,
          out PSInput PSIn)
{
    PSIn.Pos   = mul(float4(VSIn.Pos, 1.0), g_WorldViewProj);
    PSIn.Color = VSIn.Color;
}

backend	USE_INLINE_CONSTANTS	USE_STATIC_INLINE_CONSTANTS	USE_PRS_TEST	result
D3D12	1	1	1	√ (static cube)
D3D12	1	1	0	√ (static cube)
D3D12	1	0	1	√ (rotating cube)
D3D12	1	0	0	√ (rotating cube)
D3D11	1	1	1	√ (static cube)
D3D11	1	1	0	√ (static cube)
D3D11	1	0	1	√ (rotating cube)
D3D11	1	0	0	√ (rotating cube)
Vulkan	1	1	1	√ (static cube)
Vulkan	1	1	0	√ (static cube)
Vulkan	1	0	1	√ (rotating cube)
Vulkan	1	0	0	√ (rotating cube)

[TheMostDiligent]

Yes, all these scenarios and many others are unit-tested. Inline constants are complete in D3D11 and D3D12.