Struct Transform3D 

pub struct Transform3D<T>
where
    T: Copy + Debug + 'static,
{ /* private fields */ }

Transform3D represents a 3D transformation (rotation + translation) When the glam feature is enabled, it uses glam’s optimized types internally

Implementations

impl<T> Transform3D<T>

where T: Copy + Debug + Default + 'static,

pub fn from_matrix(mat: [[T; 4]; 4]) -> Transform3D<T>

Create a transform from a 4x4 matrix

Examples found in repository

examples/payload_usage.rs (lines 19-24)

fn main() {
    println!("Cu Transform - CuMsg Pattern Demo");
    println!("=================================");
    println!();

    // Create a transform tree
    let mut tree = TransformTree::<f32>::new();
    let clock = RobotClock::default();

    // Create transforms using the new CuMsg pattern
    println!("Creating transforms with CuMsg...");

    // World to base transform
    let transform1 = Transform3D::from_matrix([
        [1.0f32, 0.0, 0.0, 0.0], // Column-major: each inner array is a column
        [0.0, 1.0, 0.0, 0.0],
        [0.0, 0.0, 1.0, 0.0],
        [1.0, 0.0, 0.0, 1.0], // Translation (1, 0, 0)
    ]);

    let frame_transform = FrameTransform::new(
        transform1,
        FrameIdString::from("world").expect("Frame name too long"),
        FrameIdString::from("base").expect("Frame name too long"),
    );
    let mut sft = StampedFrameTransform::new(Some(frame_transform));
    sft.tov = Tov::Time(CuDuration(1_000_000_000)); // 1 second

    // Add to tree using the new API
    tree.add_transform(&sft).expect("Failed to add transform");
    println!("  Added world->base transform at t=1s");

    // Base to arm transform
    let transform2 = Transform3D::from_matrix([
        [0.0, 1.0, 0.0, 0.0], // 90-degree rotation around Z
        [-1.0, 0.0, 0.0, 0.0],
        [0.0, 0.0, 1.0, 0.0],
        [0.5, 0.0, 0.0, 1.0], // Translation (0.5, 0, 0)
    ]);

    let msg2 = FrameTransform::new(
        transform2,
        FrameIdString::from("base").expect("Frame name too long"),
        FrameIdString::from("arm").expect("Frame name too long"),
    );
    let mut sft = StampedFrameTransform::new(Some(msg2));
    sft.tov = Tov::Time(CuDuration(1_000_000_000)); // 1 second

    tree.add_transform(&sft).expect("Failed to add transform");
    println!("  Added base->arm transform at t=1s");

    // Demonstrate using time ranges for a broadcast
    println!("\nBroadcasting multiple transforms with time range...");

    // Create multiple transforms at different times
    let times = [
        CuDuration(2_000_000_000), // 2 seconds
        CuDuration(2_100_000_000), // 2.1 seconds
        CuDuration(2_200_000_000),
    ];

    for (i, &time) in times.iter().enumerate() {
        let x_translation = 1.0 + (i as f32) * 0.1;
        let transform = Transform3D::from_matrix([
            [1.0, 0.0, 0.0, 0.0],
            [0.0, 1.0, 0.0, 0.0],
            [0.0, 0.0, 1.0, 0.0],
            [x_translation, 0.0, 0.0, 1.0],
        ]);

        let msg = FrameTransform::new(
            transform,
            FrameIdString::from("world").expect("Frame name too long"),
            FrameIdString::from("base").expect("Frame name too long"),
        );
        let mut sft = StampedFrameTransform::new(Some(msg));

        // For a broadcast with multiple transforms, use Range
        if i == 0 {
            sft.tov = Tov::Range(cu29::clock::CuTimeRange {
                start: times[0],
                end: *times.last().unwrap(),
            });
        } else {
            sft.tov = Tov::Time(time);
        }

        tree.add_transform(&sft).expect("Failed to add transform");
    }

    println!("  Added 3 transforms with time range 2.0s - 2.2s");

    // Query the tree
    println!("\nQuerying transforms...");

    let result = tree.lookup_transform("world", "arm", CuDuration(1_000_000_000), &clock);
    match result {
        Ok(transform) => {
            let mat = transform.to_matrix();
            println!(
                "  World->arm at t=1s: translation=({:.2}, {:.2}, {:.2})",
                mat[3][0], mat[3][1], mat[3][2]
            );
        }
        Err(e) => println!("  Error: {e}"),
    }

    // Query velocity (requires transforms at multiple times)
    let velocity = tree.lookup_velocity("world", "base", CuDuration(2_100_000_000), &clock);
    match velocity {
        Ok(vel) => {
            println!(
                "  World->base velocity at t=2.1s: linear=({:.2}, {:.2}, {:.2}) m/s",
                vel.linear[0], vel.linear[1], vel.linear[2]
            );
        }
        Err(e) => println!("  Error computing velocity: {e}"),
    }

    println!("\nKey advantages of CuMsg pattern:");
    println!("- Integrates with Copper message system");
    println!("- Timestamps handled by CuMsg metadata (Tov)");
    println!("- Supports time ranges for broadcasts");
}

examples/basic_usage.rs (lines 19-24)

fn main() {
    // Example using the typed transform approach
    println!("Cu Transform - New Typed Approach Demo");
    println!("=====================================");

    // Create a buffer for world -> robot transforms
    let mut world_to_robot_buffer: TypedTransformBuffer<f32, WorldFrame, RobotFrame, 10> =
        TypedTransformBuffer::new();

    // Create a transform message
    let transform = Transform3D::from_matrix([
        [1.0, 0.0, 0.0, 1.0], // X translation
        [0.0, 1.0, 0.0, 2.0], // Y translation
        [0.0, 0.0, 1.0, 0.0],
        [0.0, 0.0, 0.0, 1.0],
    ]);

    let world_to_robot_msg = TypedTransform::new(transform, CuDuration(1000));

    println!(
        "Created transform from {} to {}",
        world_to_robot_msg.parent_name(),
        world_to_robot_msg.child_name()
    );
    if let Some(t) = world_to_robot_msg.transform() {
        let mat = t.to_matrix();
        println!(
            "  Translation: [{}, {}, {}]",
            mat[0][3], mat[1][3], mat[2][3]
        );
    }

    // Add to buffer
    world_to_robot_buffer.add_transform(world_to_robot_msg);

    // Create second transform
    let transform2 = Transform3D::from_matrix([
        [1.0, 0.0, 0.0, 2.0], // X translation
        [0.0, 1.0, 0.0, 4.0], // Y translation
        [0.0, 0.0, 1.0, 0.0],
        [0.0, 0.0, 0.0, 1.0],
    ]);

    let world_to_robot_msg2 = TypedTransform::new(transform2, CuDuration(2000));
    world_to_robot_buffer.add_transform(world_to_robot_msg2);

    // Query the buffer
    if let Some(latest) = world_to_robot_buffer.get_latest_transform() {
        println!(
            "\nLatest transform at time {}:",
            latest.timestamp().unwrap().as_nanos()
        );
        if let Some(t) = latest.transform() {
            let mat = t.to_matrix();
            println!(
                "  Translation: [{}, {}, {}]",
                mat[0][3], mat[1][3], mat[2][3]
            );
        }
    }

    // Query closest to a specific time
    if let Some(closest) = world_to_robot_buffer.get_closest_transform(CuDuration(1500)) {
        println!("\nClosest transform to time 1500:");
        println!("  Actual time: {}", closest.timestamp().unwrap().as_nanos());
        if let Some(t) = closest.transform() {
            let mat = t.to_matrix();
            println!(
                "  Translation: [{}, {}, {}]",
                mat[0][3], mat[1][3], mat[2][3]
            );
        }
    }

    // Demonstrate time range
    if let Some(range) = world_to_robot_buffer.get_time_range() {
        println!(
            "\nTime range: {} to {}",
            range.start.as_nanos(),
            range.end.as_nanos()
        );
    }

    // Demonstrate velocity computation
    if let Some(latest) = world_to_robot_buffer.get_latest_transform() {
        if let Some(closest) = world_to_robot_buffer.get_closest_transform(CuDuration(1000)) {
            if let Some(velocity) = latest.compute_velocity(closest) {
                println!("\nVelocity computation:");
                println!(
                    "  Linear velocity: [{}, {}, {}]",
                    velocity.linear[0], velocity.linear[1], velocity.linear[2]
                );
            }
        }
    }

    // Demonstrate the stringly typed version of the API.
    println!("\n\nConstant-Size Buffer Demo");
    println!("===========================================");

    let mut const_buffer: ConstTransformBuffer<f32, 5> = ConstTransformBuffer::new();

    // Add some stamped transforms
    let stamped_transform = StampedTransform {
        transform,
        stamp: CuDuration(1000),
        parent_frame: "world".try_into().unwrap(),
        child_frame: "robot".try_into().unwrap(),
    };

    const_buffer.add_transform(stamped_transform);

    if let Some(latest_stamped) = const_buffer.get_latest_transform() {
        println!("Latest transform in constant buffer:");
        println!(
            "  From: {} to: {}",
            latest_stamped.parent_frame, latest_stamped.child_frame
        );
        println!("  Time: {}", latest_stamped.stamp.as_nanos());
        let mat = latest_stamped.transform.to_matrix();
        println!(
            "  Translation: [{}, {}, {}]",
            mat[0][3], mat[1][3], mat[2][3]
        );
    }

    println!("\nThis buffer is stack-allocated with capacity 5 - no heap allocation!");

    // Demonstrate the StampedFrameTransform pattern with TransformTree
    println!("\n\nStampedFrameTransform Pattern Demo");
    println!("================================");

    let mut tree = TransformTree::<f32>::new();

    // Create a CuMsg with TransformMsg
    let frame_transform = FrameTransform::new(
        transform,
        FrameIdString::from("world").expect("Frame name too long"),
        FrameIdString::from("robot").expect("Frame name too long"),
    );

    let mut sft = StampedFrameTransform::new(Some(frame_transform));
    sft.tov = Tov::Time(CuDuration(1_000_000_000)); // 1 second

    // Add using the new API
    tree.add_transform(&sft).expect("Failed to add transform");
    println!("Added transform using CuMsg<TransformMsg> pattern");

    // Query the transform
    let robot_clock = cu29::clock::RobotClock::default();
    let result = tree.lookup_transform("world", "robot", CuDuration(1_000_000_000), &robot_clock);

    match result {
        Ok(transform) => {
            let mat = transform.to_matrix();
            println!(
                "Retrieved transform: translation=({:.2}, {:.2}, {:.2})",
                mat[3][0], mat[3][1], mat[3][2]
            );
        }
        Err(e) => println!("Error: {e}"),
    }
}

