load_shader() [2/3]

ShaderID MayaFlux::Portal::Graphics::ShaderFoundry::load_shader

(

const ShaderSpec &

spec

)

Compile and cache a compute shader from a declarative ShaderSpec.

Emits SPIR-V assembly text from the spec via detail::emit_spirv_asm(), assembles it via VKShaderModule::create_from_spirv_asm() using SPIRV-Tools, and caches the result by content hash. No shaderc or GLSL toolchain is involved.

Subsequent calls with a spec that produces identical assembly are cache hits and return the existing ShaderID at no cost.

The emitted shader is always a compute stage. Entry point is "main". Binding 0 at set 0 is never emitted; it is engine-reserved.

Parameters

spec	ShaderSpec produced by ShaderSpec::Assemble::build().

Returns

ShaderID on success, INVALID_SHADER on compilation failure.

Definition at line 397 of file ShaderFoundry.cpp.

{
    if (!is_initialized()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ShaderCompilation,
            "ShaderFoundry not initialized");
        return INVALID_SHADER;
    }
 
    if (spec.kernel.has_value()) {
        const std::string glsl = detail::emit_glsl_kernel(spec);
        const std::string key = generate_source_cache_key(glsl, ShaderStage::COMPUTE);
 
        auto kernel_id_it = m_shader_filepath_cache.find(key);
        if (kernel_id_it != m_shader_filepath_cache.end()) {
            MF_DEBUG(Journal::Component::Portal, Journal::Context::ShaderCompilation,
                "Using cached kernel shader: {}", key);
            return kernel_id_it->second;
        }
 
        auto module = compile_from_source_cached(glsl, ShaderStage::COMPUTE, key);
        if (!module) {
            MF_ERROR(Journal::Component::Portal, Journal::Context::ShaderCompilation,
                "Failed to compile kernel shader");
            return INVALID_SHADER;
        }
        const ShaderID id = m_next_shader_id++;
        auto& state = m_shaders[id];
        state.module = module;
        state.filepath = key;
        state.stage = ShaderStage::COMPUTE;
        state.entry_point = "main";
        m_shader_filepath_cache[key] = id;
        MF_INFO(Journal::Component::Portal, Journal::Context::ShaderCompilation,
            "Compiled kernel shader (ID: {}, key: {})", id, key);
        return id;
    }
 
    const std::string asm_text = detail::emit_spirv_asm(spec);
    const std::string key = generate_source_cache_key(asm_text, ShaderStage::COMPUTE);
 
    auto id_it = m_shader_filepath_cache.find(key);
    if (id_it != m_shader_filepath_cache.end()) {
        MF_DEBUG(Journal::Component::Portal, Journal::Context::ShaderCompilation,
            "Using cached generated shader: {}", key);
        return id_it->second;
    }
 
    auto module = compile_from_spirv_asm(asm_text, ShaderStage::COMPUTE);
    if (!module) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::ShaderCompilation,
            "Failed to compile generated shader (key: {})", key);
        return INVALID_SHADER;
    }
 
    const ShaderID id = m_next_shader_id++;
    auto& state = m_shaders[id];
    state.module = module;
    state.filepath = key;
    state.stage = ShaderStage::COMPUTE;
    state.entry_point = "main";
 
    m_shader_filepath_cache[key] = id;
 
    MF_INFO(Journal::Component::Portal, Journal::Context::ShaderCompilation,
        "Compiled generated shader (ID: {}, key: {})", id, key);
 
    return id;
}

References MayaFlux::Portal::Graphics::COMPUTE, MayaFlux::Portal::Graphics::detail::emit_glsl_kernel(), MayaFlux::Portal::Graphics::detail::emit_spirv_asm(), generate_source_cache_key(), MayaFlux::Portal::Graphics::INVALID_SHADER, is_initialized(), MayaFlux::Portal::Graphics::ShaderSpec::kernel, m_next_shader_id, m_shader_filepath_cache, m_shaders, MF_DEBUG, MF_ERROR, MF_INFO, MayaFlux::Journal::Portal, and MayaFlux::Journal::ShaderCompilation.

Here is the call graph for this function: