llml 0.2.3

Implementation of basic math data types with high level frontend and low level backend
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

use crate::{mat::{Matf2, Matd2, Matf3, Matd3}, vec::*};
use std::ops::*;

macro_rules! impl_default2 {
    ($($target:ident, $ty:ty),+) => {
        $(
            impl Default for $target {
                fn default () -> Self {
                    $target::new(<[$ty;4]>::default())
                }
            }
        )*
    };
}

macro_rules! impl_default3 {
    ($($target:ident, $ty:ty),+) => {
        $(
            impl Default for $target {
                fn default () -> Self {
                    $target::new(<[$ty;9]>::default())
                }
            }
        )*
    };
}

macro_rules! impl_rot2 {
    ($ty:ident) => {
        #[inline]
        /// Returns a matrix thet represents the specified rotation (in radians)
        pub fn from_rot (angle: $ty) -> Self {
            let (sin, cos) = angle.sin_cos();
            Self::new([cos, -sin, sin, cos])
        }
    };
}

macro_rules! impl_rot3 {
    ($ty:ident) => {
        #[inline]
        /// Returns a matrix thet represents the specified rotation (in radians)
        pub fn from_rot (roll: $ty, pitch: $ty, yaw: $ty) -> Self {
            let (s1, c1) = roll.sin_cos();
            let (s2, c2) = pitch.sin_cos();
            let (s3, c3) = yaw.sin_cos();
            
            let c3s2 = c3 * s2;
            let c1s3 = c1 * s3;
            let s1s3 = s1 * s3;

            Self::new([
                c2 * c3, c3s2 * s1 + c1s3, s1s3 - c1 * c3s2,
                -c2 * s3, c1 * c3 - s1s3 * s2, c3 * s1 + c1s3 * s2,
                s2, -c2 * s1, c1 * c2
            ])
        }
    };
}

macro_rules! impl_assign_mat {
    ($($target:ident, $ty:ty),+) => {
        $(
            impl_assign!(
                $target, 
                AddAssign, add_assign, add,
                SubAssign, sub_assign, sub,
                MulAssign, mul_assign, mul
            );
    
            impl_assign!(
                1, $target, $ty,
                AddAssign, add_assign, add,
                SubAssign, sub_assign, sub,
                MulAssign, mul_assign, mul,
                DivAssign, div_assign, div
            );
        )*
    }
}

impl_default2!(
    Matf2, f32,
    Matd2, f64
);

impl_default3!(
    Matf3, f32,
    Matd3, f64
);

impl_assign_mat!(
    Matf2, f32,
    Matf3, f32,
    Matd2, f64,
    Matd3, f64
);

impl Matf2 { impl_rot2!(f32); }
impl Matd2 { impl_rot2!(f64); }
impl Matf3 { impl_rot3!(f32); }
impl Matd3 { impl_rot3!(f64); }