pub fn to_matrix(self) -> [[T; 4]; 4]

Get the transform as a 4x4 matrix

Examples found in repository

examples/payload_usage.rs (line 104)

fn main() {
    println!("Cu Transform - CuMsg Pattern Demo");
    println!("=================================");
    println!();

    // Create a transform tree
    let mut tree = TransformTree::<f32>::new();
    let clock = RobotClock::default();

    // Create transforms using the new CuMsg pattern
    println!("Creating transforms with CuMsg...");

    // World to base transform
    let transform1 = Transform3D::from_matrix([
        [1.0f32, 0.0, 0.0, 0.0], // Column-major: each inner array is a column
        [0.0, 1.0, 0.0, 0.0],
        [0.0, 0.0, 1.0, 0.0],
        [1.0, 0.0, 0.0, 1.0], // Translation (1, 0, 0)
    ]);

    let frame_transform = FrameTransform::new(
        transform1,
        FrameIdString::from("world").expect("Frame name too long"),
        FrameIdString::from("base").expect("Frame name too long"),
    );
    let mut sft = StampedFrameTransform::new(Some(frame_transform));
    sft.tov = Tov::Time(CuDuration(1_000_000_000)); // 1 second

    // Add to tree using the new API
    tree.add_transform(&sft).expect("Failed to add transform");
    println!("  Added world->base transform at t=1s");

    // Base to arm transform
    let transform2 = Transform3D::from_matrix([
        [0.0, 1.0, 0.0, 0.0], // 90-degree rotation around Z
        [-1.0, 0.0, 0.0, 0.0],
        [0.0, 0.0, 1.0, 0.0],
        [0.5, 0.0, 0.0, 1.0], // Translation (0.5, 0, 0)
    ]);

    let msg2 = FrameTransform::new(
        transform2,
        FrameIdString::from("base").expect("Frame name too long"),
        FrameIdString::from("arm").expect("Frame name too long"),
    );
    let mut sft = StampedFrameTransform::new(Some(msg2));
    sft.tov = Tov::Time(CuDuration(1_000_000_000)); // 1 second

    tree.add_transform(&sft).expect("Failed to add transform");
    println!("  Added base->arm transform at t=1s");

    // Demonstrate using time ranges for a broadcast
    println!("\nBroadcasting multiple transforms with time range...");

    // Create multiple transforms at different times
    let times = [
        CuDuration(2_000_000_000), // 2 seconds
        CuDuration(2_100_000_000), // 2.1 seconds
        CuDuration(2_200_000_000),
    ];

    for (i, &time) in times.iter().enumerate() {
        let x_translation = 1.0 + (i as f32) * 0.1;
        let transform = Transform3D::from_matrix([
            [1.0, 0.0, 0.0, 0.0],
            [0.0, 1.0, 0.0, 0.0],
            [0.0, 0.0, 1.0, 0.0],
            [x_translation, 0.0, 0.0, 1.0],
        ]);

        let msg = FrameTransform::new(
            transform,
            FrameIdString::from("world").expect("Frame name too long"),
            FrameIdString::from("base").expect("Frame name too long"),
        );
        let mut sft = StampedFrameTransform::new(Some(msg));

        // For a broadcast with multiple transforms, use Range
        if i == 0 {
            sft.tov = Tov::Range(cu29::clock::CuTimeRange {
                start: times[0],
                end: *times.last().unwrap(),
            });
        } else {
            sft.tov = Tov::Time(time);
        }

        tree.add_transform(&sft).expect("Failed to add transform");
    }

    println!("  Added 3 transforms with time range 2.0s - 2.2s");

    // Query the tree
    println!("\nQuerying transforms...");

    let result = tree.lookup_transform("world", "arm", CuDuration(1_000_000_000), &clock);
    match result {
        Ok(transform) => {
            let mat = transform.to_matrix();
            println!(
                "  World->arm at t=1s: translation=({:.2}, {:.2}, {:.2})",
                mat[3][0], mat[3][1], mat[3][2]
            );
        }
        Err(e) => println!("  Error: {e}"),
    }

    // Query velocity (requires transforms at multiple times)
    let velocity = tree.lookup_velocity("world", "base", CuDuration(2_100_000_000), &clock);
    match velocity {
        Ok(vel) => {
            println!(
                "  World->base velocity at t=2.1s: linear=({:.2}, {:.2}, {:.2}) m/s",
                vel.linear[0], vel.linear[1], vel.linear[2]
            );
        }
        Err(e) => println!("  Error computing velocity: {e}"),
    }

    println!("\nKey advantages of CuMsg pattern:");
    println!("- Integrates with Copper message system");
    println!("- Timestamps handled by CuMsg metadata (Tov)");
    println!("- Supports time ranges for broadcasts");
}

