aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/linden/indra/test/v3math_tut.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--linden/indra/test/v3math_tut.cpp568
1 files changed, 568 insertions, 0 deletions
diff --git a/linden/indra/test/v3math_tut.cpp b/linden/indra/test/v3math_tut.cpp
new file mode 100644
index 0000000..36eaca9
--- /dev/null
+++ b/linden/indra/test/v3math_tut.cpp
@@ -0,0 +1,568 @@
1/**
2 * @file v3math_tut.cpp
3 * @author Adroit
4 * @date February 2007
5 * @brief v3math test cases.
6 *
7 * Copyright (c) 2007-2007, Linden Research, Inc.
8 *
9 * The source code in this file ("Source Code") is provided by Linden Lab
10 * to you under the terms of the GNU General Public License, version 2.0
11 * ("GPL"), unless you have obtained a separate licensing agreement
12 * ("Other License"), formally executed by you and Linden Lab. Terms of
13 * the GPL can be found in doc/GPL-license.txt in this distribution, or
14 * online at http://secondlife.com/developers/opensource/gplv2
15 *
16 * There are special exceptions to the terms and conditions of the GPL as
17 * it is applied to this Source Code. View the full text of the exception
18 * in the file doc/FLOSS-exception.txt in this software distribution, or
19 * online at http://secondlife.com/developers/opensource/flossexception
20 *
21 * By copying, modifying or distributing this software, you acknowledge
22 * that you have read and understood your obligations described above,
23 * and agree to abide by those obligations.
24 *
25 * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
26 * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
27 * COMPLETENESS OR PERFORMANCE.
28 */
29
30#include <tut/tut.h>
31#include "lltut.h"
32#include "llquaternion.h"
33#include "linden_common.h"
34#include "llquantize.h"
35#include "v3dmath.h"
36#include "m3math.h"
37#include "v4math.h"
38#include "llsd.h"
39#include "v3math.h"
40
41
42namespace tut
43{
44 struct v3math_data
45 {
46 };
47 typedef test_group<v3math_data> v3math_test;
48 typedef v3math_test::object v3math_object;
49 tut::v3math_test v3math_testcase("v3math");
50
51 template<> template<>
52 void v3math_object::test<1>()
53 {
54 LLVector3 vec3;
55 ensure("1:LLVector3:Fail to initialize ", ((0.f == vec3.mV[VX]) && (0.f == vec3.mV[VY]) && (0.f == vec3.mV[VZ])));
56 F32 x = 2.32f, y = 1.212f, z = -.12f;
57 LLVector3 vec3a(x,y,z);
58 ensure("2:LLVector3:Fail to initialize ", ((2.32f == vec3a.mV[VX]) && (1.212f == vec3a.mV[VY]) && (-.12f == vec3a.mV[VZ])));
59 const F32 vec[3] = {1.2f ,3.2f, -4.2f};
60 LLVector3 vec3b(vec);
61 ensure("3:LLVector3:Fail to initialize ", ((1.2f == vec3b.mV[VX]) && (3.2f == vec3b.mV[VY]) && (-4.2f == vec3b.mV[VZ])));
62 }
63
64 template<> template<>
65 void v3math_object::test<2>()
66 {
67 F32 x = 2.32f, y = 1.212f, z = -.12f;
68 LLVector3 vec3(x,y,z);
69 LLVector3d vector3d(vec3);
70 LLVector3 vec3a(vector3d);
71 ensure("1:LLVector3:Fail to initialize ", vec3 == vec3a);
72 LLVector4 vector4(vec3);
73 LLVector3 vec3b(vector4);
74 ensure("2:LLVector3:Fail to initialize ", vec3 == vec3b);
75 }
76
77 template<> template<>
78 void v3math_object::test<3>()
79 {
80 S32 a = 231;
81 LLSD llsd(a);
82 LLVector3 vec3(llsd);
83 LLSD sd = vec3.getValue();
84 LLVector3 vec3a(sd);
85 ensure("1:LLVector3:Fail to initialize ", (vec3 == vec3a));
86 }
87
88 template<> template<>
89 void v3math_object::test<4>()
90 {
91 S32 a = 231;
92 LLSD llsd(a);
93 LLVector3 vec3(llsd),vec3a;
94 vec3a = vec3;
95 ensure("1:Operator= Fail to initialize " ,(vec3 == vec3a));
96 }
97
98 template<> template<>
99 void v3math_object::test<5>()
100 {
101 F32 x = 2.32f, y = 1.212f, z = -.12f;
102 LLVector3 vec3(x,y,z);
103 ensure("1:isFinite= Fail to initialize ", (TRUE == vec3.isFinite()));//need more test cases:
104 vec3.clearVec();
105 ensure("2:clearVec:Fail to set values ", ((0.f == vec3.mV[VX]) && (0.f == vec3.mV[VY]) && (0.f == vec3.mV[VZ])));
106 vec3.setVec(x,y,z);
107 ensure("3:setVec:Fail to set values ", ((2.32f == vec3.mV[VX]) && (1.212f == vec3.mV[VY]) && (-.12f == vec3.mV[VZ])));
108 vec3.zeroVec();
109 ensure("4:zeroVec:Fail to set values ", ((0.f == vec3.mV[VX]) && (0.f == vec3.mV[VY]) && (0.f == vec3.mV[VZ])));
110 }
111
112 template<> template<>
113 void v3math_object::test<6>()
114 {
115 F32 x = 2.32f, y = 1.212f, z = -.12f;
116 LLVector3 vec3(x,y,z),vec3a;
117 vec3.abs();
118 ensure("1:abs:Fail ", ((x == vec3.mV[VX]) && (y == vec3.mV[VY]) && (-z == vec3.mV[VZ])));
119 vec3a.setVec(vec3);
120 ensure("2:setVec:Fail to initialize ", (vec3a == vec3));
121 const F32 vec[3] = {1.2f ,3.2f, -4.2f};
122 vec3.clearVec();
123 vec3.setVec(vec);
124 ensure("3:setVec:Fail to initialize ", ((1.2f == vec3.mV[VX]) && (3.2f == vec3.mV[VY]) && (-4.2f == vec3.mV[VZ])));
125 vec3a.clearVec();
126 LLVector3d vector3d(vec3);
127 vec3a.setVec(vector3d);
128 ensure("4:setVec:Fail to initialize ", (vec3 == vec3a));
129 LLVector4 vector4(vec3);
130 vec3a.clearVec();
131 vec3a.setVec(vector4);
132 ensure("5:setVec:Fail to initialize ", (vec3 == vec3a));
133 }
134
135 template<> template<>
136 void v3math_object::test<7>()
137 {
138 F32 x = 2.32f, y = 3.212f, z = -.12f;
139 F32 min = 0.0001f, max = 3.0f;
140 LLVector3 vec3(x,y,z);
141 ensure("1:clamp:Fail ", TRUE == vec3.clamp(min, max) && x == vec3.mV[VX] && max == vec3.mV[VY] && min == vec3.mV[VZ]);
142 x = 1.f, y = 2.2f, z = 2.8f;
143 vec3.setVec(x,y,z);
144 ensure("2:clamp:Fail ", FALSE == vec3.clamp(min, max));
145 }
146
147 template<> template<>
148 void v3math_object::test<8>()
149 {
150 F32 x = 2.32f, y = 1.212f, z = -.12f;
151 LLVector3 vec3(x,y,z);
152 ensure("1:magVecSquared:Fail ", is_approx_equal(vec3.magVecSquared(), (x*x + y*y + z*z)));
153 ensure("2:magVec:Fail ", is_approx_equal(vec3.magVec(), fsqrtf(x*x + y*y + z*z)));
154 }
155
156 template<> template<>
157 void v3math_object::test<9>()
158 {
159 F32 x =-2.0f, y = -3.0f, z = 1.23f ;
160 LLVector3 vec3(x,y,z);
161 ensure("1:abs():Fail ", (TRUE == vec3.abs()));
162 ensure("2:isNull():Fail", (FALSE == vec3.isNull())); //Returns TRUE if vector has a _very_small_ length
163 x =.00000001f, y = .000001001f, z = .000001001f;
164 vec3.setVec(x,y,z);
165 ensure("3:isNull(): Fail ", (TRUE == vec3.isNull()));
166 }
167
168 template<> template<>
169 void v3math_object::test<10>()
170 {
171 F32 x =-2.0f, y = -3.0f, z = 1.f ;
172 LLVector3 vec3(x,y,z),vec3a;
173 ensure("1:isExactlyZero():Fail ", (TRUE == vec3a.isExactlyZero()));
174 vec3a = vec3a.scaleVec(vec3);
175 ensure("2:scaleVec: Fail ", vec3a.mV[VX] == 0.f && vec3a.mV[VY] == 0.f && vec3a.mV[VZ] == 0.f);
176 vec3a.setVec(x,y,z);
177 vec3a = vec3a.scaleVec(vec3);
178 ensure("3:scaleVec: Fail ", ((4 == vec3a.mV[VX]) && (9 == vec3a.mV[VY]) &&(1 == vec3a.mV[VZ])));
179 ensure("4:isExactlyZero():Fail ", (FALSE == vec3.isExactlyZero()));
180 }
181
182 template<> template<>
183 void v3math_object::test<11>()
184 {
185 F32 x =20.0f, y = 30.0f, z = 15.f ;
186 F32 angle = 100.f;
187 LLVector3 vec3(x,y,z),vec3a(1.f,2.f,3.f);
188 vec3a = vec3a.rotVec(angle, vec3);
189 LLVector3 vec3b(1.f,2.f,3.f);
190 vec3b = vec3b.rotVec(angle, vec3);
191 ensure_equals("rotVec():Fail" ,vec3b,vec3a);
192 }
193
194 template<> template<>
195 void v3math_object::test<12>()
196 {
197 F32 x =-2.0f, y = -3.0f, z = 1.f ;
198 LLVector3 vec3(x,y,z);
199 ensure("1:operator [] failed",( x == vec3[0]));
200 ensure("2:operator [] failed",( y == vec3[1]));
201 ensure("3:operator [] failed",( z == vec3[2]));
202
203 vec3.clearVec();
204 x = 23.f, y = -.2361f, z = 3.25;
205 vec3.setVec(x,y,z);
206 F32 &ref1 = vec3[0];
207 ensure("4:operator [] failed",( ref1 == vec3[0]));
208 F32 &ref2 = vec3[1];
209 ensure("5:operator [] failed",( ref2 == vec3[1]));
210 F32 &ref3 = vec3[2];
211 ensure("6:operator [] failed",( ref3 == vec3[2]));
212 }
213
214 template<> template<>
215 void v3math_object::test<13>()
216 {
217 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 = -2.3f, y2 = 1.11f, z2 = 1234.234f;
218 F32 val1, val2, val3;
219 LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2), vec3b;
220 vec3b = vec3 + vec3a ;
221 val1 = x1+x2;
222 val2 = y1+y2;
223 val3 = z1+z2;
224 ensure("1:operator+ failed",(val1 == vec3b.mV[VX]) && (val2 == vec3b.mV[VY]) && (val3 == vec3b.mV[VZ]));
225
226 vec3.clearVec();
227 vec3a.clearVec();
228 vec3b.clearVec();
229 x1 = -.235f, y1 = -24.32f,z1 = 2.13f, x2 = -2.3f, y2 = 1.f, z2 = 34.21f;
230 vec3.setVec(x1,y1,z1);
231 vec3a.setVec(x2,y2,z2);
232 vec3b = vec3 + vec3a;
233 val1 = x1+x2;
234 val2 = y1+y2;
235 val3 = z1+z2;
236 ensure("2:operator+ failed",(val1 == vec3b.mV[VX]) && (val2 == vec3b.mV[VY]) && (val3 == vec3b.mV[VZ]));
237 }
238
239 template<> template<>
240 void v3math_object::test<14>()
241 {
242 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 = -2.3f, y2 = 1.11f, z2 = 1234.234f;
243 F32 val1, val2, val3;
244 LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2), vec3b;
245 vec3b = vec3 - vec3a ;
246 val1 = x1-x2;
247 val2 = y1-y2;
248 val3 = z1-z2;
249 ensure("1:operator- failed",(val1 == vec3b.mV[VX]) && (val2 == vec3b.mV[VY]) && (val3 == vec3b.mV[VZ]));
250
251 vec3.clearVec();
252 vec3a.clearVec();
253 vec3b.clearVec();
254 x1 = -.235f, y1 = -24.32f,z1 = 2.13f, x2 = -2.3f, y2 = 1.f, z2 = 34.21f;
255 vec3.setVec(x1,y1,z1);
256 vec3a.setVec(x2,y2,z2);
257 vec3b = vec3 - vec3a;
258 val1 = x1-x2;
259 val2 = y1-y2;
260 val3 = z1-z2;
261 ensure("2:operator- failed",(val1 == vec3b.mV[VX]) && (val2 == vec3b.mV[VY]) && (val3 == vec3b.mV[VZ]));
262 }
263
264 template<> template<>
265 void v3math_object::test<15>()
266 {
267 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 = -2.3f, y2 = 1.11f, z2 = 1234.234f;
268 F32 val1, val2, val3;
269 LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2);
270 val1 = vec3 * vec3a;
271 val2 = x1*x2 + y1*y2 + z1*z2;
272 ensure_equals("1:operator* failed",val1,val2);
273
274 vec3a.clearVec();
275 F32 mulVal = 4.332f;
276 vec3a = vec3 * mulVal;
277 val1 = x1*mulVal;
278 val2 = y1*mulVal;
279 val3 = z1*mulVal;
280 ensure("2:operator* failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY])&& (val3 == vec3a.mV[VZ]));
281 vec3a.clearVec();
282 vec3a = mulVal * vec3;
283 ensure("3:operator* failed ", (val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY])&& (val3 == vec3a.mV[VZ]));
284 }
285
286 template<> template<>
287 void v3math_object::test<16>()
288 {
289 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 = -2.3f, y2 = 1.11f, z2 = 1234.234f;
290 F32 val1, val2, val3;
291 LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2), vec3b;
292 vec3b = vec3 % vec3a ;
293 val1 = y1*z2 - y2*z1;
294 val2 = z1*x2 -z2*x1;
295 val3 = x1*y2-x2*y1;
296 ensure("1:operator% failed",(val1 == vec3b.mV[VX]) && (val2 == vec3b.mV[VY]) && (val3 == vec3b.mV[VZ]));
297
298 vec3.clearVec();
299 vec3a.clearVec();
300 vec3b.clearVec();
301 x1 =112.f, y1 = 22.3f,z1 = 1.2f, x2 = -2.3f, y2 = 341.11f, z2 = 1234.234f;
302 vec3.setVec(x1,y1,z1);
303 vec3a.setVec(x2,y2,z2);
304 vec3b = vec3 % vec3a ;
305 val1 = y1*z2 - y2*z1;
306 val2 = z1*x2 -z2*x1;
307 val3 = x1*y2-x2*y1;
308 ensure("2:operator% failed ", (val1 == vec3b.mV[VX]) && (val2 == vec3b.mV[VY]) && (val3 == vec3b.mV[VZ]));
309 }
310
311 template<> template<>
312 void v3math_object::test<17>()
313 {
314 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, div = 3.2f;
315 F32 t = 1.f / div, val1, val2, val3;
316 LLVector3 vec3(x1,y1,z1), vec3a;
317 vec3a = vec3 / div;
318 val1 = x1 * t;
319 val2 = y1 * t;
320 val3 = z1 *t;
321 ensure("1:operator/ failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY]) && (val3 == vec3a.mV[VZ]));
322
323 vec3a.clearVec();
324 x1 = -.235f, y1 = -24.32f, z1 = .342f, div = -2.2f;
325 t = 1.f / div;
326 vec3.setVec(x1,y1,z1);
327 vec3a = vec3 / div;
328 val1 = x1 * t;
329 val2 = y1 * t;
330 val3 = z1 *t;
331 ensure("2:operator/ failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY]) && (val3 == vec3a.mV[VZ]));
332 }
333
334 template<> template<>
335 void v3math_object::test<18>()
336 {
337 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f;
338 LLVector3 vec3(x1,y1,z1), vec3a(x1,y1,z1);
339 ensure("1:operator== failed",(vec3 == vec3a));
340
341 vec3a.clearVec();
342 x1 = -.235f, y1 = -24.32f, z1 = .342f;
343 vec3.clearVec();
344 vec3a.clearVec();
345 vec3.setVec(x1,y1,z1);
346 vec3a.setVec(x1,y1,z1);
347 ensure("2:operator== failed ", (vec3 == vec3a));
348 }
349
350 template<> template<>
351 void v3math_object::test<19>()
352 {
353 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 =112.f, y2 = 2.234f,z2 = 11.2f;;
354 LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2);
355 ensure("1:operator!= failed",(vec3a != vec3));
356
357 vec3.clearVec();
358 vec3.clearVec();
359 vec3a.setVec(vec3);
360 ensure("2:operator!= failed", ( FALSE == (vec3a != vec3)));
361 }
362
363 template<> template<>
364 void v3math_object::test<20>()
365 {
366 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 =112.f, y2 = 2.2f,z2 = 11.2f;;
367 LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2);
368 vec3a += vec3;
369 F32 val1, val2, val3;
370 val1 = x1+x2;
371 val2 = y1+y2;
372 val3 = z1+z2;
373 ensure("1:operator+= failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY])&& (val3 == vec3a.mV[VZ]));
374 }
375
376 template<> template<>
377 void v3math_object::test<21>()
378 {
379 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 =112.f, y2 = 2.2f,z2 = 11.2f;;
380 LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2);
381 vec3a -= vec3;
382 F32 val1, val2, val3;
383 val1 = x2-x1;
384 val2 = y2-y1;
385 val3 = z2-z1;
386 ensure("1:operator-= failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY])&& (val3 == vec3a.mV[VZ]));
387 }
388
389 template<> template<>
390 void v3math_object::test<22>()
391 {
392 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 = -2.3f, y2 = 1.11f, z2 = 1234.234f;
393 F32 val1,val2,val3;
394 LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2);
395 vec3a *= vec3;
396 val1 = x1*x2;
397 val2 = y1*y2;
398 val3 = z1*z2;
399 ensure("1:operator*= failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY])&& (val3 == vec3a.mV[VZ]));
400
401 F32 mulVal = 4.332f;
402 vec3 *=mulVal;
403 val1 = x1*mulVal;
404 val2 = y1*mulVal;
405 val3 = z1*mulVal;
406 ensure("2:operator*= failed ", (val1 == vec3.mV[VX]) && (val2 == vec3.mV[VY]) && (val3 == vec3.mV[VZ]));
407 }
408
409 template<> template<>
410 void v3math_object::test<23>()
411 {
412 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, x2 = -2.3f, y2 = 1.11f, z2 = 1234.234f;
413 LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2),vec3b;
414 vec3b = vec3a % vec3;
415 vec3a %= vec3;
416 ensure_equals("1:operator%= failed",vec3a,vec3b);
417 }
418
419 template<> template<>
420 void v3math_object::test<24>()
421 {
422 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f, div = 3.2f;
423 F32 t = 1.f / div, val1, val2, val3;
424 LLVector3 vec3a(x1,y1,z1);
425 vec3a /= div;
426 val1 = x1 * t;
427 val2 = y1 * t;
428 val3 = z1 *t;
429 ensure("1:operator/= failed",(val1 == vec3a.mV[VX]) && (val2 == vec3a.mV[VY]) && (val3 == vec3a.mV[VZ]));
430 }
431
432 template<> template<>
433 void v3math_object::test<25>()
434 {
435 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f;
436 LLVector3 vec3(x1,y1,z1), vec3a;
437 vec3a = -vec3;
438 ensure("1:operator- failed",(-vec3a == vec3));
439 }
440
441 template<> template<>
442 void v3math_object::test<26>()
443 {
444 F32 x1 =1.f, y1 = 2.f,z1 = 1.2f;
445 std::ostringstream stream1, stream2;
446 LLVector3 vec3(x1,y1,z1), vec3a;
447 stream1 << vec3;
448 vec3a.setVec(x1,y1,z1);
449 stream2 << vec3a;
450 ensure("1:operator << failed",(stream1.str() == stream2.str()));
451 }
452
453 template<> template<>
454 void v3math_object::test<27>()
455 {
456 F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f, y2 = 1.11f, z2 = 1234.234f;
457 LLVector3 vec3(x1,y1,z1), vec3a(x2,y2,z2);
458 ensure("1:operator< failed", (TRUE == vec3 < vec3a));
459 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f, y2 = 2.f, z2 = 1234.234f;
460 vec3.setVec(x1,y1,z1);
461 vec3a.setVec(x2,y2,z2);
462 ensure("2:operator< failed ", (TRUE == vec3 < vec3a));
463 x1 =2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f,
464 vec3.setVec(x1,y1,z1);
465 vec3a.setVec(x2,y2,z2);
466 ensure("3:operator< failed ", (FALSE == vec3 < vec3a));
467 }
468
469 template<> template<>
470 void v3math_object::test<28>()
471 {
472 F32 x1 =1.23f, y1 = 2.f,z1 = 4.f;
473 char buf[] = "1.23 2. 4";
474 LLVector3 vec3, vec3a(x1,y1,z1);
475 LLVector3::parseVector3(buf, &vec3);
476 ensure_equals("1:parseVector3 failed", vec3, vec3a);
477 }
478
479 template<> template<>
480 void v3math_object::test<29>()
481 {
482 F32 x1 =1.f, y1 = 2.f,z1 = 4.f;
483 LLVector3 vec3(x1,y1,z1),vec3a,vec3b;
484 vec3a.setVec(1,1,1);
485 vec3a.scaleVec(vec3);
486 ensure_equals("1:scaleVec failed", vec3, vec3a);
487 vec3a.clearVec();
488 vec3a.setVec(x1,y1,z1);
489 vec3a.scaleVec(vec3);
490 ensure("2:scaleVec failed", ((1.f ==vec3a.mV[VX])&& (4.f ==vec3a.mV[VY]) && (16.f ==vec3a.mV[VZ])));
491 }
492
493 template<> template<>
494 void v3math_object::test<30>()
495 {
496 F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f, y2 = 1.11f, z2 = 1234.234f;
497 F32 val = 2.3f,val1,val2,val3;
498 val1 = x1 + (x2 - x1)* val;
499 val2 = y1 + (y2 - y1)* val;
500 val3 = z1 + (z2 - z1)* val;
501 LLVector3 vec3(x1,y1,z1),vec3a(x2,y2,z2);
502 LLVector3 vec3b = lerp(vec3,vec3a,val);
503 ensure("1:lerp failed", ((val1 ==vec3b.mV[VX])&& (val2 ==vec3b.mV[VY]) && (val3 ==vec3b.mV[VZ])));
504 }
505
506 template<> template<>
507 void v3math_object::test<31>()
508 {
509 F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f, y2 = 1.f, z2 = 1.f;
510 F32 val1,val2;
511 LLVector3 vec3(x1,y1,z1),vec3a(x2,y2,z2);
512 val1 = dist_vec(vec3,vec3a);
513 val2 = fsqrtf((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
514 ensure_equals("1:dist_vec: Fail ",val2, val1);
515 val1 = dist_vec_squared(vec3,vec3a);
516 val2 =((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
517 ensure_equals("2:dist_vec_squared: Fail ",val2, val1);
518 val1 = dist_vec_squared2D(vec3, vec3a);
519 val2 =(x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2);
520 ensure_equals("3:dist_vec_squared2D: Fail ",val2, val1);
521 }
522
523 template<> template<>
524 void v3math_object::test<32>()
525 {
526 F32 x =12.3524f, y = -342.f,z = 4.126341f;
527 LLVector3 vec3(x,y,z);
528 F32 mag = vec3.normVec();
529 mag = 1.f/ mag;
530 F32 val1 = x* mag, val2 = y* mag, val3 = z* mag;
531 ensure("1:normVec: Fail ", (val1 == vec3.mV[VX]) && (val2 == vec3.mV[VY])&& (val3 == vec3.mV[VZ]));
532 x = 0.000000001f, y = 0.f, z = 0.f;
533 vec3.clearVec();
534 vec3.setVec(x,y,z);
535 mag = vec3.normVec();
536 val1 = x* mag, val2 = y* mag, val3 = z* mag;
537 ensure("2:normVec: Fail ", (mag == 0.) && (0. == vec3.mV[VX]) && (0. == vec3.mV[VY])&& (0. == vec3.mV[VZ]));
538 }
539
540 template<> template<>
541 void v3math_object::test<33>()
542 {
543 F32 x = -202.23412f, y = 123.2312f, z = -89.f;
544 LLVector3 vec(x,y,z);
545 vec.snap(2);
546 ensure("1:snap: Fail ", is_approx_equal(-202.23f, vec.mV[VX]) && is_approx_equal(123.23f, vec.mV[VY]) && is_approx_equal(-89.f, vec.mV[VZ]));
547 }
548
549 template<> template<>
550 void v3math_object::test<34>()
551 {
552 F32 x = 10.f, y = 20.f, z = -15.f;
553 F32 x1, y1, z1;
554 F32 lowerxy = 0.f, upperxy = 1.0f, lowerz = -1.0f, upperz = 1.f;
555 LLVector3 vec3(x,y,z);
556 vec3.quantize16(lowerxy,upperxy,lowerz,upperz);
557 x1 = U16_to_F32(F32_to_U16(x, lowerxy, upperxy), lowerxy, upperxy);
558 y1 = U16_to_F32(F32_to_U16(y, lowerxy, upperxy), lowerxy, upperxy);
559 z1 = U16_to_F32(F32_to_U16(z, lowerz, upperz), lowerz, upperz);
560 ensure("1:quantize16: Fail ", (x1 == vec3.mV[VX]) && (y1 == vec3.mV[VY])&& (z1 == vec3.mV[VZ]));
561 LLVector3 vec3a(x,y,z);
562 vec3a.quantize8(lowerxy,upperxy,lowerz,upperz);
563 x1 = U8_to_F32(F32_to_U8(x, lowerxy, upperxy), lowerxy, upperxy);
564 y1 = U8_to_F32(F32_to_U8(y, lowerxy, upperxy), lowerxy, upperxy);
565 z1 = U8_to_F32(F32_to_U8(z, lowerz, upperz), lowerz, upperz);
566 ensure("2:quantize8: Fail ", (x1 == vec3a.mV[VX]) && (y1 == vec3a.mV[VY])&& (z1 == vec3a.mV[VZ]));
567 }
568} \ No newline at end of file
generated by cgit v1.1 at 2025-04-25 12:50:29 +0000