pymomentum-cpu 0.1.82.post0__cp313-cp313-macosx_14_0_arm64.whl

include/rerun/compiler_utils.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+// Push pop warnings
+#if defined(__GNUC__) || defined(__clang__)
+#define RR_PUSH_WARNINGS _Pragma("GCC diagnostic push")
+#define RR_POP_WARNINGS _Pragma("GCC diagnostic pop")
+#elif defined(_MSC_VER)
+#define RR_PUSH_WARNINGS __pragma(warning(push))
+#define RR_POP_WARNINGS __pragma(warning(pop))
+#else
+#define RR_PUSH_WARNINGS
+#define RR_POP_WARNINGS
+#endif
+
+// Macro for enabling and disabling the "-Wmaybe-uninitialized" warning in GCC.
+// See: https://github.com/rerun-io/rerun/issues/4027
+
+#define RR_WITH_MAYBE_UNINITIALIZED_DISABLED(expr) \
+    RR_DISABLE_MAYBE_UNINITIALIZED_PUSH            \
+    expr RR_DISABLE_MAYBE_UNINITIALIZED_POP
+
+#if defined(__GNUC__) && !defined(__clang__)
+
+#define RR_DISABLE_MAYBE_UNINITIALIZED_PUSH \
+    RR_PUSH_WARNINGS                        \
+    _Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+#else
+#define RR_DISABLE_MAYBE_UNINITIALIZED_PUSH RR_PUSH_WARNINGS
+#endif
+
+#define RR_DISABLE_MAYBE_UNINITIALIZED_POP RR_POP_WARNINGS
+
+// Macro for marking code as unreachable.
+// Reaching the code after all is undefined behavior.
+
+#if defined(__GNUC__) || defined(__clang__)
+#define RR_UNREACHABLE() __builtin_unreachable()
+#elif defined(_MSC_VER)
+#define RR_UNREACHABLE() __assume(false)
+#else
+#define RR_UNREACHABLE() \
+    do {                 \
+    } while (false)
+#endif
+
+// Disable deprecation warning
+#if defined(__GNUC__) || defined(__clang__)
+#define RR_DISABLE_DEPRECATION_WARNING \
+    _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif defined(_MSC_VER)
+#define RR_DISABLE_DEPRECATION_WARNING __pragma(warning(disable : 4996))
+#else
+#define RR_DISABLE_DEPRECATION_WARNING
+#endif
+
+// Disable possible null reference warning
+#if defined(__GNUC__) || defined(__clang__)
+#define RR_DISABLE_NULL_DEREF_WARNING _Pragma("GCC diagnostic ignored \"-Wnull-dereference\"")
+#else
+#define RR_DISABLE_NULL_DEREF_WARNING
+#endif

include/rerun/component_batch.hpp

@@ -0,0 +1,163 @@
+#pragma once
+
+#include <memory> // shared_ptr
+#include <optional>
+#include <unordered_map>
+
+#include "collection.hpp"
+#include "component_descriptor.hpp"
+#include "component_type.hpp"
+#include "error.hpp"
+#include "loggable.hpp"
+
+namespace arrow {
+    class Array;
+    class DataType;
+} // namespace arrow
+
+struct rr_component_batch;
+
+namespace rerun {
+    struct ComponentColumn;
+}
+
+namespace rerun {
+    /// Arrow-encoded data of a single batch of components together with a component descriptor.
+    ///
+    /// Component descriptors are registered when first encountered.
+    struct ComponentBatch {
+        /// Arrow-encoded data of the component instances.
+        std::shared_ptr<arrow::Array> array;
+
+        /// The type of the component instances in array.
+        ComponentTypeHandle component_type;
+
+      public:
+        /// Creates a new empty component batch with a given descriptor.
+        template <typename T>
+        static Result<ComponentBatch> empty(const ComponentDescriptor& descriptor) {
+            return from_loggable(Collection<T>(), descriptor);
+        }
+
+        /// Creates a new component batch from a collection of component instances.
+        ///
+        /// Automatically registers the descriptor the first time it is encountered.
+        template <typename T>
+        static Result<ComponentBatch> from_loggable(
+            const rerun::Collection<T>& components, const ComponentDescriptor& descriptor
+        ) {
+            static_assert(
+                rerun::is_loggable<T>,
+                "The given type does not implement the rerun::Loggable trait."
+            );
+
+            /// TODO(#4257) should take a rerun::Collection instead of pointer and size.
+            auto array = Loggable<T>::to_arrow(components.data(), components.size());
+            RR_RETURN_NOT_OK(array.error);
+
+            return from_arrow_array(std::move(array.value), descriptor);
+        }
+
+        /// Creates a new component batch from a single component instance.
+        ///
+        /// Automatically registers the descriptor the first time it is encountered.
+        template <typename T>
+        static Result<ComponentBatch> from_loggable(
+            const T& component, const ComponentDescriptor& descriptor
+        ) {
+            // Collection adapter will automatically borrow for single elements, but let's do this explicitly, avoiding the extra hoop.
+            const auto collection = Collection<T>::borrow(&component, 1);
+            return from_loggable(collection, descriptor);
+        }
+
+        /// Creates a new data cell from a single optional component instance.
+        ///
+        /// None is represented as a data cell with 0 instances.
+        ///
+        /// Automatically registers the descriptor the first time it is encountered.
+        template <typename T>
+        static Result<ComponentBatch> from_loggable(
+            const std::optional<T>& component, const ComponentDescriptor& descriptor
+        ) {
+            if (component.has_value()) {
+                return from_loggable(component.value(), descriptor);
+            } else {
+                return from_loggable(Collection<T>(), descriptor);
+            }
+        }
+
+        /// Creates a new data cell from an optional collection of component instances.
+        ///
+        /// None is represented as a data cell with 0 instances.
+        ///
+        /// Automatically registers the descriptor the first time it is encountered.
+        template <typename T>
+        static Result<ComponentBatch> from_loggable(
+            const std::optional<rerun::Collection<T>>& components,
+            const ComponentDescriptor& descriptor
+        ) {
+            if (components.has_value()) {
+                return from_loggable(components.value(), descriptor);
+            } else {
+                return from_loggable(Collection<T>(), descriptor);
+            }
+        }
+
+        /// Creates a new component batch for an archetype indicator.
+        template <typename Archetype>
+        static Result<ComponentBatch> from_indicator() {
+            return ComponentBatch::from_loggable(
+                typename Archetype::IndicatorComponent(),
+                Loggable<typename Archetype::IndicatorComponent>::Descriptor
+            );
+        }
+
+        /// Creates a new component batch from an already existing arrow array.
+        ///
+        /// Automatically registers the descriptor the first time it is encountered.
+        static Result<ComponentBatch> from_arrow_array(
+            std::shared_ptr<arrow::Array> array, const ComponentDescriptor& descriptor
+        );
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into a `ComponentColumn`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// \param lengths The number of components in each run. for `rerun::RecordingStream::send_columns`,
+        /// this specifies the number of components at each time point.
+        /// The sum of the lengths must be equal to the number of components in the batch.
+        Result<ComponentColumn> partitioned(const Collection<uint32_t>& lengths) &&;
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into a `ComponentColumn`.
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        Result<ComponentColumn> partitioned() &&;
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into a `ComponentColumn`.
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// \param lengths The number of components in each run. for `rerun::RecordingStream::send_columns`,
+        /// this specifies the number of components at each time point.
+        /// The sum of the lengths must be equal to the number of components in the batch.
+        Result<ComponentColumn> partitioned(const Collection<uint32_t>& lengths) const&;
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into a `ComponentColumn`.
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        Result<ComponentColumn> partitioned() const&;
+
+        /// Size in the number of elements the underlying arrow array contains.
+        size_t length() const;
+
+        /// To rerun C API component batch.
+        ///
+        /// The resulting `rr_component_batch` keeps the `arrow::Array` alive until it is released.
+        Error to_c_ffi_struct(rr_component_batch& out_component_batch) const;
+    };
+} // namespace rerun

