register_element() [2/2]

template<typename T >

void MayaFlux::Portal::Forma::Bridge::register_element ( std::shared_ptr< MappedState< T > >  state, uint32_t  id, std::shared_ptr< Buffers::FormaBuffer >  buffer, std::function< float(T)>  project = {}  )

inline

Register a MappedState<T> so that MappedState overloads and outbound bindings can resolve to the correct element id and reader.

Called by Forma::create_element. The reader closes over the MappedState and is stored type-erased as std::function<float()>.

Template Parameters

T	MappedState value type.

Parameters

state	MappedState to register.
id	Element id from Layer::add.
buffer	FormaBuffer the element renders into.
project	Optional T -> float projection. Identity cast if empty.

Definition at line 280 of file Bridge.hpp.

                                        {})
    {
        std::function<float()> reader;
        if (project) {
            reader = [s = state, p = std::move(project)] {
                return p(s->value);
            };
        } else if constexpr (std::is_convertible_v<T, float>) {
            reader = [s = state] {
                return static_cast<float>(s->value);
            };
        } else {
            reader = [] { return 0.F; };
        }
 
        std::function<std::vector<float>()> bulk_reader;
        if constexpr (std::is_same_v<T, std::vector<float>>) {
            bulk_reader = [s = state] { return s->value; };
        } else if constexpr (std::is_same_v<T, std::vector<double>>) {
            bulk_reader = [s = state] {
                std::vector<float> out;
                out.reserve(s->value.size());
                for (double v : s->value)
                    out.push_back(static_cast<float>(v));
                return out;
            };
        }
 
        std::function<void(float)> writer;
        if constexpr (std::is_convertible_v<float, T>) {
            writer = [s = state](float v) {
                s->write(static_cast<T>(v));
            };
        } else {
            writer = [](float) { };
        }
 
        state->id = id;
        m_records[id] = ElementRecord {
            .buffer = std::move(buffer),
            .bindings = nullptr,
            .reader = std::move(reader),
            .bulk_reader = std::move(bulk_reader),
            .writer = std::move(writer),
            .inbound_task = {},
            .outbound_tasks = {},
        };
    }