examples/basic_usage.rs (line 34)

fn main() {
    // Example using the typed transform approach
    println!("Cu Transform - New Typed Approach Demo");
    println!("=====================================");

    // Create a buffer for world -> robot transforms
    let mut world_to_robot_buffer: TypedTransformBuffer<f32, WorldFrame, RobotFrame, 10> =
        TypedTransformBuffer::new();

    // Create a transform message
    let transform = Transform3D::from_matrix([
        [1.0, 0.0, 0.0, 1.0], // X translation
        [0.0, 1.0, 0.0, 2.0], // Y translation
        [0.0, 0.0, 1.0, 0.0],
        [0.0, 0.0, 0.0, 1.0],
    ]);

    let world_to_robot_msg = TypedTransform::new(transform, CuDuration(1000));

    println!(
        "Created transform from {} to {}",
        world_to_robot_msg.parent_name(),
        world_to_robot_msg.child_name()
    );
    if let Some(t) = world_to_robot_msg.transform() {
        let mat = t.to_matrix();
        println!(
            "  Translation: [{}, {}, {}]",
            mat[0][3], mat[1][3], mat[2][3]
        );
    }

    // Add to buffer
    world_to_robot_buffer.add_transform(world_to_robot_msg);

    // Create second transform
    let transform2 = Transform3D::from_matrix([
        [1.0, 0.0, 0.0, 2.0], // X translation
        [0.0, 1.0, 0.0, 4.0], // Y translation
        [0.0, 0.0, 1.0, 0.0],
        [0.0, 0.0, 0.0, 1.0],
    ]);

    let world_to_robot_msg2 = TypedTransform::new(transform2, CuDuration(2000));
    world_to_robot_buffer.add_transform(world_to_robot_msg2);

    // Query the buffer
    if let Some(latest) = world_to_robot_buffer.get_latest_transform() {
        println!(
            "\nLatest transform at time {}:",
            latest.timestamp().unwrap().as_nanos()
        );
        if let Some(t) = latest.transform() {
            let mat = t.to_matrix();
            println!(
                "  Translation: [{}, {}, {}]",
                mat[0][3], mat[1][3], mat[2][3]
            );
        }
    }

    // Query closest to a specific time
    if let Some(closest) = world_to_robot_buffer.get_closest_transform(CuDuration(1500)) {
        println!("\nClosest transform to time 1500:");
        println!("  Actual time: {}", closest.timestamp().unwrap().as_nanos());
        if let Some(t) = closest.transform() {
            let mat = t.to_matrix();
            println!(
                "  Translation: [{}, {}, {}]",
                mat[0][3], mat[1][3], mat[2][3]
            );
        }
    }

    // Demonstrate time range
    if let Some(range) = world_to_robot_buffer.get_time_range() {
        println!(
            "\nTime range: {} to {}",
            range.start.as_nanos(),
            range.end.as_nanos()
        );
    }

    // Demonstrate velocity computation
    if let Some(latest) = world_to_robot_buffer.get_latest_transform() {
        if let Some(closest) = world_to_robot_buffer.get_closest_transform(CuDuration(1000)) {
            if let Some(velocity) = latest.compute_velocity(closest) {
                println!("\nVelocity computation:");
                println!(
                    "  Linear velocity: [{}, {}, {}]",
                    velocity.linear[0], velocity.linear[1], velocity.linear[2]
                );
            }
        }
    }

    // Demonstrate the stringly typed version of the API.
    println!("\n\nConstant-Size Buffer Demo");
    println!("===========================================");

    let mut const_buffer: ConstTransformBuffer<f32, 5> = ConstTransformBuffer::new();

    // Add some stamped transforms
    let stamped_transform = StampedTransform {
        transform,
        stamp: CuDuration(1000),
        parent_frame: "world".try_into().unwrap(),
        child_frame: "robot".try_into().unwrap(),
    };

    const_buffer.add_transform(stamped_transform);

    if let Some(latest_stamped) = const_buffer.get_latest_transform() {
        println!("Latest transform in constant buffer:");
        println!(
            "  From: {} to: {}",
            latest_stamped.parent_frame, latest_stamped.child_frame
        );
        println!("  Time: {}", latest_stamped.stamp.as_nanos());
        let mat = latest_stamped.transform.to_matrix();
        println!(
            "  Translation: [{}, {}, {}]",
            mat[0][3], mat[1][3], mat[2][3]
        );
    }

    println!("\nThis buffer is stack-allocated with capacity 5 - no heap allocation!");

    // Demonstrate the StampedFrameTransform pattern with TransformTree
    println!("\n\nStampedFrameTransform Pattern Demo");
    println!("================================");

    let mut tree = TransformTree::<f32>::new();

    // Create a CuMsg with TransformMsg
    let frame_transform = FrameTransform::new(
        transform,
        FrameIdString::from("world").expect("Frame name too long"),
        FrameIdString::from("robot").expect("Frame name too long"),
    );

    let mut sft = StampedFrameTransform::new(Some(frame_transform));
    sft.tov = Tov::Time(CuDuration(1_000_000_000)); // 1 second

    // Add using the new API
    tree.add_transform(&sft).expect("Failed to add transform");
    println!("Added transform using CuMsg<TransformMsg> pattern");

    // Query the transform
    let robot_clock = cu29::clock::RobotClock::default();
    let result = tree.lookup_transform("world", "robot", CuDuration(1_000_000_000), &robot_clock);

    match result {
        Ok(transform) => {
            let mat = transform.to_matrix();
            println!(
                "Retrieved transform: translation=({:.2}, {:.2}, {:.2})",
                mat[3][0], mat[3][1], mat[3][2]
            );
        }
        Err(e) => println!("Error: {e}"),
    }
}

