track()

template<typename T >

void MayaFlux::Portal::Forma::internal::Atelier::track ( Scrollable &  panel, Layer &  layer, const Mapped< T > &  mapped, Kinesis::AABB2D  base_bounds, std::function< void(Kinesis::AABB2D)>  reposition = {}  )

inline

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.

Parameters

panel	Scrollable to track into.
layer	Layer both panel and mapped's element were registered on.
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.
base_bounds	mapped's current on-screen NDC bounds.
reposition	Called with the scrolled bounds on every scroll. Built as described above when empty.

Definition at line 227 of file Atelier.hpp.

                                                          {})
        {
            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);
        }