Emitter.hpp

Go to the documentation of this file.

#pragma once
 
#include "MayaFlux/Nexus/Pheme/Attachment.hpp"
#include "MayaFlux/Nexus/Pheme/Influence.hpp"
#include "MayaFlux/Nexus/Pheme/Sinks.hpp"
 
namespace MayaFlux::Buffers {
class VKBuffer;
}
 
namespace MayaFlux::Nexus {
 
/**
 * @class Emitter
 * @brief Object that acts on existing MayaFlux objects when committed.
 *
 * Constructed with an optional influence function. Position is optional: call
 * @c set_position before registering with @c Fabric if spatial indexing is
 * required. Entities without a position are committed normally but are not
 * inserted into the spatial index.
 *
 * The id is assigned by @c Fabric::wire and is stable for the object's
 * lifetime. It is zero until the object has been registered.
 *
 * RenderConfig takes a designated initializer.
 *
 * @code
 * emitter->set_influence<InfluenceBlock>(InfluenceBlock::from, bind_influence_block(proc));
 * emitter->render(mgr, { .target_window = window });
 * @endcode
 */
class MAYAFLUX_API Emitter {
public:
    using InfluenceFn = std::function<void(const InfluenceContext&)>;
 
    /**
     * @brief Construct with no function, for an Emitter whose behaviour comes
     *        from a typed influence.
     */
    Emitter() = default;
 
    /**
     * @brief Construct with an influence function.
     * @param fn Called on every commit with the current context.
     */
    explicit Emitter(InfluenceFn fn)
        : m_fn(std::move(fn))
    {
    }
 
    /**
     * @brief Construct with a named influence function.
     * @param fn_name Identifier used for state encoding.
     * @param fn      Called on every commit with the current context.
     */
    Emitter(std::string fn_name, InfluenceFn fn)
        : m_fn_name(std::move(fn_name))
        , m_fn(std::move(fn))
    {
    }
 
    /** @brief Identifier assigned to the influence function, empty if anonymous. */
    [[nodiscard]] const std::string& fn_name() const { return m_fn_name; }
 
    /** @brief Set or replace the influence function's identifier. */
    void set_fn_name(std::string name) { m_fn_name = std::move(name); }
 
    /** @brief The influence function itself. */
    [[nodiscard]] const InfluenceFn& fn() const { return m_fn; }
 
    /**
     * @brief Return the current position, if set.
     */
    [[nodiscard]] const std::optional<glm::vec3>& position() const { return m_position; }
 
    /**
     * @brief Set the position, enabling spatial indexing for this object.
     * @param p World-space coordinates.
     */
    void set_position(const glm::vec3& p) { m_position = p; }
 
    /**
     * @brief Clear the position, removing this object from spatial queries.
     */
    void clear_position() { m_position.reset(); }
 
    /**
     * @brief Return the stable object id assigned by Fabric.
     */
    [[nodiscard]] uint32_t id() const { return m_id; }
 
    // =========================================================================
    // Output sinks
    // =========================================================================
 
    /** @brief Register an audio output on @p channel. */
    void sink_audio(Buffers::BufferManager& mgr, uint32_t channel)
    {
        add_audio_sink(m_audio_sinks, mgr, channel);
    }
 
    /** @brief Register an audio output on @p channel with a producer function. */
    void sink_audio(Buffers::BufferManager& mgr, uint32_t channel,
        std::function<Kakshya::DataVariant(const InfluenceContext&)> fn,
        std::string fn_name = "")
    {
        add_audio_sink(m_audio_sinks, mgr, channel, std::move(fn), std::move(fn_name));
    }
 
    /** @brief Unregister the audio sink on @p channel. */
    void remove_audio_sink(Buffers::BufferManager& mgr, uint32_t channel)
    {
        Nexus::remove_audio_sink(m_audio_sinks, mgr, channel);
    }
 
    /** @brief Register a render output targeting @p window. */
    void render(Buffers::BufferManager& mgr, const Portal::Graphics::RenderConfig& config)
    {
        add_render_sink(m_render_sinks, mgr, config, {}, "", m_position);
    }
 
    /** @brief Register a render output targeting @p window with a producer function. */
    void render(Buffers::BufferManager& mgr, const Portal::Graphics::RenderConfig& config,
        std::string fn_name, RenderFn fn)
    {
        add_render_sink(m_render_sinks, mgr, config, std::move(fn), std::move(fn_name), m_position);
    }
 
    [[nodiscard]] const std::vector<AudioSink>& audio_sinks() const { return m_audio_sinks; }
    [[nodiscard]] const std::vector<RenderSink>& render_sinks() const { return m_render_sinks; }
 
    /* @brief Return the render processor for the sink targeting @p window, or nullptr if not found. */
    std::shared_ptr<Buffers::RenderProcessor> get_render_processor(
        const std::shared_ptr<Core::Window>& window) const
    {
        auto it = std::ranges::find_if(m_render_sinks,
            [&window](const RenderSink& s) { return s.window == window; });
        return it != m_render_sinks.end() ? it->renderer : nullptr;
    }
 
    /** @brief Unregister the render sink targeting @p window. */
    void remove_render(Buffers::BufferManager& mgr, const std::shared_ptr<Core::Window>& window)
    {
        remove_render_sink(m_render_sinks, mgr, window);
    }
 
