BuildMaterial()

void Spices::Material::BuildMaterial

(

bool

isAutoRegistry = true

)

This interface need to be overwritten by specific material. It defines how we build texture and descriptor set.

Parameters

[in]

isAutoRegistry

True if this material need registry to renderer automatically.

Todo

empty texture.

Registry to renderer if already build.

Create PipelineLayout.

Registry ShaderModule.

If ReBuild, need clear old descripotrset first.

Iter the constantParams and fill it's data to memoryblock.

Return if not valid textureParameter or constantParameter.

Create Material Parameter to store all address and index.

Registry texture to both ResourcePool, BindLessTextureManager, DescriptorSetManager and MaterialParameterBuffer.

Only work with Texture2D now.

Todo

more type support, reflection.

Instance a VkWriteDescriptorSet.

Update DescriptorSet.

Not supported format.

Create ConstantParameter Buffer .

Fill in data to memory block.

Create PipelineLayout.

Registry to renderer if already build.

Create PipelineLayout.

Registry ShaderModule.

If ReBuild, need clear old descripotrset first.

Iter the constantParams and fill it's data to memoryblock.

Return if not valid textureParameter or constantParameter.

Create Material Parameter to store all address and index.

Registry texture to both ResourcePool, BindLessTextureManager, DescriptorSetManager and MaterialParameterBuffer.

Only work with Texture2D now.

Todo

more type support, reflection.

Instance a VkWriteDescriptorSet.

Update DescriptorSet.

Not supported format.

Create ConstantParameter Buffer .

Fill in data to memory block.

Create PipelineLayout.

Definition at line 136 of file Material.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        std::unique_lock<std::mutex> lock(m_Mutex);
 
        {
            SPICES_PROFILE_ZONEN("BuildMaterial::RegistryToRenderer");
 
            if (m_AlreadyBuild)
            {
                {
                    std::vector<std::string> sv = StringLibrary::SplitString(m_MaterialPath, '.');
                    auto renderer = RendererManager::GetRenderer(sv[0]);
                    renderer->RegistryMaterial(m_MaterialPath, sv[1]);
                }
 
                return;
            }
 
            m_AlreadyBuild = true;
        }
 
        {
            SPICES_PROFILE_ZONEN("BuildMaterial::Registry ShaderModule");
 
            for (auto& pair : m_Shaders)
            {
                for (int i = 0; i < pair.second.size(); i++)
                {
                    std::stringstream ss;
                    ss << pair.second[i] << "." << pair.first;
 
                    ResourcePool<Shader>::Load<Shader>(ss.str(), pair.second[i], pair.first);
                }
            }
        }
 
        {
            SPICES_PROFILE_ZONEN("BuildMaterial::Clean Up old descripotrset");
 
            m_MaterialParameterBuffer  = nullptr;
            m_Buffermemoryblocks       = scl::runtime_memory_block();
        }
 
        {
            SPICES_PROFILE_ZONEN("BuildMaterial::Build Local ConstantParameter Block");
 
            m_ConstantParams.for_each([&](const std::string& k, const ConstantParams& v) {
                m_Buffermemoryblocks.add_element(k, v.value.paramType);
                return false;
            });
 
            m_Buffermemoryblocks.build();
        }
 
        uint64_t size = m_TextureParams.size() * sizeof(int) + m_Buffermemoryblocks.get_bytes();
        if (size == 0)
        {
            if (isAutoRegistry)
            {
                const std::vector<std::string> sv = StringLibrary::SplitString(m_MaterialPath, '.');
                auto renderer = RendererManager::GetRenderer(sv[0]);
                renderer->RegistryMaterial(m_MaterialPath, sv[1]);
            }
 
            return;
        }
 
        {
            SPICES_PROFILE_ZONEN("BuildMaterial::Create Material Parameter Buffer");
 
            m_MaterialParameterBuffer = std::make_unique<VulkanBuffer>(
                VulkanRenderBackend::GetState(),
                "MaterialParameterBuffer",
                size,
                VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
                VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
            );
        }
 
        {
            SPICES_PROFILE_ZONEN("BuildMaterial::Registry texture");
 
            int tindex = 0;
            m_TextureParams.for_each([&](const std::string& k, TextureParam& v) {
 
                if (v.textureType == "Texture2D")
                {
                    if(v.texturePath == "")
                    {
                        v.index = -1;
                    }
                    else
                    {
                        const std::shared_ptr<Texture> texture = ResourcePool<Texture>::Load<Texture2D>(v.texturePath, v.texturePath);
                        v.index = BindLessTextureManager::Registry(v.texturePath);
 
                        const auto descriptorSet = DescriptorSetManager::Registry("PreRenderer", SpicesShader::BINDLESS_TEXTURE_SET);
 
                        VkWriteDescriptorSet         write {};
                        write.sType                = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
                        write.dstBinding           = SpicesShader::BINDLESS_TEXTURE_BINDING;
                        write.dstSet               = descriptorSet->Get();
                        write.descriptorType       = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
                        write.pImageInfo           = texture->GetResource<VulkanImage>()->GetImageInfo();
                        write.descriptorCount      = 1;
                        write.dstArrayElement      = v.index;
 
                        vkUpdateDescriptorSets(VulkanRenderBackend::GetState().m_Device, 1, &write, 0, nullptr);
                    }
                        
                    m_MaterialParameterBuffer->WriteToBuffer(&v.index, sizeof(int), tindex * sizeof(int));
                    m_MaterialParameterBuffer->Flush();
                }
 
                else
                {
                    SPICES_CORE_ERROR("Material::BuildMaterial(): Invalid textureType.");
                }
 
                tindex++;
                return false;
            });
        }
 
        {
            SPICES_PROFILE_ZONEN("BuildMaterial::Add ConstantParameter Buffer");
 
            m_Buffermemoryblocks.for_each([&](const std::string& name, void* pt) {
                ConstantParam& ref = m_ConstantParams.find_value(name)->value;
                size_t size = m_TextureParams.size() * sizeof(int) + m_Buffermemoryblocks.item_location(name);
                
                if      (ref.paramType == "float4")
                {
                    *static_cast<glm::vec4*>(pt)     = std::any_cast<glm::vec4>(ref.paramValue);
                    m_MaterialParameterBuffer->WriteToBuffer(pt, sizeof(glm::vec4), size);
                    m_MaterialParameterBuffer->Flush();
                }
                else if (ref.paramType == "float3")
                {
                    *static_cast<glm::vec3*>(pt)     = std::any_cast<glm::vec3>(ref.paramValue);
                    m_MaterialParameterBuffer->WriteToBuffer(pt, sizeof(glm::vec3), size);
                    m_MaterialParameterBuffer->Flush();
                }
                else if (ref.paramType == "float2")
                {
                    *static_cast<glm::vec2*>(pt)     = std::any_cast<glm::vec2>(ref.paramValue);
                    m_MaterialParameterBuffer->WriteToBuffer(pt, sizeof(glm::vec2), size);
                    m_MaterialParameterBuffer->Flush();
                }
                else if (ref.paramType == "float")
                {
                    *static_cast<float*>(pt)         = std::any_cast<float>(ref.paramValue);
                    m_MaterialParameterBuffer->WriteToBuffer(pt, sizeof(float), size);
                    m_MaterialParameterBuffer->Flush();
                }
                else if (ref.paramType == "int")
                {
                    *static_cast<int*>(pt)           = std::any_cast<int>(ref.paramValue);
                    m_MaterialParameterBuffer->WriteToBuffer(pt, sizeof(int), size);
                    m_MaterialParameterBuffer->Flush();
                }
                else if (ref.paramType == "bool")
                {
                    *static_cast<bool*>(pt)          = std::any_cast<bool>(ref.paramValue);
                    m_MaterialParameterBuffer->WriteToBuffer(pt, sizeof(bool), size);
                    m_MaterialParameterBuffer->Flush();
                }
                else
                {
                    SPICES_CORE_ERROR("Material::BuildMaterial(): Invalid paramType.")
                }
    
                return false;
            });
        }
 
        if (isAutoRegistry)
        {
            std::vector<std::string> sv = StringLibrary::SplitString(m_MaterialPath, '.');
            auto renderer = RendererManager::GetRenderer(sv[0]);
            renderer->RegistryMaterial(m_MaterialPath, sv[1]);
        }
    }

References m_AlreadyBuild.