impl Transform3D<f64>

pub fn translation( &self, ) -> [Quantity<dyn Dimension<J = Z0, M = Z0, N = Z0, I = Z0, Th = Z0, L = PInt<UInt<UTerm, B1>>, Kind = dyn Kind, T = Z0>, dyn Units<f64, amount_of_substance = mole, length = meter, electric_current = ampere, thermodynamic_temperature = kelvin, luminous_intensity = candela, mass = kilogram, time = second>, f64>; 3]

pub fn rotation( &self, ) -> [[Quantity<dyn Dimension<J = Z0, M = Z0, N = Z0, I = Z0, Th = Z0, L = Z0, Kind = dyn AngleKind, T = Z0>, dyn Units<f64, amount_of_substance = mole, length = meter, electric_current = ampere, thermodynamic_temperature = kelvin, luminous_intensity = candela, mass = kilogram, time = second>, f64>; 3]; 3]

impl Transform3D<f32>

pub fn translation( &self, ) -> [Quantity<dyn Dimension<J = Z0, M = Z0, N = Z0, I = Z0, Th = Z0, L = PInt<UInt<UTerm, B1>>, Kind = dyn Kind, T = Z0>, dyn Units<f32, amount_of_substance = mole, length = meter, electric_current = ampere, thermodynamic_temperature = kelvin, luminous_intensity = candela, mass = kilogram, time = second>, f32>; 3]

