pymomentum-cpu 0.1.93.post0__cp312-cp312-macosx_14_0_arm64.whl

include/rerun/archetypes/view_coordinates.hpp

@@ -0,0 +1,393 @@
+// 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/archetypes/view_coordinates.fbs".
+
+#pragma once
+
+#include "../collection.hpp"
+#include "../component_batch.hpp"
+#include "../component_column.hpp"
+#include "../components/view_coordinates.hpp"
+#include "../indicator_component.hpp"
+#include "../rerun_sdk_export.hpp"
+#include "../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::archetypes {
+    /// **Archetype**: How we interpret the coordinate system of an entity/space.
+    ///
+    /// For instance: What is "up"? What does the Z axis mean?
+    ///
+    /// The three coordinates are always ordered as [x, y, z].
+    ///
+    /// For example [Right, Down, Forward] means that the X axis points to the right, the Y axis points
+    /// down, and the Z axis points forward.
+    ///
+    /// Make sure that this archetype is logged at or above the origin entity path of your 3D views.
+    ///
+    /// ⚠ [Rerun does not yet support left-handed coordinate systems](https://github.com/rerun-io/rerun/issues/5032).
+    ///
+    /// ## Example
+    ///
+    /// ### View coordinates for adjusting the eye camera
+    /// ![image](https://static.rerun.io/viewcoordinates/0833f0dc8616a676b7b2c566f2a6f613363680c5/full.png)
+    ///
+    /// ```cpp
+    /// #include <rerun.hpp>
+    ///
+    /// int main() {
+    ///     const auto rec = rerun::RecordingStream("rerun_example_view_coordinates");
+    ///     rec.spawn().exit_on_failure();
+    ///
+    ///     rec.log_static("world", rerun::ViewCoordinates::RIGHT_HAND_Z_UP); // Set an up-axis
+    ///     rec.log(
+    ///         "world/xyz",
+    ///         rerun::Arrows3D::from_vectors({{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}}
+    ///         ).with_colors({{255, 0, 0}, {0, 255, 0}, {0, 0, 255}})
+    ///     );
+    /// }
+    /// ```
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct ViewCoordinates {
+        /// The directions of the [x, y, z] axes.
+        std::optional<ComponentBatch> xyz;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.components.ViewCoordinatesIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] = "rerun.archetypes.ViewCoordinates";
+
+        /// `ComponentDescriptor` for the `xyz` field.
+        static constexpr auto Descriptor_xyz = ComponentDescriptor(
+            ArchetypeName, "xyz",
+            Loggable<rerun::components::ViewCoordinates>::Descriptor.component_name
+        );
+
+      public: // START of extensions from view_coordinates_ext.cpp:
+        /// Construct Vec3D from x/y/z values.
+        ViewCoordinates(uint8_t axis0, uint8_t axis1, uint8_t axis2)
+            : ViewCoordinates(rerun::components::ViewCoordinates(axis0, axis1, axis2)) {}
+
+        // <BEGIN_GENERATED:declarations>
+        // This section is generated by running `scripts/generate_view_coordinate_defs.py --cpp`
+        /// X=Up, Y=Left, Z=Forward
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates ULF;
+
+        /// X=Up, Y=Forward, Z=Left
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates UFL;
+
+        /// X=Left, Y=Up, Z=Forward
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LUF;
+
+        /// X=Left, Y=Forward, Z=Up
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LFU;
+
+        /// X=Forward, Y=Up, Z=Left
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates FUL;
+
+        /// X=Forward, Y=Left, Z=Up
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates FLU;
+
+        /// X=Up, Y=Left, Z=Back
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates ULB;
+
+        /// X=Up, Y=Back, Z=Left
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates UBL;
+
+        /// X=Left, Y=Up, Z=Back
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LUB;
+
+        /// X=Left, Y=Back, Z=Up
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LBU;
+
+        /// X=Back, Y=Up, Z=Left
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates BUL;
+
+        /// X=Back, Y=Left, Z=Up
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates BLU;
+
+        /// X=Up, Y=Right, Z=Forward
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates URF;
+
+        /// X=Up, Y=Forward, Z=Right
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates UFR;
+
+        /// X=Right, Y=Up, Z=Forward
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RUF;
+
+        /// X=Right, Y=Forward, Z=Up
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RFU;
+
+        /// X=Forward, Y=Up, Z=Right
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates FUR;
+
+        /// X=Forward, Y=Right, Z=Up
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates FRU;
+
+        /// X=Up, Y=Right, Z=Back
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates URB;
+
+        /// X=Up, Y=Back, Z=Right
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates UBR;
+
+        /// X=Right, Y=Up, Z=Back
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RUB;
+
+        /// X=Right, Y=Back, Z=Up
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RBU;
+
+        /// X=Back, Y=Up, Z=Right
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates BUR;
+
+        /// X=Back, Y=Right, Z=Up
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates BRU;
+
+        /// X=Down, Y=Left, Z=Forward
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates DLF;
+
+        /// X=Down, Y=Forward, Z=Left
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates DFL;
+
+        /// X=Left, Y=Down, Z=Forward
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LDF;
+
+        /// X=Left, Y=Forward, Z=Down
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LFD;
+
+        /// X=Forward, Y=Down, Z=Left
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates FDL;
+
+        /// X=Forward, Y=Left, Z=Down
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates FLD;
+
+        /// X=Down, Y=Left, Z=Back
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates DLB;
+
+        /// X=Down, Y=Back, Z=Left
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates DBL;
+
+        /// X=Left, Y=Down, Z=Back
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LDB;
+
+        /// X=Left, Y=Back, Z=Down
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LBD;
+
+        /// X=Back, Y=Down, Z=Left
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates BDL;
+
+        /// X=Back, Y=Left, Z=Down
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates BLD;
+
+        /// X=Down, Y=Right, Z=Forward
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates DRF;
+
+        /// X=Down, Y=Forward, Z=Right
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates DFR;
+
+        /// X=Right, Y=Down, Z=Forward
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RDF;
+
+        /// X=Right, Y=Forward, Z=Down
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RFD;
+
+        /// X=Forward, Y=Down, Z=Right
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates FDR;
+
+        /// X=Forward, Y=Right, Z=Down
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates FRD;
+
+        /// X=Down, Y=Right, Z=Back
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates DRB;
+
+        /// X=Down, Y=Back, Z=Right
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates DBR;
+
+        /// X=Right, Y=Down, Z=Back
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RDB;
+
+        /// X=Right, Y=Back, Z=Down
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RBD;
+
+        /// X=Back, Y=Down, Z=Right
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates BDR;
+
+        /// X=Back, Y=Right, Z=Down
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates BRD;
+
+        /// X=Up, Y=Right, Z=Forward
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RIGHT_HAND_X_UP;
+
+        /// X=Down, Y=Right, Z=Back
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RIGHT_HAND_X_DOWN;
+
+        /// X=Right, Y=Up, Z=Back
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RIGHT_HAND_Y_UP;
+
+        /// X=Right, Y=Down, Z=Forward
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RIGHT_HAND_Y_DOWN;
+
+        /// X=Right, Y=Forward, Z=Up
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RIGHT_HAND_Z_UP;
+
+        /// X=Right, Y=Back, Z=Down
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates RIGHT_HAND_Z_DOWN;
+
+        /// X=Up, Y=Right, Z=Back
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LEFT_HAND_X_UP;
+
+        /// X=Down, Y=Right, Z=Forward
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LEFT_HAND_X_DOWN;
+
+        /// X=Right, Y=Up, Z=Forward
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LEFT_HAND_Y_UP;
+
+        /// X=Right, Y=Down, Z=Back
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LEFT_HAND_Y_DOWN;
+
+        /// X=Right, Y=Back, Z=Up
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LEFT_HAND_Z_UP;
+
+        /// X=Right, Y=Forward, Z=Down
+        ///
+        /// ⚠️ This is a left-handed coordinate system, which is [not yet supported by Rerun](https://github.com/rerun-io/rerun/issues/5032).
+        RERUN_SDK_EXPORT static const rerun::archetypes::ViewCoordinates LEFT_HAND_Z_DOWN;
+
+        // <END_GENERATED:declarations>
+
+        // END of extensions from view_coordinates_ext.cpp, start of generated code:
+
+      public:
+        ViewCoordinates() = default;
+        ViewCoordinates(ViewCoordinates&& other) = default;
+        ViewCoordinates(const ViewCoordinates& other) = default;
+        ViewCoordinates& operator=(const ViewCoordinates& other) = default;
+        ViewCoordinates& operator=(ViewCoordinates&& other) = default;
+
+        explicit ViewCoordinates(rerun::components::ViewCoordinates _xyz)
+            : xyz(ComponentBatch::from_loggable(std::move(_xyz), Descriptor_xyz).value_or_throw()) {
+        }
+
+        /// Update only some specific fields of a `ViewCoordinates`.
+        static ViewCoordinates update_fields() {
+            return ViewCoordinates();
+        }
+
+        /// Clear all the fields of a `ViewCoordinates`.
+        static ViewCoordinates clear_fields();
+
+        /// The directions of the [x, y, z] axes.
+        ViewCoordinates with_xyz(const rerun::components::ViewCoordinates& _xyz) && {
+            xyz = ComponentBatch::from_loggable(_xyz, Descriptor_xyz).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// This method makes it possible to pack multiple `xyz` in a single component batch.
+        ///
+        /// This only makes sense when used in conjunction with `columns`. `with_xyz` should
+        /// be used when logging a single row's worth of data.
+        ViewCoordinates with_many_xyz(const Collection<rerun::components::ViewCoordinates>& _xyz
+        ) && {
+            xyz = ComponentBatch::from_loggable(_xyz, Descriptor_xyz).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::partitioned`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// The specified `lengths` must sum to the total length of the component batch.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<archetypes::ViewCoordinates> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const archetypes::ViewCoordinates& archetype
+        );
+    };
+} // namespace rerun

include/rerun/archetypes.hpp

@@ -0,0 +1,43 @@
+// DO NOT EDIT! This file was auto-generated by crates/build/re_types_builder/src/codegen/cpp/mod.rs
+
+#pragma once
+
+#include "archetypes/annotation_context.hpp"
+#include "archetypes/arrows2d.hpp"
+#include "archetypes/arrows3d.hpp"
+#include "archetypes/asset3d.hpp"
+#include "archetypes/asset_video.hpp"
+#include "archetypes/bar_chart.hpp"
+#include "archetypes/boxes2d.hpp"
+#include "archetypes/boxes3d.hpp"
+#include "archetypes/capsules3d.hpp"
+#include "archetypes/clear.hpp"
+#include "archetypes/depth_image.hpp"
+#include "archetypes/ellipsoids3d.hpp"
+#include "archetypes/encoded_image.hpp"
+#include "archetypes/geo_line_strings.hpp"
+#include "archetypes/geo_points.hpp"
+#include "archetypes/graph_edges.hpp"
+#include "archetypes/graph_nodes.hpp"
+#include "archetypes/image.hpp"
+#include "archetypes/instance_poses3d.hpp"
+#include "archetypes/line_strips2d.hpp"
+#include "archetypes/line_strips3d.hpp"
+#include "archetypes/mesh3d.hpp"
+#include "archetypes/pinhole.hpp"
+#include "archetypes/points2d.hpp"
+#include "archetypes/points3d.hpp"
+#include "archetypes/recording_properties.hpp"
+#include "archetypes/scalar.hpp"
+#include "archetypes/scalars.hpp"
+#include "archetypes/segmentation_image.hpp"
+#include "archetypes/series_line.hpp"
+#include "archetypes/series_lines.hpp"
+#include "archetypes/series_point.hpp"
+#include "archetypes/series_points.hpp"
+#include "archetypes/tensor.hpp"
+#include "archetypes/text_document.hpp"
+#include "archetypes/text_log.hpp"
+#include "archetypes/transform3d.hpp"
+#include "archetypes/video_frame_reference.hpp"
+#include "archetypes/view_coordinates.hpp"

include/rerun/arrow_utils.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <arrow/buffer.h>
+
+// Do not include this file in any public header as we don't want to infect the user's namespace
+// with symbols from arrow.
+// (in order to keep compile times low and avoid potential arrow version conflicts)
+
+namespace rerun {
+    /// Creates an arrow buffer from a vector without allocating new memory.
+    ///
+    /// Newer version of the arrow sdk have this builtin as `arrow::Buffer::FromVector`.
+    template <typename T>
+    inline std::shared_ptr<arrow::Buffer> arrow_buffer_from_vector(std::vector<T> vec) {
+        static_assert(
+            std::is_trivial_v<T>,
+            "Buffer::FromVector can only wrap vectors of trivial objects"
+        );
+
+        if (vec.empty()) {
+            return std::make_shared<arrow::Buffer>(nullptr, 0);
+        }
+
+        auto* data = reinterpret_cast<uint8_t*>(vec.data());
+        auto size_in_bytes = static_cast<int64_t>(vec.size() * sizeof(T));
+        return std::shared_ptr<arrow::Buffer>{
+            new arrow::Buffer{data, size_in_bytes},
+            // Keep the vector's buffer alive inside the shared_ptr's destructor until after we have deleted the Buffer.
+            [vec = std::move(vec)](arrow::Buffer* buffer) { delete buffer; }};
+    }
+
+} // namespace rerun

include/rerun/as_components.hpp

@@ -0,0 +1,90 @@
+#pragma once
+
+#include "collection.hpp"
+#include "component_batch.hpp"
+#include "indicator_component.hpp"
+#include "loggable.hpp"
+
+namespace rerun {
+    /// The AsComponents trait is used to convert a type into a list of component batches.
+    ///
+    /// It is implemented for various built-in types as well as collections of components.
+    /// You can build your own archetypes by implementing this trait.
+    /// Anything that implements `AsComponents` can be logged to a recording stream.
+    template <typename T>
+    struct AsComponents {
+        /// \private
+        /// `NoAsComponentsFor` always evaluates to false, but in a way that requires template instantiation.
+        template <typename T2>
+        struct NoAsComponentsFor : std::false_type {};
+
+        // TODO(andreas): This should also mention an example of how to implement this.
+        static_assert(
+            NoAsComponentsFor<T>::value,
+            "AsComponents is not implemented for this type. "
+            "It is implemented for all built-in archetypes as well as invidiual & collections of `rerun::ComponentBatch`."
+            "You can add your own implementation by specializing AsComponents<T> for your type T."
+        );
+
+        /// Converts the type `T` into a collection of `ComponentBatch`s.
+        static Result<Collection<ComponentBatch>> as_batches(const T& archetype);
+    };
+
+    // Documenting the builtin generic `AsComponents` impls is too much clutter for the doc class overview.
+    /// \cond private
+
+    /// `AsComponents` for a `Collection<ComponentBatch>`.
+    template <>
+    struct AsComponents<Collection<ComponentBatch>> {
+        static Result<Collection<ComponentBatch>> as_batches(Collection<ComponentBatch> components
+        ) {
+            return components;
+        }
+    };
+
+    /// `AsComponents` for a single `ComponentBatch`.
+    template <>
+    struct AsComponents<ComponentBatch> {
+        static Result<Collection<ComponentBatch>> as_batches(ComponentBatch components) {
+            return rerun::take_ownership(std::move(components));
+        }
+    };
+
+    /// `AsComponents` for a `Collection<ComponentBatch>` wrapped in a `Result`, forwarding errors for convenience.
+    template <>
+    struct AsComponents<Result<Collection<ComponentBatch>>> {
+        static Result<Collection<ComponentBatch>> as_batches(
+            Result<Collection<ComponentBatch>> components
+        ) {
+            RR_RETURN_NOT_OK(components.error);
+            return components.value;
+        }
+    };
+
+    /// `AsComponents` for a `Collection<ComponentBatch>` individually wrapped in `Result`, forwarding errors for convenience.
+    template <>
+    struct AsComponents<Collection<Result<ComponentBatch>>> {
+        static Result<Collection<ComponentBatch>> as_batches(
+            Collection<Result<ComponentBatch>> components
+        ) {
+            std::vector<ComponentBatch> result;
+            result.reserve(components.size());
+            for (auto& component : components) {
+                RR_RETURN_NOT_OK(component.error);
+                result.push_back(std::move(component.value));
+            }
+            return rerun::take_ownership(std::move(result));
+        }
+    };
+
+    /// `AsComponents` for a single `ComponentBatch` wrapped in a `Result`, forwarding errors for convenience.
+    template <>
+    struct AsComponents<Result<ComponentBatch>> {
+        static Result<Collection<ComponentBatch>> as_batches(Result<ComponentBatch> components) {
+            RR_RETURN_NOT_OK(components.error);
+            return rerun::take_ownership(std::move(components.value));
+        }
+    };
+
+    /// \endcond
+} // namespace rerun

include/rerun/blueprint/archetypes/background.hpp

@@ -0,0 +1,113 @@
+// 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/blueprint/archetypes/background.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/background_kind.hpp"
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.hpp"
+#include "../../components/color.hpp"
+#include "../../indicator_component.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::blueprint::archetypes {
+    /// **Archetype**: Configuration for the background of a view.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct Background {
+        /// The type of the background.
+        std::optional<ComponentBatch> kind;
+
+        /// Color used for the solid background type.
+        std::optional<ComponentBatch> color;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.BackgroundIndicator";
+
+        /// Indicator component, used to identify the archetype when converting to a list of components.
+        using IndicatorComponent = rerun::components::IndicatorComponent<IndicatorComponentName>;
+        /// The name of the archetype as used in `ComponentDescriptor`s.
+        static constexpr const char ArchetypeName[] = "rerun.blueprint.archetypes.Background";
+
+        /// `ComponentDescriptor` for the `kind` field.
+        static constexpr auto Descriptor_kind = ComponentDescriptor(
+            ArchetypeName, "kind",
+            Loggable<rerun::blueprint::components::BackgroundKind>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `color` field.
+        static constexpr auto Descriptor_color = ComponentDescriptor(
+            ArchetypeName, "color", Loggable<rerun::components::Color>::Descriptor.component_name
+        );
+
+      public:
+        Background() = default;
+        Background(Background&& other) = default;
+        Background(const Background& other) = default;
+        Background& operator=(const Background& other) = default;
+        Background& operator=(Background&& other) = default;
+
+        explicit Background(rerun::blueprint::components::BackgroundKind _kind)
+            : kind(ComponentBatch::from_loggable(std::move(_kind), Descriptor_kind).value_or_throw()
+              ) {}
+
+        /// Update only some specific fields of a `Background`.
+        static Background update_fields() {
+            return Background();
+        }
+
+        /// Clear all the fields of a `Background`.
+        static Background clear_fields();
+
+        /// The type of the background.
+        Background with_kind(const rerun::blueprint::components::BackgroundKind& _kind) && {
+            kind = ComponentBatch::from_loggable(_kind, Descriptor_kind).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Color used for the solid background type.
+        Background with_color(const rerun::components::Color& _color) && {
+            color = ComponentBatch::from_loggable(_color, Descriptor_color).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Partitions the component data into multiple sub-batches.
+        ///
+        /// Specifically, this transforms the existing `ComponentBatch` data into `ComponentColumn`s
+        /// instead, via `ComponentBatch::partitioned`.
+        ///
+        /// This makes it possible to use `RecordingStream::send_columns` to send columnar data directly into Rerun.
+        ///
+        /// The specified `lengths` must sum to the total length of the component batch.
+        Collection<ComponentColumn> columns(const Collection<uint32_t>& lengths_);
+
+        /// Partitions the component data into unit-length sub-batches.
+        ///
+        /// This is semantically similar to calling `columns` with `std::vector<uint32_t>(n, 1)`,
+        /// where `n` is automatically guessed.
+        Collection<ComponentColumn> columns();
+    };
+
+} // namespace rerun::blueprint::archetypes
+
+namespace rerun {
+    /// \private
+    template <typename T>
+    struct AsComponents;
+
+    /// \private
+    template <>
+    struct AsComponents<blueprint::archetypes::Background> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::Background& archetype
+        );
+    };
+} // namespace rerun