create_element() [2/2]

template<typename T >

Mapped< T > MayaFlux::Portal::Forma::create_element	(	Surface &	surface,
		GeometryFn< T >	geom,
		T	initial,
		Graphics::PrimitiveTopology	topology = Graphics::PrimitiveTopology::TRIANGLE_STRIP,
		std::function< float(T)>	project = {}
	)

Build a FormaBuffer, register it, construct a Mapped<T>, add the element to surface's layer, and register it with the application Bridge.

Surface-accepting overload of create_element. Reads the layer and window from surface; everything else matches the existing (Layer&, Window) overload.

After registration, one sync() is run so that bounds_hint and contains populated by the geometry function are visible on the Element before the first frame. This removes the manual

layer->set_bounds(el.element.id, ...);
layer->set_contains(el.element.id, ...);

boilerplate seen at fader-style call sites: those values now arrive directly from the geometry function on construction. The geometry function remains the user's; the sync is the same one that runs every frame.

Template Parameters

T	MappedState value type.

Parameters

surface	Canvas to register the element on.
geom	Geometry function producing vertex bytes from T.
initial	Starting value written into MappedState.
topology	Primitive topology for the FormaBuffer.
project	Optional T -> float projection for outbound readers.

Returns

Fully constructed Mapped<T> with element registered.

Definition at line 333 of file Forma.hpp.

                                    {})
{
    auto mapped = create_element<T>(
        surface.layer(), surface.window(),
        std::move(geom), std::move(initial),
        topology, internal::k_capacity_bytes, std::move(project));
 
    mapped.sync();
    if (mapped.element.bounds_hint)
        surface.layer().set_bounds(mapped.element.id, *mapped.element.bounds_hint);
    if (mapped.element.contains)
        surface.layer().set_contains(mapped.element.id, mapped.element.contains);
 
    return mapped;
}