include/rerun/component_column.hpp

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <memory> // shared_ptr
+
+#include "collection.hpp"
+#include "component_batch.hpp"
+#include "component_type.hpp"
+#include "error.hpp"
+#include "loggable.hpp"
+
+struct rr_component_column;
+
+namespace rerun {
+    /// Arrow-encoded data of a column of components.
+    ///
+    /// This is essentially an array of `rerun::ComponentBatch` with all batches
+    /// continuously in a single array.
+    ///
+    /// \see `rerun::RecordingStream::send_columns`
+    struct ComponentColumn {
+        /// Arrow-encoded list array of component batches.
+        std::shared_ptr<arrow::Array> array;
+
+        /// The type of the component instances in array.
+        ComponentTypeHandle component_type;
+
+      public:
+        /// Creates a new component column from a collection of component instances.
+        ///
+        /// Automatically registers the component type the first time this type is encountered.
+        ///
+        /// \param components Continuous collection of components which is about to be partitioned.
+        /// \param lengths The number of components in each run. for `rerun::RecordingStream::send_columns`,
+        /// this specifies the number of components at each time point.
+        /// The sum of the lengths must be equal to the number of components in the batch.
+        /// \param descriptor Descriptor of the component type for this column.
+        template <typename T>
+        static Result<ComponentColumn> from_loggable_with_lengths(
+            const Collection<T>& components, const Collection<uint32_t>& lengths,
+            const ComponentDescriptor& descriptor = rerun::Loggable<T>::Descriptor
+        ) {
+            auto component_batch_result = ComponentBatch::from_loggable(components, descriptor);
+            if (component_batch_result.is_err()) {
+                return component_batch_result.error;
+            }
+            return from_batch_with_lengths(component_batch_result.value, lengths);
+        }
+
+        /// Creates a new component column from a collection of component instances where each run has a length of one.
+        ///
+        /// When used with `rerun::RecordingStream::send_columns`, this is equivalent to `from_loggable(components, std::vector{1, 1, ...})`.
+        /// I.e. there's a single component for each time point.
+        ///
+        /// Automatically registers the component type the first time this type is encountered.
+        ///
+        /// \param components Continuous collection of components which is about to be partitioned into runs of length one.
+        /// \param descriptor Descriptor of the component type for this column.
+        template <typename T>
+        static Result<ComponentColumn> from_loggable(
+            const Collection<T>& components,
+            const ComponentDescriptor& descriptor = rerun::Loggable<T>::Descriptor
+        ) {
+            return ComponentColumn::from_loggable_with_lengths(
+                components,
+                Collection<uint32_t>::take_ownership(std::vector<uint32_t>(components.size(), 1)),
+                descriptor
+            );
+        }
+
+        /// Creates a new component column with a given number of archetype indicators for a given archetype type.
+        template <typename Archetype>
+        static Result<ComponentColumn> from_indicators(uint32_t num_indicators) {
+            auto component_batch_result = ComponentBatch::from_indicator<Archetype>();
+            if (component_batch_result.is_err()) {
+                return component_batch_result.error;
+            }
+            return ComponentColumn::from_batch_with_lengths(
+                component_batch_result.value,
+                Collection<uint32_t>::take_ownership(std::vector<uint32_t>(num_indicators, 0))
+            );
+        }
+
+        /// Creates a new component batch partition from a batch and a collection of run lengths.
+        ///
+        /// \param batch A batch of components which is about to be partitioned.
+        /// \param lengths The number of components in each run. for `rerun::RecordingStream::send_columns`,
+        /// this specifies the number of components at each time point.
+        /// The sum of the lengths must be equal to the number of components in the batch.
+        static Result<ComponentColumn> from_batch_with_lengths(
+            ComponentBatch batch, const Collection<uint32_t>& lengths
+        );
+
+        /// Creates a new component batch partition from a batch and a collection of component offsets.
+        ///
+        /// \param batch A batch of components which is about to be partitioned.
+        /// \param offsets An offset within `batch` for each array of components.
+        /// The last offset is the total number of components in the batch. Meaning that this array has to be
+        /// one element longer than the number of component runs.
+        /// E.g. a `ParitionedComponentBatch` with a single component would have an offset array of `[0, 1]`.
+        /// A `ComponentColumn` with 5 components divided into runs of length 2 and 3
+        // would have an offset array of `[0, 2, 5]`.
+        static Result<ComponentColumn> from_batch_with_offsets(
+            ComponentBatch batch, Collection<uint32_t> offsets
+        );
+
+        /// To rerun C API component batch.
+        ///
+        /// The resulting `rr_component_column` keeps the `arrow::Array` alive until it is released.
+        Error to_c_ffi_struct(rr_component_column& out_component_batch) const;
+    };
+} // namespace rerun

include/rerun/component_descriptor.hpp

@@ -0,0 +1,142 @@
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <string_view>
+
+namespace rerun {
+    /// See `ComponentDescriptor::hashed`.
+    using ComponentDescriptorHash = uint64_t;
+
+    /// A `ComponentDescriptor` fully describes the semantics of a column of data.
+    ///
+    /// Every component is uniquely identified by its `ComponentDescriptor`.
+    struct ComponentDescriptor {
+        /// Optional name of the `Archetype` associated with this data.
+        ///
+        /// `None` if the data wasn't logged through an archetype.
+        ///
+        /// Example: `rerun.archetypes.Points3D`.
+        std::optional<std::string_view> archetype_name;
+
+        /// Optional name of the field within `Archetype` associated with this data.
+        ///
+        /// `None` if the data wasn't logged through an archetype.
+        ///
+        /// Example: `positions`.
+        std::optional<std::string_view> archetype_field_name;
+
+        /// Semantic name associated with this data.
+        ///
+        /// This is fully implied by `archetype_name` and `archetype_field`, but
+        /// included for semantic convenience.
+        ///
+        /// Example: `rerun.components.Position3D`.
+        std::string_view component_name;
+
+        constexpr ComponentDescriptor(
+            std::optional<std::string_view> archetype_name_,
+            std::optional<std::string_view> archetype_field_name_, std::string_view component_name_
+        )
+            : archetype_name(archetype_name_),
+              archetype_field_name(archetype_field_name_),
+              component_name(component_name_) {}
+
+        constexpr ComponentDescriptor(
+            const char* archetype_name_, const char* archetype_field_name_,
+            const char* component_name_
+        )
+            : archetype_name(archetype_name_),
+              archetype_field_name(archetype_field_name_),
+              component_name(component_name_) {}
+
+        constexpr ComponentDescriptor(std::string_view component_name_)
+            : component_name(component_name_) {}
+
+        constexpr ComponentDescriptor(const char* component_name_)
+            : component_name(component_name_) {}
+
+        ComponentDescriptorHash hashed() const {
+            std::size_t archetype_name_h =
+                std::hash<std::optional<std::string_view>>{}(this->archetype_name);
+            std::size_t component_name_h = std::hash<std::string_view>{}(this->component_name);
+            std::size_t archetype_field_name_h =
+                std::hash<std::optional<std::string_view>>{}(this->archetype_field_name);
+            return archetype_name_h ^ component_name_h ^ archetype_field_name_h;
+        }
+
+        /// Unconditionally sets `archetype_name` to the given one.
+        ComponentDescriptor with_archetype_name(std::optional<std::string_view> archetype_name_
+        ) const {
+            ComponentDescriptor descriptor = *this;
+            descriptor.archetype_name = archetype_name_;
+            return descriptor;
+        }
+
+        /// Unconditionally sets `archetype_name` to the given one.
+        ComponentDescriptor with_archetype_name(const char* archetype_name_) const {
+            ComponentDescriptor descriptor = *this;
+            descriptor.archetype_name = archetype_name_;
+            return descriptor;
+        }
+
+        /// Unconditionally sets `archetype_field_name` to the given one.
+        ComponentDescriptor with_archetype_field_name(
+            std::optional<std::string_view> archetype_field_name_
+        ) const {
+            ComponentDescriptor descriptor = *this;
+            descriptor.archetype_field_name = archetype_field_name_;
+            return descriptor;
+        }
+
+        /// Unconditionally sets `archetype_field_name` to the given one.
+        ComponentDescriptor with_archetype_field_name(const char* archetype_field_name_) const {
+            ComponentDescriptor descriptor = *this;
+            descriptor.archetype_field_name = archetype_field_name_;
+            return descriptor;
+        }
+
+        /// Sets `archetype_name` to the given one iff it's not already set.
+        ComponentDescriptor or_with_archetype_name(std::optional<std::string_view> archetype_name_
+        ) const {
+            if (this->archetype_field_name.has_value()) {
+                return *this;
+            }
+            ComponentDescriptor descriptor = *this;
+            descriptor.archetype_name = archetype_name_;
+            return descriptor;
+        }
+
+        /// Sets `archetype_name` to the given one iff it's not already set.
+        ComponentDescriptor or_with_archetype_name(const char* archetype_name_) const {
+            if (this->archetype_field_name.has_value()) {
+                return *this;
+            }
+            ComponentDescriptor descriptor = *this;
+            descriptor.archetype_name = archetype_name_;
+            return descriptor;
+        }
+
+        /// Sets `archetype_field_name` to the given one iff it's not already set.
+        ComponentDescriptor or_with_archetype_field_name(
+            std::optional<std::string_view> archetype_field_name_
+        ) const {
+            if (this->archetype_field_name.has_value()) {
+                return *this;
+            }
+            ComponentDescriptor descriptor = *this;
+            descriptor.archetype_field_name = archetype_field_name_;
+            return descriptor;
+        }
+
+        /// Sets `archetype_field_name` to the given one iff it's not already set.
+        ComponentDescriptor or_with_archetype_field_name(const char* archetype_field_name_) const {
+            if (this->archetype_field_name.has_value()) {
+                return *this;
+            }
+            ComponentDescriptor descriptor = *this;
+            descriptor.archetype_field_name = archetype_field_name_;
+            return descriptor;
+        }
+    };
+} // namespace rerun

