[−][src]Struct amethyst_core::transform::components::Transform

pub struct Transform { /* fields omitted */ }

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.

Methods

`impl Transform`[src]

`pub fn isometry(&self) -> &Isometry3<f32>`[src]

Translation + rotation value

`pub fn scale(&self) -> &Vector3<f32>`[src]

Scale vector

`pub fn global_matrix(&self) -> &Matrix4<f32>`[src]

The global transformation matrix.

`impl Transform`[src]

`pub fn isometry_mut(&mut self) -> &mut Isometry3<f32>`[src]

Translation + rotation value

`pub fn scale_mut(&mut self) -> &mut Vector3<f32>`[src]

Scale vector

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 set_scale<N: RealField + SubsetOf<f32>>(&mut self, scale: Vector3<N>)`[src]

Set the scaling factor of this transform.

`pub fn face_towards<N: RealField + SubsetOf<f32>>( &mut self, target: Vector3<N>, up: Vector3<N> ) -> &mut Self`[src]

Makes the entity point towards target.

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>`[src]

Returns the local object matrix for the transform.

`pub fn translation(&self) -> &Vector3<f32>`[src]

Returns a reference to the translation vector.

`pub fn translation_mut(&mut self) -> &mut Vector3<f32>`[src]

Returns a mutable reference to the translation vector.

`pub fn rotation(&self) -> &UnitQuaternion<f32>`[src]

Returns a reference to the rotation quaternion.

`pub fn rotation_mut(&mut self) -> &mut UnitQuaternion<f32>`[src]

Returns a mutable reference to the rotation quaternion.

`pub fn prepend_translation(&mut self, translation: Vector3<f32>) -> &mut Self`[src]

Move relatively to its current position, but the parent's (or global, if no parent exists) orientation.

For example, if the object is rotated 45 degrees about its Y axis, then you prepend a translation along the Z axis, it will still move along the parent's Z axis rather than its local Z axis (which is rotated 45 degrees).

`pub fn append_translation(&mut self, translation: Vector3<f32>) -> &mut Self`[src]

Move relatively to its current position and orientation.

For example, if the object is rotated 45 degrees about its Y axis, then you append a translation along the Z axis, that Z axis is now rotated 45 degrees, and so the appended translation will go along that rotated Z axis.

Equivalent to rotating the translation by the transform's current rotation before applying.

`pub fn prepend_translation_along( &mut self, direction: Unit<Vector3<f32>>, distance: f32 ) -> &mut Self`[src]

Move a distance along an axis relative to the parent's orientation (or the global orientation if no parent exists).

For example, if the object is rotated 45 degrees about its Y axis, then you prepend a translation along the Z axis, it will still move along the parent's Z axis rather than its local Z axis (which is rotated 45 degrees).

`pub fn append_translation_along( &mut self, direction: Unit<Vector3<f32>>, distance: f32 ) -> &mut Self`[src]

Move a distance along an axis relative to the local orientation.

`pub fn move_forward(&mut self, amount: f32) -> &mut Self`[src]

Move forward relative to current position and orientation.

`pub fn move_backward(&mut self, amount: f32) -> &mut Self`[src]

Move backward relative to current position and orientation.

`pub fn move_right(&mut self, amount: f32) -> &mut Self`[src]

Move right relative to current position and orientation.

`pub fn move_left(&mut self, amount: f32) -> &mut Self`[src]

Move left relative to current position and orientation.

`pub fn move_up(&mut self, amount: f32) -> &mut Self`[src]

Move up relative to current position and orientation.

`pub fn move_down(&mut self, amount: f32) -> &mut Self`[src]

Move down relative to current position and orientation.

`pub fn prepend_translation_x(&mut self, amount: f32) -> &mut Self`[src]

Adds the specified amount to the translation vector's x component. i.e. move relative to the parent's (or global, if no parent exists) x axis.

`pub fn prepend_translation_y(&mut self, amount: f32) -> &mut Self`[src]

Adds the specified amount to the translation vector's y component. i.e. move relative to the parent's (or global, if no parent exists) y axis.

`pub fn prepend_translation_z(&mut self, amount: f32) -> &mut Self`[src]

Adds the specified amount to the translation vector's z component. i.e. move relative to the parent's (or global, if no parent exists) z axis.

`pub fn set_translation_x(&mut self, value: f32) -> &mut Self`[src]

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

`pub fn set_translation_y(&mut self, value: f32) -> &mut Self`[src]

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

`pub fn set_translation_z(&mut self, value: f32) -> &mut Self`[src]

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

`pub fn prepend_rotation_x_axis(&mut self, delta_angle: f32) -> &mut Self`[src]

Premultiply a rotation about the x axis, i.e. perform a rotation about the parent's x axis (or the global x axis if no parent exists).