Struct Transform3D

Source

pub struct Transform3D {
    pub translation: Option<SerializedComponentBatch>,
    pub rotation_axis_angle: Option<SerializedComponentBatch>,
    pub quaternion: Option<SerializedComponentBatch>,
    pub scale: Option<SerializedComponentBatch>,
    pub mat3x3: Option<SerializedComponentBatch>,
    pub relation: Option<SerializedComponentBatch>,
    pub child_frame: Option<SerializedComponentBatch>,
    pub parent_frame: Option<SerializedComponentBatch>,
}

Expand description

Archetype: A transform between two 3D spaces, i.e. a pose.

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 mat3x3 transform are present, the 3x3 matrix is applied first, followed by the translation.

Whenever you log this archetype, the state of the resulting transform relationship is fully reset to the new archetype. This means that if you first log a transform with only a translation, and then log one with only a rotation, it will be resolved to a transform with only a rotation. (This is unlike how we usually apply latest-at semantics on an archetype where we take the latest state of any component independently)

For transforms that affect only a single entity and do not propagate along the entity tree refer to archetypes::InstancePoses3D.

§Examples

§Variety of 3D transforms

use std::f32::consts::TAU;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rec = rerun::RecordingStreamBuilder::new("rerun_example_transform3d").spawn()?;

    let arrow = rerun::Arrows3D::from_vectors([(0.0, 1.0, 0.0)]).with_origins([(0.0, 0.0, 0.0)]);

    rec.log("base", &arrow)?;

    rec.log(
        "base/translated",
        &rerun::Transform3D::from_translation([1.0, 0.0, 0.0]),
    )?;

    rec.log("base/translated", &arrow)?;

    rec.log(
        "base/rotated_scaled",
        &rerun::Transform3D::from_rotation_scale(
            rerun::RotationAxisAngle::new([0.0, 0.0, 1.0], rerun::Angle::from_radians(TAU / 8.0)),
            rerun::Scale3D::from(2.0),
        ),
    )?;

    rec.log("base/rotated_scaled", &arrow)?;

    Ok(())
}

§Update a transform over time

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rec =
        rerun::RecordingStreamBuilder::new("rerun_example_transform3d_row_updates").spawn()?;

    rec.set_time_sequence("tick", 0);
    rec.log(
        "box",
        &[
            &rerun::Boxes3D::from_half_sizes([(4.0, 2.0, 1.0)])
                .with_fill_mode(rerun::FillMode::Solid) as &dyn rerun::AsComponents,
            &rerun::TransformAxes3D::new(10.0),
        ],
    )?;

    for t in 0..100 {
        rec.set_time_sequence("tick", t + 1);
        rec.log(
            "box",
            &rerun::Transform3D::default()
                .with_translation([0.0, 0.0, t as f32 / 10.0])
                .with_rotation(rerun::RotationAxisAngle::new(
                    [0.0, 1.0, 0.0],
                    rerun::Angle::from_radians(truncated_radians((t * 4) as f32)),
                )),
        )?;
    }

    Ok(())
}

fn truncated_radians(deg: f32) -> f32 {
    ((deg.to_radians() * 1000.0) as i32) as f32 / 1000.0
}

§Update a transform over time, in a single operation

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rec =
        rerun::RecordingStreamBuilder::new("rerun_example_transform3d_column_updates").spawn()?;

    rec.set_time_sequence("tick", 0);
    rec.log(
        "box",
        &[
            &rerun::Boxes3D::from_half_sizes([(4.0, 2.0, 1.0)])
                .with_fill_mode(rerun::FillMode::Solid) as &dyn rerun::AsComponents,
            &rerun::TransformAxes3D::new(10.0),
        ],
    )?;

    let translations = (0..100).map(|t| [0.0, 0.0, t as f32 / 10.0]);
    let rotations = (0..100)
        .map(|t| truncated_radians((t * 4) as f32))
        .map(|rad| rerun::RotationAxisAngle::new([0.0, 1.0, 0.0], rerun::Angle::from_radians(rad)));

    let ticks = rerun::TimeColumn::new_sequence("tick", 1..101);
    rec.send_columns(
        "box",
        [ticks],
        rerun::Transform3D::default()
            .with_many_translation(translations)
            .with_many_rotation_axis_angle(rotations)
            .columns_of_unit_batches()?,
    )?;

    Ok(())
}

fn truncated_radians(deg: f32) -> f32 {
    ((deg.to_radians() * 1000.0) as i32) as f32 / 1000.0
}

§Update specific properties of a transform over time

use rerun::AsComponents;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rec =
        rerun::RecordingStreamBuilder::new("rerun_example_transform3d_partial_updates").spawn()?;

    // Set up a 3D box.
    rec.log(
        "box",
        &[
            &rerun::Boxes3D::from_half_sizes([(4.0, 2.0, 1.0)])
                .with_fill_mode(rerun::FillMode::Solid) as &dyn AsComponents,
        ],
    )?;

    // Update only the rotation of the box.
    for deg in 0..=45 {
        let rad = truncated_radians((deg * 4) as f32);
        rec.log(
            "box",
            &rerun::Transform3D::new().with_rotation(rerun::RotationAxisAngle::new(
                [0.0, 1.0, 0.0],
                rerun::Angle::from_radians(rad),
            )),
        )?;
    }

    // Update only the position of the box.
    for t in 0..=50 {
        rec.log(
            "box",
            &rerun::Transform3D::new().with_translation([0.0, 0.0, t as f32 / 10.0]),
        )?;
    }

    // Update only the rotation of the box.
    for deg in 0..=45 {
        let rad = truncated_radians(((deg + 45) * 4) as f32);
        rec.log(
            "box",
            &rerun::Transform3D::new().with_rotation(rerun::RotationAxisAngle::new(
                [0.0, 1.0, 0.0],
                rerun::Angle::from_radians(rad),
            )),
        )?;
    }

    // Clear all of the box's attributes.
    rec.log("box", &rerun::Transform3D::clear_fields())?;

    Ok(())
}

fn truncated_radians(deg: f32) -> f32 {
    ((deg.to_radians() * 1000.0) as i32) as f32 / 1000.0
}