include/rerun/component_type.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <memory>
+
+#include "component_descriptor.hpp"
+#include "result.hpp"
+
+namespace arrow {
+    class DataType;
+} // namespace arrow
+
+namespace rerun {
+    /// Handle to a registered component types.
+    using ComponentTypeHandle = uint32_t;
+
+    /// A type of component that can be registered.
+    ///
+    /// All built-in components automatically register their types lazily upon first serialization.
+    struct ComponentType {
+        ComponentDescriptor descriptor;
+        const std::shared_ptr<arrow::DataType>& arrow_datatype;
+
+        ComponentType(
+            const ComponentDescriptor& descriptor_,
+            const std::shared_ptr<arrow::DataType>& arrow_datatype_
+        )
+            : descriptor(descriptor_), arrow_datatype(arrow_datatype_) {}
+
+        /// Registers a component type with the SDK.
+        ///
+        /// There is currently no deregistration mechanism.
+        /// Ideally, this method is only ever called once per component type.
+        Result<ComponentTypeHandle> register_component() const;
+    };
+} // namespace rerun

include/rerun/components/aggregation_policy.hpp

@@ -0,0 +1,76 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/components/aggregation_policy.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace arrow {
+    /// \private
+    template <typename T>
+    class NumericBuilder;
+
+    class Array;
+    class DataType;
+    class UInt8Type;
+    using UInt8Builder = NumericBuilder<UInt8Type>;
+} // namespace arrow
+
+namespace rerun::components {
+    /// **Component**: Policy for aggregation of multiple scalar plot values.
+    ///
+    /// This is used for lines in plots when the X axis distance of individual points goes below a single pixel,
+    /// i.e. a single pixel covers more than one tick worth of data. It can greatly improve performance
+    /// (and readability) in such situations as it prevents overdraw.
+    enum class AggregationPolicy : uint8_t {
+
+        /// No aggregation.
+        Off = 1,
+
+        /// Average all points in the range together.
+        Average = 2,
+
+        /// Keep only the maximum values in the range.
+        Max = 3,
+
+        /// Keep only the minimum values in the range.
+        Min = 4,
+
+        /// Keep both the minimum and maximum values in the range.
+        ///
+        /// This will yield two aggregated points instead of one, effectively creating a vertical line.
+        MinMax = 5,
+
+        /// Find both the minimum and maximum values in the range, then use the average of those.
+        MinMaxAverage = 6,
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    template <typename T>
+    struct Loggable;
+
+    /// \private
+    template <>
+    struct Loggable<components::AggregationPolicy> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.AggregationPolicy";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype();
+
+        /// Serializes an array of `rerun::components::AggregationPolicy` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::AggregationPolicy* instances, size_t num_instances
+        );
+
+        /// Fills an arrow array builder with an array of this type.
+        static rerun::Error fill_arrow_array_builder(
+            arrow::UInt8Builder* builder, const components::AggregationPolicy* elements,
+            size_t num_elements
+        );
+    };
+} // namespace rerun

