Process-wide Forma workshop. More...

#include <Atelier.hpp>

Collaboration diagram for MayaFlux::Portal::Forma::internal::Atelier:

Public Member Functions
	Atelier (Atelier &&)=delete

	Atelier (const Atelier &)=delete

Bridge &	bridge ()
	Bridge instance constructed during initialize.

std::shared_ptr< Buffers::FormaBuffer >	create_buffer (std::shared_ptr< Core::Window > window, size_t capacity, Graphics::PrimitiveTopology topology, const std::string &texture_binding={}, std::vector< std::pair< std::string, std::shared_ptr< Core::VKImage > > > additional_textures={})
	Capacity-explicit FormaBuffer construction.

template<typename T >
Mapped< T >	create_element (Layer &layer, std::shared_ptr< Core::Window > window, GeometryFn< T > geom, T initial, Graphics::PrimitiveTopology topology=Graphics::PrimitiveTopology::TRIANGLE_STRIP, size_t capacity=k_capacity_bytes, std::function< float(T)> project={})
	Build a FormaBuffer, construct a Mapped<T>, register the element on `layer`, and register it with the Bridge.

template<typename T >
Mapped< T >	create_element (Surface &surface, GeometryFn< T > geom, T initial, Graphics::PrimitiveTopology topology=Graphics::PrimitiveTopology::TRIANGLE_STRIP, std::function< float(T)> project={})
	create_element against a Surface, followed by one sync so bounds_hint and contains from the geometry function reach the Layer before the first frame.

std::pair< std::shared_ptr< Layer >, std::shared_ptr< Context > >	create_layer (const std::shared_ptr< Core::Window > &window, std::string name)
	Construct a Layer and a Context wired to `window`.

Surface	create_surface (std::shared_ptr< Core::Window > window, std::string name)
	create_layer plus ownership of the window, as a Surface.

std::shared_ptr< Core::Window >	create_window (const Core::WindowCreateInfo &info)
	Create a window through the stored WindowManager and show it.

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)

Inspector &	inspector ()
	Inspector instance constructed during initialize.

bool	is_initialized () const noexcept

Atelier &	operator= (Atelier &&)=delete

Atelier &	operator= (const Atelier &)=delete

void	place_adornments (Surface &surface, const Plot::SeriesSpec &spec, uint32_t relate_to)
	Create and place every adornment declared on `spec`.

void	shutdown ()

Static Public Member Functions
static Atelier &	instance ()

Private Member Functions
	Atelier ()

	~Atelier ()

Private Attributes
std::unique_ptr< Bridge >	m_bridge

std::shared_ptr< Buffers::BufferManager >	m_buffer_manager

std::shared_ptr< Vruta::EventManager >	m_event_manager

bool	m_initialized {}

std::unique_ptr< Inspector >	m_inspect

std::shared_ptr< Nodes::NodeGraphManager >	m_node_graph_manager

std::shared_ptr< Vruta::TaskScheduler >	m_scheduler

std::shared_ptr< Core::WindowManager >	m_window_manager

Detailed Description

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.

Definition at line 52 of file Atelier.hpp.

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description