1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use na::{DefaultAllocator, Real, Unit, Rotation3, Point3};

use traits::{Dimension, Number, Alloc};
use aliases::{TMat, TVec, TVec3, TMat4};

/// The identity matrix.
pub fn identity<N: Number, D: Dimension>() -> TMat<N, D, D>
    where DefaultAllocator: Alloc<N, D, D> {
    TMat::<N, D, D>::identity()
}

/// Build a look at view matrix based on the right handedness.
///
/// # Parameters
///    * `eye`   − Position of the camera
///    * `center` − Position where the camera is looking at
///    * `u` − Normalized up vector, how the camera is oriented. Typically `(0, 1, 0)`
pub fn look_at<N: Real>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
    look_at_rh(eye, center, up)
}

/// Build a left handed look at view matrix.
///
/// # Parameters
///    * `eye`   − Position of the camera
///    * `center` − Position where the camera is looking at
///    * `u` − Normalized up vector, how the camera is oriented. Typically `(0, 1, 0)`
pub fn look_at_lh<N: Real>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
    TMat::look_at_lh(&Point3::from_coordinates(*eye), &Point3::from_coordinates(*center), up)
}

/// Build a right handed look at view matrix.
///
/// # Parameters
///    * `eye`   − Position of the camera
///    * `center` − Position where the camera is looking at
///    * `u` − Normalized up vector, how the camera is oriented. Typically `(0, 1, 0)`
pub fn look_at_rh<N: Real>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
    TMat::look_at_rh(&Point3::from_coordinates(*eye), &Point3::from_coordinates(*center), up)
}

/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle and right-multiply it to `m`.
///
/// # Parameters
///    * `m` − Input matrix multiplied by this rotation matrix.
///    * `angle` − Rotation angle expressed in radians.
///    * `axis`  − Rotation axis, recommended to be normalized.
pub fn rotate<N: Real>(m: &TMat4<N>, angle: N, axis: &TVec3<N>) -> TMat4<N> {
    m * Rotation3::from_axis_angle(&Unit::new_normalize(*axis), angle).to_homogeneous()
}

/// Builds a rotation 4 * 4 matrix around the X axis and right-multiply it to `m`.
///
/// # Parameters
///    * `m` − Input matrix multiplied by this rotation matrix.
///    * `angle` − Rotation angle expressed in radians.
pub fn rotate_x<N: Real>(m: &TMat4<N>, angle: N) -> TMat4<N> {
    rotate(m, angle, &TVec::x())
}

/// Builds a rotation 4 * 4 matrix around the Y axis and right-multiply it to `m`.
///
/// # Parameters
///    * `m` − Input matrix multiplied by this rotation matrix.
///    * `angle` − Rotation angle expressed in radians.
pub fn rotate_y<N: Real>(m: &TMat4<N>, angle: N) -> TMat4<N> {
    rotate(m, angle, &TVec::y())
}

/// Builds a rotation 4 * 4 matrix around the Z axis and right-multiply it to `m`.
///
/// # Parameters
///    * `m` − Input matrix multiplied by this rotation matrix.
///    * `angle` − Rotation angle expressed in radians.
pub fn rotate_z<N: Real>(m: &TMat4<N>, angle: N) -> TMat4<N> {
    rotate(m, angle, &TVec::z())
}

/// Builds a scale 4 * 4 matrix created from 3 scalars and right-multiply it to `m`.
///
/// # Parameters
///    * `m` − Input matrix multiplied by this scale matrix.
///    * `v` − Ratio of scaling for each axis.
pub fn scale<N: Number>(m: &TMat4<N>, v: &TVec3<N>) -> TMat4<N> {
    m.prepend_nonuniform_scaling(v)
}

/// Builds a translation 4 * 4 matrix created from a vector of 3 components and right-multiply it to `m`.
///
/// # Parameters
///    * `m` − Input matrix multiplied by this translation matrix.
///    * `v` − Coordinates of a translation vector.
pub fn translate<N: Number>(m: &TMat4<N>, v: &TVec3<N>) -> TMat4<N> {
    m.prepend_translation(v)
}