include/rerun/components/albedo_factor.hpp

@@ -0,0 +1,74 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+// Based on "crates/store/re_types/definitions/rerun/components/albedo_factor.fbs".
+
+#pragma once
+
+#include "../component_descriptor.hpp"
+#include "../datatypes/rgba32.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace rerun::components {
+    /// **Component**: A color multiplier, usually applied to a whole entity, e.g. a mesh.
+    struct AlbedoFactor {
+        rerun::datatypes::Rgba32 albedo_factor;
+
+      public:
+        AlbedoFactor() = default;
+
+        AlbedoFactor(rerun::datatypes::Rgba32 albedo_factor_) : albedo_factor(albedo_factor_) {}
+
+        AlbedoFactor& operator=(rerun::datatypes::Rgba32 albedo_factor_) {
+            albedo_factor = albedo_factor_;
+            return *this;
+        }
+
+        AlbedoFactor(uint32_t rgba_) : albedo_factor(rgba_) {}
+
+        AlbedoFactor& operator=(uint32_t rgba_) {
+            albedo_factor = rgba_;
+            return *this;
+        }
+
+        /// Cast to the underlying Rgba32 datatype
+        operator rerun::datatypes::Rgba32() const {
+            return albedo_factor;
+        }
+    };
+} // namespace rerun::components
+
+namespace rerun {
+    static_assert(sizeof(rerun::datatypes::Rgba32) == sizeof(components::AlbedoFactor));
+
+    /// \private
+    template <>
+    struct Loggable<components::AlbedoFactor> {
+        static constexpr ComponentDescriptor Descriptor = "rerun.components.AlbedoFactor";
+
+        /// Returns the arrow data type this type corresponds to.
+        static const std::shared_ptr<arrow::DataType>& arrow_datatype() {
+            return Loggable<rerun::datatypes::Rgba32>::arrow_datatype();
+        }
+
+        /// Serializes an array of `rerun::components::AlbedoFactor` into an arrow array.
+        static Result<std::shared_ptr<arrow::Array>> to_arrow(
+            const components::AlbedoFactor* instances, size_t num_instances
+        ) {
+            if (num_instances == 0) {
+                return Loggable<rerun::datatypes::Rgba32>::to_arrow(nullptr, 0);
+            } else if (instances == nullptr) {
+                return rerun::Error(
+                    ErrorCode::UnexpectedNullArgument,
+                    "Passed array instances is null when num_elements> 0."
+                );
+            } else {
+                return Loggable<rerun::datatypes::Rgba32>::to_arrow(
+                    &instances->albedo_factor,
+                    num_instances
+                );
+            }
+        }
+    };
+} // namespace rerun