◆ build_spec()

std::optional< Portal::Graphics::ShaderSpec > MayaFlux::Nodes::Network::GpuFieldOperator::build_spec ( ) const

Assemble the compute spec for the current bindings.

Emits one GLSL function per distinct bound field, then a kernel that guards against the dispatch tail, reads the position once, and writes every touched target in a single pass. Fields sharing a target sum before the write; NORMAL and TANGENT normalise after the sum. POSITION accumulates onto the existing vertex, every other target is assigned, matching FieldOperator.

The kernel addresses a range rather than the whole buffer, since a NetworkGeometryBuffer aggregates one slice per producing operator. The range and the record stride arrive as push constants written by the processor, so neither the caller nor the field author offsets anything, and a layout or slice change needs no recompile. Attribute offsets are baked, since those describe the record the spec was built against.

Cached until a bind, unbind or configuration change invalidates it. Returns nullopt when nothing is bound or the layout carries no position attribute.

A cluster_id SSBO binding and the read that feeds it are emitted only when needs_cluster_id() is true: an operator with no cluster-scoped binding gets exactly the shader it always has, unchanged.

Definition at line 516 of file GpuFieldOperator.cpp.

{
    if (m_spec_cache.has_value())
        return m_spec_cache;
 
    if (m_bindings.empty())
        return std::nullopt;
 
    const auto position = resolve_target(Kinesis::FieldTarget::POSITION);
    if (!position.has_value()) {
        MF_ERROR(Journal::Component::Nodes, Journal::Context::NodeProcessing,
            "GpuFieldOperator: layout carries no position attribute. Fields are "
            "functions of position and cannot be evaluated without one.");
        return std::nullopt;
    }
 
    const bool needs_cluster = needs_cluster_id();
 
    Portal::Graphics::ShaderSpec::Assemble assemble;
    assemble.start_binding(m_vertex_binding)
        .ssbo("vertices", Portal::Graphics::BindingDirection::InOut,
            Kakshya::GpuDataFormat::FLOAT32);
 
    if (needs_cluster) {
        assemble.ssbo("cluster_id", Portal::Graphics::BindingDirection::Input,
            Kakshya::GpuDataFormat::UINT32);
    }
 
    assemble.pc("first_vertex", Kakshya::GpuDataFormat::UINT32)
        .pc("vertex_count", Kakshya::GpuDataFormat::UINT32)
        .pc("stride_words", Kakshya::GpuDataFormat::UINT32)
        .pc("time", Kakshya::GpuDataFormat::FLOAT32)
        .pc("geometry", Kakshya::GpuDataFormat::MAT4_F32);
 
    if (uses_params()) {
        assemble.pc("params", Kakshya::GpuDataFormat::VEC4_F32);
    }
 
    assemble.workgroup(m_workgroup_size);
 
    std::vector<std::string_view> emitted;
    for (const auto& b : m_bindings) {
        const auto seen = std::ranges::find(emitted, b.source.name);
        if (seen != emitted.end())
            continue;
        emitted.push_back(b.source.name);
        assemble.function(b.source.return_type, b.source.name,
            b.source.params, b.source.body);
    }
 
    const uint32_t pw = position->first;
    std::string body;
    body += "    if (i >= vertex_count) { return; }\n";
    body += "    uint b = (first_vertex + i) * stride_words;\n";
    body += "    vec3 p = (geometry * vec4(vertices[b + " + word(pw)
        + "], vertices[b + " + word(pw + 1)
        + "], vertices[b + " + word(pw + 2) + "], 1.0f)).xyz;\n";
 
    if (needs_cluster) {
        body += "    uint my_cluster = cluster_id[first_vertex + i];\n";
    }
 
    for (Kinesis::FieldTarget t : Kinesis::k_field_targets) {
        const bool touched = std::ranges::any_of(m_bindings,
            [t](const Binding& b) { return has_flag(b.targets, t); });
        if (!touched)
            continue;
 
        const auto slot = resolve_target(t);
        if (!slot.has_value())
            continue;
 
        const auto [w, components] = *slot;
        const std::string acc = std::string("acc_") + target_name(t);
 
        body += "\n    " + std::string(glsl_type(components)) + " " + acc
            + " = " + glsl_zero(components) + ";\n";
 
        for (const auto& b : m_bindings) {
            if (!has_flag(b.targets, t))
                continue;
 
            const char* arguments = "(p)";
            if (b.parametric) {
                arguments = "(p, time, params)";
            } else if (b.temporal) {
                arguments = "(p, time)";
            }
            const std::string call = std::string(b.source.name) + arguments;
 
            if (b.cluster.has_value()) {
                body += "    if (my_cluster == " + word(*b.cluster) + ") { "
                    + acc + " += " + call + "; }\n";
            } else {
                body += "    " + acc + " += " + call + ";\n";
            }
        }
 
        if (t == Kinesis::FieldTarget::POSITION || t == Kinesis::FieldTarget::TANGENT) {
            body += "    " + acc + " = inverse(mat3(geometry)) * " + acc + ";\n";
        } else if (t == Kinesis::FieldTarget::NORMAL) {
            body += "    " + acc + " = transpose(mat3(geometry)) * " + acc + ";\n";
        }
 
        if (t == Kinesis::FieldTarget::NORMAL || t == Kinesis::FieldTarget::TANGENT) {
            const std::string len = std::string("len_") + target_name(t);
            body += "    float " + len + " = length(" + acc + ");\n";
            body += "    " + acc + " = " + len + " > 1e-6f ? " + acc + " / "
                + len + " : " + acc + ";\n";
        }
 
        const char* assign = target_accumulates(t) ? " += " : " = ";
        for (uint32_t k = 0; k < components; ++k) {
            body += "    vertices[b + " + word(w + k) + "]" + assign
                + acc + (components == 1 ? "" : k_swizzle[k]) + ";\n";
        }
    }
 
    assemble.kernel(Portal::Graphics::KernelSource { .body = std::move(body) });
 
    m_spec_cache = assemble.build();
    return m_spec_cache;
}

Here is the call graph for this function: