World grid part 2/2: Integrate into Viewer

Cargo.lock

@@ -6499,6 +6499,7 @@ dependencies = [
  "re_format",
  "re_log",
  "re_log_types",
+ "re_math",
  "re_tracing",
  "re_types_builder",
  "re_types_core",

crates/store/re_types/Cargo.toml

@@ -33,8 +33,8 @@ ecolor = ["dep:ecolor"]
 ## Enable conversions to plot primitives
 egui_plot = ["dep:egui_plot"]
 
-## Add support for some math operations using [`glam`](https://crates.io/crates/glam/).
-glam = ["dep:glam"]
+## Add support for some math operations using [`glam`](https://crates.io/crates/glam/) and [`re_math`](https://crates.io/crates/re_math/).
+glam = ["dep:glam", "dep:re_math"]
 
 ## Integration with the [`image`](https://crates.io/crates/image/) crate, plus JPEG support.
 image = ["dep:ecolor", "dep:image"]
@@ -92,6 +92,7 @@ image = { workspace = true, optional = true, default-features = false, features
   "jpeg",
 ] }
 mint = { workspace = true, optional = true }
+re_math = { workspace = true, optional = true }
 serde = { workspace = true, optional = true, features = ["derive", "rc"] }
 
 

crates/store/re_types/definitions/rerun/archetypes/instance_poses3d.fbs

@@ -13,7 +13,7 @@ namespace rerun.archetypes;
 ///
 /// Currently, many visualizers support only a single instance transform per entity.
 /// Check archetype documentations for details - if not otherwise specified, only the first instance transform is applied.
-/// Some visualizers like the mesh visualizer used for [`archetype.Mesh3D`],
+/// Some visualizers like the mesh visualizer used for [archetypes.Mesh3D],
 /// will draw an object for every pose, a behavior also known as "instancing".
 ///
 /// \example archetypes/instance_poses3d_combined title="Regular & instance transforms in tandem" image="https://static.rerun.io/leaf_transform3d/41674f0082d6de489f8a1cd1583f60f6b5820ddf/1200w.png"

crates/store/re_types/definitions/rerun/archetypes/pinhole.fbs

@@ -32,7 +32,7 @@ table Pinhole (
 
   /// Sets the view coordinates for the camera.
   ///
-  /// All common values are available as constants on the `components.ViewCoordinates` class.
+  /// All common values are available as constants on the [components.ViewCoordinates] class.
   ///
   /// The default is `ViewCoordinates::RDF`, i.e. X=Right, Y=Down, Z=Forward, and this is also the recommended setting.
   /// This means that the camera frustum will point along the positive Z axis of the parent space,

crates/store/re_types/definitions/rerun/blueprint/archetypes/line_grid3d.fbs

@@ -0,0 +1,33 @@
+namespace rerun.blueprint.archetypes;
+
+/// Configuration for the 3D line grid.
+table LineGrid3D (
+    "attr.rerun.scope": "blueprint"
+) {
+    /// Whether the grid is visible.
+    ///
+    /// Defaults to true.
+    visible: rerun.blueprint.components.Visible ("attr.rerun.component_optional", nullable, order: 1000);
+
+    /// 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.
+    spacing: rerun.blueprint.components.GridSpacing ("attr.rerun.component_optional", nullable, order: 2000);
+
+    /// 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.
+    plane: rerun.components.Plane3D ("attr.rerun.component_optional", nullable, order: 3000);
+
+    /// How thick the lines should be in ui units.
+    ///
+    /// Default is 1.0 ui unit.
+    stroke_width: rerun.components.StrokeWidth ("attr.rerun.component_optional", nullable, order: 5000);
+
+    /// Color used for the grid.
+    ///
+    /// Transparency via alpha channel is supported.
+    /// Defaults to a slightly transparent light gray.
+    color: rerun.components.Color ("attr.rerun.component_optional", nullable, order: 6000);
+}

crates/store/re_types/definitions/rerun/blueprint/components/grid_spacing.fbs

@@ -0,0 +1,11 @@
+namespace rerun.blueprint.components;
+
+/// Space between grid lines of one line to the next in scene units.
+table GridSpacing (
+    "attr.python.aliases": "float",
+    "attr.python.array_aliases": "npt.ArrayLike",
+    "attr.rerun.scope": "blueprint"
+) {
+    /// Space between grid lines of one line to the next in scene units.
+    distance: rerun.datatypes.Float32 (order: 100);
+}

crates/store/re_types/definitions/rerun/blueprint/views/spatial3d.fbs

@@ -9,6 +9,9 @@ table Spatial3DView (
     /// Configuration for the background of the view.
     background: rerun.blueprint.archetypes.Background (order: 1000);
 
+    /// Configuration for the 3D line grid.
+    line_grid: rerun.blueprint.archetypes.LineGrid3D (order: 2000);
+
     /// Configures which range on each timeline is shown by this view (unless specified differently per entity).
     ///
     /// If not specified, the default is to show the latest state of each component.

crates/store/re_types/definitions/rerun/components/plane3d.fbs

@@ -0,0 +1,18 @@
+namespace rerun.components;
+
+/// An infinite 3D plane represented by a unit normal vector and a distance.
+///
+/// Any point P on the plane fulfills the equation `dot(xyz, P) - d = 0`,
+/// where `xyz` is the plane's normal and `d` the distance of the plane from the origin.
+/// This representation is also known as the Hesse normal form.
+///
+/// Note: although the normal will be passed through to the
+/// datastore as provided, when used in the Viewer, planes will always be normalized.
+/// I.e. the plane with xyz = (2, 0, 0), d = 1 is equivalent to xyz = (1, 0, 0), d = 0.5
+struct Plane3D (
+  "attr.docs.unreleased",
+  "attr.rust.derive": "Copy, PartialEq, bytemuck::Pod, bytemuck::Zeroable",
+  "attr.rust.repr": "transparent"
+) {
+  xyzd: rerun.datatypes.Plane3D (order: 100);
+}

crates/store/re_types/definitions/rerun/datatypes/plane3d.fbs

@@ -0,0 +1,22 @@
+namespace rerun.datatypes;
+
+/// An infinite 3D plane represented by a unit normal vector and a distance.
+///
+/// Any point P on the plane fulfills the equation `dot(xyz, P) - d = 0`,
+/// where `xyz` is the plane's normal and `d` the distance of the plane from the origin.
+/// This representation is also known as the Hesse normal form.
+///
+/// Note: although the normal will be passed through to the
+/// datastore as provided, when used in the Viewer, planes will always be normalized.
+/// I.e. the plane with xyz = (2, 0, 0), d = 1 is equivalent to xyz = (1, 0, 0), d = 0.5
+struct Plane3D (
+  "attr.docs.unreleased",
+  "attr.arrow.transparent",
+  "attr.python.array_aliases": "npt.NDArray[Any], npt.ArrayLike, Sequence[Sequence[float]]",
+  "attr.rust.derive": "Copy, PartialEq, PartialOrd, bytemuck::Pod, bytemuck::Zeroable",
+  "attr.rust.tuple_struct",
+  "attr.rust.repr": "C",
+  "attr.cpp.no_field_ctors" // Always be explicit about the values of the fields.
+) {
+  xyzd: [float: 4] (order: 100);
+}