pub fn rotation( &self, ) -> [[Quantity<dyn Dimension<J = Z0, M = Z0, N = Z0, I = Z0, Th = Z0, L = Z0, Kind = dyn AngleKind, T = Z0>, dyn Units<f32, amount_of_substance = mole, length = meter, electric_current = ampere, thermodynamic_temperature = kelvin, luminous_intensity = candela, mass = kilogram, time = second>, f32>; 3]; 3]

impl Transform3D<f32>

pub fn inverse(&self) -> Transform3D<f32>

Computes the inverse of this transformation matrix.

impl Transform3D<f64>

pub fn inverse(&self) -> Transform3D<f64>

Computes the inverse of this transformation matrix.

Trait Implementations

impl<T> Clone for Transform3D<T>

where T: Clone + Copy + Debug + 'static,

fn clone(&self) -> Transform3D<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Transform3D<T>

where T: Debug + Copy + 'static,

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

Formats the value using the given formatter.

impl<T> Decode<()> for Transform3D<T>

where T: Copy + Debug + 'static + Decode<()> + Default,

fn decode<D>(decoder: &mut D) -> Result<Transform3D<T>, DecodeError>

where D: Decoder<Context = ()>,

Attempt to decode this type with the given Decode.

impl<T> Default for Transform3D<T>

