decode()

bool MayaFlux::Nexus::StateDecoder::decode	(	Fabric &	fabric,
		const std::string &	base_path
	)

Decode and apply to fabric.

Parameters

fabric	Target fabric. Must already contain entities with ids matching the schema.
base_path	Path stem without extension, same value passed to StateEncoder::encode.

Returns

True on success. Partial patches (some ids missing) still return true; failures are logged.

Definition at line 134 of file Decoder.cpp.

{
    m_last_error.clear();
    m_patched_count = 0;
    m_missing_count = 0;
 
    const std::string json_path = base_path + ".json";
    const std::string exr_path = base_path + ".exr";
 
    IO::JSONSerializer ser;
    auto schema_opt = ser.read<State::FabricSchema>(json_path);
    if (!schema_opt) {
        m_last_error = "Failed to load schema: " + ser.last_error();
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return false;
    }
    const auto& schema = *schema_opt;
 
    if (schema.version != State::k_schema_version) {
        m_last_error = "Unsupported schema version: " + std::to_string(schema.version)
            + " (expected " + std::to_string(State::k_schema_version) + ")";
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    if (schema.entities.empty()) {
        m_last_error = "Schema contains no entities: " + json_path;
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    const uint32_t expected_rows = State::k_exr_rows;
    auto pv_opt = load_exr(exr_path, static_cast<uint32_t>(schema.entities.size()), expected_rows, m_last_error);
    if (!pv_opt) {
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return false;
    }
    auto& pv = *pv_opt;
    const auto* pixels = pv.image.as_float();
    const uint32_t width = pv.width;
    const auto& r = schema.ranges;
 
    for (size_t i = 0; i < schema.entities.size(); ++i) {
        const auto& entry = schema.entities[i];
 
        if (!State::kind_known(entry.kind)) {
            MF_WARN(Journal::Component::Nexus, Journal::Context::Runtime,
                "StateDecoder: unknown kind '{}' for id {}, skipping", entry.kind, entry.id);
            ++m_missing_count;
            continue;
        }
 
        const size_t row0 = (static_cast<size_t>(0) * width + i) * State::k_channels;
        const size_t row1 = (static_cast<size_t>(1) * width + i) * State::k_channels;
        const size_t row2 = (static_cast<size_t>(2) * width + i) * State::k_channels;
 
        const glm::vec3 position {
            denormalize((*pixels)[row0 + 0], r.pos_x),
            denormalize((*pixels)[row0 + 1], r.pos_y),
            denormalize((*pixels)[row0 + 2], r.pos_z),
        };
 
        switch (State::parse_kind(entry.kind)) {
        case Fabric::Kind::Emitter: {
            auto e = fabric.get_emitter(entry.id);
            if (!e) {
                MF_WARN(Journal::Component::Nexus, Journal::Context::Runtime,
                    "StateDecoder: id {} not found as Emitter, skipping", entry.id);
                ++m_missing_count;
                continue;
            }
            if (!entry.influence_fn_name.empty() && e->fn_name() != entry.influence_fn_name) {
                MF_WARN(Journal::Component::Nexus, Journal::Context::Runtime,
                    "StateDecoder: Emitter {} fn_name mismatch: schema='{}' live='{}'",
                    entry.id, entry.influence_fn_name, e->fn_name());
            }
            e->set_position(position);
            e->set_intensity(denormalize((*pixels)[row0 + 3], r.intensity));
            if (entry.color) {
                e->set_color(glm::vec3 {
                    denormalize((*pixels)[row1 + 0], r.color_r),
                    denormalize((*pixels)[row1 + 1], r.color_g),
                    denormalize((*pixels)[row1 + 2], r.color_b),
                });
            }
            if (entry.size) {
                e->set_size(denormalize((*pixels)[row1 + 3], r.size));
            }
            e->set_radius(denormalize((*pixels)[row2 + 0], r.radius));
            break;
        }
        case Fabric::Kind::Sensor: {
            auto s = fabric.get_sensor(entry.id);
            if (!s) {
                MF_WARN(Journal::Component::Nexus, Journal::Context::Runtime,
                    "StateDecoder: id {} not found as Sensor, skipping", entry.id);
                ++m_missing_count;
                continue;
            }
            if (!entry.perception_fn_name.empty() && s->fn_name() != entry.perception_fn_name) {
                MF_WARN(Journal::Component::Nexus, Journal::Context::Runtime,
                    "StateDecoder: Sensor {} fn_name mismatch: schema='{}' live='{}'",
                    entry.id, entry.perception_fn_name, s->fn_name());
            }
            s->set_position(position);
            s->set_query_radius(denormalize((*pixels)[row2 + 1], r.query_radius));
            break;
        }
        case Fabric::Kind::Agent: {
            auto a = fabric.get_agent(entry.id);
            if (!a) {
                MF_WARN(Journal::Component::Nexus, Journal::Context::Runtime,
                    "StateDecoder: id {} not found as Agent, skipping", entry.id);
                ++m_missing_count;
                continue;
            }
            if (!entry.perception_fn_name.empty() && a->perception_fn_name() != entry.perception_fn_name) {
                MF_WARN(Journal::Component::Nexus, Journal::Context::Runtime,
                    "StateDecoder: Agent {} perception_fn_name mismatch: schema='{}' live='{}'",
                    entry.id, entry.perception_fn_name, a->perception_fn_name());
            }
            if (!entry.influence_fn_name.empty() && a->influence_fn_name() != entry.influence_fn_name) {
                MF_WARN(Journal::Component::Nexus, Journal::Context::Runtime,
                    "StateDecoder: Agent {} influence_fn_name mismatch: schema='{}' live='{}'",
                    entry.id, entry.influence_fn_name, a->influence_fn_name());
            }
            a->set_position(position);
            a->set_intensity(denormalize((*pixels)[row0 + 3], r.intensity));
            if (entry.color) {
                a->set_color(glm::vec3 {
                    denormalize((*pixels)[row1 + 0], r.color_r),
                    denormalize((*pixels)[row1 + 1], r.color_g),
                    denormalize((*pixels)[row1 + 2], r.color_b),
                });
            }
            if (entry.size) {
                a->set_size(denormalize((*pixels)[row1 + 3], r.size));
            }
            a->set_radius(denormalize((*pixels)[row2 + 0], r.radius));
            a->set_query_radius(denormalize((*pixels)[row2 + 1], r.query_radius));
 
            if (entry.locus_nav) {
                if (!apply_locus_nav(a, *entry.locus_nav)) {
                    MF_WARN(Journal::Component::Nexus, Journal::Context::Runtime,
                        "StateDecoder: Agent {} has locus_nav in schema but is not a Locus at runtime",
                        entry.id);
                }
            }
 
            if (auto presence = std::dynamic_pointer_cast<Presence>(a)) {
                if (!entry.falloff_curve_name.empty()) {
                    if (auto fc = Reflect::string_to_enum_case_insensitive<Presence::FalloffCurve>(entry.falloff_curve_name))
                        presence->set_falloff_curve(*fc);
                }
                if (entry.falloff_radius)
                    presence->set_falloff_radius(*entry.falloff_radius);
            }
            break;
        }
        }
 
        ++m_patched_count;
    }
 
    for (const auto& xrec : schema.expanses) {
        if (xrec.fn_name.empty()) {
            MF_WARN(Journal::Component::Nexus, Journal::Context::FileIO,
                "StateDecoder: Expanse {} has no fn_name, skipping", xrec.id);
            continue;
        }
        auto contains_fn = fabric.resolve_expanse_fn(xrec.fn_name);
        if (!contains_fn || !*contains_fn) {
            MF_WARN(Journal::Component::Nexus, Journal::Context::FileIO,
                "StateDecoder: Expanse {} fn '{}' not in registry, skipping",
                xrec.id, xrec.fn_name);
            continue;
        }
        auto on_enter_fn = xrec.on_enter_fn_name.empty()
            ? Expanse::CrossingFn {}
            : [ptr = fabric.resolve_crossing_fn(xrec.on_enter_fn_name)](uint32_t id) {
                  if (ptr && *ptr)
                      (*ptr)(id);
              };
        auto on_exit_fn = xrec.on_exit_fn_name.empty()
            ? Expanse::CrossingFn {}
            : [ptr = fabric.resolve_crossing_fn(xrec.on_exit_fn_name)](uint32_t id) {
                  if (ptr && *ptr)
                      (*ptr)(id);
              };
        auto expanse = std::make_shared<Expanse>(
            xrec.fn_name,
            xrec.on_enter_fn_name,
            xrec.on_exit_fn_name,
            *contains_fn,
            std::move(on_enter_fn),
            std::move(on_exit_fn));
        fabric.add_expanse(std::move(expanse));
    }
 
    MF_INFO(Journal::Component::Nexus, Journal::Context::FileIO,
        "StateDecoder: patched {} entities ({} missing) from {} + {}",
        m_patched_count, m_missing_count, exr_path, json_path);
 
    return true;
}

References a, MayaFlux::Nexus::Fabric::add_expanse(), MayaFlux::Nexus::Fabric::Agent, MayaFlux::Nexus::Fabric::Emitter, MayaFlux::Journal::FileIO, MayaFlux::Nexus::Fabric::get_agent(), MayaFlux::Nexus::Fabric::get_emitter(), MayaFlux::Nexus::Fabric::get_sensor(), MayaFlux::Nexus::State::k_channels, MayaFlux::Nexus::State::k_exr_rows, MayaFlux::Nexus::State::k_schema_version, MayaFlux::Nexus::State::kind_known(), MayaFlux::IO::JSONSerializer::last_error(), m_last_error, m_missing_count, m_patched_count, MF_ERROR, MF_INFO, MF_WARN, MayaFlux::Journal::Nexus, MayaFlux::Nexus::State::parse_kind(), pixels, ptr, MayaFlux::IO::JSONSerializer::read(), MayaFlux::Nexus::Fabric::resolve_crossing_fn(), MayaFlux::Nexus::Fabric::resolve_expanse_fn(), MayaFlux::Journal::Runtime, MayaFlux::Nexus::Fabric::Sensor, and width.

Here is the call graph for this function: