#![allow(clippy::too_many_lines)]
#![allow(clippy::wildcard_imports)]
#![allow(unused_imports)]
use crate::blueprint::components::*;
use crate::components::*;
use re_types_core::components::*;
use re_types_core::{
reflection::{
ArchetypeFieldReflection, ArchetypeReflection, ArchetypeReflectionMap, ComponentReflection,
ComponentReflectionMap, Reflection,
},
ArchetypeName, Component, ComponentName, Loggable as _, LoggableBatch as _, SerializationError,
};
pub fn generate_reflection() -> Result<Reflection, SerializationError> {
re_tracing::profile_function!();
Ok(Reflection {
components: generate_component_reflection()?,
archetypes: generate_archetype_reflection(),
})
}
#[allow(deprecated)]
fn generate_component_reflection() -> Result<ComponentReflectionMap, SerializationError> {
re_tracing::profile_function!();
let array = [
(
<ActiveTab as Component>::name(),
ComponentReflection {
docstring_md: "The active tab in a tabbed container.",
custom_placeholder: Some(ActiveTab::default().to_arrow2()?),
datatype: ActiveTab::arrow2_datatype(),
},
),
(
<ApplyLatestAt as Component>::name(),
ComponentReflection {
docstring_md: "Whether empty cells in a dataframe should be filled with a latest-at query.",
custom_placeholder: Some(ApplyLatestAt::default().to_arrow2()?),
datatype: ApplyLatestAt::arrow2_datatype(),
},
),
(
<AutoLayout as Component>::name(),
ComponentReflection {
docstring_md: "Whether the viewport layout is determined automatically.",
custom_placeholder: Some(AutoLayout::default().to_arrow2()?),
datatype: AutoLayout::arrow2_datatype(),
},
),
(
<AutoViews as Component>::name(),
ComponentReflection {
docstring_md: "Whether or not views should be created automatically.",
custom_placeholder: Some(AutoViews::default().to_arrow2()?),
datatype: AutoViews::arrow2_datatype(),
},
),
(
<BackgroundKind as Component>::name(),
ComponentReflection {
docstring_md: "The type of the background in a view.",
custom_placeholder: Some(BackgroundKind::default().to_arrow2()?),
datatype: BackgroundKind::arrow2_datatype(),
},
),
(
<ColumnShare as Component>::name(),
ComponentReflection {
docstring_md: "The layout share of a column in the container.",
custom_placeholder: Some(ColumnShare::default().to_arrow2()?),
datatype: ColumnShare::arrow2_datatype(),
},
),
(
<ComponentColumnSelector as Component>::name(),
ComponentReflection {
docstring_md: "Describe a component column to be selected in the dataframe view.",
custom_placeholder: Some(
ComponentColumnSelector::default().to_arrow2()?,
),
datatype: ComponentColumnSelector::arrow2_datatype(),
},
),
(
<ContainerKind as Component>::name(),
ComponentReflection {
docstring_md: "The kind of a blueprint container (tabs, grid, …).",
custom_placeholder: Some(ContainerKind::default().to_arrow2()?),
datatype: ContainerKind::arrow2_datatype(),
},
),
(
<Corner2D as Component>::name(),
ComponentReflection {
docstring_md: "One of four 2D corners, typically used to align objects.",
custom_placeholder: Some(Corner2D::default().to_arrow2()?),
datatype: Corner2D::arrow2_datatype(),
},
),
(
<Enabled as Component>::name(),
ComponentReflection {
docstring_md: "Whether a procedure is enabled.",
custom_placeholder: Some(Enabled::default().to_arrow2()?),
datatype: Enabled::arrow2_datatype(),
},
),
(
<FilterByRange as Component>::name(),
ComponentReflection {
docstring_md: "Configuration for a filter-by-range feature of the dataframe view.",
custom_placeholder: Some(FilterByRange::default().to_arrow2()?),
datatype: FilterByRange::arrow2_datatype(),
},
),
(
<FilterIsNotNull as Component>::name(),
ComponentReflection {
docstring_md: "Configuration for the filter is not null feature of the dataframe view.",
custom_placeholder: Some(FilterIsNotNull::default().to_arrow2()?),
datatype: FilterIsNotNull::arrow2_datatype(),
},
),
(
<ForceDistance as Component>::name(),
ComponentReflection {
docstring_md: "The target distance between two nodes.\n\nThis is helpful to scale the layout, for example if long labels are involved.",
custom_placeholder: Some(ForceDistance::default().to_arrow2()?),
datatype: ForceDistance::arrow2_datatype(),
},
),
(
<ForceIterations as Component>::name(),
ComponentReflection {
docstring_md: "Specifies how often this force should be applied per iteration.\n\nIncreasing this parameter can lead to better results at the cost of longer computation time.",
custom_placeholder: Some(ForceIterations::default().to_arrow2()?),
datatype: ForceIterations::arrow2_datatype(),
},
),
(
<ForceStrength as Component>::name(),
ComponentReflection {
docstring_md: "The strength of a given force.\n\nAllows to assign different weights to the individual forces, prioritizing one over the other.",
custom_placeholder: Some(ForceStrength::default().to_arrow2()?),
datatype: ForceStrength::arrow2_datatype(),
},
),
(
<GridColumns as Component>::name(),
ComponentReflection {
docstring_md: "How many columns a grid container should have.",
custom_placeholder: Some(GridColumns::default().to_arrow2()?),
datatype: GridColumns::arrow2_datatype(),
},
),
(
<GridSpacing as Component>::name(),
ComponentReflection {
docstring_md: "Space between grid lines of one line to the next in scene units.",
custom_placeholder: Some(GridSpacing::default().to_arrow2()?),
datatype: GridSpacing::arrow2_datatype(),
},
),
(
<IncludedContent as Component>::name(),
ComponentReflection {
docstring_md: "All the contents in the container.",
custom_placeholder: Some(IncludedContent::default().to_arrow2()?),
datatype: IncludedContent::arrow2_datatype(),
},
),
(
<Interactive as Component>::name(),
ComponentReflection {
docstring_md: "Whether the entity can be interacted with.\n\nNon interactive components are still visible, but mouse interactions in the view are disabled.",
custom_placeholder: Some(Interactive::default().to_arrow2()?),
datatype: Interactive::arrow2_datatype(),
},
),
(
<LockRangeDuringZoom as Component>::name(),
ComponentReflection {
docstring_md: "Indicate whether the range should be locked when zooming in on the data.\n\nDefault is `false`, i.e. zoom will change the visualized range.",
custom_placeholder: Some(LockRangeDuringZoom::default().to_arrow2()?),
datatype: LockRangeDuringZoom::arrow2_datatype(),
},
),
(
<MapProvider as Component>::name(),
ComponentReflection {
docstring_md: "Name of the map provider to be used in Map views.",
custom_placeholder: Some(MapProvider::default().to_arrow2()?),
datatype: MapProvider::arrow2_datatype(),
},
),
(
<NearClipPlane as Component>::name(),
ComponentReflection {
docstring_md: "Distance to the near clip plane used for `Spatial2DView`.",
custom_placeholder: Some(NearClipPlane::default().to_arrow2()?),
datatype: NearClipPlane::arrow2_datatype(),
},
),
(
<PanelState as Component>::name(),
ComponentReflection {
docstring_md: "Tri-state for panel controls.",
custom_placeholder: Some(PanelState::default().to_arrow2()?),
datatype: PanelState::arrow2_datatype(),
},
),
(
<QueryExpression as Component>::name(),
ComponentReflection {
docstring_md: "An individual query expression used to filter a set of [`datatypes.EntityPath`](https://rerun.io/docs/reference/types/datatypes/entity_path)s.\n\nEach expression is either an inclusion or an exclusion expression.\nInclusions start with an optional `+` and exclusions must start with a `-`.\n\nMultiple expressions are combined together as part of archetypes.ViewContents.\n\nThe `/**` suffix matches the whole subtree, i.e. self and any child, recursively\n(`/world/**` matches both `/world` and `/world/car/driver`).\nOther uses of `*` are not (yet) supported.",
custom_placeholder: Some(QueryExpression::default().to_arrow2()?),
datatype: QueryExpression::arrow2_datatype(),
},
),
(
<RootContainer as Component>::name(),
ComponentReflection {
docstring_md: "The container that sits at the root of a viewport.",
custom_placeholder: Some(RootContainer::default().to_arrow2()?),
datatype: RootContainer::arrow2_datatype(),
},
),
(
<RowShare as Component>::name(),
ComponentReflection {
docstring_md: "The layout share of a row in the container.",
custom_placeholder: Some(RowShare::default().to_arrow2()?),
datatype: RowShare::arrow2_datatype(),
},
),
(
<SelectedColumns as Component>::name(),
ComponentReflection {
docstring_md: "Describe a component column to be selected in the dataframe view.",
custom_placeholder: Some(SelectedColumns::default().to_arrow2()?),
datatype: SelectedColumns::arrow2_datatype(),
},
),
(
<TensorDimensionIndexSlider as Component>::name(),
ComponentReflection {
docstring_md: "Show a slider for the index of some dimension of a slider.",
custom_placeholder: Some(
TensorDimensionIndexSlider::default().to_arrow2()?,
),
datatype: TensorDimensionIndexSlider::arrow2_datatype(),
},
),
(
<TimelineName as Component>::name(),
ComponentReflection {
docstring_md: "A timeline identified by its name.",
custom_placeholder: Some(TimelineName::default().to_arrow2()?),
datatype: TimelineName::arrow2_datatype(),
},
),
(
<ViewClass as Component>::name(),
ComponentReflection {
docstring_md: "The class identifier of view, e.g. `\"2D\"`, `\"TextLog\"`, ….",
custom_placeholder: Some(ViewClass::default().to_arrow2()?),
datatype: ViewClass::arrow2_datatype(),
},
),
(
<ViewFit as Component>::name(),
ComponentReflection {
docstring_md: "Determines whether an image or texture should be scaled to fit the viewport.",
custom_placeholder: Some(ViewFit::default().to_arrow2()?),
datatype: ViewFit::arrow2_datatype(),
},
),
(
<ViewMaximized as Component>::name(),
ComponentReflection {
docstring_md: "Whether a view is maximized.",
custom_placeholder: Some(ViewMaximized::default().to_arrow2()?),
datatype: ViewMaximized::arrow2_datatype(),
},
),
(
<ViewOrigin as Component>::name(),
ComponentReflection {
docstring_md: "The origin of a view.",
custom_placeholder: Some(ViewOrigin::default().to_arrow2()?),
datatype: ViewOrigin::arrow2_datatype(),
},
),
(
<ViewerRecommendationHash as Component>::name(),
ComponentReflection {
docstring_md: "Hash of a viewer recommendation.\n\nThe formation of this hash is considered an internal implementation detail of the viewer.",
custom_placeholder: Some(
ViewerRecommendationHash::default().to_arrow2()?,
),
datatype: ViewerRecommendationHash::arrow2_datatype(),
},
),
(
<Visible as Component>::name(),
ComponentReflection {
docstring_md: "Whether the container, view, entity or instance is currently visible.",
custom_placeholder: Some(Visible::default().to_arrow2()?),
datatype: Visible::arrow2_datatype(),
},
),
(
<VisibleTimeRange as Component>::name(),
ComponentReflection {
docstring_md: "The range of values on a given timeline that will be included in a view's query.\n\nRefer to `VisibleTimeRanges` archetype for more information.",
custom_placeholder: Some(VisibleTimeRange::default().to_arrow2()?),
datatype: VisibleTimeRange::arrow2_datatype(),
},
),
(
<VisualBounds2D as Component>::name(),
ComponentReflection {
docstring_md: "Visual bounds in 2D space used for `Spatial2DView`.",
custom_placeholder: Some(VisualBounds2D::default().to_arrow2()?),
datatype: VisualBounds2D::arrow2_datatype(),
},
),
(
<VisualizerOverrides as Component>::name(),
ComponentReflection {
docstring_md: "Override the visualizers for an entity.\n\nThis component is a stop-gap mechanism based on the current implementation details\nof the visualizer system. It is not intended to be a long-term solution, but provides\nenough utility to be useful in the short term.\n\nThe long-term solution is likely to be based off: <https://github.com/rerun-io/rerun/issues/6626>\n\nThis can only be used as part of blueprints. It will have no effect if used\nin a regular entity.",
custom_placeholder: Some(VisualizerOverrides::default().to_arrow2()?),
datatype: VisualizerOverrides::arrow2_datatype(),
},
),
(
<ZoomLevel as Component>::name(),
ComponentReflection {
docstring_md: "A zoom level determines how much of the world is visible on a map.",
custom_placeholder: Some(ZoomLevel::default().to_arrow2()?),
datatype: ZoomLevel::arrow2_datatype(),
},
),
(
<AggregationPolicy as Component>::name(),
ComponentReflection {
docstring_md: "Policy for aggregation of multiple scalar plot values.\n\nThis is used for lines in plots when the X axis distance of individual points goes below a single pixel,\ni.e. a single pixel covers more than one tick worth of data. It can greatly improve performance\n(and readability) in such situations as it prevents overdraw.",
custom_placeholder: Some(AggregationPolicy::default().to_arrow2()?),
datatype: AggregationPolicy::arrow2_datatype(),
},
),
(
<AlbedoFactor as Component>::name(),
ComponentReflection {
docstring_md: "A color multiplier, usually applied to a whole entity, e.g. a mesh.",
custom_placeholder: Some(AlbedoFactor::default().to_arrow2()?),
datatype: AlbedoFactor::arrow2_datatype(),
},
),
(
<AnnotationContext as Component>::name(),
ComponentReflection {
docstring_md: "The annotation context provides additional information on how to display entities.\n\nEntities can use [`datatypes.ClassId`](https://rerun.io/docs/reference/types/datatypes/class_id)s and [`datatypes.KeypointId`](https://rerun.io/docs/reference/types/datatypes/keypoint_id)s to provide annotations, and\nthe labels and colors will be looked up in the appropriate\nannotation context. We use the *first* annotation context we find in the\npath-hierarchy when searching up through the ancestors of a given entity\npath.",
custom_placeholder: Some(AnnotationContext::default().to_arrow2()?),
datatype: AnnotationContext::arrow2_datatype(),
},
),
(
<AxisLength as Component>::name(),
ComponentReflection {
docstring_md: "The length of an axis in local units of the space.",
custom_placeholder: Some(AxisLength::default().to_arrow2()?),
datatype: AxisLength::arrow2_datatype(),
},
),
(
<Blob as Component>::name(),
ComponentReflection {
docstring_md: "A binary blob of data.",
custom_placeholder: None,
datatype: Blob::arrow2_datatype(),
},
),
(
<ClassId as Component>::name(),
ComponentReflection {
docstring_md: "A 16-bit ID representing a type of semantic class.",
custom_placeholder: Some(ClassId::default().to_arrow2()?),
datatype: ClassId::arrow2_datatype(),
},
),
(
<ClearIsRecursive as Component>::name(),
ComponentReflection {
docstring_md: "Configures how a clear operation should behave - recursive or not.",
custom_placeholder: Some(ClearIsRecursive::default().to_arrow2()?),
datatype: ClearIsRecursive::arrow2_datatype(),
},
),
(
<Color as Component>::name(),
ComponentReflection {
docstring_md: "An RGBA color with unmultiplied/separate alpha, in sRGB gamma space with linear alpha.\n\nThe color is stored as a 32-bit integer, where the most significant\nbyte is `R` and the least significant byte is `A`.",
custom_placeholder: Some(Color::default().to_arrow2()?),
datatype: Color::arrow2_datatype(),
},
),
(
<Colormap as Component>::name(),
ComponentReflection {
docstring_md: "Colormap for mapping scalar values within a given range to a color.\n\nThis provides a number of popular pre-defined colormaps.\nIn the future, the Rerun Viewer will allow users to define their own colormaps,\nbut currently the Viewer is limited to the types defined here.",
custom_placeholder: Some(Colormap::default().to_arrow2()?),
datatype: Colormap::arrow2_datatype(),
},
),
(
<DepthMeter as Component>::name(),
ComponentReflection {
docstring_md: "The world->depth map scaling factor.\n\nThis measures how many depth map units are in a world unit.\nFor instance, if a depth map uses millimeters and the world uses meters,\nthis value would be `1000`.\n\nNote that the only effect on 2D views is the physical depth values shown when hovering the image.\nIn 3D views on the other hand, this affects where the points of the point cloud are placed.",
custom_placeholder: Some(DepthMeter::default().to_arrow2()?),
datatype: DepthMeter::arrow2_datatype(),
},
),
(
<DisconnectedSpace as Component>::name(),
ComponentReflection {
docstring_md: "Spatially disconnect this entity from its parent.\n\nSpecifies that the entity path at which this is logged is spatially disconnected from its parent,\nmaking it impossible to transform the entity path into its parent's space and vice versa.\nIt *only* applies to views that work with spatial transformations, i.e. 2D & 3D views.\nThis is useful for specifying that a subgraph is independent of the rest of the scene.",
custom_placeholder: Some(DisconnectedSpace::default().to_arrow2()?),
datatype: DisconnectedSpace::arrow2_datatype(),
},
),
(
<DrawOrder as Component>::name(),
ComponentReflection {
docstring_md: "Draw order of 2D elements. Higher values are drawn on top of lower values.\n\nAn entity can have only a single draw order component.\nWithin an entity draw order is governed by the order of the components.\n\nDraw order for entities with the same draw order is generally undefined.",
custom_placeholder: Some(DrawOrder::default().to_arrow2()?),
datatype: DrawOrder::arrow2_datatype(),
},
),
(
<EntityPath as Component>::name(),
ComponentReflection {
docstring_md: "A path to an entity, usually to reference some data that is part of the target entity.",
custom_placeholder: Some(EntityPath::default().to_arrow2()?),
datatype: EntityPath::arrow2_datatype(),
},
),
(
<FillMode as Component>::name(),
ComponentReflection {
docstring_md: "How a geometric shape is drawn and colored.",
custom_placeholder: Some(FillMode::default().to_arrow2()?),
datatype: FillMode::arrow2_datatype(),
},
),
(
<FillRatio as Component>::name(),
ComponentReflection {
docstring_md: "How much a primitive fills out the available space.\n\nUsed for instance to scale the points of the point cloud created from [`archetypes.DepthImage`](https://rerun.io/docs/reference/types/archetypes/depth_image) projection in 3D views.\nValid range is from 0 to max float although typically values above 1.0 are not useful.\n\nDefaults to 1.0.",
custom_placeholder: Some(FillRatio::default().to_arrow2()?),
datatype: FillRatio::arrow2_datatype(),
},
),
(
<GammaCorrection as Component>::name(),
ComponentReflection {
docstring_md: "A gamma correction value to be used with a scalar value or color.\n\nUsed to adjust the gamma of a color or scalar value between 0 and 1 before rendering.\n`new_value = old_value ^ gamma`\n\nValid range is from 0 (excluding) to max float.\nDefaults to 1.0 unless otherwise specified.",
custom_placeholder: Some(GammaCorrection::default().to_arrow2()?),
datatype: GammaCorrection::arrow2_datatype(),
},
),
(
<GeoLineString as Component>::name(),
ComponentReflection {
docstring_md: "A geospatial line string expressed in [EPSG:4326](https://epsg.io/4326) latitude and longitude (North/East-positive degrees).",
custom_placeholder: Some(GeoLineString::default().to_arrow2()?),
datatype: GeoLineString::arrow2_datatype(),
},
),
(
<GraphEdge as Component>::name(),
ComponentReflection {
docstring_md: "An edge in a graph connecting two nodes.",
custom_placeholder: Some(GraphEdge::default().to_arrow2()?),
datatype: GraphEdge::arrow2_datatype(),
},
),
(
<GraphNode as Component>::name(),
ComponentReflection {
docstring_md: "A string-based ID representing a node in a graph.",
custom_placeholder: Some(GraphNode::default().to_arrow2()?),
datatype: GraphNode::arrow2_datatype(),
},
),
(
<GraphType as Component>::name(),
ComponentReflection {
docstring_md: "Specifies if a graph has directed or undirected edges.",
custom_placeholder: Some(GraphType::default().to_arrow2()?),
datatype: GraphType::arrow2_datatype(),
},
),
(
<HalfSize2D as Component>::name(),
ComponentReflection {
docstring_md: "Half-size (radius) of a 2D box.\n\nMeasured in its local coordinate system.\n\nThe box extends both in negative and positive direction along each axis.\nNegative sizes indicate that the box is flipped along the respective axis, but this has no effect on how it is displayed.",
custom_placeholder: Some(HalfSize2D::default().to_arrow2()?),
datatype: HalfSize2D::arrow2_datatype(),
},
),
(
<HalfSize3D as Component>::name(),
ComponentReflection {
docstring_md: "Half-size (radius) of a 3D box.\n\nMeasured in its local coordinate system.\n\nThe box extends both in negative and positive direction along each axis.\nNegative sizes indicate that the box is flipped along the respective axis, but this has no effect on how it is displayed.",
custom_placeholder: Some(HalfSize3D::default().to_arrow2()?),
datatype: HalfSize3D::arrow2_datatype(),
},
),
(
<ImageBuffer as Component>::name(),
ComponentReflection {
docstring_md: "A buffer that is known to store image data.\n\nTo interpret the contents of this buffer, see, [`components.ImageFormat`](https://rerun.io/docs/reference/types/components/image_format).",
custom_placeholder: None,
datatype: ImageBuffer::arrow2_datatype(),
},
),
(
<ImageFormat as Component>::name(),
ComponentReflection {
docstring_md: "The metadata describing the contents of a [`components.ImageBuffer`](https://rerun.io/docs/reference/types/components/image_buffer).",
custom_placeholder: Some(ImageFormat::default().to_arrow2()?),
datatype: ImageFormat::arrow2_datatype(),
},
),
(
<ImagePlaneDistance as Component>::name(),
ComponentReflection {
docstring_md: "The distance from the camera origin to the image plane when the projection is shown in a 3D viewer.\n\nThis is only used for visualization purposes, and does not affect the projection itself.",
custom_placeholder: Some(ImagePlaneDistance::default().to_arrow2()?),
datatype: ImagePlaneDistance::arrow2_datatype(),
},
),
(
<KeypointId as Component>::name(),
ComponentReflection {
docstring_md: "A 16-bit ID representing a type of semantic keypoint within a class.",
custom_placeholder: Some(KeypointId::default().to_arrow2()?),
datatype: KeypointId::arrow2_datatype(),
},
),
(
<LatLon as Component>::name(),
ComponentReflection {
docstring_md: "A geospatial position expressed in [EPSG:4326](https://epsg.io/4326) latitude and longitude (North/East-positive degrees).",
custom_placeholder: Some(LatLon::default().to_arrow2()?),
datatype: LatLon::arrow2_datatype(),
},
),
(
<Length as Component>::name(),
ComponentReflection {
docstring_md: "Length, or one-dimensional size.\n\nMeasured in its local coordinate system; consult the archetype in use to determine which\naxis or part of the entity this is the length of.",
custom_placeholder: Some(Length::default().to_arrow2()?),
datatype: Length::arrow2_datatype(),
},
),
(
<LineStrip2D as Component>::name(),
ComponentReflection {
docstring_md: "A line strip in 2D space.\n\nA line strip is a list of points connected by line segments. It can be used to draw\napproximations of smooth curves.\n\nThe points will be connected in order, like so:\n```text\n 2------3 5\n / \\ /\n0----1 \\ /\n 4\n```",
custom_placeholder: Some(LineStrip2D::default().to_arrow2()?),
datatype: LineStrip2D::arrow2_datatype(),
},
),
(
<LineStrip3D as Component>::name(),
ComponentReflection {
docstring_md: "A line strip in 3D space.\n\nA line strip is a list of points connected by line segments. It can be used to draw\napproximations of smooth curves.\n\nThe points will be connected in order, like so:\n```text\n 2------3 5\n / \\ /\n0----1 \\ /\n 4\n```",
custom_placeholder: Some(LineStrip3D::default().to_arrow2()?),
datatype: LineStrip3D::arrow2_datatype(),
},
),
(
<MagnificationFilter as Component>::name(),
ComponentReflection {
docstring_md: "Filter used when magnifying an image/texture such that a single pixel/texel is displayed as multiple pixels on screen.",
custom_placeholder: Some(MagnificationFilter::default().to_arrow2()?),
datatype: MagnificationFilter::arrow2_datatype(),
},
),
(
<MarkerShape as Component>::name(),
ComponentReflection {
docstring_md: "The visual appearance of a point in e.g. a 2D plot.",
custom_placeholder: Some(MarkerShape::default().to_arrow2()?),
datatype: MarkerShape::arrow2_datatype(),
},
),
(
<MarkerSize as Component>::name(),
ComponentReflection {
docstring_md: "Radius of a marker of a point in e.g. a 2D plot, measured in UI points.",
custom_placeholder: Some(MarkerSize::default().to_arrow2()?),
datatype: MarkerSize::arrow2_datatype(),
},
),
(
<MediaType as Component>::name(),
ComponentReflection {
docstring_md: "A standardized media type (RFC2046, formerly known as MIME types), encoded as a string.\n\nThe complete reference of officially registered media types is maintained by the IANA and can be\nconsulted at <https://www.iana.org/assignments/media-types/media-types.xhtml>.",
custom_placeholder: Some(MediaType::default().to_arrow2()?),
datatype: MediaType::arrow2_datatype(),
},
),
(
<Name as Component>::name(),
ComponentReflection {
docstring_md: "A display name, typically for an entity or a item like a plot series.",
custom_placeholder: Some(Name::default().to_arrow2()?),
datatype: Name::arrow2_datatype(),
},
),
(
<Opacity as Component>::name(),
ComponentReflection {
docstring_md: "Degree of transparency ranging from 0.0 (fully transparent) to 1.0 (fully opaque).\n\nThe final opacity value may be a result of multiplication with alpha values as specified by other color sources.\nUnless otherwise specified, the default value is 1.",
custom_placeholder: Some(Opacity::default().to_arrow2()?),
datatype: Opacity::arrow2_datatype(),
},
),
(
<PinholeProjection as Component>::name(),
ComponentReflection {
docstring_md: "Camera projection, from image coordinates to view coordinates.\n\nChild from parent.\nImage coordinates from camera view coordinates.\n\nExample:\n```text\n1496.1 0.0 980.5\n 0.0 1496.1 744.5\n 0.0 0.0 1.0\n```",
custom_placeholder: Some(PinholeProjection::default().to_arrow2()?),
datatype: PinholeProjection::arrow2_datatype(),
},
),
(
<Plane3D as Component>::name(),
ComponentReflection {
docstring_md: "An infinite 3D plane represented by a unit normal vector and a distance.\n\nAny point P on the plane fulfills the equation `dot(xyz, P) - d = 0`,\nwhere `xyz` is the plane's normal and `d` the distance of the plane from the origin.\nThis representation is also known as the Hesse normal form.\n\nNote: although the normal will be passed through to the\ndatastore as provided, when used in the Viewer, planes will always be normalized.\nI.e. the plane with xyz = (2, 0, 0), d = 1 is equivalent to xyz = (1, 0, 0), d = 0.5",
custom_placeholder: None,
datatype: Plane3D::arrow2_datatype(),
},
),
(
<PoseRotationAxisAngle as Component>::name(),
ComponentReflection {
docstring_md: "3D rotation represented by a rotation around a given axis that doesn't propagate in the transform hierarchy.\n\nIf normalization of the rotation axis fails the rotation is treated as an invalid transform.",
custom_placeholder: Some(PoseRotationAxisAngle::default().to_arrow2()?),
datatype: PoseRotationAxisAngle::arrow2_datatype(),
},
),
(
<PoseRotationQuat as Component>::name(),
ComponentReflection {
docstring_md: "A 3D rotation expressed as a quaternion that doesn't propagate in the transform hierarchy.\n\nNote: although the x,y,z,w components of the quaternion will be passed through to the\ndatastore as provided, when used in the Viewer, quaternions will always be normalized.\nIf normalization fails the rotation is treated as an invalid transform.",
custom_placeholder: Some(PoseRotationQuat::default().to_arrow2()?),
datatype: PoseRotationQuat::arrow2_datatype(),
},
),
(
<PoseScale3D as Component>::name(),
ComponentReflection {
docstring_md: "A 3D scale factor that doesn't propagate in the transform hierarchy.\n\nA scale of 1.0 means no scaling.\nA scale of 2.0 means doubling the size.\nEach component scales along the corresponding axis.",
custom_placeholder: Some(PoseScale3D::default().to_arrow2()?),
datatype: PoseScale3D::arrow2_datatype(),
},
),
(
<PoseTransformMat3x3 as Component>::name(),
ComponentReflection {
docstring_md: "A 3x3 transformation matrix Matrix that doesn't propagate in the transform hierarchy.\n\n3x3 matrixes are able to represent any affine transformation in 3D space,\ni.e. rotation, scaling, shearing, reflection etc.\n\nMatrices in Rerun are stored as flat list of coefficients in column-major order:\n```text\n column 0 column 1 column 2\n -------------------------------------------------\nrow 0 | flat_columns[0] flat_columns[3] flat_columns[6]\nrow 1 | flat_columns[1] flat_columns[4] flat_columns[7]\nrow 2 | flat_columns[2] flat_columns[5] flat_columns[8]\n```",
custom_placeholder: Some(PoseTransformMat3x3::default().to_arrow2()?),
datatype: PoseTransformMat3x3::arrow2_datatype(),
},
),
(
<PoseTranslation3D as Component>::name(),
ComponentReflection {
docstring_md: "A translation vector in 3D space that doesn't propagate in the transform hierarchy.",
custom_placeholder: Some(PoseTranslation3D::default().to_arrow2()?),
datatype: PoseTranslation3D::arrow2_datatype(),
},
),
(
<Position2D as Component>::name(),
ComponentReflection {
docstring_md: "A position in 2D space.",
custom_placeholder: Some(Position2D::default().to_arrow2()?),
datatype: Position2D::arrow2_datatype(),
},
),
(
<Position3D as Component>::name(),
ComponentReflection {
docstring_md: "A position in 3D space.",
custom_placeholder: Some(Position3D::default().to_arrow2()?),
datatype: Position3D::arrow2_datatype(),
},
),
(
<Radius as Component>::name(),
ComponentReflection {
docstring_md: "The radius of something, e.g. a point.\n\nInternally, positive values indicate scene units, whereas negative values\nare interpreted as UI points.\n\nUI points are independent of zooming in Views, but are sensitive to the application UI scaling.\nat 100% UI scaling, UI points are equal to pixels\nThe Viewer's UI scaling defaults to the OS scaling which typically is 100% for full HD screens and 200% for 4k screens.",
custom_placeholder: Some(Radius::default().to_arrow2()?),
datatype: Radius::arrow2_datatype(),
},
),
(
<Range1D as Component>::name(),
ComponentReflection {
docstring_md: "A 1D range, specifying a lower and upper bound.",
custom_placeholder: Some(Range1D::default().to_arrow2()?),
datatype: Range1D::arrow2_datatype(),
},
),
(
<RecordingUri as Component>::name(),
ComponentReflection {
docstring_md: "A recording URI (Uniform Resource Identifier).",
custom_placeholder: None,
datatype: RecordingUri::arrow2_datatype(),
},
),
(
<Resolution as Component>::name(),
ComponentReflection {
docstring_md: "Pixel resolution width & height, e.g. of a camera sensor.\n\nTypically in integer units, but for some use cases floating point may be used.",
custom_placeholder: Some(Resolution::default().to_arrow2()?),
datatype: Resolution::arrow2_datatype(),
},
),
(
<RotationAxisAngle as Component>::name(),
ComponentReflection {
docstring_md: "3D rotation represented by a rotation around a given axis.\n\nIf normalization of the rotation axis fails the rotation is treated as an invalid transform.",
custom_placeholder: Some(RotationAxisAngle::default().to_arrow2()?),
datatype: RotationAxisAngle::arrow2_datatype(),
},
),
(
<RotationQuat as Component>::name(),
ComponentReflection {
docstring_md: "A 3D rotation expressed as a quaternion.\n\nNote: although the x,y,z,w components of the quaternion will be passed through to the\ndatastore as provided, when used in the Viewer, quaternions will always be normalized.\nIf normalization fails the rotation is treated as an invalid transform.",
custom_placeholder: Some(RotationQuat::default().to_arrow2()?),
datatype: RotationQuat::arrow2_datatype(),
},
),
(
<Scalar as Component>::name(),
ComponentReflection {
docstring_md: "A scalar value, encoded as a 64-bit floating point.\n\nUsed for time series plots.",
custom_placeholder: Some(Scalar::default().to_arrow2()?),
datatype: Scalar::arrow2_datatype(),
},
),
(
<Scale3D as Component>::name(),
ComponentReflection {
docstring_md: "A 3D scale factor.\n\nA scale of 1.0 means no scaling.\nA scale of 2.0 means doubling the size.\nEach component scales along the corresponding axis.",
custom_placeholder: Some(Scale3D::default().to_arrow2()?),
datatype: Scale3D::arrow2_datatype(),
},
),
(
<ShowLabels as Component>::name(),
ComponentReflection {
docstring_md: "Whether the entity's [`components.Text`](https://rerun.io/docs/reference/types/components/text) label is shown.\n\nThe main purpose of this component existing separately from the labels themselves\nis to be overridden when desired, to allow hiding and showing from the viewer and\nblueprints.",
custom_placeholder: None,
datatype: ShowLabels::arrow2_datatype(),
},
),
(
<StrokeWidth as Component>::name(),
ComponentReflection {
docstring_md: "The width of a stroke specified in UI points.",
custom_placeholder: Some(StrokeWidth::default().to_arrow2()?),
datatype: StrokeWidth::arrow2_datatype(),
},
),
(
<TensorData as Component>::name(),
ComponentReflection {
docstring_md: "An N-dimensional array of numbers.\n\nThe number of dimensions and their respective lengths is specified by the `shape` field.\nThe dimensions are ordered from outermost to innermost. For example, in the common case of\na 2D RGB Image, the shape would be `[height, width, channel]`.\n\nThese dimensions are combined with an index to look up values from the `buffer` field,\nwhich stores a contiguous array of typed values.",
custom_placeholder: Some(TensorData::default().to_arrow2()?),
datatype: TensorData::arrow2_datatype(),
},
),
(
<TensorDimensionIndexSelection as Component>::name(),
ComponentReflection {
docstring_md: "Specifies a concrete index on a tensor dimension.",
custom_placeholder: Some(
TensorDimensionIndexSelection::default().to_arrow2()?,
),
datatype: TensorDimensionIndexSelection::arrow2_datatype(),
},
),
(
<TensorHeightDimension as Component>::name(),
ComponentReflection {
docstring_md: "Specifies which dimension to use for height.",
custom_placeholder: Some(TensorHeightDimension::default().to_arrow2()?),
datatype: TensorHeightDimension::arrow2_datatype(),
},
),
(
<TensorWidthDimension as Component>::name(),
ComponentReflection {
docstring_md: "Specifies which dimension to use for width.",
custom_placeholder: Some(TensorWidthDimension::default().to_arrow2()?),
datatype: TensorWidthDimension::arrow2_datatype(),
},
),
(
<Texcoord2D as Component>::name(),
ComponentReflection {
docstring_md: "A 2D texture UV coordinate.\n\nTexture coordinates specify a position on a 2D texture.\nA range from 0-1 covers the entire texture in the respective dimension.\nUnless configured otherwise, the texture repeats outside of this range.\nRerun uses top-left as the origin for UV coordinates.\n\n 0 U 1\n0 + --------- →\n | .\nV | .\n | .\n1 ↓ . . . . . .\n\nThis is the same convention as in Vulkan/Metal/DX12/WebGPU, but (!) unlike OpenGL,\nwhich places the origin at the bottom-left.",
custom_placeholder: Some(Texcoord2D::default().to_arrow2()?),
datatype: Texcoord2D::arrow2_datatype(),
},
),
(
<Text as Component>::name(),
ComponentReflection {
docstring_md: "A string of text, e.g. for labels and text documents.",
custom_placeholder: Some(Text::default().to_arrow2()?),
datatype: Text::arrow2_datatype(),
},
),
(
<TextLogLevel as Component>::name(),
ComponentReflection {
docstring_md: "The severity level of a text log message.\n\nRecommended to be one of:\n* `\"CRITICAL\"`\n* `\"ERROR\"`\n* `\"WARN\"`\n* `\"INFO\"`\n* `\"DEBUG\"`\n* `\"TRACE\"`",
custom_placeholder: Some(TextLogLevel::default().to_arrow2()?),
datatype: TextLogLevel::arrow2_datatype(),
},
),
(
<TransformMat3x3 as Component>::name(),
ComponentReflection {
docstring_md: "A 3x3 transformation matrix Matrix.\n\n3x3 matrixes are able to represent any affine transformation in 3D space,\ni.e. rotation, scaling, shearing, reflection etc.\n\nMatrices in Rerun are stored as flat list of coefficients in column-major order:\n```text\n column 0 column 1 column 2\n -------------------------------------------------\nrow 0 | flat_columns[0] flat_columns[3] flat_columns[6]\nrow 1 | flat_columns[1] flat_columns[4] flat_columns[7]\nrow 2 | flat_columns[2] flat_columns[5] flat_columns[8]\n```",
custom_placeholder: Some(TransformMat3x3::default().to_arrow2()?),
datatype: TransformMat3x3::arrow2_datatype(),
},
),
(
<TransformRelation as Component>::name(),
ComponentReflection {
docstring_md: "Specifies relation a spatial transform describes.",
custom_placeholder: Some(TransformRelation::default().to_arrow2()?),
datatype: TransformRelation::arrow2_datatype(),
},
),
(
<Translation3D as Component>::name(),
ComponentReflection {
docstring_md: "A translation vector in 3D space.",
custom_placeholder: Some(Translation3D::default().to_arrow2()?),
datatype: Translation3D::arrow2_datatype(),
},
),
(
<TriangleIndices as Component>::name(),
ComponentReflection {
docstring_md: "The three indices of a triangle in a triangle mesh.",
custom_placeholder: Some(TriangleIndices::default().to_arrow2()?),
datatype: TriangleIndices::arrow2_datatype(),
},
),
(
<ValueRange as Component>::name(),
ComponentReflection {
docstring_md: "Range of expected or valid values, specifying a lower and upper bound.",
custom_placeholder: Some(ValueRange::default().to_arrow2()?),
datatype: ValueRange::arrow2_datatype(),
},
),
(
<Vector2D as Component>::name(),
ComponentReflection {
docstring_md: "A vector in 2D space.",
custom_placeholder: Some(Vector2D::default().to_arrow2()?),
datatype: Vector2D::arrow2_datatype(),
},
),
(
<Vector3D as Component>::name(),
ComponentReflection {
docstring_md: "A vector in 3D space.",
custom_placeholder: Some(Vector3D::default().to_arrow2()?),
datatype: Vector3D::arrow2_datatype(),
},
),
(
<VideoTimestamp as Component>::name(),
ComponentReflection {
docstring_md: "Timestamp inside a [`archetypes.AssetVideo`](https://rerun.io/docs/reference/types/archetypes/asset_video).",
custom_placeholder: Some(VideoTimestamp::default().to_arrow2()?),
datatype: VideoTimestamp::arrow2_datatype(),
},
),
(
<ViewCoordinates as Component>::name(),
ComponentReflection {
docstring_md: "How we interpret the coordinate system of an entity/space.\n\nFor instance: What is \"up\"? What does the Z axis mean?\n\nThe three coordinates are always ordered as [x, y, z].\n\nFor example [Right, Down, Forward] means that the X axis points to the right, the Y axis points\ndown, and the Z axis points forward.\n\nâš [Rerun does not yet support left-handed coordinate systems](https://github.com/rerun-io/rerun/issues/5032).\n\nThe following constants are used to represent the different directions:\n * Up = 1\n * Down = 2\n * Right = 3\n * Left = 4\n * Forward = 5\n * Back = 6",
custom_placeholder: Some(ViewCoordinates::default().to_arrow2()?),
datatype: ViewCoordinates::arrow2_datatype(),
},
),
];
Ok(ComponentReflectionMap::from_iter(array))
}
fn generate_archetype_reflection() -> ArchetypeReflectionMap {
re_tracing::profile_function!();
let array = [
(
ArchetypeName::new("rerun.archetypes.AnnotationContext"),
ArchetypeReflection {
display_name: "Annotation context",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { name : "context", display_name :
"Context", component_name : "rerun.components.AnnotationContext"
.into(), docstring_md :
"List of class descriptions, mapping class indices to class names, colors etc.",
is_required : true, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Arrows2D"),
ArchetypeReflection {
display_name: "Arrows 2D",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Arrows3D"),
ArchetypeReflection {
display_name: "Arrows 3D",
scope: None,
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Asset3D"),
ArchetypeReflection {
display_name: "Asset 3D",
scope: None,
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec (if specified).",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.AssetVideo"),
ArchetypeReflection {
display_name: "Asset video",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { name : "blob", display_name : "Blob",
component_name : "rerun.components.Blob".into(), docstring_md :
"The asset's bytes.", is_required : true, }, ArchetypeFieldReflection
{ name : "media_type", display_name : "Media type", component_name :
"rerun.components.MediaType".into(), docstring_md :
"The Media Type of the asset.\n\nSupported values:\n* `video/mp4`\n\nIf omitted, the viewer will try to guess from the data blob.\nIf it cannot guess, it won't be able to render the asset.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.BarChart"),
ArchetypeReflection {
display_name: "Bar chart",
scope: None,
view_types: &["BarChartView"],
fields: vec![
ArchetypeFieldReflection { name : "values", display_name : "Values",
component_name : "rerun.components.TensorData".into(), docstring_md :
"The values. Should always be a 1-dimensional tensor (i.e. a vector).",
is_required : true, }, ArchetypeFieldReflection { name : "color",
display_name : "Color", component_name : "rerun.components.Color"
.into(), docstring_md : "The color of the bar chart", is_required :
false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Boxes2D"),
ArchetypeReflection {
display_name: "Boxes 2D",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vecs for the boxes.\n\nThe [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Boxes3D"),
ArchetypeReflection {
display_name: "Boxes 3D",
scope: None,
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { name :
"rotation_axis_angles", display_name : "Rotation axis angles",
component_name : "rerun.components.PoseRotationAxisAngle".into(),
docstring_md :
"Rotations via axis + angle.\n\nIf no rotation is specified, the axes of the boxes align with the axes of the local coordinate system.\nNote that this uses a [`components.PoseRotationAxisAngle`](https://rerun.io/docs/reference/types/components/pose_rotation_axis_angle) which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { name :
"quaternions", display_name : "Quaternions", component_name :
"rerun.components.PoseRotationQuat".into(), docstring_md :
"Rotations via quaternion.\n\nIf no rotation is specified, the axes of the boxes align with the axes of the local coordinate system.\nNote that this uses a [`components.PoseRotationQuat`](https://rerun.io/docs/reference/types/components/pose_rotation_quat) which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { name : "colors",
display_name : "Colors", component_name : "rerun.components.Color"
.into(), docstring_md : "Optional colors for the boxes.", is_required
: false, }, ArchetypeFieldReflection { name : "radii", display_name :
"Radii", component_name : "rerun.components.Radius".into(),
docstring_md :
"Optional radii for the lines that make up the boxes.", is_required :
false, }, ArchetypeFieldReflection { name : "fill_mode", display_name
: "Fill mode", component_name : "rerun.components.FillMode".into(),
docstring_md :
"Optionally choose whether the boxes are drawn with lines or solid.",
is_required : false, }, ArchetypeFieldReflection { name : "labels",
display_name : "Labels", component_name : "rerun.components.Text"
.into(), docstring_md :
"Optional text labels for the boxes.\n\nIf there's a single label present, it will be placed at the center of the entity.\nOtherwise, each instance will have its own label.",
is_required : false, }, ArchetypeFieldReflection { name :
"show_labels", display_name : "Show labels", component_name :
"rerun.components.ShowLabels".into(), docstring_md :
"Optional choice of whether the text labels should be shown by default.",
is_required : false, }, ArchetypeFieldReflection { name :
"class_ids", display_name : "Class ids", component_name :
"rerun.components.ClassId".into(), docstring_md :
"Optional [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id)s for the boxes.\n\nThe [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Capsules3D"),
ArchetypeReflection {
display_name: "Capsules 3D",
scope: None,
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { name :
"rotation_axis_angles", display_name : "Rotation axis angles",
component_name : "rerun.components.PoseRotationAxisAngle".into(),
docstring_md :
"Rotations via axis + angle.\n\nIf no rotation is specified, the capsules align with the +Z axis of the local coordinate system.\nNote that this uses a [`components.PoseRotationAxisAngle`](https://rerun.io/docs/reference/types/components/pose_rotation_axis_angle) which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { name :
"quaternions", display_name : "Quaternions", component_name :
"rerun.components.PoseRotationQuat".into(), docstring_md :
"Rotations via quaternion.\n\nIf no rotation is specified, the capsules align with the +Z axis of the local coordinate system.\nNote that this uses a [`components.PoseRotationQuat`](https://rerun.io/docs/reference/types/components/pose_rotation_quat) which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { name : "colors",
display_name : "Colors", component_name : "rerun.components.Color"
.into(), docstring_md : "Optional colors for the capsules.",
is_required : false, }, ArchetypeFieldReflection { name : "labels",
display_name : "Labels", component_name : "rerun.components.Text"
.into(), docstring_md :
"Optional text labels for the capsules, which will be located at their centers.",
is_required : false, }, ArchetypeFieldReflection { name :
"show_labels", display_name : "Show labels", component_name :
"rerun.components.ShowLabels".into(), docstring_md :
"Optional choice of whether the text labels should be shown by default.",
is_required : false, }, ArchetypeFieldReflection { name :
"class_ids", display_name : "Class ids", component_name :
"rerun.components.ClassId".into(), docstring_md :
"Optional class ID for the ellipsoids.\n\nThe class ID provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Clear"),
ArchetypeReflection {
display_name: "Clear",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView", "TimeSeriesView"],
fields: vec![
ArchetypeFieldReflection { name : "is_recursive", display_name :
"Is recursive", component_name : "rerun.components.ClearIsRecursive"
.into(), docstring_md : "", is_required : true, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.DepthImage"),
ArchetypeReflection {
display_name: "Depth image",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { name : "buffer", display_name : "Buffer",
component_name : "rerun.components.ImageBuffer".into(), docstring_md
: "The raw depth image data.", is_required : true, },
ArchetypeFieldReflection { name : "format", display_name : "Format",
component_name : "rerun.components.ImageFormat".into(), docstring_md
: "The format of the image.", is_required : true, },
ArchetypeFieldReflection { name : "meter", display_name : "Meter",
component_name : "rerun.components.DepthMeter".into(), docstring_md :
"An optional floating point value that specifies how long a meter is in the native depth units.\n\nFor instance: with uint16, perhaps meter=1000 which would mean you have millimeter precision\nand a range of up to ~65 meters (2^16 / 1000).\n\nNote that the only effect on 2D views is the physical depth values shown when hovering the image.\nIn 3D views on the other hand, this affects where the points of the point cloud are placed.",
is_required : false, }, ArchetypeFieldReflection { name : "colormap",
display_name : "Colormap", component_name :
"rerun.components.Colormap".into(), docstring_md :
"Colormap to use for rendering the depth image.\n\nIf not set, the depth image will be rendered using the Turbo colormap.",
is_required : false, }, ArchetypeFieldReflection { name :
"depth_range", display_name : "Depth range", component_name :
"rerun.components.ValueRange".into(), docstring_md :
"The expected range of depth values.\n\nThis is typically the expected range of valid values.\nEverything outside of the range is clamped to the range for the purpose of colormpaping.\nNote that point clouds generated from this image will still display all points, regardless of this range.\n\nIf not specified, the range will be automatically estimated from the data.\nNote that the Viewer may try to guess a wider range than the minimum/maximum of values\nin the contents of the depth image.\nE.g. if all values are positive, some bigger than 1.0 and all smaller than 255.0,\nthe Viewer will guess that the data likely came from an 8bit image, thus assuming a range of 0-255.",
is_required : false, }, ArchetypeFieldReflection { name :
"point_fill_ratio", display_name : "Point fill ratio", component_name
: "rerun.components.FillRatio".into(), docstring_md :
"Scale the radii of the points in the point cloud generated from this image.\n\nA fill ratio of 1.0 (the default) means that each point is as big as to touch the center of its neighbor\nif it is at the same depth, leaving no gaps.\nA fill ratio of 0.5 means that each point touches the edge of its neighbor if it has the same depth.\n\nTODO(#6744): This applies only to 3D views!",
is_required : false, }, ArchetypeFieldReflection { name :
"draw_order", display_name : "Draw order", component_name :
"rerun.components.DrawOrder".into(), docstring_md :
"An optional floating point value that specifies the 2D drawing order, used only if the depth image is shown as a 2D image.\n\nObjects with higher values are drawn on top of those with lower values.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.DisconnectedSpace"),
ArchetypeReflection {
display_name: "Disconnected space",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { name : "disconnected_space", display_name
: "Disconnected space", component_name :
"rerun.components.DisconnectedSpace".into(), docstring_md :
"Whether the entity path at which this is logged is disconnected from its parent.",
is_required : true, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Ellipsoids3D"),
ArchetypeReflection {
display_name: "Ellipsoids 3D",
scope: None,
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { name :
"rotation_axis_angles", display_name : "Rotation axis angles",
component_name : "rerun.components.PoseRotationAxisAngle".into(),
docstring_md :
"Rotations via axis + angle.\n\nIf no rotation is specified, the axes of the ellipsoid align with the axes of the local coordinate system.\nNote that this uses a [`components.PoseRotationAxisAngle`](https://rerun.io/docs/reference/types/components/pose_rotation_axis_angle) which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { name :
"quaternions", display_name : "Quaternions", component_name :
"rerun.components.PoseRotationQuat".into(), docstring_md :
"Rotations via quaternion.\n\nIf no rotation is specified, the axes of the ellipsoid align with the axes of the local coordinate system.\nNote that this uses a [`components.PoseRotationQuat`](https://rerun.io/docs/reference/types/components/pose_rotation_quat) which is also used by [`archetypes.InstancePoses3D`](https://rerun.io/docs/reference/types/archetypes/instance_poses3d).",
is_required : false, }, ArchetypeFieldReflection { name : "colors",
display_name : "Colors", component_name : "rerun.components.Color"
.into(), docstring_md : "Optional colors for the ellipsoids.",
is_required : false, }, ArchetypeFieldReflection { name :
"line_radii", display_name : "Line radii", component_name :
"rerun.components.Radius".into(), docstring_md :
"Optional radii for the lines used when the ellipsoid is rendered as a wireframe.",
is_required : false, }, ArchetypeFieldReflection { name :
"fill_mode", display_name : "Fill mode", component_name :
"rerun.components.FillMode".into(), docstring_md :
"Optionally choose whether the ellipsoids are drawn with lines or solid.",
is_required : false, }, ArchetypeFieldReflection { name : "labels",
display_name : "Labels", component_name : "rerun.components.Text"
.into(), docstring_md : "Optional text labels for the ellipsoids.",
is_required : false, }, ArchetypeFieldReflection { name :
"show_labels", display_name : "Show labels", component_name :
"rerun.components.ShowLabels".into(), docstring_md :
"Optional choice of whether the text labels should be shown by default.",
is_required : false, }, ArchetypeFieldReflection { name :
"class_ids", display_name : "Class ids", component_name :
"rerun.components.ClassId".into(), docstring_md :
"Optional class ID for the ellipsoids.\n\nThe class ID provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.EncodedImage"),
ArchetypeReflection {
display_name: "Encoded image",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { name : "blob", display_name : "Blob",
component_name : "rerun.components.Blob".into(), docstring_md :
"The encoded content of some image file, e.g. a PNG or JPEG.",
is_required : true, }, ArchetypeFieldReflection { name :
"media_type", display_name : "Media type", component_name :
"rerun.components.MediaType".into(), docstring_md :
"The Media Type of the asset.\n\nSupported values:\n* `image/jpeg`\n* `image/png`\n\nIf omitted, the viewer will try to guess from the data blob.\nIf it cannot guess, it won't be able to render the asset.",
is_required : false, }, ArchetypeFieldReflection { name : "opacity",
display_name : "Opacity", component_name : "rerun.components.Opacity"
.into(), docstring_md :
"Opacity of the image, useful for layering several images.\n\nDefaults to 1.0 (fully opaque).",
is_required : false, }, ArchetypeFieldReflection { name :
"draw_order", display_name : "Draw order", component_name :
"rerun.components.DrawOrder".into(), docstring_md :
"An optional floating point value that specifies the 2D drawing order.\n\nObjects with higher values are drawn on top of those with lower values.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.GeoLineStrings"),
ArchetypeReflection {
display_name: "Geo line strings",
scope: None,
view_types: &["MapView"],
fields: vec coordinates (North/East-positive degrees).",
is_required : true, }, ArchetypeFieldReflection { name : "radii",
display_name : "Radii", component_name : "rerun.components.Radius"
.into(), docstring_md :
"Optional radii for the line strings.\n\n*Note*: scene units radiii are interpreted as meters. Currently, the display scale only considers the latitude of\nthe first vertex of each line string (see [this issue](https://github.com/rerun-io/rerun/issues/8013)).",
is_required : false, }, ArchetypeFieldReflection { name : "colors",
display_name : "Colors", component_name : "rerun.components.Color"
.into(), docstring_md : "Optional colors for the line strings.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.GeoPoints"),
ArchetypeReflection {
display_name: "Geo points",
scope: None,
view_types: &["MapView"],
fields: vec coordinates for the points (North/East-positive degrees).",
is_required : true, }, ArchetypeFieldReflection { name : "radii",
display_name : "Radii", component_name : "rerun.components.Radius"
.into(), docstring_md :
"Optional radii for the points, effectively turning them into circles.\n\n*Note*: scene units radiii are interpreted as meters.",
is_required : false, }, ArchetypeFieldReflection { name : "colors",
display_name : "Colors", component_name : "rerun.components.Color"
.into(), docstring_md : "Optional colors for the points.",
is_required : false, }, ArchetypeFieldReflection { name :
"class_ids", display_name : "Class ids", component_name :
"rerun.components.ClassId".into(), docstring_md :
"Optional class Ids for the points.\n\nThe [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) provides colors if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.GraphEdges"),
ArchetypeReflection {
display_name: "Graph edges",
scope: None,
view_types: &["GraphView"],
fields: vec is provided, the graph is assumed to be undirected.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.GraphNodes"),
ArchetypeReflection {
display_name: "Graph nodes",
scope: None,
view_types: &["GraphView"],
fields: vec![
ArchetypeFieldReflection { name : "node_ids", display_name :
"Node ids", component_name : "rerun.components.GraphNode".into(),
docstring_md : "A list of node IDs.", is_required : true, },
ArchetypeFieldReflection { name : "positions", display_name :
"Positions", component_name : "rerun.components.Position2D".into(),
docstring_md : "Optional center positions of the nodes.", is_required
: false, }, ArchetypeFieldReflection { name : "colors", display_name
: "Colors", component_name : "rerun.components.Color".into(),
docstring_md : "Optional colors for the boxes.", is_required : false,
}, ArchetypeFieldReflection { name : "labels", display_name :
"Labels", component_name : "rerun.components.Text".into(),
docstring_md : "Optional text labels for the node.", is_required :
false, }, ArchetypeFieldReflection { name : "show_labels",
display_name : "Show labels", component_name :
"rerun.components.ShowLabels".into(), docstring_md :
"Optional choice of whether the text labels should be shown by default.",
is_required : false, }, ArchetypeFieldReflection { name : "radii",
display_name : "Radii", component_name : "rerun.components.Radius"
.into(), docstring_md : "Optional radii for nodes.", is_required :
false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Image"),
ArchetypeReflection {
display_name: "Image",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { name : "buffer", display_name : "Buffer",
component_name : "rerun.components.ImageBuffer".into(), docstring_md
: "The raw image data.", is_required : true, },
ArchetypeFieldReflection { name : "format", display_name : "Format",
component_name : "rerun.components.ImageFormat".into(), docstring_md
: "The format of the image.", is_required : true, },
ArchetypeFieldReflection { name : "opacity", display_name :
"Opacity", component_name : "rerun.components.Opacity".into(),
docstring_md :
"Opacity of the image, useful for layering several images.\n\nDefaults to 1.0 (fully opaque).",
is_required : false, }, ArchetypeFieldReflection { name :
"draw_order", display_name : "Draw order", component_name :
"rerun.components.DrawOrder".into(), docstring_md :
"An optional floating point value that specifies the 2D drawing order.\n\nObjects with higher values are drawn on top of those with lower values.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.InstancePoses3D"),
ArchetypeReflection {
display_name: "Instance poses 3D",
scope: None,
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec![
ArchetypeFieldReflection { name : "translations", display_name :
"Translations", component_name : "rerun.components.PoseTranslation3D"
.into(), docstring_md : "Translation vectors.", is_required : false,
}, ArchetypeFieldReflection { name : "rotation_axis_angles",
display_name : "Rotation axis angles", component_name :
"rerun.components.PoseRotationAxisAngle".into(), docstring_md :
"Rotations via axis + angle.", is_required : false, },
ArchetypeFieldReflection { name : "quaternions", display_name :
"Quaternions", component_name : "rerun.components.PoseRotationQuat"
.into(), docstring_md : "Rotations via quaternion.", is_required :
false, }, ArchetypeFieldReflection { name : "scales", display_name :
"Scales", component_name : "rerun.components.PoseScale3D".into(),
docstring_md : "Scaling factors.", is_required : false, },
ArchetypeFieldReflection { name : "mat3x3", display_name :
"Mat 3x 3", component_name : "rerun.components.PoseTransformMat3x3"
.into(), docstring_md : "3x3 transformation matrices.", is_required :
false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.LineStrips2D"),
ArchetypeReflection {
display_name: "Line strips 2D",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vecs for the lines.\n\nThe [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.LineStrips3D"),
ArchetypeReflection {
display_name: "Line strips 3D",
scope: None,
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vecs for the lines.\n\nThe [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Mesh3D"),
ArchetypeReflection {
display_name: "Mesh 3D",
scope: None,
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec of the mesh.\n\nCurrently supports only sRGB(A) textures, ignoring alpha.\n(meaning that the tensor must have 3 or 4 channels and use the `u8` format)",
is_required : false, }, ArchetypeFieldReflection { name :
"albedo_texture_format", display_name : "Albedo texture format",
component_name : "rerun.components.ImageFormat".into(), docstring_md
: "The format of the `albedo_texture_buffer`, if any.", is_required :
false, }, ArchetypeFieldReflection { name : "class_ids", display_name
: "Class ids", component_name : "rerun.components.ClassId".into(),
docstring_md :
"Optional class Ids for the vertices.\n\nThe [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) provides colors and labels if not specified explicitly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Pinhole"),
ArchetypeReflection {
display_name: "Pinhole",
scope: None,
view_types: &["Spatial2DView", "Spatial2DView"],
fields: vec![
ArchetypeFieldReflection { name : "image_from_camera", display_name :
"Image from camera", component_name :
"rerun.components.PinholeProjection".into(), docstring_md :
"Camera projection, from image coordinates to view coordinates.",
is_required : true, }, ArchetypeFieldReflection { name :
"resolution", display_name : "Resolution", component_name :
"rerun.components.Resolution".into(), docstring_md :
"Pixel resolution (usually integers) of child image space. Width and height.\n\nExample:\n```text\n[1920.0, 1440.0]\n```\n\n`image_from_camera` project onto the space spanned by `(0,0)` and `resolution - 1`.",
is_required : false, }, ArchetypeFieldReflection { name :
"camera_xyz", display_name : "Camera xyz", component_name :
"rerun.components.ViewCoordinates".into(), docstring_md :
"Sets the view coordinates for the camera.\n\nAll common values are available as constants on the [`components.ViewCoordinates`](https://rerun.io/docs/reference/types/components/view_coordinates) class.\n\nThe default is `ViewCoordinates::RDF`, i.e. X=Right, Y=Down, Z=Forward, and this is also the recommended setting.\nThis means that the camera frustum will point along the positive Z axis of the parent space,\nand the cameras \"up\" direction will be along the negative Y axis of the parent space.\n\nThe camera frustum will point whichever axis is set to `F` (or the opposite of `B`).\nWhen logging a depth image under this entity, this is the direction the point cloud will be projected.\nWith `RDF`, the default forward is +Z.\n\nThe frustum's \"up\" direction will be whichever axis is set to `U` (or the opposite of `D`).\nThis will match the negative Y direction of pixel space (all images are assumed to have xyz=RDF).\nWith `RDF`, the default is up is -Y.\n\nThe frustum's \"right\" direction will be whichever axis is set to `R` (or the opposite of `L`).\nThis will match the positive X direction of pixel space (all images are assumed to have xyz=RDF).\nWith `RDF`, the default right is +x.\n\nOther common formats are `RUB` (X=Right, Y=Up, Z=Back) and `FLU` (X=Forward, Y=Left, Z=Up).\n\nNOTE: setting this to something else than `RDF` (the default) will change the orientation of the camera frustum,\nand make the pinhole matrix not match up with the coordinate system of the pinhole entity.\n\nThe pinhole matrix (the `image_from_camera` argument) always project along the third (Z) axis,\nbut will be re-oriented to project along the forward axis of the `camera_xyz` argument.",
is_required : false, }, ArchetypeFieldReflection { name :
"image_plane_distance", display_name : "Image plane distance",
component_name : "rerun.components.ImagePlaneDistance".into(),
docstring_md :
"The distance from the camera origin to the image plane when the projection is shown in a 3D viewer.\n\nThis is only used for visualization purposes, and does not affect the projection itself.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Points2D"),
ArchetypeReflection {
display_name: "Points 2D",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec provides colors and labels if not specified explicitly.",
is_required : false, }, ArchetypeFieldReflection { name :
"keypoint_ids", display_name : "Keypoint ids", component_name :
"rerun.components.KeypointId".into(), docstring_md :
"Optional keypoint IDs for the points, identifying them within a class.\n\nIf keypoint IDs are passed in but no [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id)s were specified, the [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) will\ndefault to 0.\nThis is useful to identify points within a single classification (which is identified\nwith `class_id`).\nE.g. the classification might be 'Person' and the keypoints refer to joints on a\ndetected skeleton.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Points3D"),
ArchetypeReflection {
display_name: "Points 3D",
scope: None,
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec provides colors and labels if not specified explicitly.",
is_required : false, }, ArchetypeFieldReflection { name :
"keypoint_ids", display_name : "Keypoint ids", component_name :
"rerun.components.KeypointId".into(), docstring_md :
"Optional keypoint IDs for the points, identifying them within a class.\n\nIf keypoint IDs are passed in but no [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id)s were specified, the [`components.ClassId`](https://rerun.io/docs/reference/types/components/class_id) will\ndefault to 0.\nThis is useful to identify points within a single classification (which is identified\nwith `class_id`).\nE.g. the classification might be 'Person' and the keypoints refer to joints on a\ndetected skeleton.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Scalar"),
ArchetypeReflection {
display_name: "Scalar",
scope: None,
view_types: &["TimeSeriesView"],
fields: vec![
ArchetypeFieldReflection { name : "scalar", display_name : "Scalar",
component_name : "rerun.components.Scalar".into(), docstring_md :
"The scalar value to log.", is_required : true, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.SegmentationImage"),
ArchetypeReflection {
display_name: "Segmentation image",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { name : "buffer", display_name : "Buffer",
component_name : "rerun.components.ImageBuffer".into(), docstring_md
: "The raw image data.", is_required : true, },
ArchetypeFieldReflection { name : "format", display_name : "Format",
component_name : "rerun.components.ImageFormat".into(), docstring_md
: "The format of the image.", is_required : true, },
ArchetypeFieldReflection { name : "opacity", display_name :
"Opacity", component_name : "rerun.components.Opacity".into(),
docstring_md :
"Opacity of the image, useful for layering the segmentation image on top of another image.\n\nDefaults to 0.5 if there's any other images in the scene, otherwise 1.0.",
is_required : false, }, ArchetypeFieldReflection { name :
"draw_order", display_name : "Draw order", component_name :
"rerun.components.DrawOrder".into(), docstring_md :
"An optional floating point value that specifies the 2D drawing order.\n\nObjects with higher values are drawn on top of those with lower values.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.SeriesLine"),
ArchetypeReflection {
display_name: "Series line",
scope: None,
view_types: &["TimeSeriesView"],
fields: vec![
ArchetypeFieldReflection { name : "color", display_name : "Color",
component_name : "rerun.components.Color".into(), docstring_md :
"Color for the corresponding series.", is_required : false, },
ArchetypeFieldReflection { name : "width", display_name : "Width",
component_name : "rerun.components.StrokeWidth".into(), docstring_md
: "Stroke width for the corresponding series.", is_required : false,
}, ArchetypeFieldReflection { name : "name", display_name : "Name",
component_name : "rerun.components.Name".into(), docstring_md :
"Display name of the series.\n\nUsed in the legend.", is_required :
false, }, ArchetypeFieldReflection { name : "aggregation_policy",
display_name : "Aggregation policy", component_name :
"rerun.components.AggregationPolicy".into(), docstring_md :
"Configures the zoom-dependent scalar aggregation.\n\nThis is done only if steps on the X axis go below a single pixel,\ni.e. a single pixel covers more than one tick worth of data. It can greatly improve performance\n(and readability) in such situations as it prevents overdraw.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.SeriesPoint"),
ArchetypeReflection {
display_name: "Series point",
scope: None,
view_types: &["TimeSeriesView"],
fields: vec![
ArchetypeFieldReflection { name : "color", display_name : "Color",
component_name : "rerun.components.Color".into(), docstring_md :
"Color for the corresponding series.", is_required : false, },
ArchetypeFieldReflection { name : "marker", display_name : "Marker",
component_name : "rerun.components.MarkerShape".into(), docstring_md
: "What shape to use to represent the point", is_required : false, },
ArchetypeFieldReflection { name : "name", display_name : "Name",
component_name : "rerun.components.Name".into(), docstring_md :
"Display name of the series.\n\nUsed in the legend.", is_required :
false, }, ArchetypeFieldReflection { name : "marker_size",
display_name : "Marker size", component_name :
"rerun.components.MarkerSize".into(), docstring_md :
"Size of the marker.", is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Tensor"),
ArchetypeReflection {
display_name: "Tensor",
scope: None,
view_types: &["TensorView", "BarChartView"],
fields: vec![
ArchetypeFieldReflection { name : "data", display_name : "Data",
component_name : "rerun.components.TensorData".into(), docstring_md :
"The tensor data", is_required : true, }, ArchetypeFieldReflection {
name : "value_range", display_name : "Value range", component_name :
"rerun.components.ValueRange".into(), docstring_md :
"The expected range of values.\n\nThis is typically the expected range of valid values.\nEverything outside of the range is clamped to the range for the purpose of colormpaping.\nAny colormap applied for display, will map this range.\n\nIf not specified, the range will be automatically estimated from the data.\nNote that the Viewer may try to guess a wider range than the minimum/maximum of values\nin the contents of the tensor.\nE.g. if all values are positive, some bigger than 1.0 and all smaller than 255.0,\nthe Viewer will guess that the data likely came from an 8bit image, thus assuming a range of 0-255.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.TextDocument"),
ArchetypeReflection {
display_name: "Text document",
scope: None,
view_types: &["TextDocumentView"],
fields: vec![
ArchetypeFieldReflection { name : "text", display_name : "Text",
component_name : "rerun.components.Text".into(), docstring_md :
"Contents of the text document.", is_required : true, },
ArchetypeFieldReflection { name : "media_type", display_name :
"Media type", component_name : "rerun.components.MediaType".into(),
docstring_md :
"The Media Type of the text.\n\nFor instance:\n* `text/plain`\n* `text/markdown`\n\nIf omitted, `text/plain` is assumed.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.TextLog"),
ArchetypeReflection {
display_name: "Text log",
scope: None,
view_types: &["TextLogView"],
fields: vec![
ArchetypeFieldReflection { name : "text", display_name : "Text",
component_name : "rerun.components.Text".into(), docstring_md :
"The body of the message.", is_required : true, },
ArchetypeFieldReflection { name : "level", display_name : "Level",
component_name : "rerun.components.TextLogLevel".into(), docstring_md
:
"The verbosity level of the message.\n\nThis can be used to filter the log messages in the Rerun Viewer.",
is_required : false, }, ArchetypeFieldReflection { name : "color",
display_name : "Color", component_name : "rerun.components.Color"
.into(), docstring_md :
"Optional color to use for the log line in the Rerun Viewer.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.Transform3D"),
ArchetypeReflection {
display_name: "Transform 3D",
scope: None,
view_types: &["Spatial3DView", "Spatial2DView"],
fields: vec![
ArchetypeFieldReflection { name : "translation", display_name :
"Translation", component_name : "rerun.components.Translation3D"
.into(), docstring_md : "Translation vector.", is_required : false,
}, ArchetypeFieldReflection { name : "rotation_axis_angle",
display_name : "Rotation axis angle", component_name :
"rerun.components.RotationAxisAngle".into(), docstring_md :
"Rotation via axis + angle.", is_required : false, },
ArchetypeFieldReflection { name : "quaternion", display_name :
"Quaternion", component_name : "rerun.components.RotationQuat"
.into(), docstring_md : "Rotation via quaternion.", is_required :
false, }, ArchetypeFieldReflection { name : "scale", display_name :
"Scale", component_name : "rerun.components.Scale3D".into(),
docstring_md : "Scaling factor.", is_required : false, },
ArchetypeFieldReflection { name : "mat3x3", display_name :
"Mat 3x 3", component_name : "rerun.components.TransformMat3x3"
.into(), docstring_md : "3x3 transformation matrix.", is_required :
false, }, ArchetypeFieldReflection { name : "relation", display_name
: "Relation", component_name : "rerun.components.TransformRelation"
.into(), docstring_md :
"Specifies the relation this transform establishes between this entity and its parent.",
is_required : false, }, ArchetypeFieldReflection { name :
"axis_length", display_name : "Axis length", component_name :
"rerun.components.AxisLength".into(), docstring_md :
"Visual length of the 3 axes.\n\nThe length is interpreted in the local coordinate system of the transform.\nIf the transform is scaled, the axes will be scaled accordingly.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.VideoFrameReference"),
ArchetypeReflection {
display_name: "Video frame reference",
scope: None,
view_types: &["Spatial2DView", "Spatial3DView"],
fields: vec.\n\nIf none is specified, the video is assumed to be at the same entity.\nNote that blueprint overrides on the referenced video will be ignored regardless,\nas this is always interpreted as a reference to the data store.\n\nFor a series of video frame references, it is recommended to specify this path only once\nat the beginning of the series and then rely on latest-at query semantics to\nkeep the video reference active.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.archetypes.ViewCoordinates"),
ArchetypeReflection {
display_name: "View coordinates",
scope: None,
view_types: &["Spatial3DView"],
fields: vec![
ArchetypeFieldReflection { name : "xyz", display_name : "Xyz",
component_name : "rerun.components.ViewCoordinates".into(),
docstring_md : "The directions of the [x, y, z] axes.", is_required :
true, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.Background"),
ArchetypeReflection {
display_name: "Background",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "kind", display_name : "Kind",
component_name : "rerun.blueprint.components.BackgroundKind".into(),
docstring_md : "The type of the background.", is_required : true, },
ArchetypeFieldReflection { name : "color", display_name : "Color",
component_name : "rerun.components.Color".into(), docstring_md :
"Color used for the solid background type.", is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ContainerBlueprint"),
ArchetypeReflection {
display_name: "Container blueprint",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "container_kind", display_name :
"Container kind", component_name :
"rerun.blueprint.components.ContainerKind".into(), docstring_md :
"The class of the view.", is_required : true, },
ArchetypeFieldReflection { name : "display_name", display_name :
"Display name", component_name : "rerun.components.Name".into(),
docstring_md : "The name of the container.", is_required : false, },
ArchetypeFieldReflection { name : "contents", display_name :
"Contents", component_name :
"rerun.blueprint.components.IncludedContent".into(), docstring_md :
"`ContainerId`s or `ViewId`s that are children of this container.",
is_required : false, }, ArchetypeFieldReflection { name :
"col_shares", display_name : "Col shares", component_name :
"rerun.blueprint.components.ColumnShare".into(), docstring_md :
"The layout shares of each column in the container.\n\nFor components.ContainerKind containers, the length of this list should always match the number of contents.\n\nIgnored for components.ContainerKind containers.",
is_required : false, }, ArchetypeFieldReflection { name :
"row_shares", display_name : "Row shares", component_name :
"rerun.blueprint.components.RowShare".into(), docstring_md :
"The layout shares of each row of the container.\n\nFor components.ContainerKind containers, the length of this list should always match the number of contents.\n\nIgnored for components.ContainerKind containers.",
is_required : false, }, ArchetypeFieldReflection { name :
"active_tab", display_name : "Active tab", component_name :
"rerun.blueprint.components.ActiveTab".into(), docstring_md :
"Which tab is active.\n\nOnly applies to `Tabs` containers.",
is_required : false, }, ArchetypeFieldReflection { name : "visible",
display_name : "Visible", component_name :
"rerun.blueprint.components.Visible".into(), docstring_md :
"Whether this container is visible.\n\nDefaults to true if not specified.",
is_required : false, }, ArchetypeFieldReflection { name :
"grid_columns", display_name : "Grid columns", component_name :
"rerun.blueprint.components.GridColumns".into(), docstring_md :
"How many columns this grid should have.\n\nIf unset, the grid layout will be auto.\n\nIgnored for components.ContainerKind/components.ContainerKind containers.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.DataframeQuery"),
ArchetypeReflection {
display_name: "Dataframe query",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "timeline", display_name :
"Timeline", component_name :
"rerun.blueprint.components.TimelineName".into(), docstring_md :
"The timeline for this query.\n\nIf unset, the timeline currently active on the time panel is used.",
is_required : false, }, ArchetypeFieldReflection { name :
"filter_by_range", display_name : "Filter by range", component_name :
"rerun.blueprint.components.FilterByRange".into(), docstring_md :
"If provided, only rows whose timestamp is within this range will be shown.\n\nNote: will be unset as soon as `timeline` is changed.",
is_required : false, }, ArchetypeFieldReflection { name :
"filter_is_not_null", display_name : "Filter is not null",
component_name : "rerun.blueprint.components.FilterIsNotNull".into(),
docstring_md :
"If provided, only show rows which contains a logged event for the specified component.",
is_required : false, }, ArchetypeFieldReflection { name :
"apply_latest_at", display_name : "Apply latest at", component_name :
"rerun.blueprint.components.ApplyLatestAt".into(), docstring_md :
"Should empty cells be filled with latest-at queries?", is_required :
false, }, ArchetypeFieldReflection { name : "select", display_name :
"Select", component_name :
"rerun.blueprint.components.SelectedColumns".into(), docstring_md :
"Selected columns. If unset, all columns are selected.", is_required
: false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ForceCenter"),
ArchetypeReflection {
display_name: "Force center",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "enabled", display_name :
"Enabled", component_name : "rerun.blueprint.components.Enabled"
.into(), docstring_md :
"Whether the center force is enabled.\n\nThe center force tries to move the center of mass of the graph towards the origin.",
is_required : false, }, ArchetypeFieldReflection { name : "strength",
display_name : "Strength", component_name :
"rerun.blueprint.components.ForceStrength".into(), docstring_md :
"The strength of the force.", is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ForceCollisionRadius"),
ArchetypeReflection {
display_name: "Force collision radius",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "enabled", display_name :
"Enabled", component_name : "rerun.blueprint.components.Enabled"
.into(), docstring_md :
"Whether the collision force is enabled.\n\nThe collision force resolves collisions between nodes based on the bounding circle defined by their radius.",
is_required : false, }, ArchetypeFieldReflection { name : "strength",
display_name : "Strength", component_name :
"rerun.blueprint.components.ForceStrength".into(), docstring_md :
"The strength of the force.", is_required : false, },
ArchetypeFieldReflection { name : "iterations", display_name :
"Iterations", component_name :
"rerun.blueprint.components.ForceIterations".into(), docstring_md :
"Specifies how often this force should be applied per iteration.\n\nIncreasing this parameter can lead to better results at the cost of longer computation time.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ForceLink"),
ArchetypeReflection {
display_name: "Force link",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "enabled", display_name :
"Enabled", component_name : "rerun.blueprint.components.Enabled"
.into(), docstring_md :
"Whether the link force is enabled.\n\nThe link force aims to achieve a target distance between two nodes that are connected by one ore more edges.",
is_required : false, }, ArchetypeFieldReflection { name : "distance",
display_name : "Distance", component_name :
"rerun.blueprint.components.ForceDistance".into(), docstring_md :
"The target distance between two nodes.", is_required : false, },
ArchetypeFieldReflection { name : "iterations", display_name :
"Iterations", component_name :
"rerun.blueprint.components.ForceIterations".into(), docstring_md :
"Specifies how often this force should be applied per iteration.\n\nIncreasing this parameter can lead to better results at the cost of longer computation time.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ForceManyBody"),
ArchetypeReflection {
display_name: "Force many body",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "enabled", display_name :
"Enabled", component_name : "rerun.blueprint.components.Enabled"
.into(), docstring_md :
"Whether the many body force is enabled.\n\nThe many body force is applied on each pair of nodes in a way that ressembles an electrical charge. If the\nstrength is smaller than 0, it pushes nodes apart; if it is larger than 0, it pulls them together.",
is_required : false, }, ArchetypeFieldReflection { name : "strength",
display_name : "Strength", component_name :
"rerun.blueprint.components.ForceStrength".into(), docstring_md :
"The strength of the force.\n\nIf `strength` is smaller than 0, it pushes nodes apart, if it is larger than 0 it pulls them together.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ForcePosition"),
ArchetypeReflection {
display_name: "Force position",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "enabled", display_name :
"Enabled", component_name : "rerun.blueprint.components.Enabled"
.into(), docstring_md :
"Whether the position force is enabled.\n\nThe position force pulls nodes towards a specific position, similar to gravity.",
is_required : false, }, ArchetypeFieldReflection { name : "strength",
display_name : "Strength", component_name :
"rerun.blueprint.components.ForceStrength".into(), docstring_md :
"The strength of the force.", is_required : false, },
ArchetypeFieldReflection { name : "position", display_name :
"Position", component_name : "rerun.components.Position2D".into(),
docstring_md :
"The position where the nodes should be pulled towards.", is_required
: false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.LineGrid3D"),
ArchetypeReflection {
display_name: "Line grid 3D",
scope: Some("blueprint"),
view_types: &[],
fields: vec if present.",
is_required : false, }, ArchetypeFieldReflection { name :
"stroke_width", display_name : "Stroke width", component_name :
"rerun.components.StrokeWidth".into(), docstring_md :
"How thick the lines should be in ui units.\n\nDefault is 1.0 ui unit.",
is_required : false, }, ArchetypeFieldReflection { name : "color",
display_name : "Color", component_name : "rerun.components.Color"
.into(), docstring_md :
"Color used for the grid.\n\nTransparency via alpha channel is supported.\nDefaults to a slightly transparent light gray.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.MapBackground"),
ArchetypeReflection {
display_name: "Map background",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "provider", display_name :
"Provider", component_name : "rerun.blueprint.components.MapProvider"
.into(), docstring_md :
"Map provider and style to use.\n\n**Note**: Requires a Mapbox API key in the `RERUN_MAPBOX_ACCESS_TOKEN` environment variable.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.MapZoom"),
ArchetypeReflection {
display_name: "Map zoom",
scope: Some("blueprint"),
view_types: &[],
fields: vec.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.NearClipPlane"),
ArchetypeReflection {
display_name: "Near clip plane",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "near_clip_plane", display_name :
"Near clip plane", component_name :
"rerun.blueprint.components.NearClipPlane".into(), docstring_md :
"Controls the distance to the near clip plane in 3D scene units.\n\nContent closer than this distance will not be visible.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.PanelBlueprint"),
ArchetypeReflection {
display_name: "Panel blueprint",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "state", display_name : "State",
component_name : "rerun.blueprint.components.PanelState".into(),
docstring_md : "Current state of the panels.", is_required : false,
},
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.PlotLegend"),
ArchetypeReflection {
display_name: "Plot legend",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "corner", display_name : "Corner",
component_name : "rerun.blueprint.components.Corner2D".into(),
docstring_md :
"To what corner the legend is aligned.\n\nDefaults to the right bottom corner.",
is_required : false, }, ArchetypeFieldReflection { name : "visible",
display_name : "Visible", component_name :
"rerun.blueprint.components.Visible".into(), docstring_md :
"Whether the legend is shown at all.\n\nTrue by default.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ScalarAxis"),
ArchetypeReflection {
display_name: "Scalar axis",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "range", display_name : "Range",
component_name : "rerun.components.Range1D".into(), docstring_md :
"The range of the axis.\n\nIf unset, the range well be automatically determined based on the queried data.",
is_required : false, }, ArchetypeFieldReflection { name :
"zoom_lock", display_name : "Zoom lock", component_name :
"rerun.blueprint.components.LockRangeDuringZoom".into(), docstring_md
:
"If enabled, the Y axis range will remain locked to the specified range when zooming.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.TensorScalarMapping"),
ArchetypeReflection {
display_name: "Tensor scalar mapping",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "mag_filter", display_name :
"Mag filter", component_name : "rerun.components.MagnificationFilter"
.into(), docstring_md :
"Filter used when zooming in on the tensor.\n\nNote that the filter is applied to the scalar values *before* they are mapped to color.",
is_required : false, }, ArchetypeFieldReflection { name : "colormap",
display_name : "Colormap", component_name :
"rerun.components.Colormap".into(), docstring_md :
"How scalar values map to colors.", is_required : false, },
ArchetypeFieldReflection { name : "gamma", display_name : "Gamma",
component_name : "rerun.components.GammaCorrection".into(),
docstring_md :
"Gamma exponent applied to normalized values before mapping to color.\n\nRaises the normalized values to the power of this value before mapping to color.\nActs like an inverse brightness. Defaults to 1.0.\n\nThe final value for display is set as:\n`colormap( ((value - data_display_range.min) / (data_display_range.max - data_display_range.min)) ** gamma )`",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.TensorSliceSelection"),
ArchetypeReflection {
display_name: "Tensor slice selection",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "width", display_name : "Width",
component_name : "rerun.components.TensorWidthDimension".into(),
docstring_md :
"Which dimension to map to width.\n\nIf not specified, the height will be determined automatically based on the name and index of the dimension.",
is_required : false, }, ArchetypeFieldReflection { name : "height",
display_name : "Height", component_name :
"rerun.components.TensorHeightDimension".into(), docstring_md :
"Which dimension to map to height.\n\nIf not specified, the height will be determined automatically based on the name and index of the dimension.",
is_required : false, }, ArchetypeFieldReflection { name : "indices",
display_name : "Indices", component_name :
"rerun.components.TensorDimensionIndexSelection".into(), docstring_md
:
"Selected indices for all other dimensions.\n\nIf any of the here listed dimensions is equal to `width` or `height`, it will be ignored.",
is_required : false, }, ArchetypeFieldReflection { name : "slider",
display_name : "Slider", component_name :
"rerun.blueprint.components.TensorDimensionIndexSlider".into(),
docstring_md :
"Any dimension listed here will have a slider for the index.\n\nEdits to the sliders will directly manipulate dimensions on the `indices` list.\nIf any of the here listed dimensions is equal to `width` or `height`, it will be ignored.\nIf not specified, adds slides for any dimension in `indices`.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.TensorViewFit"),
ArchetypeReflection {
display_name: "Tensor view fit",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "scaling", display_name :
"Scaling", component_name : "rerun.blueprint.components.ViewFit"
.into(), docstring_md : "How the image is scaled to fit the view.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ViewBlueprint"),
ArchetypeReflection {
display_name: "View blueprint",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "class_identifier", display_name :
"Class identifier", component_name :
"rerun.blueprint.components.ViewClass".into(), docstring_md :
"The class of the view.", is_required : true, },
ArchetypeFieldReflection { name : "display_name", display_name :
"Display name", component_name : "rerun.components.Name".into(),
docstring_md : "The name of the view.", is_required : false, },
ArchetypeFieldReflection { name : "space_origin", display_name :
"Space origin", component_name :
"rerun.blueprint.components.ViewOrigin".into(), docstring_md :
"The \"anchor point\" of this view.\n\nDefaults to the root path '/' if not specified.\n\nThe transform at this path forms the reference point for all scene->world transforms in this view.\nI.e. the position of this entity path in space forms the origin of the coordinate system in this view.\nFurthermore, this is the primary indicator for heuristics on what entities we show in this view.",
is_required : false, }, ArchetypeFieldReflection { name : "visible",
display_name : "Visible", component_name :
"rerun.blueprint.components.Visible".into(), docstring_md :
"Whether this view is visible.\n\nDefaults to true if not specified.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ViewContents"),
ArchetypeReflection {
display_name: "View contents",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "query", display_name : "Query",
component_name : "rerun.blueprint.components.QueryExpression".into(),
docstring_md :
"The `QueryExpression` that populates the contents for the view.\n\nThey determine which entities are part of the view.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.ViewportBlueprint"),
ArchetypeReflection {
display_name: "Viewport blueprint",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "root_container", display_name :
"Root container", component_name :
"rerun.blueprint.components.RootContainer".into(), docstring_md :
"The layout of the views", is_required : false, },
ArchetypeFieldReflection { name : "maximized", display_name :
"Maximized", component_name :
"rerun.blueprint.components.ViewMaximized".into(), docstring_md :
"Show one tab as maximized?", is_required : false, },
ArchetypeFieldReflection { name : "auto_layout", display_name :
"Auto layout", component_name :
"rerun.blueprint.components.AutoLayout".into(), docstring_md :
"Whether the viewport layout is determined automatically.\n\nIf `true`, the container layout will be reset whenever a new view is added or removed.\nThis defaults to `false` and is automatically set to `false` when there is user determined layout.",
is_required : false, }, ArchetypeFieldReflection { name :
"auto_views", display_name : "Auto views", component_name :
"rerun.blueprint.components.AutoViews".into(), docstring_md :
"Whether or not views should be created automatically.\n\nIf `true`, the viewer will only add views that it hasn't considered previously (as identified by `past_viewer_recommendations`)\nand which aren't deemed redundant to existing views.\nThis defaults to `false` and is automatically set to `false` when the user adds views manually in the viewer.",
is_required : false, }, ArchetypeFieldReflection { name :
"past_viewer_recommendations", display_name :
"Past viewer recommendations", component_name :
"rerun.blueprint.components.ViewerRecommendationHash".into(),
docstring_md :
"Hashes of all recommended views the viewer has already added and that should not be added again.\n\nThis is an internal field and should not be set usually.\nIf you want the viewer from stopping to add views, you should set `auto_views` to `false`.\n\nThe viewer uses this to determine whether it should keep adding views.",
is_required : false, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.VisibleTimeRanges"),
ArchetypeReflection {
display_name: "Visible time ranges",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "ranges", display_name : "Ranges",
component_name : "rerun.blueprint.components.VisibleTimeRange"
.into(), docstring_md :
"The time ranges to show for each timeline unless specified otherwise on a per-entity basis.\n\nIf a timeline is specified more than once, the first entry will be used.",
is_required : true, },
],
},
),
(
ArchetypeName::new("rerun.blueprint.archetypes.VisualBounds2D"),
ArchetypeReflection {
display_name: "Visual bounds 2D",
scope: Some("blueprint"),
view_types: &[],
fields: vec![
ArchetypeFieldReflection { name : "range", display_name : "Range",
component_name : "rerun.blueprint.components.VisualBounds2D".into(),
docstring_md :
"Controls the visible range of a 2D view.\n\nUse this to control pan & zoom of the view.",
is_required : true, },
],
},
),
];
ArchetypeReflectionMap::from_iter(array)
}