Atelier.hpp

Go to the documentation of this file.

#pragma once
 
#include "MayaFlux/Portal/Forma/Bridge.hpp"
#include "MayaFlux/Portal/Forma/Primitives/Mapped.hpp"
#include "MayaFlux/Portal/Forma/Primitives/Scrollable.hpp"
#include "MayaFlux/Portal/Forma/Surface.hpp"
 
#include "MayaFlux/Portal/Forma/Plot/Plot.hpp"
 
#include "MayaFlux/Portal/Text/AtlasImage.hpp"
 
namespace MayaFlux::Nodes {
class NodeGraphManager;
}
 
namespace MayaFlux::Core {
class Window;
class WindowManager;
struct WindowCreateInfo;
}
 
namespace MayaFlux::Vruta {
class TaskScheduler;
class EventManager;
}
 
namespace MayaFlux::Buffers {
class BufferManager;
}
 
namespace MayaFlux::Portal::Forma {
 
class Inspector;
 
namespace internal {
 
    constexpr size_t k_capacity_bytes = 4096;
 
    /**
     * @class Atelier
     * @brief Process-wide Forma workshop. Not part of the public surface.
     *
     * Holds the engine references stored by Portal::Forma::initialize and
     * owns every construction path that depends on them: buffers, layers,
     * contexts, surfaces, elements, windows.
     *
     * Everything under Internal/ is implementation detail and carries no
     * stability guarantee. The public entry points in Forma.hpp are thin
     * wrappers over the methods here. User code calls those, not these.
     *
     * Lifetime follows the Portal::Graphics singleton contract: the Meyers
     * instance is never destroyed, and shutdown() releases the held
     * references explicitly before static teardown.
     */
    class MAYAFLUX_API Atelier {
    public:
        static Atelier& instance();
 
        Atelier(const Atelier&) = delete;
        Atelier& operator=(const Atelier&) = delete;
        Atelier(Atelier&&) = delete;
        Atelier& operator=(Atelier&&) = delete;
 
        // =====================================================================
        // Lifecycle
        // =====================================================================
 
        bool initialize(
            std::shared_ptr<Nodes::NodeGraphManager> node_graph_manager,
            std::shared_ptr<Buffers::BufferManager> buffer_manager,
            std::shared_ptr<Vruta::TaskScheduler> scheduler,
            std::shared_ptr<Vruta::EventManager> event_manager,
            std::shared_ptr<Core::WindowManager> window_manager);
 
        void shutdown();
 
        [[nodiscard]] bool is_initialized() const noexcept { return m_initialized; }
 
        /**
         * @brief Bridge instance constructed during initialize.
         * @throws std::runtime_error if called before initialize().
         */
        [[nodiscard]] Bridge& bridge();
 
        /**
         * @brief Inspector instance constructed during initialize.
         * @throws std::runtime_error if called before initialize().
         */
        [[nodiscard]] Inspector& inspector();
 
        /**
         * @brief The GPU image of @p atlas, shared by every text slice drawing from it.
         *
         * One per atlas, so slices on different atlases never replace each
         * other's image, and a growth of an atlas is seen by all text on it at
         * once. Released by shutdown().
         */
        [[nodiscard]] Text::AtlasImage& atlas_image(const Text::GlyphAtlas& atlas)
        {
            return m_atlas_images[&atlas];
        }
 
        // =====================================================================
        // Construction
        // =====================================================================
 
        /**
         * @brief Create a window through the stored WindowManager and show it.
         *
         * Present so that callers needing a window do not reach the manager
         * directly.
         */
        [[nodiscard]] std::shared_ptr<Core::Window> create_window(
            const Core::WindowCreateInfo& info);
 
        /**
         * @brief The single buffer construction path.
         *
         * Registers a FormaBuffer with the stored BufferManager under
         * GRAPHICS_BACKEND and sets up rendering. The buffer always triangulates
         * with TRIANGLE_LIST: what it draws is expressed by the topology of the
         * slices made on it with FormaTarget::slice_of. Line and point slices
         * are milled into NDC ribbons whose scalar is a width in pixels of the
         * window's height at creation.
         *
         * @param render Render settings; build it with Surface::render_config.
         *               Its topology and triangulate are set here.
         */
        [[nodiscard]] std::shared_ptr<Buffers::FormaBuffer> create_buffer(
            Graphics::RenderConfig render);
 
        /**
         * @brief Construct a Layer and a Context wired to @p window.
         *
         * The Context is stored so its event coroutines outlive the call.
         */
        [[nodiscard]] std::pair<std::shared_ptr<Layer>, std::shared_ptr<Context>>
        create_layer(const std::shared_ptr<Core::Window>& window, std::string name);
 
        /**
         * @brief Build a Surface from a SurfaceConfig, creating Layer and
         *        Context when config.layer/config.ctx are unset.
         */
        [[nodiscard]] Surface create_surface(SurfaceConfig config);
 
        /**
         * @brief Build a window through create_window, then a Surface on it.
         *
         * One step further back than create_surface(SurfaceConfig): for
         * when there is no window yet either. Uses default close-handling
         * behavior (SurfaceConfig::detach_on_close true, no on_close). Call
         * create_surface(SurfaceConfig) directly instead when that needs
         * configuring.
         */
        [[nodiscard]] Surface create_surface(
            const Core::WindowCreateInfo& window_info, std::string name);
 
        /**
         * @brief create_element on a buffer of its own, as a slice of
         *        @p topology, followed by one sync so bounds_hint and contains
         *        from the geometry function reach the Layer before the first
         *        frame.
         */
        template <typename T>
        [[nodiscard]] Mapped<T> create_element(
            Surface& surface,
            GeometryFn<T> geom,
            T initial,
            Graphics::PrimitiveTopology topology = Graphics::PrimitiveTopology::TRIANGLE_STRIP,
            std::function<float(T)> project = {})
        {
            return create_element<T>(
                surface,
                FormaTarget::slice_of(create_buffer(surface.render_config()), topology),
                std::move(geom), std::move(initial), std::move(project));
        }
 
        /**
         * @brief create_element writing into @p target, which may be a slice
         *        shared with other elements.
         */
        template <typename T>
        [[nodiscard]] Mapped<T> create_element(
            Surface& surface,
            FormaTarget target,
            GeometryFn<T> geom,
            T initial,
            std::function<float(T)> project = {})
        {
            auto mapped = make_mapped<T>(
                std::move(initial), std::move(geom), std::move(target));
            mapped.element.id = surface.layer().add(mapped.element);
            bridge().register_element(
                surface.layer(), mapped, std::move(project));
 
            mapped.sync(&surface.layer());
 
            return mapped;
        }
 
        /**
         * @brief Register mapped's element for scroll reflow in panel.
         *
         * When reposition is empty, one is built from mapped's own buffer,
         * geometry_fn, and state: it reruns geometry_fn unconditionally
         * (assumes the Form was built with live_offset wired to panel's own
         * offset, so it reads the new position itself) and pushes the
         * resulting bounds_hint/contains to layer. These are the same two
         * effects Mapped<T>::sync(Layer*) has, replicated rather than
         * called through, so the closure captures only independently-owned
         * pieces (buffer and state are shared_ptr, geometry_fn is a
         * copyable std::function), never a pointer back to mapped itself,
         * since the closure outlives this call, stored inside panel.
         *
         * @param panel       Scrollable to track into.
         * @param layer       Layer both panel and mapped's element were
         *                    registered on.
         * @param mapped      Element to track. Only buffer/geometry_fn/
         *                    state/element.id are read, nothing is stored.
         *                    Its buffer is scissored to the panel's viewport,
         *                    so it is not drawn outside it.
         * @param base_bounds mapped's current on-screen NDC bounds.
         * @param reposition  Called with the scrolled bounds on every
         *                    scroll. Built as described above when empty.
         */
        template <typename T>
        void track(
            Scrollable& panel,
            Layer& layer,
            const Mapped<T>& mapped,
            Kinesis::AABB2D base_bounds,
            std::function<void(Kinesis::AABB2D)> reposition = {})
        {
            if (!reposition) {
                auto buffer = mapped.element.buffer;
                auto geometry_fn = mapped.geometry_fn;
                auto state = mapped.state;
                auto id = mapped.element.id;
                auto* layer_ptr = &layer;
 
                reposition = [buffer, geometry_fn, state, id, layer_ptr](Kinesis::AABB2D) {
                    if (!buffer || !geometry_fn || !state)
                        return;
 
                    std::vector<uint8_t> bytes;
                    Element el;
                    el.id = id;
                    geometry_fn(state->value, bytes, el);
                    buffer.submit(bytes);
 
                    if (el.bounds_hint)
                        layer_ptr->set_bounds(id, *el.bounds_hint);
                    if (el.contains)
                        layer_ptr->set_contains(id, el.contains);
                };
            }
 
            panel.track(layer, mapped.element.id, base_bounds, std::move(reposition), mapped.element.buffer);
        }
 
        /**
         * @brief Create and place every adornment declared on @p spec.
         *
         * Makes a target for each axis label, tick label, legend swatch, and
         * legend label, then hands each to the corresponding Plot placement
         * function. Each adornment is related to @p relate_to so removal and
         * visibility cascade from the series element.
         *
         * Lives here rather than in Plot because it constructs buffers,
         * which requires the BufferManager. Plot composes placement from
         * arguments it is given.
         *
         * @param surface   Surface to place on.
         * @param spec      Series spec carrying the adornment declarations.
         * @param relate_to Element id the adornments are related to.
         * @param batch     Shared plot buffer for swatches and labels. With
         *                  labels, it needs a text slot and forma_plot.frag.
         *                  When empty, one buffer is created for all adornments.
         */
        void place_adornments(
            Surface& surface,
            const Plot::SeriesSpec& spec,
            uint32_t relate_to,
            const std::shared_ptr<Buffers::FormaBuffer>& batch = {});
 
    private:
        Atelier();
        ~Atelier();
 
        std::shared_ptr<Nodes::NodeGraphManager> m_node_graph_manager;
        std::shared_ptr<Buffers::BufferManager> m_buffer_manager;
        std::shared_ptr<Vruta::TaskScheduler> m_scheduler;
        std::shared_ptr<Vruta::EventManager> m_event_manager;
        std::shared_ptr<Core::WindowManager> m_window_manager;
 
        std::unique_ptr<Bridge> m_bridge;
        std::unique_ptr<Inspector> m_inspect;
        std::unordered_map<const Text::GlyphAtlas*, Text::AtlasImage> m_atlas_images;
 
        bool m_initialized {};
    };
 
    /// @brief Accessor for the process-wide Atelier.
    inline Atelier& atelier() { return Atelier::instance(); }
 
} // namespace internal
} // namespace MayaFlux::Portal::Forma