transform-matrix 0.1.1

Easy transformation matrices
Documentation 
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Utility for transformation matrix creation
//!
//! This crate allows the user to
//! create transformation matrices, mostly for the use in
//! OpenGL applications.
//!
//! # Quick Start
//!
//! You can start by creating a new
//! [`Transform`](struct.Transform.html) object, then adding
//! some transformations, and finalizing the transformation
//! with the
//! [`orthographic()`](struct.Transform.html#method.orthographic)
//! projection.
//!
//! ```
//! use transform_matrix::*;
//!
//! let t = Transform::new()
//!     .translate(2.0, 0.0, 0.0)
//!     .scale(3.0, 0.0, 0.0)
//!     .orthographic(10.0, 10.0, 1.0);
//!
//! assert_eq!(t, [
//!     [0.6, 0.0, 0.0, 0.0],
//!     [0.0, 0.0, 0.0, 0.0],
//!     [0.0, 0.0, 0.0, 0.0],
//!     [0.20000005, 1.0, -1.0, 1.0]
//! ]);
//! ```

mod matrix;

use matrix::Matrix;

pub struct Transform {
    matrix: Matrix,
}

impl Transform {
    /// Begins a new transformation
    ///
    /// *Note*: The transformation starts as an identity matrix
    pub fn new() -> Self {
        Self {
            matrix: matrix::identity(),
        }
    }

    /// Adds a translation transformation
    ///
    /// # Arguments
    ///
    /// * `x` - Amount by which to move on the x-axis
    ///
    /// * `y` - Amount by which to move on the y-axis
    ///
    /// * `z` - Amount by which to move on the z-axis
    pub fn translate(mut self, x: f32, y: f32, z: f32) -> Self {
        self.matrix = matrix::multiply(self.matrix, matrix::translate(x, y, z));
        self
    }

    /// Adds a scale transformation
    ///
    /// # Arguments
    ///
    /// * `x` - Amount by which to scale on the x-axis
    ///
    /// * `y` - Amount by which to scale on the y-axis
    ///
    /// * `z` - Amount by which to scale on the z-axis
    pub fn scale(mut self, x: f32, y: f32, z: f32) -> Self {
        self.matrix = matrix::multiply(self.matrix, matrix::scale(x, y, z));
        self
    }

    /// Adds a rotation transformation
    ///
    /// # Arguments
    ///
    /// * `x` - Amount by which to rotate on the x-axis
    ///
    /// * `y` - Amount by which to rotate on the y-axis
    ///
    /// * `z` - Amount by which to rotate on the z-axis
    pub fn rotate(mut self, x: f32, y: f32, z: f32) -> Self {
        self.matrix = matrix::multiply(self.matrix, matrix::rotate_x(x));
        self.matrix = matrix::multiply(self.matrix, matrix::rotate_y(y));
        self.matrix = matrix::multiply(self.matrix, matrix::rotate_z(z));
        self
    }

    /// Adds an orthographic projection transformation
    ///
    /// # Arguments
    ///
    /// * `width` - Size of the view on the x-axis
    ///
    /// * `height` - Size of the view on the y-axis
    ///
    /// * `depth` - Size of the view on the z-axis
    ///
    /// *Note*: This is the last step of the transformation
    /// and returns the matrix
    pub fn orthographic(self, width: f32, height: f32, depth: f32) -> Matrix {
        matrix::multiply(self.matrix, matrix::orthographic(width, height, depth))
    }
}

impl Default for Transform {
    fn default() -> Self {
        Transform::new()
    }
}