Encoder.cpp

Go to the documentation of this file.

#include "Encoder.hpp"
 
#include "MayaFlux/Nexus/Pheme/Sinks.hpp"
 
#include "MayaFlux/Nexus/Expanses/Hull.hpp"
#include "MayaFlux/Nexus/Expanses/Mantle.hpp"
 
#include "MayaFlux/Buffers/VKBuffer.hpp"
 
#include "MayaFlux/Nexus/Principals/Locus.hpp"
#include "MayaFlux/Nexus/Principals/Presence.hpp"
 
#include "MayaFlux/IO/Image/ImageWriter.hpp"
#include "MayaFlux/Journal/Archivist.hpp"
 
#include "MayaFlux/Transitive/IO/JSONSerializer.hpp"
 
#include "MayaFlux/IO/GlmSerializer.hpp"
 
namespace MayaFlux::Nexus {
 
namespace {
 
    // -------------------------------------------------------------------------
    // State::Range helpers
    // -------------------------------------------------------------------------
 
    void expand_range(State::Range& r, float value, bool& initialized)
    {
        if (!initialized) {
            r.min = r.max = value;
            initialized = true;
        } else {
            r.min = std::min(r.min, value);
            r.max = std::max(r.max, value);
        }
    }
 
    float normalize(float value, const State::Range& r)
    {
        if (r.max <= r.min) {
            return 0.0F;
        }
        return (value - r.min) / (r.max - r.min);
    }
 
    // -------------------------------------------------------------------------
    // Sink records
    // -------------------------------------------------------------------------
 
    void fill_sinks(
        State::EntityRecord& ent,
        const std::vector<AudioSink>& audio_sinks,
        const std::vector<RenderSink>& render_sinks)
    {
        for (const auto& s : audio_sinks)
            ent.audio_sinks.push_back({ .channel = s.channel, .fn_name = s.fn_name });
 
        for (const auto& s : render_sinks) {
            State::RenderSinkRecord rec { .fn_name = s.fn_name };
            if (s.buf) {
                const auto config = s.buf->get_render_config();
                rec.vertex_shader = config.vertex_shader;
                rec.fragment_shader = config.fragment_shader;
                rec.geometry_shader = config.geometry_shader;
                rec.default_texture_binding = config.default_texture_binding;
                rec.topology = config.topology;
                rec.polygon_mode = config.polygon_mode;
                rec.cull_mode = config.cull_mode;
                rec.triangulate = config.triangulate;
                rec.draw_priority = config.draw_priority;
                rec.extra_string_params = config.extra_string_params;
            }
            ent.render_sinks.push_back(std::move(rec));
        }
    }
 
    void fill_wiring_pixels(const Fabric& fabric, uint32_t id, float& trigger_out, float& time_out)
    {
        const Wiring* w = fabric.wiring_for(id);
        trigger_out = 0.0F;
        time_out = 0.0F;
        if (!w)
            return;
        if (!w->move_steps().empty()) {
            time_out = 1.0F;
        } else if (w->interval().has_value()) {
            trigger_out = 0.2F;
            if (w->duration().has_value())
                time_out = 0.5F;
        }
    }
 
} // namespace
 
State::WiringRecord StateEncoder::build_wiring(const Fabric& fabric, uint32_t id)
{
    const Wiring* w = fabric.wiring_for(id);
    if (!w)
        return { .kind = State::WiringKind::Unsupported };
 
    State::WiringRecord rec;
    rec.position_fn_name = w->position_fn_name();
 
    const auto take_times = [&] {
        if (w->times_count() > 1)
            rec.times = w->times_count();
    };
    const auto take_duration = [&] {
        if (w->duration()) {
            rec.duration = w->duration();
            rec.duration_token = w->m_duration_token;
        }
    };
 
    if (!std::holds_alternative<std::monostate>(w->factory()) || w->event_factory()) {
        rec.kind = State::WiringKind::Factory;
        rec.factory_name = w->factory_name();
 
    } else if (w->has_bind()) {
        rec.kind = State::WiringKind::Bind;
        rec.attach_fn_name = w->bind_attach_name();
        rec.detach_fn_name = w->bind_detach_name();
        take_duration();
 
    } else if (!w->move_steps().empty()) {
        rec.kind = State::WiringKind::MoveTo;
        std::vector<State::WiringStep> steps;
        steps.reserve(w->move_steps().size());
        for (const auto& s : w->move_steps())
            steps.push_back({ .position = s.position, .delay_seconds = s.delay_seconds });
        rec.steps = std::move(steps);
        take_times();
 
    } else if (!std::holds_alternative<std::monostate>(w->trigger())) {
        std::visit([&rec](const auto& trigger) {
            using T = std::decay_t<decltype(trigger)>;
            if constexpr (std::is_same_v<T, Wiring::KeyTrigger>) {
                rec.kind = State::WiringKind::Key;
                rec.key = trigger.key;
                rec.held = trigger.held;
            } else if constexpr (std::is_same_v<T, Wiring::MouseTrigger>) {
                rec.kind = State::WiringKind::Mouse;
                rec.button = trigger.button;
                rec.held = trigger.held;
            } else if constexpr (std::is_same_v<T, Wiring::ScrollTrigger>) {
                rec.kind = State::WiringKind::Scroll;
            } else if constexpr (std::is_same_v<T, Wiring::NetworkTrigger>) {
                rec.kind = State::WiringKind::Network;
            } else if constexpr (std::is_same_v<T, Wiring::WindowEventTrigger>) {
                rec.kind = State::WiringKind::WindowEvent;
            } else {
                rec.kind = State::WiringKind::Unsupported;
            }
        },
            w->trigger());
 
    } else if (w->interval()) {
        rec.kind = State::WiringKind::Every;
        rec.interval = w->interval();
        rec.interval_token = w->m_metro_token;
        take_duration();
        take_times();
    }
 
    return rec;
}
 
template <typename Record>
void StateEncoder::fill_expanse(Record& record, const Expanse& expanse)
{
    record.fn_name = expanse.fn_name();
    record.on_enter_fn_name = expanse.on_enter_fn_name();
    record.on_exit_fn_name = expanse.on_exit_fn_name();
    if (expanse.bounds()) {
        record.bounds_min = expanse.bounds()->min;
        record.bounds_max = expanse.bounds()->max;
    }
 
    if (const auto* hull = dynamic_cast<const Hull*>(&expanse)) {
        record.subkind = "hull";
        record.collection = hull->m_collection;
    } else if (const auto* mantle = dynamic_cast<const Mantle*>(&expanse)) {
        record.subkind = "mantle";
        record.fit_name = Reflect::enum_to_lowercase_string(mantle->m_fit);
    }
 
    if (!record.subkind.empty()) {
        MF_WARN(Journal::Component::Nexus, Journal::Context::FileIO,
            "StateEncoder: {} wraps a live buffer that is not encoded", record.subkind);
    }
}
 
bool StateEncoder::encode(const Fabric& fabric, const std::string& base_path)
{
    return encode_fabric(fabric, base_path, {});
}
 
bool StateEncoder::encode_fabric(
    const Fabric& fabric,
    const std::string& base_path,
    const std::unordered_set<const Expanse*>& tapestry_owned)
{
    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;
}
 
bool StateEncoder::encode(const Tapestry& tapestry, const std::string& base_dir, nlohmann::json user_state)
{
    m_last_error.clear();
 
    State::TapestrySchema schema;
 
    std::unordered_set<const Expanse*> tapestry_owned;
    for (const auto& [xname, xptr] : tapestry.all_expanses()) {
        tapestry_owned.insert(xptr.get());
    }
 
    for (const auto& fabric : tapestry.all_fabrics()) {
        const std::string fabric_id = fabric->name().empty()
            ? std::to_string(fabric->id())
            : fabric->name();
 
        const std::string base_path = base_dir + "/" + fabric_id;
 
        if (!encode_fabric(*fabric, base_path, tapestry_owned)) {
            return false;
        }
 
        schema.fabrics.push_back(State::FabricRef {
            .name = fabric_id,
            .base_path = base_path,
        });
    }
 
    for (const auto& [xname, xptr] : tapestry.all_expanses()) {
        State::TapestryExpanseRecord xrec { .name = xname };
        fill_expanse(xrec, *xptr);
        for (const auto& fabric : tapestry.all_fabrics()) {
            for (uint32_t xid : fabric->all_expanse_ids()) {
                if (fabric->get_expanse(xid) == xptr) {
                    const std::string fname = fabric->name().empty()
                        ? std::to_string(fabric->id())
                        : fabric->name();
                    xrec.fabric_names.push_back(fname);
                    break;
                }
            }
        }
        schema.expanses.push_back(std::move(xrec));
    }
 
    schema.user_state = std::move(user_state);
 
    IO::JSONSerializer ser;
    const std::string tapestry_path = base_dir + "/tapestry.json";
    if (!ser.write(tapestry_path, schema)) {
        m_last_error = "Failed to write tapestry 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 {} fabrics to {}", schema.fabrics.size(), tapestry_path);
    return true;
}
 
} // namespace MayaFlux::Nexus