    /** @brief Push @p samples to all registered audio sinks. */
    void set_audio_data(std::span<const double> samples)
    {
        push_audio_data(m_audio_sinks, samples);
    }
 
    /**
     * @brief Set pre-packed interleaved vertex bytes to all registered render sinks.
     *
     * data must point to N contiguous 60-byte Vertex records.
     * byte_count must be a multiple of 60.
     */
    void set_vertices(const void* data, size_t byte_count);
 
    /**
     * @brief Set typed vertex data to all registered render sinks.
     * @tparam T One of Kakshya::PointVertex, Kakshya::LineVertex, Kakshya::MeshVertex, Kakshya::Vertex.
     */
    template <typename T>
    void set_vertices(std::span<const T> vertices)
    {
        static_assert(sizeof(T) == 60, "set_vertices: T must be a 60-byte vertex type");
        set_vertices(vertices.data(), vertices.size_bytes());
    }
 
    /** @brief Set the intensity, a general-purpose parameter for influence functions. */
    void set_intensity(float i) { m_intensity = i; }
 
    /** @brief Get the current intensity. */
    [[nodiscard]] float intensity() const { return m_intensity; }
 
    /** @brief Set the radius, a general-purpose parameter for influence functions. */
    void set_radius(float r) { m_radius = r; }
 
    /** @brief Get the current radius. */
    [[nodiscard]] float radius() const { return m_radius; }
 
    /** @brief Set the color, a general-purpose parameter for influence functions. */
    void set_color(const glm::vec3& c) { m_color = c; }
 
    /** @brief Clear the color, resetting it to an unset state. */
    void clear_color() { m_color.reset(); }
 
    /** @brief Get the current color, if set. */
    [[nodiscard]] const std::optional<glm::vec3>& color() const { return m_color; }
 
    /** @brief Set the size, a general-purpose parameter for influence functions. */
    void set_size(float s) { m_size = s; }
 
    /** @brief Clear the size, resetting it to an unset state. */
    void clear_size() { m_size.reset(); }
 
    /** @brief Get the current size, if set. */
    [[nodiscard]] const std::optional<float>& size() const { return m_size; }
 
    /**
     * @brief Make an existing, already rendered buffer the look of this object.
     *
     * Works as Agent::attach does, except that an Emitter has no orientation:
     * every render processor the buffer has is moved to the object's position
     * and never rotated. If the object already has a position, that position is
     * kept and becomes the offset. Replaces any previous attachment. An
     * attachment is not part of encoded state and must be made again after
     * decoding.
     *
     * @param buf    Buffer to attach. Ignored if null.
     * @param config Anchor vertex, offset and move behaviour.
     */
    void attach(const std::shared_ptr<Buffers::VKBuffer>& buf, const AttachConfig& config = {});
 
    /** @brief Release the attached buffer and reset its placement. */
    void detach();
 
    /**
     * @brief Read the attached buffer's geometry again and move the anchor to match.
     *
     * The object keeps its position. Blocks for a ComputeMeshBuffer, so call it
     * off the graphics thread.
     */
    void recenter();
 
    /** @brief True while a buffer is attached. */
    [[nodiscard]] bool attached() const { return m_attachment.has_value(); }
 
    /**
     * @brief Set the one target of an influence of any type.
     * @tparam T Type the producer returns; whatever the target takes.
     * @param producer Builds the value from the influence context.
     * @param target   Takes the value and decides what it affects.
     *
     * An Emitter has a single target: setting another replaces it. Runs on
     * every invoke after the influence function, independent of the render
     * processor target. Not part of encoded state.
     */
    template <typename T>
    void set_influence(typename Influence<T>::Producer producer, typename Influence<T>::Target target)
    {
        auto influence = std::make_shared<Influence<T>>(std::move(producer));
        influence->add_target(std::move(target));
        m_influence = [influence](const InfluenceContext& ctx) { influence->invoke(ctx); };
    }
 
    /** @brief Remove the target set with set_influence(). */
    void clear_influence() { m_influence = nullptr; }
 
    /**
     * @brief Invoke the influence function with the supplied context.
     * @param ctx Populated context for this commit.
     */
    void invoke(const InfluenceContext& ctx) const
    {
        if (m_fn) {
            m_fn(ctx);
        }
        dispatch_audio_sinks(m_audio_sinks, ctx);
        dispatch_render_sinks(m_render_sinks, ctx);
        if (m_attachment)
            apply_attachment(*m_attachment, ctx);
        if (m_influence) {
            m_influence(ctx);
        }
    }
 
private:
    std::optional<glm::vec3> m_position;
    std::optional<glm::vec3> m_color;
    std::optional<float> m_size;
    float m_intensity { 1.0F };
    float m_radius { 1.0F };
 
    InfluenceFn m_fn;
    uint32_t m_id {};
    std::string m_fn_name;
 
    mutable std::vector<AudioSink> m_audio_sinks;
    mutable std::vector<RenderSink> m_render_sinks;
    InfluenceFn m_influence;
    mutable std::optional<Attachment> m_attachment;
 
    void follow_attachment();
 
    friend class Fabric;
};
 
} // namespace MayaFlux::Nexus