◆ reflect_spirv()

bool MayaFlux::Core::VKShaderModule::reflect_spirv ( const std::vector< uint32_t > & spirv_code )
private
Perform reflection on SPIR-V bytecode.
Parameters
spirv_code SPIR-V bytecode
Returns: true if reflection succeeded
Uses SPIRV-Cross library to extract bindings, push constants, workgroup sizes, etc. Falls back to basic parsing if library unavailable.
Definition at line 515 of file VKShaderModule.cpp.
{
    try {
        spirv_cross::Compiler compiler(spirv_code);
        spirv_cross::ShaderResources resources = compiler.get_shader_resources();
 
        auto reflect_resources = [&](const spirv_cross::SmallVector<spirv_cross::Resource>& res_vec,
                                     bool is_storage = false) {
            for (const auto& resource : res_vec) {
                ShaderReflection::DescriptorBinding desc;
                desc.set = compiler.get_decoration(resource.id, spv::DecorationDescriptorSet);
                desc.binding = compiler.get_decoration(resource.id, spv::DecorationBinding);
                desc.stage = m_stage;
                desc.name = resource.name;
 
                const auto& type = compiler.get_type(resource.type_id);
                desc.count = type.array.empty() ? 1 : type.array[0];
                desc.type = spirv_to_vk_descriptor_type(type.basetype, type, is_storage);
 
                m_reflection.bindings.push_back(desc);
            }
        };
 
        reflect_resources(resources.uniform_buffers, false);
 
        reflect_resources(resources.storage_buffers, true);
 
        reflect_resources(resources.sampled_images, false);
 
        reflect_resources(resources.storage_images, true);
 
        reflect_resources(resources.separate_images, false);
        reflect_resources(resources.separate_samplers, false);
 
        try {
            const spirv_cross::ShaderResources used = compiler.get_shader_resources(
                compiler.get_active_interface_variables());
 
            auto collect_active = [&](const spirv_cross::SmallVector<spirv_cross::Resource>& res_vec,
                                      bool is_storage) {
                for (const auto& resource : res_vec) {
                    ShaderReflection::DescriptorBinding desc;
                    desc.set = compiler.get_decoration(resource.id, spv::DecorationDescriptorSet);
                    desc.binding = compiler.get_decoration(resource.id, spv::DecorationBinding);
                    desc.stage = m_stage;
                    const std::string block_name = compiler.get_name(resource.base_type_id);
                    desc.name = block_name.empty() ? resource.name : block_name;
 
                    const auto& type = compiler.get_type(resource.type_id);
                    desc.count = type.array.empty() ? 1 : type.array[0];
                    desc.type = spirv_to_vk_descriptor_type(type.basetype, type, is_storage);
 
                    m_active_bindings.push_back(desc);
                }
            };
 
            collect_active(used.uniform_buffers, false);
            collect_active(used.storage_buffers, true);
            collect_active(used.sampled_images, false);
            collect_active(used.storage_images, true);
            collect_active(used.separate_images, false);
            collect_active(used.separate_samplers, false);
        } catch (const std::exception& e) {
            m_active_bindings.clear();
            MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "Active descriptor binding analysis failed: {}", e.what());
        }
 
        if (!m_reflection.bindings.empty()) {
            MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "Reflected {} descriptor bindings", m_reflection.bindings.size());
        }
 
        for (const auto& pc_buffer : resources.push_constant_buffers) {
            const auto& type = compiler.get_type(pc_buffer.type_id);
 
            ShaderReflection::PushConstantRange range;
            range.stage = m_stage;
            range.offset = 0;
            range.size = static_cast<uint32_t>(compiler.get_declared_struct_size(type));
 
            m_reflection.push_constants.push_back(range);
        }
 
        if (!m_reflection.push_constants.empty()) {
            MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "Reflected {} push constant blocks", m_reflection.push_constants.size());
        }
 
        auto spec_constants = compiler.get_specialization_constants();
        for (const auto& spec : spec_constants) {
            ShaderReflection::SpecializationConstant sc;
            sc.constant_id = spec.constant_id;
            sc.name = compiler.get_name(spec.id);
 
            const auto& type = compiler.get_type(compiler.get_constant(spec.id).constant_type);
            sc.size = type.basetype == spirv_cross::SPIRType::Boolean
                ? static_cast<uint32_t>(sizeof(vk::Bool32))
                : type.width / 8;
 
            m_reflection.specialization_constants.push_back(sc);
        }
 
        if (!m_reflection.specialization_constants.empty()) {
            MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "Reflected {} specialization constants",
                m_reflection.specialization_constants.size());
        }
 
        if (m_stage == vk::ShaderStageFlagBits::eCompute
            || m_stage == vk::ShaderStageFlagBits::eMeshEXT
            || m_stage == vk::ShaderStageFlagBits::eTaskEXT) {
            auto entry_points = compiler.get_entry_points_and_stages();
 
            for (const auto& ep : entry_points) {
                if (ep.name == m_entry_point && ep.execution_model == spv::ExecutionModelGLCompute) {
 
                    std::array<uint32_t, 3> workgroup_size {
                        compiler.get_execution_mode_argument(spv::ExecutionModeLocalSize, 0),
                        compiler.get_execution_mode_argument(spv::ExecutionModeLocalSize, 1),
                        compiler.get_execution_mode_argument(spv::ExecutionModeLocalSize, 2)
                    };
 
                    if (!workgroup_size.empty() && workgroup_size.size() >= 3) {
                        m_reflection.workgroup_size = std::array<uint32_t, 3> {
                            workgroup_size[0],
                            workgroup_size[1],
                            workgroup_size[2]
                        };
 
                        MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
                            "Compute shader workgroup size: [{}, {}, {}]",
                            workgroup_size[0], workgroup_size[1], workgroup_size[2]);
                    }
                    break;
                }
            }
        }
 
        if (m_stage == vk::ShaderStageFlagBits::eVertex) {
            for (const auto& input : resources.stage_inputs) {
                uint32_t location = compiler.get_decoration(input.id, spv::DecorationLocation);
                const auto& type = compiler.get_type(input.type_id);
 
                vk::VertexInputAttributeDescription attr;
                attr.location = location;
                attr.binding = 0;
                attr.format = spirv_type_to_vk_format(type);
                attr.offset = 0;
 
                m_reflection.vertex_attributes.push_back(attr);
            }
 
            if (!m_reflection.vertex_attributes.empty()) {
                MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
                    "Reflected {} vertex input attributes",
                    m_reflection.vertex_attributes.size());
            }
        }
 
        return true;
 
    } catch (const spirv_cross::CompilerError& e) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "SPIRV-Cross reflection failed: {}", e.what());
        return false;
    }
}
Referenced by create_from_spirv().
Here is the call graph for this function:
Here is the caller graph for this function: