Struct amethyst_core::transform::components::Transform

pub struct Transform { /* private fields */ }

Local position, rotation, and scale (from parent if it exists).

Used for rendering position and orientation.

The transforms are preformed in this order: scale, then rotation, then translation.

Implementations

impl Transform

pub fn new(
    position: Translation3<f32>,
    rotation: UnitQuaternion<f32>,
    scale: Vector3<f32>
) -> Self

Create a new Transform.

Examples

let position = Translation3::new(0.0, 2.0, 4.0);
let rotation = UnitQuaternion::from_euler_angles(0.4, 0.2, 0.0);
let scale = Vector3::new(1.0, 1.0, 1.0);

let t = Transform::new(position, rotation, scale);

assert_eq!(t.translation().y, 2.0);

pub fn face_towards(
    &mut self,
    target: Vector3<f32>,
    up: Vector3<f32>
) -> &mut Self

Makes the entity point towards position.

up says which direction the entity should be ‘rolled’ to once it is pointing at position. If up is parallel to the direction the entity is looking, the result will be garbage.

This function only works with respect to the coordinate system of its parent, so when used with an object that’s not a sibling it will not do what you expect.

Examples

let mut t = Transform::default();
// No rotation by default
assert_eq!(*t.rotation().quaternion(), Quaternion::identity());
// look up with up pointing backwards
t.face_towards(Vector3::new(0.0, 1.0, 0.0), Vector3::new(0.0, 0.0, 1.0));
// our rotation should match the angle from straight ahead to straight up
let rotation = UnitQuaternion::rotation_between(
    &Vector3::new(0.0, 1.0, 0.0),
    &Vector3::new(0.0, 0.0, 1.0),
).unwrap();
assert_eq!(*t.rotation(), rotation);
// now if we move forwards by 1.0, we'll end up at the point we are facing
// (modulo some floating point error)
t.move_forward(1.0);
assert!((*t.translation() - Vector3::new(0.0, 1.0, 0.0)).magnitude() <= 0.0001);

pub fn matrix(&self) -> Matrix4<f32>

Returns the local object matrix for the transform.

Combined with the parent’s GlobalTransform component it gives the global (or world) matrix for the current entity.

pub fn translation(&self) -> &Vector3<f32>

Returns a reference to the translation vector.

pub fn translation_mut(&mut self) -> &mut Vector3<f32>

Returns a mutable reference to the translation vector.

pub fn rotation(&self) -> &UnitQuaternion<f32>

Returns a reference to the rotation quaternion.

pub fn rotation_mut(&mut self) -> &mut UnitQuaternion<f32>

Returns a mutable reference to the rotation quaternion.

pub fn scale(&self) -> &Vector3<f32>

Returns a reference to the scale vector.

pub fn scale_mut(&mut self) -> &mut Vector3<f32>

Returns a mutable reference to the scale vector.

pub fn isometry(&self) -> &Isometry3<f32>

Returns a reference to the isometry of the transform (translation and rotation combined).

pub fn isometry_mut(&mut self) -> &mut Isometry3<f32>

Returns a mutable reference to the isometry of the transform (translation and rotation combined).

pub fn move_global(&mut self, translation: Vector3<f32>) -> &mut Self

Move relatively to its current position.

pub fn move_local(&mut self, translation: Vector3<f32>) -> &mut Self

Move relatively to its current position and orientation.

Equivalent to rotating the translation before applying.

pub fn move_along_global(
    &mut self,
    direction: Unit<Vector3<f32>>,
    distance: f32
) -> &mut Self

Move a distance along an axis.

It will not move in the case where the axis is zero, for any distance.

pub fn move_along_local(
    &mut self,
    direction: Unit<Vector3<f32>>,
    distance: f32
) -> &mut Self

Move a distance along an axis.

It will not move in the case where the axis is zero, for any distance.

pub fn move_forward(&mut self, amount: f32) -> &mut Self

Move forward relative to current position and orientation.

pub fn move_backward(&mut self, amount: f32) -> &mut Self

Move backward relative to current position and orientation.

pub fn move_right(&mut self, amount: f32) -> &mut Self

Move right relative to current position and orientation.

pub fn move_left(&mut self, amount: f32) -> &mut Self

Move left relative to current position and orientation.

pub fn move_up(&mut self, amount: f32) -> &mut Self

Move up relative to current position and orientation.

pub fn move_down(&mut self, amount: f32) -> &mut Self

Move down relative to current position and orientation.

pub fn translate_x(&mut self, amount: f32) -> &mut Self

Adds the specified amount to the translation vector’s x component.

pub fn translate_y(&mut self, amount: f32) -> &mut Self

Adds the specified amount to the translation vector’s y component.

pub fn translate_z(&mut self, amount: f32) -> &mut Self

Adds the specified amount to the translation vector’s z component.

pub fn set_x(&mut self, value: f32) -> &mut Self

Sets the translation vector’s x component to the specified value.

pub fn set_y(&mut self, value: f32) -> &mut Self

Sets the translation vector’s y component to the specified value.

pub fn set_z(&mut self, value: f32) -> &mut Self

Sets the translation vector’s z component to the specified value.

pub fn pitch_global(&mut self, angle: f32) -> &mut Self

Pitch relatively to the world. angle is specified in radians.

pub fn pitch_local(&mut self, angle: f32) -> &mut Self

Pitch relatively to its own rotation. angle is specified in radians.

pub fn yaw_global(&mut self, angle: f32) -> &mut Self

Yaw relatively to the world. angle is specified in radians.

pub fn yaw_local(&mut self, angle: f32) -> &mut Self

Yaw relatively to its own rotation. angle is specified in radians.

pub fn roll_global(&mut self, angle: f32) -> &mut Self

Roll relatively to the world. angle is specified in radians.

pub fn roll_local(&mut self, angle: f32) -> &mut Self

Roll relatively to its own rotation. angle is specified in radians.

pub fn rotate_global(&mut self, axis: Unit<Vector3<f32>>, angle: f32) -> &mut Self

Rotate relatively to the world. angle is specified in radians.

pub fn rotate_local(&mut self, axis: Unit<Vector3<f32>>, angle: f32) -> &mut Self

Rotate relatively to the current orientation. angle is specified in radians.

pub fn set_position(&mut self, position: Vector3<f32>) -> &mut Self

Set the position.

pub fn translate_xyz(&mut self, x: f32, y: f32, z: f32) -> &mut Self

Adds the specified amounts to the translation vector.

pub fn set_xyz(&mut self, x: f32, y: f32, z: f32) -> &mut Self

Sets the specified values of the translation vector.

pub fn set_rotation(&mut self, rotation: UnitQuaternion<f32>) -> &mut Self

Sets the rotation of the transform.

pub fn set_scale(&mut self, x: f32, y: f32, z: f32) -> &mut Self

Sets the scale of the transform.

pub fn set_rotation_euler(&mut self, x: f32, y: f32, z: f32) -> &mut Self

Set the rotation using Euler x, y, z.

All angles are specified in radians. Euler order is roll → pitch → yaw.

Arguments

• x - The angle to apply around the x axis. Also known as the roll.
• y - The angle to apply around the y axis. Also known as the pitch.
• z - The angle to apply around the z axis. Also known as the yaw.

let mut transform = Transform::default();

transform.set_rotation_euler(1.0, 0.0, 0.0);

assert_eq!(transform.rotation().euler_angles().0, 1.0);

pub fn concat(&mut self, other: &Self) -> &mut Self

Concatenates another transform onto self.

Concatenating is roughly equivalent to doing matrix multiplication except for the fact that it’s done on Transform which is decomposed.

pub fn view_matrix(&self) -> Matrix4<f32>

Calculates the inverse of this transform, which we need to render.

We can exploit the extra information we have to perform this inverse faster than O(n^3).

Trait Implementations

impl Clone for Transform

fn clone(&self) -> Transform

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for Transform

type Storage = FlaggedStorage<Transform, DenseVecStorage<Transform>>

Associated storage type for this component.

impl Debug for Transform

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

Formats the value using the given formatter.

impl Default for Transform

fn default() -> Self

The default transform does nothing when used to transform an entity.

impl<'de> Deserialize<'de> for Transform

fn deserialize<D>(deserializer: D) -> Result<Transform, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>> for Transform

Creates a Transform using the Vector3 as the translation vector.

let transform = Transform::from(Vector3::new(100.0, 200.0, 300.0));

assert_eq!(transform.translation().x, 100.0);

fn from(translation: Vector3<f32>) -> Self

Converts to this type from the input type.

impl PartialEq<Transform> for Transform

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

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Transform