Struct rerun::InstancePoses3D

pub struct InstancePoses3D {
    pub translations: Option<SerializedComponentBatch>,
    pub rotation_axis_angles: Option<SerializedComponentBatch>,
    pub quaternions: Option<SerializedComponentBatch>,
    pub scales: Option<SerializedComponentBatch>,
    pub mat3x3: Option<SerializedComponentBatch>,
}

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 archetypes::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<SerializedComponentBatch>

Translation vectors.

rotation_axis_angles: Option<SerializedComponentBatch>

Rotations via axis + angle.

quaternions: Option<SerializedComponentBatch>

Rotations via quaternion.

scales: Option<SerializedComponentBatch>

Scaling factors.

mat3x3: Option<SerializedComponentBatch>

3x3 transformation matrices.

Implementations

impl InstancePoses3D

pub fn descriptor_translations() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::translations.

pub fn descriptor_rotation_axis_angles() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::rotation_axis_angles.

pub fn descriptor_quaternions() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::quaternions.

pub fn descriptor_scales() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::scales.

pub fn descriptor_mat3x3() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::mat3x3.

pub fn descriptor_indicator() -> ComponentDescriptor

Returns the ComponentDescriptor for the associated indicator component.

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() -> InstancePoses3D

Create a new InstancePoses3D.

pub fn update_fields() -> InstancePoses3D

Update only some specific fields of a InstancePoses3D.

pub fn clear_fields() -> InstancePoses3D

Clear all the fields of a InstancePoses3D.

pub fn columns<I>( self, _lengths: I, ) -> Result<impl Iterator<Item = SerializedComponentColumn>, SerializationError>

where I: IntoIterator<Item = usize> + Clone,

Partitions the component data into multiple sub-batches.

Specifically, this transforms the existing SerializedComponentBatches data into SerializedComponentColumns instead, via SerializedComponentBatch::partitioned.

This makes it possible to use RecordingStream::send_columns to send columnar data directly into Rerun.

The specified lengths must sum to the total length of the component batch.

pub fn columns_of_unit_batches( self, ) -> Result<impl Iterator<Item = SerializedComponentColumn>, SerializationError>

Helper to partition the component data into unit-length sub-batches.

This is semantically similar to calling Self::columns with std::iter::take(1).repeat(n), where n is automatically guessed.

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

Translation vectors.

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

Rotations via axis + angle.

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

Rotations via quaternion.

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

Scaling factors.

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

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() -> SerializedComponentBatch

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

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

Returns all component descriptors that must be provided by the user when constructing this archetype.

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

Returns all component descriptors that should be provided by the user when constructing this archetype.

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

Returns all component descriptors that may be provided by the user when constructing this archetype.

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

Returns all component descriptors that must, should and may be provided by the user when constructing this archetype.

fn from_arrow_components( arrow_data: impl IntoIterator<Item = (ComponentDescriptor, Arc<dyn Array>)>, ) -> Result<InstancePoses3D, DeserializationError>

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

fn from_arrow( data: impl IntoIterator<Item = (Field, Arc<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_serialized_batches(&self) -> Vec<SerializedComponentBatch>

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

fn to_arrow(&self) -> Result<Vec<(Field, Arc<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<(), Error>

Formats the value using the given formatter.

impl Default for InstancePoses3D

fn default() -> InstancePoses3D

Returns the “default value” for a type.

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 how many bytes self uses on the heap.

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.

fn is_pod() -> bool

Is Self just plain old data?

impl ArchetypeReflectionMarker for InstancePoses3D

impl StructuralPartialEq for InstancePoses3D