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-Reflect library to extract bindings, push constants, workgroup sizes, etc. Falls back to basic parsing if library unavailable.

Definition at line 343 of file VKShaderModule.cpp.

{
#ifdef MAYAFLUX_USE_SPIRV_REFLECT
    SpvReflectShaderModule module;
    SpvReflectResult result = spvReflectCreateShaderModule(
        spirv_code.size() * sizeof(uint32_t),
        spirv_code.data(),
        &module);
 
    if (result != SPV_REFLECT_RESULT_SUCCESS) {
        MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "SPIRV-Reflect failed: {}", static_cast<int>(result));
        return false;
    }
 
    uint32_t binding_count = 0;
    result = spvReflectEnumerateDescriptorBindings(&module, &binding_count, nullptr);
    if (result == SPV_REFLECT_RESULT_SUCCESS && binding_count > 0) {
        std::vector<SpvReflectDescriptorBinding*> bindings(binding_count);
        spvReflectEnumerateDescriptorBindings(&module, &binding_count, bindings.data());
 
        for (const auto* binding : bindings) {
            ShaderReflection::DescriptorBinding desc;
            desc.set = binding->set;
            desc.binding = binding->binding;
            desc.type = static_cast<vk::DescriptorType>(binding->descriptor_type);
            desc.stage = m_stage;
            desc.count = binding->count;
            desc.name = binding->name ? binding->name : "";
 
            m_reflection.bindings.push_back(desc);
        }
 
        MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Reflected {} descriptor bindings", binding_count);
    }
 
    uint32_t push_constant_count = 0;
    result = spvReflectEnumeratePushConstantBlocks(&module, &push_constant_count, nullptr);
    if (result == SPV_REFLECT_RESULT_SUCCESS && push_constant_count > 0) {
        std::vector<SpvReflectBlockVariable*> push_constants(push_constant_count);
        spvReflectEnumeratePushConstantBlocks(&module, &push_constant_count, push_constants.data());
 
        for (const auto* block : push_constants) {
            ShaderReflection::PushConstantRange range;
            range.stage = m_stage;
            range.offset = block->offset;
            range.size = block->size;
 
            m_reflection.push_constants.push_back(range);
        }
 
        MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Reflected {} push constant blocks", push_constant_count);
    }
 
    if (m_stage == vk::ShaderStageFlagBits::eCompute) {
        m_reflection.workgroup_size = std::array<uint32_t, 3> {
            module.entry_points[0].local_size.x,
            module.entry_points[0].local_size.y,
            module.entry_points[0].local_size.z
        };
 
        MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Compute shader workgroup size: [{}, {}, {}]",
            (*m_reflection.workgroup_size)[0],
            (*m_reflection.workgroup_size)[1],
            (*m_reflection.workgroup_size)[2]);
    }
 
    spvReflectDestroyShaderModule(&module);
    return true;
 
#else
    MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
        "SPIRV-Reflect not available - shader reflection disabled");
 
    if (m_stage == vk::ShaderStageFlagBits::eCompute) {
        // SPIR-V OpExecutionMode LocalSize pattern
        // This is a simplified parser - production code should use SPIRV-Reflect
        for (size_t i = 0; i < spirv_code.size() - 4; ++i) {
            if ((spirv_code[i] & 0xFFFF) == 17) {
                uint32_t mode = spirv_code[i + 2];
                if (mode == 17) {
                    m_reflection.workgroup_size = std::array<uint32_t, 3> {
                        spirv_code[i + 3],
                        spirv_code[i + 4],
                        spirv_code[i + 5]
                    };
 
                    MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
                        "Extracted compute workgroup size: [{}, {}, {}]",
                        (*m_reflection.workgroup_size)[0],
                        (*m_reflection.workgroup_size)[1],
                        (*m_reflection.workgroup_size)[2]);
                    break;
                }
            }
        }
    }
 
    return false; // Reflection incomplete without SPIRV-Reflect
#endif
}

References MayaFlux::Core::ShaderReflection::DescriptorBinding::binding, MayaFlux::Core::ShaderReflection::bindings, MayaFlux::Journal::Core, MayaFlux::Core::ShaderReflection::DescriptorBinding::count, MayaFlux::Journal::GraphicsBackend, m_reflection, m_stage, MF_DEBUG, MF_WARN, MayaFlux::Core::ShaderReflection::DescriptorBinding::name, MayaFlux::Core::ShaderReflection::PushConstantRange::offset, MayaFlux::Core::ShaderReflection::push_constants, MayaFlux::Core::ShaderReflection::DescriptorBinding::set, MayaFlux::Core::ShaderReflection::PushConstantRange::size, MayaFlux::Core::ShaderReflection::DescriptorBinding::stage, MayaFlux::Core::ShaderReflection::PushConstantRange::stage, MayaFlux::Core::ShaderReflection::DescriptorBinding::type, and MayaFlux::Core::ShaderReflection::workgroup_size.

Referenced by create_from_spirv().

Here is the caller graph for this function: