ear-algae 0.5.0

Linear algebra featuring Vectors, Normal Vectors, Matrices, Rotors (Unit Quaternions) and Rigid Transforms (Rotation + Translation)
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

use culit::culit;

use crate::{Mat, Nrml, Vect, op_wrapper::scs, traits::*};

mod vect3;

impl<S: Field> Vect<4, S> {
    #[culit]
    pub fn point(position: Vect<3, S>) -> Self {
        Vect([position[0], position[1], position[2], 1S])
    }

    #[culit]
    pub fn point_at_inf(direction: Nrml<3, S>) -> Self {
        Vect([direction[0], direction[1], direction[2], 0S])
    }
}

impl<S: Field> Mat<4, 4, S> {
    #[culit]
    pub fn affine(linear: Mat<3, 3, S>, translation: Vect<3, S>) -> Self {
        let [[xx, xy, xz], [yx, yy, yz], [zx, zy, zz]] = linear.0;
        let [x, y, z] = translation.0;
        Mat([
            [xx, xy, xz, x],
            [yx, yy, yz, y],
            [zx, zy, zz, z],
            [0S, 0S, 0S, 1S],
        ])
    }

    #[culit]
    pub fn linear(linear: Mat<3, 3, S>) -> Self {
        let [[xx, xy, xz], [yx, yy, yz], [zx, zy, zz]] = linear.0;
        Mat([
            [xx, xy, xz, 0S],
            [yx, yy, yz, 0S],
            [zx, zy, zz, 0S],
            [0S, 0S, 0S, 1S],
        ])
    }

    #[culit]
    pub fn translation(translation: Vect<3, S>) -> Self {
        let [x, y, z] = translation.0;
        Mat([
            [1S, 0S, 0S, x],
            [0S, 1S, 0S, y],
            [0S, 0S, 1S, z],
            [0S, 0S, 0S, 1S],
        ])
    }

    #[culit]
    pub fn perspective_projection(aspect: S, fov: S, n: S, f: S) -> Self {
        scs!(aspect, fov, f, n);
        let view = (fov * 0.5Sc).tan();

        Mat::from_scs([
            [1Sc / (aspect * view), 0Sc, 0Sc, 0Sc],
            [0Sc, 1Sc / view, 0Sc, 0Sc],
            [0Sc, 0Sc, ((f + n) / (n - f) - 1Sc) / 2Sc, f * n / (n - f)],
            [0Sc, 0Sc, -1Sc, 0Sc],
        ])
    }

    #[culit]
    pub fn uniform_scale(scale: S) -> Self {
        Mat([
            [scale, 0S, 0S, 0S],
            [0S, scale, 0S, 0S],
            [0S, 0S, scale, 0S],
            [0S, 0S, 0S, 1S],
        ])
    }
}