1 #include <glm/gtc/epsilon.hpp>
2 #include <glm/matrix.hpp>
3 #include <glm/vector_relational.hpp>
4 #include <glm/mat2x2.hpp>
5 #include <glm/mat2x3.hpp>
6 #include <glm/mat2x4.hpp>
7 #include <glm/mat3x2.hpp>
8 #include <glm/mat3x3.hpp>
9 #include <glm/mat3x4.hpp>
10 #include <glm/mat4x2.hpp>
11 #include <glm/mat4x3.hpp>
12 #include <glm/mat4x4.hpp>
13 #include <cstdio>
14 #include <vector>
15
print(glm::dmat3 const & Mat0)16 void print(glm::dmat3 const & Mat0)
17 {
18 printf("mat3(\n");
19 printf("\tvec3(%2.3f, %2.3f, %2.3f)\n", Mat0[0][0], Mat0[0][1], Mat0[0][2]);
20 printf("\tvec3(%2.3f, %2.3f, %2.3f)\n", Mat0[1][0], Mat0[1][1], Mat0[1][2]);
21 printf("\tvec3(%2.3f, %2.3f, %2.3f))\n\n", Mat0[2][0], Mat0[2][1], Mat0[2][2]);
22 }
23
test_mat3x3()24 int test_mat3x3()
25 {
26 glm::dmat3 Mat0(
27 glm::dvec3(0.6f, 0.2f, 0.3f),
28 glm::dvec3(0.2f, 0.7f, 0.5f),
29 glm::dvec3(0.3f, 0.5f, 0.7f));
30 glm::dmat3 Inv0 = glm::inverse(Mat0);
31 glm::dmat3 Res0 = Mat0 * Inv0;
32
33 print(Mat0);
34 print(Inv0);
35 print(Res0);
36
37 return 0;
38 }
39
test_operators()40 static int test_operators()
41 {
42 glm::mat3x3 l(1.0f);
43 glm::mat3x3 m(1.0f);
44 glm::vec3 u(1.0f);
45 glm::vec3 v(1.0f);
46 float x = 1.0f;
47 glm::vec3 a = m * u;
48 glm::vec3 b = v * m;
49 glm::mat3x3 n = x / m;
50 glm::mat3x3 o = m / x;
51 glm::mat3x3 p = x * m;
52 glm::mat3x3 q = m * x;
53 bool R = m != q;
54 bool S = m == l;
55
56 return (S && !R) ? 0 : 1;
57 }
58
test_inverse()59 int test_inverse()
60 {
61 int Error(0);
62
63 {
64 glm::mat3 const Matrix(
65 glm::vec3(0.6f, 0.2f, 0.3f),
66 glm::vec3(0.2f, 0.7f, 0.5f),
67 glm::vec3(0.3f, 0.5f, 0.7f));
68 glm::mat3 const Inverse = glm::inverse(Matrix);
69 glm::mat3 const Identity = Matrix * Inverse;
70
71 Error += glm::all(glm::epsilonEqual(Identity[0], glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.01f))) ? 0 : 1;
72 Error += glm::all(glm::epsilonEqual(Identity[1], glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.01f))) ? 0 : 1;
73 Error += glm::all(glm::epsilonEqual(Identity[2], glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(0.01f))) ? 0 : 1;
74 }
75
76 {
77 glm::mat3 const Matrix(
78 glm::vec3(0.6f, 0.2f, 0.3f),
79 glm::vec3(0.2f, 0.7f, 0.5f),
80 glm::vec3(0.3f, 0.5f, 0.7f));
81 glm::mat3 const Identity = Matrix / Matrix;
82
83 Error += glm::all(glm::epsilonEqual(Identity[0], glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.01f))) ? 0 : 1;
84 Error += glm::all(glm::epsilonEqual(Identity[1], glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.01f))) ? 0 : 1;
85 Error += glm::all(glm::epsilonEqual(Identity[2], glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(0.01f))) ? 0 : 1;
86 }
87
88 return Error;
89 }
90
test_ctr()91 int test_ctr()
92 {
93 int Error(0);
94
95 #if(GLM_HAS_INITIALIZER_LISTS)
96 glm::mat3x3 m0(
97 glm::vec3(0, 1, 2),
98 glm::vec3(3, 4, 5),
99 glm::vec3(6, 7, 8));
100
101 glm::mat3x3 m1{0, 1, 2, 3, 4, 5, 6, 7, 8};
102
103 glm::mat3x3 m2{
104 {0, 1, 2},
105 {3, 4, 5},
106 {6, 7, 8}};
107
108 for(glm::length_t i = 0; i < m0.length(); ++i)
109 Error += glm::all(glm::equal(m0[i], m2[i])) ? 0 : 1;
110
111 for(glm::length_t i = 0; i < m1.length(); ++i)
112 Error += glm::all(glm::equal(m1[i], m2[i])) ? 0 : 1;
113
114 std::vector<glm::mat3x3> v1{
115 {0, 1, 2, 3, 4, 5, 6, 7, 8},
116 {0, 1, 2, 3, 4, 5, 6, 7, 8}
117 };
118
119 std::vector<glm::mat3x3> v2{
120 {
121 { 0, 1, 2},
122 { 3, 4, 5},
123 { 6, 7, 8}
124 },
125 {
126 { 0, 1, 2},
127 { 3, 4, 5},
128 { 6, 7, 8}
129 }
130 };
131
132 #endif//GLM_HAS_INITIALIZER_LISTS
133
134 return Error;
135 }
136
137 namespace cast
138 {
139 template <typename genType>
entry()140 int entry()
141 {
142 int Error = 0;
143
144 genType A(1.0f);
145 glm::mat3x3 B(A);
146 glm::mat3x3 Identity(1.0f);
147
148 for(glm::length_t i = 0, length = B.length(); i < length; ++i)
149 Error += glm::all(glm::equal(B[i], Identity[i])) ? 0 : 1;
150
151 return Error;
152 }
153
test()154 int test()
155 {
156 int Error = 0;
157
158 Error += entry<glm::mat2x2>();
159 Error += entry<glm::mat2x3>();
160 Error += entry<glm::mat2x4>();
161 Error += entry<glm::mat3x2>();
162 Error += entry<glm::mat3x3>();
163 Error += entry<glm::mat3x4>();
164 Error += entry<glm::mat4x2>();
165 Error += entry<glm::mat4x3>();
166 Error += entry<glm::mat4x4>();
167
168 return Error;
169 }
170 }//namespace cast
171
test_size()172 int test_size()
173 {
174 int Error = 0;
175
176 Error += 36 == sizeof(glm::mat3x3) ? 0 : 1;
177 Error += 72 == sizeof(glm::dmat3x3) ? 0 : 1;
178 Error += glm::mat3x3().length() == 3 ? 0 : 1;
179 Error += glm::dmat3x3().length() == 3 ? 0 : 1;
180 Error += glm::mat3x3::length() == 3 ? 0 : 1;
181 Error += glm::dmat3x3::length() == 3 ? 0 : 1;
182
183 return Error;
184 }
185
main()186 int main()
187 {
188 int Error = 0;
189
190 Error += cast::test();
191 Error += test_ctr();
192 Error += test_mat3x3();
193 Error += test_operators();
194 Error += test_inverse();
195 Error += test_size();
196
197 return Error;
198 }
199
200