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

include/rerun/blueprint/archetypes/line_grid3d.hpp

@@ -0,0 +1,178 @@
+// 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/line_grid3d.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/grid_spacing.hpp"
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.hpp"
+#include "../../components/color.hpp"
+#include "../../components/plane3d.hpp"
+#include "../../components/stroke_width.hpp"
+#include "../../components/visible.hpp"
+#include "../../indicator_component.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::blueprint::archetypes {
+    /// **Archetype**: Configuration for the 3D line grid.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct LineGrid3D {
+        /// Whether the grid is visible.
+        ///
+        /// Defaults to true.
+        std::optional<ComponentBatch> visible;
+
+        /// Space between grid lines spacing of one line to the next in scene units.
+        ///
+        /// As you zoom out, successively only every tenth line is shown.
+        /// This controls the closest zoom level.
+        std::optional<ComponentBatch> spacing;
+
+        /// In what plane the grid is drawn.
+        ///
+        /// Defaults to whatever plane is determined as the plane at zero units up/down as defined by `components::ViewCoordinates` if present.
+        std::optional<ComponentBatch> plane;
+
+        /// How thick the lines should be in ui units.
+        ///
+        /// Default is 1.0 ui unit.
+        std::optional<ComponentBatch> stroke_width;
+
+        /// Color used for the grid.
+        ///
+        /// Transparency via alpha channel is supported.
+        /// Defaults to a slightly transparent light gray.
+        std::optional<ComponentBatch> color;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.LineGrid3DIndicator";
+
+        /// 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.LineGrid3D";
+
+        /// `ComponentDescriptor` for the `visible` field.
+        static constexpr auto Descriptor_visible = ComponentDescriptor(
+            ArchetypeName, "visible",
+            Loggable<rerun::components::Visible>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `spacing` field.
+        static constexpr auto Descriptor_spacing = ComponentDescriptor(
+            ArchetypeName, "spacing",
+            Loggable<rerun::blueprint::components::GridSpacing>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `plane` field.
+        static constexpr auto Descriptor_plane = ComponentDescriptor(
+            ArchetypeName, "plane", Loggable<rerun::components::Plane3D>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `stroke_width` field.
+        static constexpr auto Descriptor_stroke_width = ComponentDescriptor(
+            ArchetypeName, "stroke_width",
+            Loggable<rerun::components::StrokeWidth>::Descriptor.component_name
+        );
+        /// `ComponentDescriptor` for the `color` field.
+        static constexpr auto Descriptor_color = ComponentDescriptor(
+            ArchetypeName, "color", Loggable<rerun::components::Color>::Descriptor.component_name
+        );
+
+      public:
+        LineGrid3D() = default;
+        LineGrid3D(LineGrid3D&& other) = default;
+        LineGrid3D(const LineGrid3D& other) = default;
+        LineGrid3D& operator=(const LineGrid3D& other) = default;
+        LineGrid3D& operator=(LineGrid3D&& other) = default;
+
+        /// Update only some specific fields of a `LineGrid3D`.
+        static LineGrid3D update_fields() {
+            return LineGrid3D();
+        }
+
+        /// Clear all the fields of a `LineGrid3D`.
+        static LineGrid3D clear_fields();
+
+        /// Whether the grid is visible.
+        ///
+        /// Defaults to true.
+        LineGrid3D with_visible(const rerun::components::Visible& _visible) && {
+            visible = ComponentBatch::from_loggable(_visible, Descriptor_visible).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Space between grid lines spacing of one line to the next in scene units.
+        ///
+        /// As you zoom out, successively only every tenth line is shown.
+        /// This controls the closest zoom level.
+        LineGrid3D with_spacing(const rerun::blueprint::components::GridSpacing& _spacing) && {
+            spacing = ComponentBatch::from_loggable(_spacing, Descriptor_spacing).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// In what plane the grid is drawn.
+        ///
+        /// Defaults to whatever plane is determined as the plane at zero units up/down as defined by `components::ViewCoordinates` if present.
+        LineGrid3D with_plane(const rerun::components::Plane3D& _plane) && {
+            plane = ComponentBatch::from_loggable(_plane, Descriptor_plane).value_or_throw();
+            return std::move(*this);
+        }
+
+        /// How thick the lines should be in ui units.
+        ///
+        /// Default is 1.0 ui unit.
+        LineGrid3D with_stroke_width(const rerun::components::StrokeWidth& _stroke_width) && {
+            stroke_width = ComponentBatch::from_loggable(_stroke_width, Descriptor_stroke_width)
+                               .value_or_throw();
+            return std::move(*this);
+        }
+
+        /// Color used for the grid.
+        ///
+        /// Transparency via alpha channel is supported.
+        /// Defaults to a slightly transparent light gray.
+        LineGrid3D 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::LineGrid3D> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::LineGrid3D& archetype
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/archetypes/map_background.hpp

@@ -0,0 +1,104 @@
+// 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/map_background.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/map_provider.hpp"
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.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 map of the map view.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct MapBackground {
+        /// Map provider and style to use.
+        ///
+        /// **Note**: Requires a Mapbox API key in the `RERUN_MAPBOX_ACCESS_TOKEN` environment variable.
+        std::optional<ComponentBatch> provider;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.MapBackgroundIndicator";
+
+        /// 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.MapBackground";
+
+        /// `ComponentDescriptor` for the `provider` field.
+        static constexpr auto Descriptor_provider = ComponentDescriptor(
+            ArchetypeName, "provider",
+            Loggable<rerun::blueprint::components::MapProvider>::Descriptor.component_name
+        );
+
+      public:
+        MapBackground() = default;
+        MapBackground(MapBackground&& other) = default;
+        MapBackground(const MapBackground& other) = default;
+        MapBackground& operator=(const MapBackground& other) = default;
+        MapBackground& operator=(MapBackground&& other) = default;
+
+        explicit MapBackground(rerun::blueprint::components::MapProvider _provider)
+            : provider(ComponentBatch::from_loggable(std::move(_provider), Descriptor_provider)
+                           .value_or_throw()) {}
+
+        /// Update only some specific fields of a `MapBackground`.
+        static MapBackground update_fields() {
+            return MapBackground();
+        }
+
+        /// Clear all the fields of a `MapBackground`.
+        static MapBackground clear_fields();
+
+        /// Map provider and style to use.
+        ///
+        /// **Note**: Requires a Mapbox API key in the `RERUN_MAPBOX_ACCESS_TOKEN` environment variable.
+        MapBackground with_provider(const rerun::blueprint::components::MapProvider& _provider) && {
+            provider =
+                ComponentBatch::from_loggable(_provider, Descriptor_provider).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::MapBackground> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::MapBackground& archetype
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/archetypes/map_zoom.hpp

@@ -0,0 +1,103 @@
+// 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/map_zoom.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/zoom_level.hpp"
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.hpp"
+#include "../../indicator_component.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::blueprint::archetypes {
+    /// **Archetype**: Configuration of the map view zoom level.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct MapZoom {
+        /// Zoom level for the map.
+        ///
+        /// Zoom level follow the [`OpenStreetMap` definition](https://wiki.openstreetmap.org/wiki/Zoom_levels).
+        std::optional<ComponentBatch> zoom;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.MapZoomIndicator";
+
+        /// 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.MapZoom";
+
+        /// `ComponentDescriptor` for the `zoom` field.
+        static constexpr auto Descriptor_zoom = ComponentDescriptor(
+            ArchetypeName, "zoom",
+            Loggable<rerun::blueprint::components::ZoomLevel>::Descriptor.component_name
+        );
+
+      public:
+        MapZoom() = default;
+        MapZoom(MapZoom&& other) = default;
+        MapZoom(const MapZoom& other) = default;
+        MapZoom& operator=(const MapZoom& other) = default;
+        MapZoom& operator=(MapZoom&& other) = default;
+
+        explicit MapZoom(rerun::blueprint::components::ZoomLevel _zoom)
+            : zoom(ComponentBatch::from_loggable(std::move(_zoom), Descriptor_zoom).value_or_throw()
+              ) {}
+
+        /// Update only some specific fields of a `MapZoom`.
+        static MapZoom update_fields() {
+            return MapZoom();
+        }
+
+        /// Clear all the fields of a `MapZoom`.
+        static MapZoom clear_fields();
+
+        /// Zoom level for the map.
+        ///
+        /// Zoom level follow the [`OpenStreetMap` definition](https://wiki.openstreetmap.org/wiki/Zoom_levels).
+        MapZoom with_zoom(const rerun::blueprint::components::ZoomLevel& _zoom) && {
+            zoom = ComponentBatch::from_loggable(_zoom, Descriptor_zoom).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::MapZoom> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::MapZoom& archetype
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/archetypes/near_clip_plane.hpp

@@ -0,0 +1,109 @@
+// 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/near_clip_plane.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/near_clip_plane.hpp"
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.hpp"
+#include "../../indicator_component.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::blueprint::archetypes {
+    /// **Archetype**: Controls the distance to the near clip plane in 3D scene units.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct NearClipPlane {
+        /// Controls the distance to the near clip plane in 3D scene units.
+        ///
+        /// Content closer than this distance will not be visible.
+        std::optional<ComponentBatch> near_clip_plane;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.NearClipPlaneIndicator";
+
+        /// 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.NearClipPlane";
+
+        /// `ComponentDescriptor` for the `near_clip_plane` field.
+        static constexpr auto Descriptor_near_clip_plane = ComponentDescriptor(
+            ArchetypeName, "near_clip_plane",
+            Loggable<rerun::blueprint::components::NearClipPlane>::Descriptor.component_name
+        );
+
+      public:
+        NearClipPlane() = default;
+        NearClipPlane(NearClipPlane&& other) = default;
+        NearClipPlane(const NearClipPlane& other) = default;
+        NearClipPlane& operator=(const NearClipPlane& other) = default;
+        NearClipPlane& operator=(NearClipPlane&& other) = default;
+
+        explicit NearClipPlane(rerun::blueprint::components::NearClipPlane _near_clip_plane)
+            : near_clip_plane(ComponentBatch::from_loggable(
+                                  std::move(_near_clip_plane), Descriptor_near_clip_plane
+              )
+                                  .value_or_throw()) {}
+
+        /// Update only some specific fields of a `NearClipPlane`.
+        static NearClipPlane update_fields() {
+            return NearClipPlane();
+        }
+
+        /// Clear all the fields of a `NearClipPlane`.
+        static NearClipPlane clear_fields();
+
+        /// Controls the distance to the near clip plane in 3D scene units.
+        ///
+        /// Content closer than this distance will not be visible.
+        NearClipPlane with_near_clip_plane(
+            const rerun::blueprint::components::NearClipPlane& _near_clip_plane
+        ) && {
+            near_clip_plane =
+                ComponentBatch::from_loggable(_near_clip_plane, Descriptor_near_clip_plane)
+                    .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::NearClipPlane> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::NearClipPlane& archetype
+        );
+    };
+} // namespace rerun

include/rerun/blueprint/archetypes/panel_blueprint.hpp

@@ -0,0 +1,95 @@
+// 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/panel_blueprint.fbs".
+
+#pragma once
+
+#include "../../blueprint/components/panel_state.hpp"
+#include "../../collection.hpp"
+#include "../../component_batch.hpp"
+#include "../../component_column.hpp"
+#include "../../indicator_component.hpp"
+#include "../../result.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace rerun::blueprint::archetypes {
+    /// **Archetype**: Shared state for the 3 collapsible panels.
+    ///
+    /// ⚠ **This type is _unstable_ and may change significantly in a way that the data won't be backwards compatible.**
+    ///
+    struct PanelBlueprint {
+        /// Current state of the panels.
+        std::optional<ComponentBatch> state;
+
+      public:
+        static constexpr const char IndicatorComponentName[] =
+            "rerun.blueprint.components.PanelBlueprintIndicator";
+
+        /// 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.PanelBlueprint";
+
+        /// `ComponentDescriptor` for the `state` field.
+        static constexpr auto Descriptor_state = ComponentDescriptor(
+            ArchetypeName, "state",
+            Loggable<rerun::blueprint::components::PanelState>::Descriptor.component_name
+        );
+
+      public:
+        PanelBlueprint() = default;
+        PanelBlueprint(PanelBlueprint&& other) = default;
+        PanelBlueprint(const PanelBlueprint& other) = default;
+        PanelBlueprint& operator=(const PanelBlueprint& other) = default;
+        PanelBlueprint& operator=(PanelBlueprint&& other) = default;
+
+        /// Update only some specific fields of a `PanelBlueprint`.
+        static PanelBlueprint update_fields() {
+            return PanelBlueprint();
+        }
+
+        /// Clear all the fields of a `PanelBlueprint`.
+        static PanelBlueprint clear_fields();
+
+        /// Current state of the panels.
+        PanelBlueprint with_state(const rerun::blueprint::components::PanelState& _state) && {
+            state = ComponentBatch::from_loggable(_state, Descriptor_state).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::PanelBlueprint> {
+        /// Serialize all set component batches.
+        static Result<Collection<ComponentBatch>> as_batches(
+            const blueprint::archetypes::PanelBlueprint& archetype
+        );
+    };
+} // namespace rerun