Struct Isometry3d

pub struct Isometry3d {
    pub rotation: Quat,
    pub translation: Vec3A,
}

An isometry in three dimensions, representing a rotation followed by a translation. This can often be useful for expressing relative positions and transformations from one position to another.

In particular, this type represents a distance-preserving transformation known as a rigid motion or a direct motion, and belongs to the special Euclidean group SE(3). This includes translation and rotation, but excludes reflection.

For the two-dimensional version, see Isometry2d.

Example

Isometries can be created from a given translation and rotation:

let iso = Isometry3d::new(Vec3::new(2.0, 1.0, 3.0), Quat::from_rotation_z(FRAC_PI_2));

Or from separate parts:

let iso1 = Isometry3d::from_translation(Vec3::new(2.0, 1.0, 3.0));
let iso2 = Isometry3d::from_rotation(Quat::from_rotation_z(FRAC_PI_2));

The isometries can be used to transform points:

let iso = Isometry3d::new(Vec3::new(2.0, 1.0, 3.0), Quat::from_rotation_z(FRAC_PI_2));
let point = Vec3::new(4.0, 4.0, 4.0);

// These are equivalent
let result = iso.transform_point(point);
let result = iso * point;

assert_relative_eq!(result, Vec3::new(-2.0, 5.0, 7.0));

Isometries can also be composed together:

assert_eq!(iso1 * iso2, iso);

One common operation is to compute an isometry representing the relative positions of two objects for things like intersection tests. This can be done with an inverse transformation:

let sphere_iso = Isometry3d::from_translation(Vec3::new(2.0, 1.0, 3.0));
let cuboid_iso = Isometry3d::from_rotation(Quat::from_rotation_z(FRAC_PI_2));

// Compute the relative position and orientation between the two shapes
let relative_iso = sphere_iso.inverse() * cuboid_iso;

// Or alternatively, to skip an extra rotation operation:
let relative_iso = sphere_iso.inverse_mul(cuboid_iso);

Fields

rotation: Quat

The rotational part of a three-dimensional isometry.

translation: Vec3A

The translational part of a three-dimensional isometry.

Implementations

impl Isometry3d

pub const IDENTITY: Self = _

The identity isometry which represents the rigid motion of not doing anything.

pub fn new(translation: impl Into<Vec3A>, rotation: Quat) -> Self

Create a three-dimensional isometry from a rotation and a translation.

pub fn from_rotation(rotation: Quat) -> Self

Create a three-dimensional isometry from a rotation.

pub fn from_translation(translation: impl Into<Vec3A>) -> Self

Create a three-dimensional isometry from a translation.

pub fn from_xyz(x: f32, y: f32, z: f32) -> Self

Create a three-dimensional isometry from a translation with the given x, y, and z components.

pub fn inverse(&self) -> Self

The inverse isometry that undoes this one.

pub fn inverse_mul(&self, rhs: Self) -> Self

Compute iso1.inverse() * iso2 in a more efficient way for one-shot cases.

If the same isometry is used multiple times, it is more efficient to instead compute the inverse once and use that for each transformation.

pub fn transform_point(&self, point: impl Into<Vec3A>) -> Vec3A

Transform a point by rotating and translating it using this isometry.

pub fn inverse_transform_point(&self, point: impl Into<Vec3A>) -> Vec3A

Transform a point by rotating and translating it using the inverse of this isometry.

This is more efficient than iso.inverse().transform_point(point) for one-shot cases. If the same isometry is used multiple times, it is more efficient to instead compute the inverse once and use that for each transformation.

Trait Implementations

impl Clone for Isometry3d

fn clone(&self) -> Isometry3d

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Isometry3d

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

Formats the value using the given formatter.

impl Default for Isometry3d

fn default() -> Isometry3d

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Isometry3d

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Isometry3d> for Affine3

fn from(iso: Isometry3d) -> Self

Converts to this type from the input type.

impl From<Isometry3d> for Affine3A

fn from(iso: Isometry3d) -> Self

Converts to this type from the input type.

impl From<Quat> for Isometry3d

fn from(rotation: Quat) -> Self

Converts to this type from the input type.

impl From<Vec3> for Isometry3d

fn from(translation: Vec3) -> Self

Converts to this type from the input type.

impl From<Vec3A> for Isometry3d

fn from(translation: Vec3A) -> Self

Converts to this type from the input type.

impl FromReflect for Isometry3d

where Isometry3d: Any + Send + Sync, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for Isometry3d

where Isometry3d: Any + Send + Sync, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl Mul<Dir3> for Isometry3d

type Output = Dir3

The resulting type after applying the * operator.

fn mul(self, rhs: Dir3) -> Self::Output

Performs the * operation.

impl Mul<Vec3> for Isometry3d

type Output = Vec3

The resulting type after applying the * operator.

fn mul(self, rhs: Vec3) -> Self::Output

Performs the * operation.

impl Mul<Vec3A> for Isometry3d

type Output = Vec3A

The resulting type after applying the * operator.

fn mul(self, rhs: Vec3A) -> Self::Output

Performs the * operation.

impl Mul for Isometry3d

type Output = Isometry3d

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl PartialEq for Isometry3d

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialReflect for Isometry3d

where Isometry3d: Any + Send + Sync, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn clone_value(&self) -> Box<dyn PartialReflect>

Clones the value as a Reflect trait object.

fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for Isometry3d

where Isometry3d: Any + Send + Sync, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Serialize for Isometry3d

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Struct for Isometry3d

where Isometry3d: Any + Send + Sync, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn field(&self, name: &str) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut(&mut self, name: &str) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for Isometry3d

where Isometry3d: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for Isometry3d

where Isometry3d: Any + Send + Sync, Quat: FromReflect + TypePath + MaybeTyped + RegisterForReflection, Vec3A: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for Isometry3d

impl StructuralPartialEq for Isometry3d