FillIndirectRenderData()

template<typename T >

std::shared_ptr< VulkanDeviceGeneratedCommandsNV > Spices::Renderer::FillIndirectRenderData ( const std::string & subPassName, std::shared_ptr< std::vector< uint32_t > > view )

inlineinherited

Fill in World RenderAble data to IndirectBuffer.

Template Parameters

T	Specific Component.

Parameters

[in]	subPassName	.
[in]	view	Component View.

Returns

Returns new VulkanDeviceGeneratedCommandsNV.

Cache original data.

Move original to caches.

Prepare ShaderGroup

Fill in Input Buffer

Fill in Streams

Regenerate dgc pipeline

Create ProcessBuffer.

Definition at line 2058 of file Renderer.h.

    {
        SPICES_PROFILE_ZONE;
 
        auto indirectPtr = std::make_shared<VulkanDeviceGeneratedCommandsNV>(m_VulkanState);
        auto srcPtr      = m_DGCData[subPassName];
 
        indirectPtr->SetInputStride(srcPtr->GetInputStrides());
        indirectPtr->SetStrides(srcPtr->GetStrides());
        indirectPtr->SetCommandLayout(srcPtr->GetCommandLayout());
        indirectPtr->SetLayoutTokens(srcPtr->GetLayoutTokens());
 
        m_RenderCache->PushToCaches(srcPtr);
 
        uint32_t nSequences = 0;
        {
            SPICES_PROFILE_ZONEN("FillIndirectRenderData::Prepare ShaderGroup");
 
            std::unordered_map<std::string, uint32_t> pipelineMap;
            
            FrameInfo::Get().m_World->ViewComponent<T>(*view, [&](const auto& e, auto& meshComp){
                
                meshComp.GetMesh()->GetPacks().for_each([&](const auto& k, const std::shared_ptr<MeshPack>& v) {
 
                    if (pipelineMap.find(v->GetMaterial()->GetName()) == pipelineMap.end())
                    {
                        pipelineMap[v->GetMaterial()->GetName()] = pipelineMap.size();
                    }
 
                    v->SetShaderGroupHandle(pipelineMap[v->GetMaterial()->GetName()]);
                    nSequences++;
 
                    return false;
                });
            });
            indirectPtr->SetSequenceCount(nSequences);
 
            indirectPtr->GetPipelineRef().resize(pipelineMap.size(), nullptr);
 
            for (auto& pair : pipelineMap)
            {
                indirectPtr->GetPipelineRef()[pair.second] = m_Pipelines.Find(pair.first)->GetPipeline();
            }
        }
 
        std::vector<size_t> offset;
        std::shared_ptr<VulkanBuffer> inputBuffer = nullptr;
        {
            SPICES_PROFILE_ZONEN("FillIndirectRenderData::Fill in Input Buffer");
 
            size_t totalSize         = 0;
            size_t alignSeqIndexMask = m_Device->GetDGCProperties().minSequencesIndexBufferOffsetAlignment - 1;
            size_t alignMask         = m_Device->GetDGCProperties().minIndirectCommandsBufferOffsetAlignment - 1;
 
            auto& inputStrides       = indirectPtr->GetInputStrides();
            
            for (int i = 0; i < inputStrides.size(); i++)
            {
                offset.push_back(totalSize);
                totalSize += ((inputStrides[i] * nSequences + alignMask) & (~alignMask));
            }
 
            VulkanBuffer stagingBuffer(
                m_VulkanState,
                "StagingBuffer",
                totalSize,
                VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
                VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
            );
 
            auto& layoutTokens = indirectPtr->GetLayoutTokens();
 
            int index = 0;
            FrameInfo::Get().m_World->ViewComponent<T>(*view, [&](const auto& e, auto& meshComp){
                    
                meshComp.GetMesh()->GetPacks().for_each([&](const auto& k, const std::shared_ptr<MeshPack>& v) {
 
                    for (int i = 0; i < layoutTokens.size(); i++)
                    {
                        switch (layoutTokens[i].tokenType)
                        {
                            case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV:
                            {
                                VkBindShaderGroupIndirectCommandNV shader;
                                shader.groupIndex = v->GetShaderGroupHandle() + 1;
                                stagingBuffer.WriteToBuffer(&shader, inputStrides[i], index * inputStrides[i] + offset[i]);
                                break;
                            }
                            case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV:
                            {
                                VkBindVertexBufferIndirectCommandNV vbo;
                                vbo.bufferAddress = v->GetResource().positions.buffer->GetAddress();
                                vbo.size          = sizeof(v->GetResource().positions.attributes);
                                vbo.stride        = sizeof(glm::vec3);
                                stagingBuffer.WriteToBuffer(&vbo, inputStrides[i], index * inputStrides[i] + offset[i]);
                                break;
                            }
                            case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV:
                            {
                                VkBindIndexBufferIndirectCommandNV ibo;
                                ibo.bufferAddress = v->GetResource().primitivePoints.buffer->GetAddress();
                                ibo.size          = sizeof(v->GetResource().primitivePoints.attributes);
                                ibo.indexType     = VK_INDEX_TYPE_UINT32;
                                stagingBuffer.WriteToBuffer(&ibo, inputStrides[i], index * inputStrides[i] + offset[i]);
                                break;
                            }
                            case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV:
                            {
                                VkDeviceAddress push;
                                push              = v->GetMeshDesc().GetBufferAddress();
                                stagingBuffer.WriteToBuffer(&push, inputStrides[i], index * inputStrides[i] + offset[i]);
                                break;
                            }
                            case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV:
                            {
                                VkDrawIndexedIndirectCommand drawIndexed;
                                drawIndexed.firstIndex     = 0;
                                drawIndexed.firstInstance  = 0;
                                drawIndexed.indexCount     = v->GetResource().primitivePoints.attributes->size();
                                drawIndexed.instanceCount  = 1;
                                drawIndexed.vertexOffset   = 0;
                                stagingBuffer.WriteToBuffer(&drawIndexed, inputStrides[i], index* inputStrides[i] + offset[i]);
                                break;
                            }
                            case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV:
                            {
                                VkDrawMeshTasksIndirectCommandNV drawMesh;
                                drawMesh = v->GetDrawCommand();
                                stagingBuffer.WriteToBuffer(&drawMesh, inputStrides[i], index * inputStrides[i] + offset[i]);
                                break;
                            }
                            default:
                                SPICES_CORE_ERROR("Not Supported Token Type.");
                                break;
                        }
                    }
 
                    index++;
                    return false;
                });
            });
            stagingBuffer.Flush();
 
            inputBuffer = indirectPtr->CreateInputBuffer(totalSize);
            inputBuffer->CopyBuffer(stagingBuffer.Get(), inputBuffer->Get(), totalSize);
        }
 
        {
            SPICES_PROFILE_ZONEN("FillIndirectRenderData::Fill in Streams");
 
            std::vector<VkIndirectCommandsStreamNV> inputs;
            inputs.resize(offset.size());
            for (int i = 0; i < offset.size(); i++)
            {
                inputs[i].buffer = inputBuffer->Get();
                inputs[i].offset = offset[i];
            }
            indirectPtr->SetInputStreams(inputs);
        }
 
        {
            SPICES_PROFILE_ZONEN("FillIndirectRenderData::Regenerate dgc pipeline");
 
            CreateDGCMaterial(subPassName, indirectPtr.get());
        }
 
        {
            SPICES_PROFILE_ZONEN("FillIndirectRenderData:: Create ProcessBuffer");
 
            indirectPtr->CreatePreprocessBuffer();
        }
 
        return indirectPtr;
    }

References Spices::Renderer::m_VulkanState.