Struct re_types::archetypes::InstancePoses3D

pub struct InstancePoses3D {
    pub translations: Option<Vec<PoseTranslation3D>>,
    pub rotation_axis_angles: Option<Vec<PoseRotationAxisAngle>>,
    pub quaternions: Option<Vec<PoseRotationQuat>>,
    pub scales: Option<Vec<PoseScale3D>>,
    pub mat3x3: Option<Vec<PoseTransformMat3x3>>,
}

Archetype: One or more transforms between the current entity and its parent. Unlike archetypes::Transform3D, it is not propagated in the transform hierarchy.

If both archetypes::InstancePoses3D and archetypes::Transform3D are present, first the tree propagating archetypes::Transform3D is applied, then archetypes::InstancePoses3D.

From the point of view of the entity’s coordinate system, all components are applied in the inverse order they are listed here. E.g. if both a translation and a max3x3 transform are present, the 3x3 matrix is applied first, followed by the translation.

Currently, many visualizers support only a single instance transform per entity. Check archetype documentations for details - if not otherwise specified, only the first instance transform is applied. Some visualizers like the mesh visualizer used for [archetype.Mesh3D], will draw an object for every pose, a behavior also known as “instancing”.

Example

Regular & instance transforms in tandem

use rerun::{
    demo_util::grid,
    external::{anyhow, glam},
};

fn main() -> anyhow::Result<()> {
    let rec =
        rerun::RecordingStreamBuilder::new("rerun_example_instance_pose3d_combined").spawn()?;

    rec.set_time_sequence("frame", 0);

    // Log a box and points further down in the hierarchy.
    rec.log(
        "world/box",
        &rerun::Boxes3D::from_half_sizes([[1.0, 1.0, 1.0]]),
    )?;
    rec.log(
        "world/box/points",
        &rerun::Points3D::new(grid(glam::Vec3::splat(-10.0), glam::Vec3::splat(10.0), 10)),
    )?;

    for i in 0..180 {
        rec.set_time_sequence("frame", i);

        // Log a regular transform which affects both the box and the points.
        rec.log(
            "world/box",
            &rerun::Transform3D::from_rotation(rerun::RotationAxisAngle {
                axis: [0.0, 0.0, 1.0].into(),
                angle: rerun::Angle::from_degrees(i as f32 * 2.0),
            }),
        )?;

        // Log an instance pose which affects only the box.
        let translation = [0.0, 0.0, (i as f32 * 0.1 - 5.0).abs() - 5.0];
        rec.log(
            "world/box",
            &rerun::InstancePoses3D::new().with_translations([translation]),
        )?;
    }

    Ok(())
}

Fields

translations: Option<Vec<PoseTranslation3D>>

Translation vectors.

rotation_axis_angles: Option<Vec<PoseRotationAxisAngle>>

Rotations via axis + angle.

quaternions: Option<Vec<PoseRotationQuat>>

Rotations via quaternion.

scales: Option<Vec<PoseScale3D>>

Scaling factors.

mat3x3: Option<Vec<PoseTransformMat3x3>>

3x3 transformation matrices.

Implementations

impl InstancePoses3D

pub const NUM_COMPONENTS: usize = 6usize

The total number of components in the archetype: 0 required, 1 recommended, 5 optional

impl InstancePoses3D

pub fn new() -> Self

Create a new InstancePoses3D.

pub fn with_translations( self, translations: impl IntoIterator<Item = impl Into<PoseTranslation3D>> ) -> Self

Translation vectors.

pub fn with_rotation_axis_angles( self, rotation_axis_angles: impl IntoIterator<Item = impl Into<PoseRotationAxisAngle>> ) -> Self

Rotations via axis + angle.

pub fn with_quaternions( self, quaternions: impl IntoIterator<Item = impl Into<PoseRotationQuat>> ) -> Self

Rotations via quaternion.

pub fn with_scales( self, scales: impl IntoIterator<Item = impl Into<PoseScale3D>> ) -> Self

Scaling factors.

pub fn with_mat3x3( self, mat3x3: impl IntoIterator<Item = impl Into<PoseTransformMat3x3>> ) -> Self

3x3 transformation matrices.

Trait Implementations

impl Archetype for InstancePoses3D

type Indicator = GenericIndicatorComponent<InstancePoses3D>

The associated indicator component, whose presence indicates that the high-level archetype-based APIs were used to log the data.

fn name() -> ArchetypeName

The fully-qualified name of this archetype, e.g. rerun.archetypes.Points2D.

fn display_name() -> &'static str

Readable name for displaying in ui.

fn indicator() -> MaybeOwnedComponentBatch<'static>

Creates a ComponentBatch out of the associated Self::Indicator component.

fn required_components() -> Cow<'static, [ComponentName]>

Returns the names of all components that must be provided by the user when constructing this archetype.

fn recommended_components() -> Cow<'static, [ComponentName]>

Returns the names of all components that should be provided by the user when constructing this archetype.

fn optional_components() -> Cow<'static, [ComponentName]>

Returns the names of all components that may be provided by the user when constructing this archetype.

fn all_components() -> Cow<'static, [ComponentName]>

Returns the names of all components that must, should and may be provided by the user when constructing this archetype.

fn from_arrow_components( arrow_data: impl IntoIterator<Item = (ComponentName, Box<dyn Array>)> ) -> DeserializationResult<Self>

Given an iterator of Arrow arrays and their respective ComponentNames, deserializes them into this archetype.

fn from_arrow( data: impl IntoIterator<Item = (Field, Box<dyn Array>)> ) -> Result<Self, DeserializationError>

where Self: Sized,

Given an iterator of Arrow arrays and their respective field metadata, deserializes them into this archetype.

impl AsComponents for InstancePoses3D

fn as_component_batches(&self) -> Vec<MaybeOwnedComponentBatch<'_>>

Exposes the object’s contents as a set of ComponentBatchs.

fn to_arrow(&self) -> Result<Vec<(Field, Box<dyn Array>)>, SerializationError>

Serializes all non-null Components of this bundle into Arrow arrays.

impl Clone for InstancePoses3D

fn clone(&self) -> InstancePoses3D

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InstancePoses3D

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for InstancePoses3D

fn eq(&self, other: &InstancePoses3D) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SizeBytes for InstancePoses3D

fn heap_size_bytes(&self) -> u64

Returns the total size of self on the heap, in bytes.

fn is_pod() -> bool

Is Self just plain old data?

fn total_size_bytes(&self) -> u64

Returns the total size of self in bytes, accounting for both stack and heap space.

fn stack_size_bytes(&self) -> u64

Returns the total size of self on the stack, in bytes.

impl ArchetypeReflectionMarker for InstancePoses3D

impl StructuralPartialEq for InstancePoses3D