geo-nd 0.6.4

Traits and types particularly for 2D and 3D geometry with implementations for [float] and optionally SIMD
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
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

//a Imports
use serde::Serialize;

use crate::FArray;
use crate::{Float, QArray, Quaternion, SqMatrix4, Transform, Vector};

//tp FQArrayTrans
/// A transformation that is a translation . scaling . rotation
/// (i.e. it applies the rotation to an object, then scales it, then
/// translates it)
///
/// This should probably mirror the QArray in using an F, V3 and V4.
#[derive(Clone, Copy, Debug)] //, Serialize, Deserialize)]
pub struct FQArrayTrans<F>
where
    F: Float + Serialize,
    FArray<F, 4>: Vector<F, 4>,
    QArray<F>: Quaternion<F>,
{
    /// Quaternion of the rotation
    quat: QArray<F>,
    /// Translation and scaling
    trans_scale: [F; 4],
}

//mi fqarray_basic_traits!
macro_rules! fqarray_basic_traits {
    { $f:ty, $ty:ty } => {

        //ip Default
        impl std::default::Default for $ty
        {
            fn default() -> Self {
                use num_traits::{One, Zero};
                Self {
                    quat: QArray::default(),
                    trans_scale: [<$f>::zero(), <$f>
                                  ::zero(), <$f>::zero(), <$f>::one()]
                }
            }
        }

        //ip Display
        impl std::fmt::Display for $ty
        {
            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                write!(
                    f,
                    "trans[+({},{},{}) rot{} *{}]",
                    self.trans_scale[0],
                    self.trans_scale[1],
                    self.trans_scale[2],
                    self.quat,
                    self.trans_scale[3],
                )
            }
        }
    }
}

//mi fqarray_transform_trait!
macro_rules! fqarray_transform_trait {
    { $f:ty,  $v:ty, $q:ty, $ty:ty } => {

        //ip Transform for FQArrayTrans
        impl Transform<$f, $v, $q> for $ty
        {
            //fp of_trs
            /// Create an [FQArrayTrans] from a Vector3 translation, Quat
            /// rotation and Float scaling
            fn of_trs(t: $v, r: $q, s: $f) -> Self {
                Self {
                    quat: r,
                    trans_scale: [t[0], t[1], t[2], s],
                }
            }

            //mp scale
            /// Get the scaling of the transformation
            fn scale(&self) -> $f {
                self.trans_scale[3]
            }

            //mp translation
            /// Get the translation of the transformation
            fn translation(&self) -> $v {
                [
                    self.trans_scale[0],
                    self.trans_scale[1],
                    self.trans_scale[2],
                ]
                    .into()
            }

            //mp rotation
            /// Get the rotation of the transformation
            fn rotation(&self) -> QArray<$f> {
                self.quat
            }

            //cp inverse
            /// Get a transformation that is the inverse of this
            fn inverse(&self) -> Self {
                use num_traits::{Float, One};
                let scale = self.trans_scale[3];
                if scale.abs() < <$f>::epsilon() {
                    Self::default()
                } else {
                    let scale = <$f>::one() / scale;
                    let trans: $v  = [
                        self.trans_scale[0],
                        self.trans_scale[1],
                        self.trans_scale[2],
                    ]
                        .into();
                    let iquat = self.quat.conjugate();
                    let trans = iquat.apply3(&trans);
                    let trans = trans * -scale;
                    Self::of_trs(trans, iquat, scale)
                }
            }

            //mp invert
            /// Invert this transformation
            fn invert(&mut self) {
                *self = self.inverse();
            }

            //mp as_mat
            /// Return the matrix
            fn as_mat<M: SqMatrix4<$f>>(&self) -> M {
                let mut m = M::default();
                self.quat.set_rotation4(&mut m);
                m *= self.trans_scale[3];
                m[3] = self.trans_scale[0];
                m[7] = self.trans_scale[1];
                m[11] = self.trans_scale[2];
                m
            }
        }
    }
}

//a New
//mi fqarray_traits
macro_rules! fqarray_traits {
    { $f:ty,  $v:ty, $q:ty, $ty:ty } => {
        fqarray_basic_traits! {$f, $ty}
        fqarray_transform_trait! {$f, $v, $q, $ty}
    }
}

fqarray_traits! {f32, FArray<f32,3>,  QArray<f32>, FQArrayTrans<f32>}
fqarray_traits! {f64, FArray<f64,3>,  QArray<f64>, FQArrayTrans<f64>}