Struct Isometry2d 

pub struct Isometry2d {
    pub rotation: Rot2,
    pub translation: Vec2,
}

An isometry in two 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(2). This includes translation and rotation, but excludes reflection.

For the three-dimensional version, see Isometry3d.

Example

Isometries can be created from a given translation and rotation:

let iso = Isometry2d::new(Vec2::new(2.0, 1.0), Rot2::degrees(90.0));

Or from separate parts:

let iso1 = Isometry2d::from_translation(Vec2::new(2.0, 1.0));
let iso2 = Isometry2d::from_rotation(Rot2::degrees(90.0));

The isometries can be used to transform points:

let iso = Isometry2d::new(Vec2::new(2.0, 1.0), Rot2::degrees(90.0));
let point = Vec2::new(4.0, 4.0);

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

assert_eq!(result, Vec2::new(-2.0, 5.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 circle_iso = Isometry2d::from_translation(Vec2::new(2.0, 1.0));
let rectangle_iso = Isometry2d::from_rotation(Rot2::degrees(90.0));

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

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

Fields

rotation: Rot2

The rotational part of a two-dimensional isometry.

translation: Vec2

The translational part of a two-dimensional isometry.

Implementations

impl Isometry2d

pub const IDENTITY: Isometry2d

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

pub const fn new(translation: Vec2, rotation: Rot2) -> Isometry2d

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

Examples found in repository

examples/2d/mesh2d_arcs.rs (line 112)

fn draw_bounds<Shape: Bounded2d + Send + Sync + 'static>(
    q: Query<(&DrawBounds<Shape>, &GlobalTransform)>,
    mut gizmos: Gizmos,
) {
    for (shape, transform) in &q {
        let (_, rotation, translation) = transform.to_scale_rotation_translation();
        let translation = translation.truncate();
        let rotation = rotation.to_euler(EulerRot::XYZ).2;
        let isometry = Isometry2d::new(translation, Rot2::radians(rotation));

        let aabb = shape.0.aabb_2d(isometry);
        gizmos.rect_2d(aabb.center(), aabb.half_size() * 2.0, RED);

        let bounding_circle = shape.0.bounding_circle(isometry);
        gizmos.circle_2d(bounding_circle.center, bounding_circle.radius(), BLUE);
    }
}

examples/gizmos/anchored_text_gizmos.rs (line 39)

fn anchors(mut text_gizmos: Gizmos, time: Res<Time>) {
    let t = time.elapsed_secs();
    for (label, anchor, color) in [
        ("left", vec2(-0.5, 0.0), RED),
        ("right", vec2(0.5, 0.0), ORANGE),
        ("center", Vec2::ZERO, YELLOW),
        ("top", vec2(0.0, 0.5), GREEN),
        ("bottom", vec2(0.0, -0.5), BLUE),
    ] {
        let position = Vec2::splat(350.0) * anchor;
        text_gizmos.text_2d(
            Isometry2d::from_translation(position),
            "+",
            12.,
            Vec2::ZERO,
            Color::WHITE,
        );
        text_gizmos.text_2d(
            Isometry2d::new(position, Rot2::radians(t)),
            label,
            25.,
            anchor,
            color,
        );
    }
}

examples/math/bounding_2d.rs (line 106)

fn render_shapes(mut gizmos: Gizmos, query: Query<(&Shape, &Transform)>) {
    let color = GRAY;
    for (shape, transform) in query.iter() {
        let translation = transform.translation.xy();
        let rotation = transform.rotation.to_euler(EulerRot::YXZ).2;
        let isometry = Isometry2d::new(translation, Rot2::radians(rotation));
        match shape {
            Shape::Rectangle(r) => {
                gizmos.primitive_2d(r, isometry, color);
            }
            Shape::Circle(c) => {
                gizmos.primitive_2d(c, isometry, color);
            }
            Shape::Triangle(t) => {
                gizmos.primitive_2d(t, isometry, color);
            }
            Shape::Line(l) => {
                gizmos.primitive_2d(l, isometry, color);
            }
            Shape::Capsule(c) => {
                gizmos.primitive_2d(c, isometry, color);
            }
            Shape::Polygon(p) => {
                gizmos.primitive_2d(p, isometry, color);
            }
        }
    }
}

#[derive(Component)]
enum DesiredVolume {
    Aabb,
    Circle,
}

#[derive(Component, Debug)]
enum CurrentVolume {
    Aabb(Aabb2d),
    Circle(BoundingCircle),
}

fn update_volumes(
    mut commands: Commands,
    query: Query<
        (Entity, &DesiredVolume, &Shape, &Transform),
        Or<(Changed<DesiredVolume>, Changed<Shape>, Changed<Transform>)>,
    >,
) {
    for (entity, desired_volume, shape, transform) in query.iter() {
        let translation = transform.translation.xy();
        let rotation = transform.rotation.to_euler(EulerRot::YXZ).2;
        let isometry = Isometry2d::new(translation, Rot2::radians(rotation));
        match desired_volume {
            DesiredVolume::Aabb => {
                let aabb = match shape {
                    Shape::Rectangle(r) => r.aabb_2d(isometry),
                    Shape::Circle(c) => c.aabb_2d(isometry),
                    Shape::Triangle(t) => t.aabb_2d(isometry),
                    Shape::Line(l) => l.aabb_2d(isometry),
                    Shape::Capsule(c) => c.aabb_2d(isometry),
                    Shape::Polygon(p) => p.aabb_2d(isometry),
                };
                commands.entity(entity).insert(CurrentVolume::Aabb(aabb));
            }
            DesiredVolume::Circle => {
                let circle = match shape {
                    Shape::Rectangle(r) => r.bounding_circle(isometry),
                    Shape::Circle(c) => c.bounding_circle(isometry),
                    Shape::Triangle(t) => t.bounding_circle(isometry),
                    Shape::Line(l) => l.bounding_circle(isometry),
                    Shape::Capsule(c) => c.bounding_circle(isometry),
                    Shape::Polygon(p) => p.bounding_circle(isometry),
                };
                commands
                    .entity(entity)
                    .insert(CurrentVolume::Circle(circle));
            }
        }
    }
}

examples/math/custom_primitives.rs (line 292)

fn bounding_shapes_2d(
    shapes: Query<&Transform, With<Shape2d>>,
    mut gizmos: Gizmos,
    bounding_shape: Res<State<BoundingShape>>,
) {
    for transform in shapes.iter() {
        // Get the rotation angle from the 3D rotation.
        let rotation = transform.rotation.to_scaled_axis().z;
        let rotation = Rot2::radians(rotation);
        let isometry = Isometry2d::new(transform.translation.xy(), rotation);

        match bounding_shape.get() {
            BoundingShape::None => (),
            BoundingShape::BoundingBox => {
                // Get the AABB of the primitive with the rotation and translation of the mesh.
                let aabb = HEART.aabb_2d(isometry);
                gizmos.rect_2d(aabb.center(), aabb.half_size() * 2., WHITE);
            }
            BoundingShape::BoundingSphere => {
                // Get the bounding sphere of the primitive with the rotation and translation of the mesh.
                let bounding_circle = HEART.bounding_circle(isometry);
                gizmos
                    .circle_2d(bounding_circle.center(), bounding_circle.radius(), WHITE)
                    .resolution(64);
            }
        }
    }
}

examples/math/render_primitives.rs (line 433)

fn draw_gizmos_2d(mut gizmos: Gizmos, state: Res<State<PrimitiveSelected>>, time: Res<Time>) {
    const POSITION: Vec2 = Vec2::new(-LEFT_RIGHT_OFFSET_2D, 0.0);
    let angle = time.elapsed_secs();
    let isometry = Isometry2d::new(POSITION, Rot2::radians(angle));
    let color = Color::WHITE;

    #[expect(
        clippy::match_same_arms,
        reason = "Certain primitives don't have any 2D rendering support yet."
    )]
    match state.get() {
        PrimitiveSelected::RectangleAndCuboid => {
            gizmos.primitive_2d(&RECTANGLE, isometry, color);
        }
        PrimitiveSelected::CircleAndSphere => {
            gizmos.primitive_2d(&CIRCLE, isometry, color);
        }
        PrimitiveSelected::Ellipse => drop(gizmos.primitive_2d(&ELLIPSE, isometry, color)),
        PrimitiveSelected::Triangle => gizmos.primitive_2d(&TRIANGLE_2D, isometry, color),
        PrimitiveSelected::Plane => gizmos.primitive_2d(&PLANE_2D, isometry, color),
        PrimitiveSelected::Line => drop(gizmos.primitive_2d(&LINE_2D, isometry, color)),
        PrimitiveSelected::Segment => {
            drop(gizmos.primitive_2d(&SEGMENT_2D, isometry, color));
        }
        PrimitiveSelected::Polyline => gizmos.primitive_2d(
            &Polyline2d {
                vertices: POLYLINE_2D_VERTICES.to_vec(),
            },
            isometry,
            color,
        ),
        PrimitiveSelected::ConvexPolygon => gizmos.primitive_2d(
            &Polygon::from(ConvexPolygon::new(CONVEX_POLYGON_VERTICES).unwrap()),
            isometry,
            color,
        ),
        PrimitiveSelected::Polygon => gizmos.primitive_2d(
            &Polygon {
                vertices: vec![
                    Vec2::new(-BIG_2D, -SMALL_2D),
                    Vec2::new(BIG_2D, -SMALL_2D),
                    Vec2::new(BIG_2D, SMALL_2D),
                    Vec2::new(0.0, 0.0),
                    Vec2::new(-BIG_2D, SMALL_2D),
                ],
            },
            isometry,
            color,
        ),
        PrimitiveSelected::RegularPolygon => {
            gizmos.primitive_2d(&REGULAR_POLYGON, isometry, color);
        }
        PrimitiveSelected::Capsule => gizmos.primitive_2d(&CAPSULE_2D, isometry, color),
        PrimitiveSelected::Cylinder => {}
        PrimitiveSelected::Cone => {}
        PrimitiveSelected::ConicalFrustum => {}
        PrimitiveSelected::Torus => drop(gizmos.primitive_2d(&ANNULUS, isometry, color)),
        PrimitiveSelected::Tetrahedron => {}
        PrimitiveSelected::Arc => gizmos.primitive_2d(&ARC, isometry, color),
        PrimitiveSelected::CircularSector => {
            gizmos.primitive_2d(&CIRCULAR_SECTOR, isometry, color);
        }
        PrimitiveSelected::CircularSegment => {
            gizmos.primitive_2d(&CIRCULAR_SEGMENT, isometry, color);
        }
    }
}

pub const fn from_rotation(rotation: Rot2) -> Isometry2d

Create a two-dimensional isometry from a rotation.

pub const fn from_translation(translation: Vec2) -> Isometry2d

Create a two-dimensional isometry from a translation.

Examples found in repository

examples/gizmos/anchored_text_gizmos.rs (line 32)

fn anchors(mut text_gizmos: Gizmos, time: Res<Time>) {
    let t = time.elapsed_secs();
    for (label, anchor, color) in [
        ("left", vec2(-0.5, 0.0), RED),
        ("right", vec2(0.5, 0.0), ORANGE),
        ("center", Vec2::ZERO, YELLOW),
        ("top", vec2(0.0, 0.5), GREEN),
        ("bottom", vec2(0.0, -0.5), BLUE),
    ] {
        let position = Vec2::splat(350.0) * anchor;
        text_gizmos.text_2d(
            Isometry2d::from_translation(position),
            "+",
            12.,
            Vec2::ZERO,
            Color::WHITE,
        );
        text_gizmos.text_2d(
            Isometry2d::new(position, Rot2::radians(t)),
            label,
            25.,
            anchor,
            color,
        );
    }
}

examples/gizmos/2d_text_gizmos.rs (line 69)

fn draw_labels(mut text_gizmos: Gizmos, diagnostic: Res<DiagnosticsStore>) {
    let colors = [RED, GREEN, BLUE, YELLOW];
    for i in 0..TEXT_COUNT {
        let row = i / 5;
        let col = i % 5;
        let color = colors[i % 4];
        text_gizmos.text_2d(
            Isometry2d {
                translation: Vec2::new(
                    START_X + col as f32 * X_STEP,
                    START_Y - row as f32 * Y_STEP,
                ),
                rotation: Rot2::degrees(2.),
            },
            &format!("label {i}"),
            25.,
            Vec2::ZERO,
            color,
        );
    }

    if let Some(fps) = diagnostic.get(&FrameTimeDiagnosticsPlugin::FPS)
        && let Some(fps_smoothed) = fps.smoothed()
    {
        text_gizmos.text_2d(
            Isometry2d::from_translation(Vec2::new(600., START_Y + 150.)),
            &format!("fps: {:.1}", fps_smoothed),
            25.,
            Vec2::ZERO,
            Color::WHITE,
        );
    }

    text_gizmos.text_2d(
        Isometry2d::from_translation(Vec2::new(-300., START_Y + 200.)),
        "lxgh",
        150.,
        Vec2::ZERO,
        Color::WHITE,
    );
}

examples/testbed/2d.rs (line 396)

    pub fn draw_gizmos(mut gizmos: Gizmos) {
        gizmos.rect_2d(
            Isometry2d::from_translation(Vec2::new(-200.0, 0.0)),
            Vec2::new(200.0, 200.0),
            RED,
        );
        gizmos
            .circle_2d(
                Isometry2d::from_translation(Vec2::new(-200.0, 0.0)),
                200.0,
                GREEN,
            )
            .resolution(64);

        gizmos.text_2d(
            Isometry2d::from_translation(Vec2::new(-200.0, 0.0)),
            "text_2d gizmo",
            15.,
            Vec2 { x: 0., y: 0. },
            Color::WHITE,
        );

        // 2d grids with all variations of outer edges on or off
        for i in 0..4 {
            let x = 200.0 * (1.0 + (i % 2) as f32);
            let y = 150.0 * (0.5 - (i / 2) as f32);
            let mut grid = gizmos.grid(
                Vec3::new(x, y, 0.0),
                UVec2::new(5, 4),
                Vec2::splat(30.),
                Color::WHITE,
            );
            if i & 1 > 0 {
                grid = grid.outer_edges_x();
            }
            if i & 2 > 0 {
                grid.outer_edges_y();
            }
        }
    }

pub const fn from_xy(x: f32, y: f32) -> Isometry2d

Create a two-dimensional isometry from a translation with the given x and y components.

Examples found in repository

examples/gizmos/2d_text_gizmos.rs (line 98)

fn draw_all_glyphs(mut text_gizmos: Gizmos) {
    text_gizmos.text_2d(
        Isometry2d::from_xy(600., 0.),
        ALL_GLYPHS,
        30.0,
        Vec2::ZERO,
        Color::WHITE,
    );
}

pub fn inverse(&self) -> Isometry2d

The inverse isometry that undoes this one.

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

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: Vec2) -> Vec2

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

pub fn inverse_transform_point(&self, point: Vec2) -> Vec2

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 Isometry2d

fn clone(&self) -> Isometry2d

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Isometry2d

impl Debug for Isometry2d

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

Formats the value using the given formatter.

impl Default for Isometry2d

fn default() -> Isometry2d

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Isometry2d

fn deserialize<__D>( __deserializer: __D, ) -> Result<Isometry2d, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Ease for Isometry2d

fn interpolating_curve_unbounded( start: Isometry2d, end: Isometry2d, ) -> impl Curve<Isometry2d>

Given start and end values, produce a curve with unlimited domain that:

impl From<Isometry2d> for Affine2

fn from(iso: Isometry2d) -> Affine2

Converts to this type from the input type.

impl From<Rot2> for Isometry2d

fn from(rotation: Rot2) -> Isometry2d

Converts to this type from the input type.

impl From<Vec2> for Isometry2d

fn from(translation: Vec2) -> Isometry2d

Converts to this type from the input type.

impl FromArg for Isometry2d

type This<'from_arg> = Isometry2d

The type to convert into.

fn from_arg(arg: Arg<'_>) -> Result<<Isometry2d as FromArg>::This<'_>, ArgError>

Creates an item from an argument.

impl FromReflect for Isometry2d

fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<Isometry2d>

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 GetOwnership for Isometry2d

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetTypeRegistration for Isometry2d

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 IntoReturn for Isometry2d

fn into_return<'into_return>(self) -> Return<'into_return>

where Isometry2d: 'into_return,

Converts Self into a Return value.

impl Mul for Isometry2d

type Output = Isometry2d

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Dir2> for Isometry2d

type Output = Dir2

The resulting type after applying the * operator.

fn mul(self, rhs: Dir2) -> <Isometry2d as Mul<Dir2>>::Output

Performs the * operation.

impl Mul<Vec2> for Isometry2d

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2) -> <Isometry2d as Mul<Vec2>>::Output

Performs the * operation.

impl PartialEq for Isometry2d

fn eq(&self, other: &Isometry2d) -> 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 Isometry2d

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

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> 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<Isometry2d>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Isometry2d>, ) -> 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 + 'static)>

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

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

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

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

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

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

Returns a “partial equality” comparison result.

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

Returns a “partial comparison” result.

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

Debug formatter for the value.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

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

Applies a reflected value to this value.

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

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

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

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

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for Isometry2d

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

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

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

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

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

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 Isometry2d

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 Struct for Isometry2d

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

Gets 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 + 'static)>

Gets 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 + 'static)>

Gets 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 + 'static)>

Gets 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>

Gets the name of the field with index index.

fn index_of_name(&self, name: &str) -> Option<usize>

Gets the index of the field with the given name.

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 to_dynamic_struct(&self) -> DynamicStruct

Creates a new DynamicStruct from this struct.

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

Will return None if TypeInfo is not available.

impl StructuralPartialEq for Isometry2d

impl TypePath for Isometry2d

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 Isometry2d

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.