where T: Copy + Debug + Default + 'static,

fn default() -> Transform3D<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Transform3D<T>

where T: Copy + Debug + 'static + Deserialize<'de> + Default,

fn deserialize<D>( deserializer: D, ) -> Result<Transform3D<T>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Encode for Transform3D<T>

where T: Copy + Debug + Default + 'static + Encode,

fn encode<E>(&self, encoder: &mut E) -> Result<(), EncodeError>

where E: Encoder,

Encode a given type.

impl From<Affine3A> for Transform3D<f32>

fn from(aff: Affine3A) -> Transform3D<f32>

Converts to this type from the input type.

impl From<DAffine3> for Transform3D<f64>

fn from(aff: DAffine3) -> Transform3D<f64>

Converts to this type from the input type.

impl HasInverse<f32> for Transform3D<f32>

fn inverse(&self) -> Self

impl HasInverse<f64> for Transform3D<f64>

fn inverse(&self) -> Self

impl Mul<&Transform3D<f32>> for Transform3D<f32>

type Output = Transform3D<f32>

The resulting type after applying the * operator.

fn mul( self, rhs: &Transform3D<f32>, ) -> <Transform3D<f32> as Mul<&Transform3D<f32>>>::Output

Performs the * operation.

impl Mul<&Transform3D<f64>> for Transform3D<f64>

type Output = Transform3D<f64>

The resulting type after applying the * operator.

fn mul( self, rhs: &Transform3D<f64>, ) -> <Transform3D<f64> as Mul<&Transform3D<f64>>>::Output

Performs the * operation.

impl Mul<Transform3D<f32>> for &Transform3D<f32>

type Output = Transform3D<f32>

The resulting type after applying the * operator.

fn mul( self, rhs: Transform3D<f32>, ) -> <&Transform3D<f32> as Mul<Transform3D<f32>>>::Output

Performs the * operation.

impl Mul<Transform3D<f64>> for &Transform3D<f64>

type Output = Transform3D<f64>

The resulting type after applying the * operator.

fn mul( self, rhs: Transform3D<f64>, ) -> <&Transform3D<f64> as Mul<Transform3D<f64>>>::Output

Performs the * operation.

impl Mul for &Transform3D<f32>

Reference implementations for f32

type Output = Transform3D<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: &Transform3D<f32>) -> <&Transform3D<f32> as Mul>::Output

Performs the * operation.

impl Mul for &Transform3D<f64>

Reference implementations for f64

type Output = Transform3D<f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Transform3D<f64>) -> <&Transform3D<f64> as Mul>::Output

Performs the * operation.

impl Mul for Transform3D<f32>

Implementation for f32

type Output = Transform3D<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Transform3D<f32>) -> <Transform3D<f32> as Mul>::Output

Performs the * operation.

impl Mul for Transform3D<f64>

Implementation for f64

type Output = Transform3D<f64>

The resulting type after applying the * operator.

fn mul(self, rhs: Transform3D<f64>) -> <Transform3D<f64> as Mul>::Output

Performs the * operation.

impl<T> Serialize for Transform3D<T>

where T: Copy + Debug + Default + 'static + Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Copy for Transform3D<T>

where T: Copy + Debug + 'static,