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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

pub mod converter;
pub mod finalizer;
pub mod types;

#[macro_export]
macro_rules! vec2 {
    ($($e: expr),+) => {
        {
            use $crate::macros::types;
            use $crate::macros::converter::Converter;
            use $crate::macros::finalizer::Finalizer;

            let e = types::EmptyConverter;
            $(
                let e = e.convert($e);
            )+
            let f: $crate::vector::V2<_> = e.finalize();
            f
        }
    }
}

#[macro_export]
macro_rules! vec3 { ($($e: expr), +) => {
        {
            use $crate::macros::types;
            use $crate::macros::converter::Converter;
            use $crate::macros::finalizer::Finalizer;

            let e = types::EmptyConverter;
            $(
                let e = e.convert($e);
            )+
            let f: $crate::vector::V3<_> = e.finalize();
            f
        }
    }
}

#[macro_export]
macro_rules! vec4 {
    ($($e: expr), +) => {
        {
            use $crate::macros::types; use $crate::macros::converter::Converter;
            use $crate::macros::finalizer::Finalizer;

            let e = types::EmptyConverter;
            $(
                let e = e.convert($e);
            )+
            let f: $crate::vector::V4<_> = e.finalize();
            f
        }
    }
}

#[macro_export]
macro_rules! mat2 {
    ($e: expr) => {
        $crate::matrix::M2([[$e; 2]; 2])
    };
    ($e1: expr, $e2: expr, $e3: expr, $e4: expr) => {
        $crate::matrix::M2([[$e1, $e2], [$e3, $e4]])
    };
    ($($e1: expr),+; $($e2: expr),+) => {
        {
            use $crate::macros::types;
            use $crate::macros::converter::Converter;
            use $crate::macros::finalizer::Finalizer;
            use $crate::matrix::{self, FromVectors};

            let e = types::EmptyConverter;
            $(
                let e = e.convert($e1);
            )+
            let v1: $crate::vector::V2<_> = e.finalize();

            let e = types::EmptyConverter;
            $(
                let e = e.convert($e2);
            )+
            let v2: $crate::vector::V2<_> = e.finalize();

            matrix::M2::from_rows((v1, v2))
        }
    };
}

#[macro_export]
macro_rules! mat3 {
    ($e: expr) => {
        $crate::matrix::M3([[$e; 3]; 3])
    };
    ($e1: expr, $e2: expr, $e3: expr, $e4: expr, $e5: expr, $e6: expr, $e7: expr, $e8: expr, $e9: expr) => {
        $crate::matrix::M3([[$e1, $e2, $e3], [$e4, $e5, $e6], [$e7, $e8, $e9]])
    };
    ($($e1: expr),+; $($e2: expr),+; $($e3: expr),+) => {
        {
            use $crate::macros::types;
            use $crate::macros::converter::Converter;
            use $crate::macros::finalizer::Finalizer;
            use $crate::matrix::{self, FromVectors};

            let e = types::EmptyConverter;
            $(
                let e = e.convert($e1);
            )+
            let v1: $crate::vector::V3<_> = e.finalize();

            let e = types::EmptyConverter;
            $(
                let e = e.convert($e2);
            )+
            let v2: $crate::vector::V3<_> = e.finalize();

            let e = types::EmptyConverter;
            $(
                let e = e.convert($e3);
            )+
            let v3: $crate::vector::V3<_> = e.finalize();

            matrix::M3::from_rows((v1, v2, v3))
        }
    };
}

#[macro_export]
macro_rules! mat4 {
    ($e: expr) => {
        $crate::matrix::M4([[$e; 4]; 4])
    };
    ($e1: expr, $e2: expr, $e3: expr, $e4: expr, $e5: expr, $e6: expr, $e7: expr, $e8: expr, $e9: expr, $e10: expr, $e11: expr, $e12: expr, $e13: expr, $e14: expr, $e15: expr, $e16: expr) => {
        $crate::matrix::M4([[$e1, $e2, $e3, $e4], [$e5, $e6, $e7, $e8], [$e9, $e10, $e11, $e12], [$e13, $e14, $e15, $e16]])
    };
    ($($e1: expr),+; $($e2: expr),+; $($e3: expr),+; $($e4: expr),+) => {
        {
            use $crate::macros::types;
            use $crate::macros::converter::Converter;
            use $crate::macros::finalizer::Finalizer;
            use $crate::matrix::{self, FromVectors};

            let e = types::EmptyConverter;
            $(
                let e = e.convert($e1);
            )+
            let v1: $crate::vector::V4<_> = e.finalize();

            let e = types::EmptyConverter;
            $(
                let e = e.convert($e2);
            )+
            let v2: $crate::vector::V4<_> = e.finalize();

            let e = types::EmptyConverter;
            $(
                let e = e.convert($e3);
            )+
            let v3: $crate::vector::V4<_> = e.finalize();

            let e = types::EmptyConverter;
            $(
                let e = e.convert($e4);
            )+
            let v4: $crate::vector::V4<_> = e.finalize();

            matrix::M4::from_rows((v1, v2, v3, v4))
        }
    };
}