1 #ifndef GLM_FORCE_PURE
2 # define GLM_FORCE_PURE
3 #endif//GLM_FORCE_PURE
4 #define GLM_FORCE_ALIGNED
5 #define GLM_FORCE_SWIZZLE
6 #include <glm/vector_relational.hpp>
7 #include <glm/vec2.hpp>
8 #include <glm/vec3.hpp>
9 #include <glm/vec4.hpp>
10 #include <cstdio>
11 #include <ctime>
12 #include <vector>
13
test_vec4_ctor()14 int test_vec4_ctor()
15 {
16 int Error = 0;
17
18 {
19 glm::ivec4 A(1, 2, 3, 4);
20 glm::ivec4 B(A);
21 Error += glm::all(glm::equal(A, B)) ? 0 : 1;
22 }
23
24 # if GLM_HAS_TRIVIAL_QUERIES
25 // Error += std::is_trivially_default_constructible<glm::vec4>::value ? 0 : 1;
26 // Error += std::is_trivially_copy_assignable<glm::vec4>::value ? 0 : 1;
27 Error += std::is_trivially_copyable<glm::vec4>::value ? 0 : 1;
28 Error += std::is_trivially_copyable<glm::dvec4>::value ? 0 : 1;
29 Error += std::is_trivially_copyable<glm::ivec4>::value ? 0 : 1;
30 Error += std::is_trivially_copyable<glm::uvec4>::value ? 0 : 1;
31
32 Error += std::is_copy_constructible<glm::vec4>::value ? 0 : 1;
33 # endif
34
35 #if GLM_HAS_INITIALIZER_LISTS
36 {
37 glm::vec4 a{ 0, 1, 2, 3 };
38 std::vector<glm::vec4> v = {
39 {0, 1, 2, 3},
40 {4, 5, 6, 7},
41 {8, 9, 0, 1}};
42 }
43
44 {
45 glm::dvec4 a{ 0, 1, 2, 3 };
46 std::vector<glm::dvec4> v = {
47 {0, 1, 2, 3},
48 {4, 5, 6, 7},
49 {8, 9, 0, 1}};
50 }
51 #endif
52
53 #if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
54 {
55 glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f);
56 glm::vec4 B = A.xyzw;
57 glm::vec4 C(A.xyzw);
58 glm::vec4 D(A.xyzw());
59 glm::vec4 E(A.x, A.yzw);
60 glm::vec4 F(A.x, A.yzw());
61 glm::vec4 G(A.xyz, A.w);
62 glm::vec4 H(A.xyz(), A.w);
63 glm::vec4 I(A.xy, A.zw);
64 glm::vec4 J(A.xy(), A.zw());
65 glm::vec4 K(A.x, A.y, A.zw);
66 glm::vec4 L(A.x, A.yz, A.w);
67 glm::vec4 M(A.xy, A.z, A.w);
68
69 Error += glm::all(glm::equal(A, B)) ? 0 : 1;
70 Error += glm::all(glm::equal(A, C)) ? 0 : 1;
71 Error += glm::all(glm::equal(A, D)) ? 0 : 1;
72 Error += glm::all(glm::equal(A, E)) ? 0 : 1;
73 Error += glm::all(glm::equal(A, F)) ? 0 : 1;
74 Error += glm::all(glm::equal(A, G)) ? 0 : 1;
75 Error += glm::all(glm::equal(A, H)) ? 0 : 1;
76 Error += glm::all(glm::equal(A, I)) ? 0 : 1;
77 Error += glm::all(glm::equal(A, J)) ? 0 : 1;
78 Error += glm::all(glm::equal(A, K)) ? 0 : 1;
79 Error += glm::all(glm::equal(A, L)) ? 0 : 1;
80 Error += glm::all(glm::equal(A, M)) ? 0 : 1;
81 }
82 #endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
83
84 {
85 glm::vec4 A(1);
86 glm::vec4 B(1, 1, 1, 1);
87
88 Error += A == B ? 0 : 1;
89 }
90
91 {
92 std::vector<glm::vec4> Tests;
93 Tests.push_back(glm::vec4(glm::vec2(1, 2), 3, 4));
94 Tests.push_back(glm::vec4(1, glm::vec2(2, 3), 4));
95 Tests.push_back(glm::vec4(1, 2, glm::vec2(3, 4)));
96 Tests.push_back(glm::vec4(glm::vec3(1, 2, 3), 4));
97 Tests.push_back(glm::vec4(1, glm::vec3(2, 3, 4)));
98 Tests.push_back(glm::vec4(glm::vec2(1, 2), glm::vec2(3, 4)));
99 Tests.push_back(glm::vec4(1, 2, 3, 4));
100 Tests.push_back(glm::vec4(glm::vec4(1, 2, 3, 4)));
101
102 for(std::size_t i = 0; i < Tests.size(); ++i)
103 Error += Tests[i] == glm::vec4(1, 2, 3, 4) ? 0 : 1;
104 }
105
106 return Error;
107 }
108
test_bvec4_ctor()109 int test_bvec4_ctor()
110 {
111 int Error = 0;
112
113 glm::bvec4 const A(true);
114 glm::bvec4 const B(true);
115 glm::bvec4 const C(false);
116 glm::bvec4 const D = A && B;
117 glm::bvec4 const E = A && C;
118 glm::bvec4 const F = A || C;
119 bool const G = A == C;
120 bool const H = A != C;
121
122 Error += D == glm::bvec4(true) ? 0 : 1;
123 Error += E == glm::bvec4(false) ? 0 : 1;
124 Error += F == glm::bvec4(true) ? 0 : 1;
125
126 return Error;
127 }
128
test_vec4_operators()129 int test_vec4_operators()
130 {
131 int Error = 0;
132
133 {
134 glm::vec4 A(1.0f);
135 glm::vec4 B(1.0f);
136 bool R = A != B;
137 bool S = A == B;
138
139 Error += (S && !R) ? 0 : 1;
140 }
141
142 {
143 glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
144 glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f);
145
146 glm::vec4 C = A + B;
147 Error += C == glm::vec4(5, 7, 9, 11) ? 0 : 1;
148
149 glm::vec4 D = B - A;
150 Error += D == glm::vec4(3, 3, 3, 3) ? 0 : 1;
151
152 glm::vec4 E = A * B;
153 Error += E == glm::vec4(4, 10, 18, 28) ? 0 : 1;
154
155 glm::vec4 F = B / A;
156 Error += F == glm::vec4(4, 2.5, 2, 7.0f / 4.0f) ? 0 : 1;
157
158 glm::vec4 G = A + 1.0f;
159 Error += G == glm::vec4(2, 3, 4, 5) ? 0 : 1;
160
161 glm::vec4 H = B - 1.0f;
162 Error += H == glm::vec4(3, 4, 5, 6) ? 0 : 1;
163
164 glm::vec4 I = A * 2.0f;
165 Error += I == glm::vec4(2, 4, 6, 8) ? 0 : 1;
166
167 glm::vec4 J = B / 2.0f;
168 Error += J == glm::vec4(2, 2.5, 3, 3.5) ? 0 : 1;
169
170 glm::vec4 K = 1.0f + A;
171 Error += K == glm::vec4(2, 3, 4, 5) ? 0 : 1;
172
173 glm::vec4 L = 1.0f - B;
174 Error += L == glm::vec4(-3, -4, -5, -6) ? 0 : 1;
175
176 glm::vec4 M = 2.0f * A;
177 Error += M == glm::vec4(2, 4, 6, 8) ? 0 : 1;
178
179 glm::vec4 N = 2.0f / B;
180 Error += N == glm::vec4(0.5, 2.0 / 5.0, 2.0 / 6.0, 2.0 / 7.0) ? 0 : 1;
181 }
182
183 {
184 glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
185 glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f);
186
187 A += B;
188 Error += A == glm::vec4(5, 7, 9, 11) ? 0 : 1;
189
190 A += 1.0f;
191 Error += A == glm::vec4(6, 8, 10, 12) ? 0 : 1;
192 }
193 {
194 glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
195 glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f);
196
197 B -= A;
198 Error += B == glm::vec4(3, 3, 3, 3) ? 0 : 1;
199
200 B -= 1.0f;
201 Error += B == glm::vec4(2, 2, 2, 2) ? 0 : 1;
202 }
203 {
204 glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
205 glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f);
206
207 A *= B;
208 Error += A == glm::vec4(4, 10, 18, 28) ? 0 : 1;
209
210 A *= 2.0f;
211 Error += A == glm::vec4(8, 20, 36, 56) ? 0 : 1;
212 }
213 {
214 glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
215 glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f);
216
217 B /= A;
218 Error += B == glm::vec4(4, 2.5, 2, 7.0f / 4.0f) ? 0 : 1;
219
220 B /= 2.0f;
221 Error += B == glm::vec4(2, 1.25, 1, 7.0f / 4.0f / 2.0f) ? 0 : 1;
222 }
223 {
224 glm::vec4 B(2.0f);
225
226 B /= B.y;
227 Error += B == glm::vec4(1.0f) ? 0 : 1;
228 }
229
230 {
231 glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
232 glm::vec4 B = -A;
233 Error += B == glm::vec4(-1.0f, -2.0f, -3.0f, -4.0f) ? 0 : 1;
234 }
235
236 {
237 glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
238 glm::vec4 B = --A;
239 Error += B == glm::vec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1;
240 }
241
242 {
243 glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
244 glm::vec4 B = A--;
245 Error += B == glm::vec4(1.0f, 2.0f, 3.0f, 4.0f) ? 0 : 1;
246 Error += A == glm::vec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1;
247 }
248
249 {
250 glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
251 glm::vec4 B = ++A;
252 Error += B == glm::vec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1;
253 }
254
255 {
256 glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
257 glm::vec4 B = A++;
258 Error += B == glm::vec4(1.0f, 2.0f, 3.0f, 4.0f) ? 0 : 1;
259 Error += A == glm::vec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1;
260 }
261
262 return Error;
263 }
264
test_vec4_equal()265 int test_vec4_equal()
266 {
267 int Error = 0;
268
269 {
270 glm::vec4 const A(1, 2, 3, 4);
271 glm::vec4 const B(1, 2, 3, 4);
272 Error += A == B ? 0 : 1;
273 Error += A != B ? 1 : 0;
274 }
275
276 {
277 glm::ivec4 const A(1, 2, 3, 4);
278 glm::ivec4 const B(1, 2, 3, 4);
279 Error += A == B ? 0 : 1;
280 Error += A != B ? 1 : 0;
281 }
282
283 return Error;
284 }
285
test_vec4_size()286 int test_vec4_size()
287 {
288 int Error = 0;
289
290 Error += sizeof(glm::vec4) == sizeof(glm::lowp_vec4) ? 0 : 1;
291 Error += sizeof(glm::vec4) == sizeof(glm::mediump_vec4) ? 0 : 1;
292 Error += sizeof(glm::vec4) == sizeof(glm::highp_vec4) ? 0 : 1;
293 Error += 16 == sizeof(glm::mediump_vec4) ? 0 : 1;
294 Error += sizeof(glm::dvec4) == sizeof(glm::lowp_dvec4) ? 0 : 1;
295 Error += sizeof(glm::dvec4) == sizeof(glm::mediump_dvec4) ? 0 : 1;
296 Error += sizeof(glm::dvec4) == sizeof(glm::highp_dvec4) ? 0 : 1;
297 Error += 32 == sizeof(glm::highp_dvec4) ? 0 : 1;
298 Error += glm::vec4().length() == 4 ? 0 : 1;
299 Error += glm::dvec4().length() == 4 ? 0 : 1;
300
301 return Error;
302 }
303
test_vec4_swizzle_partial()304 int test_vec4_swizzle_partial()
305 {
306 int Error = 0;
307
308 glm::vec4 A(1, 2, 3, 4);
309
310 # if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE_RELAX)
311 {
312 glm::vec4 B(A.xy, A.zw);
313 Error += A == B ? 0 : 1;
314 }
315 {
316 glm::vec4 B(A.xy, 3.0f, 4.0f);
317 Error += A == B ? 0 : 1;
318 }
319 {
320 glm::vec4 B(1.0f, A.yz, 4.0f);
321 Error += A == B ? 0 : 1;
322 }
323 {
324 glm::vec4 B(1.0f, 2.0f, A.zw);
325 Error += A == B ? 0 : 1;
326 }
327
328 {
329 glm::vec4 B(A.xyz, 4.0f);
330 Error += A == B ? 0 : 1;
331 }
332 {
333 glm::vec4 B(1.0f, A.yzw);
334 Error += A == B ? 0 : 1;
335 }
336 # endif
337
338 return Error;
339 }
340
test_operator_increment()341 int test_operator_increment()
342 {
343 int Error(0);
344
345 glm::ivec4 v0(1);
346 glm::ivec4 v1(v0);
347 glm::ivec4 v2(v0);
348 glm::ivec4 v3 = ++v1;
349 glm::ivec4 v4 = v2++;
350
351 Error += glm::all(glm::equal(v0, v4)) ? 0 : 1;
352 Error += glm::all(glm::equal(v1, v2)) ? 0 : 1;
353 Error += glm::all(glm::equal(v1, v3)) ? 0 : 1;
354
355 int i0(1);
356 int i1(i0);
357 int i2(i0);
358 int i3 = ++i1;
359 int i4 = i2++;
360
361 Error += i0 == i4 ? 0 : 1;
362 Error += i1 == i2 ? 0 : 1;
363 Error += i1 == i3 ? 0 : 1;
364
365 return Error;
366 }
367
368 namespace heap
369 {
370 class A
371 {
372 float f;
373 };
374
375 class B : public A
376 {
377 float g;
378 glm::vec4 v;
379 };
380
test()381 int test()
382 {
383 int Error(0);
384
385 A* p = new B;
386 delete p;
387
388 return Error;
389 }
390 }//namespace heap
391
test_vec4_simd()392 int test_vec4_simd()
393 {
394 int Error = 0;
395
396 glm::vec4 const a(std::clock(), std::clock(), std::clock(), std::clock());
397 glm::vec4 const b(std::clock(), std::clock(), std::clock(), std::clock());
398
399 glm::vec4 const c(b * a);
400 glm::vec4 const d(a + c);
401
402 Error += glm::all(glm::greaterThanEqual(d, glm::vec4(0))) ? 0 : 1;
403
404 return Error;
405 }
406
main()407 int main()
408 {
409 int Error(0);
410
411 Error += test_vec4_ctor();
412 Error += test_bvec4_ctor();
413 Error += test_vec4_size();
414 Error += test_vec4_operators();
415 Error += test_vec4_equal();
416 Error += test_vec4_swizzle_partial();
417 Error += test_vec4_simd();
418 Error += test_operator_increment();
419 Error += heap::test();
420
421 return Error;
422 }
423
424