◆ encode_fabric()

bool MayaFlux::Nexus::StateEncoder::encode_fabric	(	const Fabric &	fabric,
		const std::string &	base_path,
		const std::unordered_set< const Expanse * > &	tapestry_owned
	)
private
Definition at line 199 of file Encoder.cpp.
{
    m_last_error.clear();
 
    // -------------------------------------------------------------------------
    // Collect encodable entities.
    // -------------------------------------------------------------------------
    struct InternalRecord {
        uint32_t id;
        Fabric::Kind kind;
        std::optional<glm::vec3> position;
        std::optional<glm::vec4> orientation;
        float intensity { 0.0F };
        float radius { 0.0F };
        float query_radius { 0.0F };
        std::optional<glm::vec3> color;
        std::optional<float> size;
        std::string influence_fn_name;
        std::string perception_fn_name;
        // Layer 0
        float entity_type_norm { 0.0F };
        float trigger_kind { 0.0F };
        float time_kind { 0.0F };
        // Layer 2
        uint32_t sink_type { 0 };
        uint32_t first_audio_channel { 0 };
    };
 
    std::vector<InternalRecord> records;
 
    auto ids = fabric.all_ids();
    std::ranges::sort(ids);
 
    for (uint32_t id : ids) {
        const auto k = fabric.kind(id);
        switch (k) {
        case Fabric::Kind::Emitter: {
            auto e = fabric.get_emitter(id);
            if (!e) {
                continue;
            }
            if (e->fn() && e->fn_name().empty()) {
                MF_WARN(Journal::Component::Nexus, Journal::Context::FileIO,
                    "StateEncoder: Emitter {} has a function but no fn_name", id);
            }
            auto& rec = records.emplace_back(InternalRecord {
                .id = id,
                .kind = k,
                .position = e->position(),
                .intensity = e->intensity(),
                .radius = e->radius(),
                .color = e->color(),
                .size = e->size(),
                .influence_fn_name = e->fn_name(),
                .entity_type_norm = 0.0F,
            });
            fill_wiring_pixels(fabric, id, rec.trigger_kind, rec.time_kind);
            rec.sink_type = (e->audio_sinks().empty() ? 0U : 1U)
                | (e->render_sinks().empty() ? 0U : 2U);
            if (!e->audio_sinks().empty())
                rec.first_audio_channel = e->audio_sinks().front().channel;
            break;
        }
        case Fabric::Kind::Sensor: {
            auto s = fabric.get_sensor(id);
            if (!s) {
                continue;
            }
            if (s->fn() && s->fn_name().empty()) {
                MF_WARN(Journal::Component::Nexus, Journal::Context::FileIO,
                    "StateEncoder: Sensor {} has a function but no fn_name", id);
            }
            auto& rec = records.emplace_back(InternalRecord {
                .id = id,
                .kind = k,
                .position = s->position(),
                .query_radius = s->query_radius(),
                .perception_fn_name = s->fn_name(),
                .entity_type_norm = 0.333F,
            });
            fill_wiring_pixels(fabric, id, rec.trigger_kind, rec.time_kind);
            break;
        }
        case Fabric::Kind::Agent: {
            auto a = fabric.get_agent(id);
            if (!a) {
                continue;
            }
            if (a->perception_fn() && a->perception_fn_name().empty()) {
                MF_WARN(Journal::Component::Nexus, Journal::Context::FileIO,
                    "StateEncoder: Agent {} has a perception function but no perception_fn_name", id);
            }
            if (a->influence_fn() && a->influence_fn_name().empty()) {
                MF_WARN(Journal::Component::Nexus, Journal::Context::FileIO,
                    "StateEncoder: Agent {} has an influence function but no influence_fn_name", id);
            }
            auto& rec = records.emplace_back(InternalRecord {
                .id = id,
                .kind = k,
                .position = a->position(),
                .intensity = a->intensity(),
                .radius = a->radius(),
                .query_radius = a->query_radius(),
                .color = a->color(),
                .size = a->size(),
                .influence_fn_name = a->influence_fn_name(),
                .perception_fn_name = a->perception_fn_name(),
                .entity_type_norm = 0.667F,
            });
            if (const auto& q = a->orientation()) {
                rec.orientation = glm::vec4(q->x, q->y, q->z, q->w);
            }
            fill_wiring_pixels(fabric, id, rec.trigger_kind, rec.time_kind);
            rec.sink_type = (a->audio_sinks().empty() ? 0U : 1U)
                | (a->render_sinks().empty() ? 0U : 2U);
            if (!a->audio_sinks().empty())
                rec.first_audio_channel = a->audio_sinks().front().channel;
            break;
        }
        }
    }
 
    if (records.empty()) {
        m_last_error = "No entities to encode";
        MF_WARN(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    // -------------------------------------------------------------------------
    // Compute per-field ranges.
    // -------------------------------------------------------------------------
    State::RangeSet rs;
    bool init_pos_x = false, init_pos_y = false, init_pos_z = false;
    bool init_intensity = false, init_radius = false, init_query_radius = false;
    bool init_color_r = false, init_color_g = false, init_color_b = false;
    bool init_size = false;
 
    for (const auto& rec : records) {
        if (rec.position) {
            expand_range(rs.pos_x, rec.position->x, init_pos_x);
            expand_range(rs.pos_y, rec.position->y, init_pos_y);
            expand_range(rs.pos_z, rec.position->z, init_pos_z);
        }
 
        if (rec.kind == Fabric::Kind::Emitter || rec.kind == Fabric::Kind::Agent) {
            expand_range(rs.intensity, rec.intensity, init_intensity);
            expand_range(rs.radius, rec.radius, init_radius);
            if (rec.color) {
                expand_range(rs.color_r, rec.color->r, init_color_r);
                expand_range(rs.color_g, rec.color->g, init_color_g);
                expand_range(rs.color_b, rec.color->b, init_color_b);
            }
            if (rec.size) {
                expand_range(rs.size, *rec.size, init_size);
            }
        }
        if (rec.kind == Fabric::Kind::Sensor || rec.kind == Fabric::Kind::Agent) {
            expand_range(rs.query_radius, rec.query_radius, init_query_radius);
        }
    }
 
    // -------------------------------------------------------------------------
    // Build RGBA32F pixel buffer.
    // -------------------------------------------------------------------------
    const auto width = static_cast<uint32_t>(records.size());
 
    IO::ImageData image;
    image.width = width;
    image.height = State::k_exr_rows;
    image.channels = State::k_channels;
    image.format = Portal::Graphics::ImageFormat::RGBA32F;
 
    std::vector<float> pixels(static_cast<size_t>(width) * State::k_exr_rows * State::k_channels, 0.0F);
 
    for (size_t i = 0; i < records.size(); ++i) {
        const auto& rec = records[i];
 
        const size_t row0 = (static_cast<size_t>(0) * width + i) * State::k_channels;
        if (rec.position) {
            pixels[row0 + 0] = normalize(rec.position->x, rs.pos_x);
            pixels[row0 + 1] = normalize(rec.position->y, rs.pos_y);
            pixels[row0 + 2] = normalize(rec.position->z, rs.pos_z);
        }
        pixels[row0 + 3] = normalize(rec.intensity, rs.intensity);
 
        const size_t row1 = (static_cast<size_t>(1) * width + i) * State::k_channels;
        if (rec.color) {
            pixels[row1 + 0] = normalize(rec.color->r, rs.color_r);
            pixels[row1 + 1] = normalize(rec.color->g, rs.color_g);
            pixels[row1 + 2] = normalize(rec.color->b, rs.color_b);
        }
        if (rec.size) {
            pixels[row1 + 3] = normalize(*rec.size, rs.size);
        }
 
        const size_t row2 = (static_cast<size_t>(2) * width + i) * State::k_channels;
        pixels[row2 + 0] = normalize(rec.radius, rs.radius);
        pixels[row2 + 1] = normalize(rec.query_radius, rs.query_radius);
 
        const size_t row3 = (static_cast<size_t>(3) * width + i) * State::k_channels;
        pixels[row3 + 0] = static_cast<float>(rec.id);
        pixels[row3 + 1] = rec.entity_type_norm;
        pixels[row3 + 2] = rec.trigger_kind;
        pixels[row3 + 3] = rec.time_kind;
 
        const size_t row4 = (static_cast<size_t>(4) * width + i) * State::k_channels;
        pixels[row4 + 0] = static_cast<float>(rec.sink_type);
        pixels[row4 + 1] = static_cast<float>(rec.first_audio_channel);
    }
 
    image.pixels = std::move(pixels);
 
    // -------------------------------------------------------------------------
    // Write EXR.
    // -------------------------------------------------------------------------
    const std::string exr_path = base_path + ".exr";
    auto writer = IO::ImageWriterRegistry::instance().create_writer(exr_path);
    if (!writer) {
        m_last_error = "No ImageWriter registered for .exr";
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    IO::ImageWriteOptions options;
 
    if (!writer->write(exr_path, image, options)) {
        m_last_error = "EXR write failed: " + writer->get_last_error();
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    // -------------------------------------------------------------------------
    // Build and write schema.
    // -------------------------------------------------------------------------
    State::FabricSchema schema;
    schema.version = State::k_schema_version;
    schema.fabric_name = fabric.name();
    schema.cell_size = fabric.m_cell_size;
    schema.ranges = rs;
    schema.entities.reserve(records.size());
 
    for (const auto& rec : records) {
        State::EntityRecord ent;
        ent.id = rec.id;
        ent.kind = State::kind_to_string(rec.kind);
        ent.position = rec.position;
        ent.orientation = rec.orientation;
        ent.intensity = rec.intensity;
        ent.radius = rec.radius;
        ent.query_radius = rec.query_radius;
        ent.color = rec.color;
        ent.size = rec.size;
        ent.influence_fn_name = rec.influence_fn_name;
        ent.perception_fn_name = rec.perception_fn_name;
        ent.wiring = build_wiring(fabric, rec.id);
 
        if (rec.kind == Fabric::Kind::Emitter) {
            auto e = fabric.get_emitter(rec.id);
            fill_sinks(ent, e->audio_sinks(), e->render_sinks());
        } else if (rec.kind == Fabric::Kind::Agent) {
            auto a = fabric.get_agent(rec.id);
            fill_sinks(ent, a->audio_sinks(), a->render_sinks());
 
            if (auto locus = std::dynamic_pointer_cast<Locus>(a)) {
                ent.subkind = "locus";
                const auto& nav = locus->nav();
                ent.locus_nav = State::LocusNavRecord {
                    .eye = nav.eye,
                    .target = nav.eye + glm::vec3 { std::cos(nav.pitch) * std::sin(nav.yaw), std::sin(nav.pitch), std::cos(nav.pitch) * std::cos(nav.yaw) },
                    .fov = nav.fov_radians,
                    .near_plane = nav.near_plane,
                    .far_plane = nav.far_plane,
                    .speed = nav.move_speed,
                    .mouse_sensitivity = nav.mouse_sensitivity,
                    .scroll_speed = nav.scroll_speed,
                    .aspect = locus->aspect(),
                };
            } else if (auto presence = std::dynamic_pointer_cast<Presence>(a)) {
                ent.subkind = "presence";
                ent.radiate_fn_name = presence->radiate_fn_name();
                ent.falloff_radius = presence->falloff_radius() != presence->query_radius()
                    ? std::optional<float>(presence->falloff_radius())
                    : std::nullopt;
                if (auto fc = presence->falloff_curve()) {
                    ent.falloff_curve_name = Reflect::enum_to_lowercase_string(*fc);
                } else {
                    MF_WARN(Journal::Component::Nexus, Journal::Context::FileIO,
                        "StateEncoder: Presence {} has a custom falloff, which is not encoded", rec.id);
                }
            }
        }
 
        schema.entities.push_back(std::move(ent));
    }
 
    for (uint32_t xid : fabric.all_expanse_ids()) {
        const auto x = fabric.get_expanse(xid);
        if (!x || tapestry_owned.contains(x.get()))
            continue;
        State::ExpanseRecord record { .id = xid };
        fill_expanse(record, *x);
        if (record.subkind.empty() && record.fn_name.empty() && !record.bounds_min) {
            MF_WARN(Journal::Component::Nexus, Journal::Context::FileIO,
                "StateEncoder: Expanse {} has neither fn_name nor bounds, skipping", xid);
            continue;
        }
        schema.expanses.push_back(std::move(record));
    }
 
    IO::JSONSerializer ser;
    const std::string json_path = base_path + ".json";
    if (!ser.write(json_path, schema)) {
        m_last_error = "Failed to write schema: " + ser.last_error();
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    MF_INFO(Journal::Component::Nexus, Journal::Context::FileIO,
        "StateEncoder: wrote {} entities to {} + {}",
        records.size(), exr_path, json_path);
 
    return true;
}
Here is the call graph for this function: