UpdateMaterial()

void Spices::Material::UpdateMaterial

(

)

Update material data to buffer.

Registry ShaderModule.

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

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.

Registry ShaderModule.

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

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.

Definition at line 369 of file Material.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        std::unique_lock<std::mutex> lock(m_Mutex);
 
        {
            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.first << "." << pair.second[i];
 
                    ResourcePool<Shader>::Load<Shader>(ss.str(), pair.second[i], pair.first);
                }
            }
        }
 
        {
            SPICES_PROFILE_ZONEN("BuildMaterial::Build Local ConstantParameter Block");
 
            m_Buffermemoryblocks = scl::runtime_memory_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();
        }
 
        {
            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
                    {
                        std::shared_ptr<Texture> texture = ResourcePool<Texture>::Load<Texture2D>(v.texturePath, v.texturePath);
                        v.index = BindLessTextureManager::Registry(v.texturePath);
 
                        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;
            });
        }
    }