register_element() [1/2]

template<typename T >

void MayaFlux::Portal::Forma::Bridge::register_element ( const ElementRef &  ref, std::shared_ptr< MappedState< T > >  state, 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 and reader.

Called by Forma::create_element. The reader closes over the MappedState and is stored type-erased as std::function<float()>. The state records ref so later calls made through it address the same element. Rejected, with an error logged, when the Layer in ref has no shared_ptr owner.

Template Parameters

T	MappedState value type.

Parameters

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

Definition at line 378 of file Bridge.hpp.

                                        {})
    {
        if (ref.first.expired()) {
            MF_ERROR(Journal::Component::Portal, Journal::Context::Init,
                "Bridge::register_element: element {} belongs to a Layer with no shared owner", ref.second);
            return;
        }
 
        const uint32_t id = ref.second;
 
        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 = [id, reported = std::make_shared<bool>(false)] {
                if (!*reported) {
                    *reported = true;
                    MF_RT_WARN(Journal::Component::Portal, Journal::Context::Init,
                        "Bridge: element {} has state type '{}' with no float conversion and no projection; its outbound reader yields 0",
                        id, typeid(T).name());
                }
                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;
            };
        } else if constexpr (std::is_same_v<T, glm::vec2> || std::is_same_v<T, glm::vec3> || std::is_same_v<T, glm::vec4>) {
            bulk_reader = [s = state] {
                return std::vector<float>(&s->value[0], &s->value[0] + T::length());
            };
        }
 
        std::function<Kakshya::GpuValue()> typed_reader;
        std::optional<Kakshya::GpuDataFormat> typed_format;
        if constexpr (Kakshya::GpuFormatElement<T>) {
            typed_reader = [s = state] { return Kakshya::GpuValue { s->value }; };
            typed_format = Kakshya::gpu_data_format_v<T>;
        }
 
        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 = [id, reported = std::make_shared<bool>(false)](float) {
                if (!*reported) {
                    *reported = true;
                    MF_RT_WARN(Journal::Component::Portal, Journal::Context::Init,
                        "Bridge: element {} has state type '{}' with no float conversion and no projection; its inbound writer does nothing",
                        id, typeid(T).name());
                }
            };
        }
 
        state->id = id;
        state->layer = ref.first;
        m_records[ref.first][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 = {},
            .binding_names = {},
            .typed_reader = std::move(typed_reader),
            .typed_format = typed_format,
        };
    }

Referenced by MayaFlux::Portal::Forma::ColorPicker::place().

Here is the caller graph for this function: