v4math_tut.cpp

Go to the documentation of this file.
00001 
00034 #include <tut/tut.h>
00035 #include "linden_common.h"
00036 #include "lltut.h"
00037 #include "llquaternion.h"
00038 #include "llsd.h"
00039 #include "m4math.h"
00040 #include "v4math.h"
00041 
00042 namespace tut
00043 {
00044         struct v4math_data
00045         {
00046         };
00047         typedef test_group<v4math_data> v4math_test;
00048         typedef v4math_test::object v4math_object;
00049         tut::v4math_test v4math_testcase("v4math");
00050 
00051         template<> template<>
00052         void v4math_object::test<1>()
00053         {
00054                 LLVector4 vec4;
00055                 ensure("1:LLVector4:Fail to initialize " ,((0 == vec4.mV[VX]) && (0 == vec4.mV[VY]) && (0 == vec4.mV[VZ])&& (1.0f == vec4.mV[VW])));
00056                 F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
00057                 LLVector4 vec4a(x,y,z);
00058                 ensure("2:LLVector4:Fail to initialize " ,((x == vec4a.mV[VX]) && (y == vec4a.mV[VY]) && (z == vec4a.mV[VZ])&& (1.0f == vec4a.mV[VW])));
00059                 LLVector4 vec4b(x,y,z,w);
00060                 ensure("3:LLVector4:Fail to initialize " ,((x == vec4b.mV[VX]) && (y == vec4b.mV[VY]) && (z == vec4b.mV[VZ])&& (w == vec4b.mV[VW])));
00061                 const F32 vec[4] = {.112f ,23.2f, -4.2f, -.0001f};
00062                 LLVector4 vec4c(vec);
00063                 ensure("4:LLVector4:Fail to initialize " ,((vec[0] == vec4c.mV[VX]) && (vec[1] == vec4c.mV[VY]) && (vec[2] == vec4c.mV[VZ])&& (vec[3] == vec4c.mV[VW])));
00064                 LLVector3 vec3(-2.23f,1.01f,42.3f);
00065                 LLVector4 vec4d(vec3);
00066                 ensure("5:LLVector4:Fail to initialize " ,((vec3.mV[VX] == vec4d.mV[VX]) && (vec3.mV[VY] == vec4d.mV[VY]) && (vec3.mV[VZ] == vec4d.mV[VZ])&& (1.f == vec4d.mV[VW])));
00067                 F32 w1 = -.234f;
00068                 LLVector4 vec4e(vec3,w1);
00069                 ensure("6:LLVector4:Fail to initialize " ,((vec3.mV[VX] == vec4e.mV[VX]) && (vec3.mV[VY] == vec4e.mV[VY]) && (vec3.mV[VZ] == vec4e.mV[VZ])&& (w1 == vec4e.mV[VW])));
00070         }
00071 
00072         template<> template<>
00073         void v4math_object::test<2>()
00074         {
00075                 F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
00076                 LLVector4 vec4;
00077                 vec4.setVec(x,y,z);
00078                 ensure("1:setVec:Fail to initialize " ,((x == vec4.mV[VX]) && (y == vec4.mV[VY]) && (z == vec4.mV[VZ])&& (1.0f == vec4.mV[VW])));
00079                 vec4.clearVec();
00080                 ensure("2:clearVec:Fail " ,((0 == vec4.mV[VX]) && (0 == vec4.mV[VY]) && (0 == vec4.mV[VZ])&& (1.0f == vec4.mV[VW])));
00081                 vec4.setVec(x,y,z,w);
00082                 ensure("3:setVec:Fail to initialize " ,((x == vec4.mV[VX]) && (y == vec4.mV[VY]) && (z == vec4.mV[VZ])&& (w == vec4.mV[VW])));
00083                 vec4.zeroVec();
00084                 ensure("4:zeroVec:Fail " ,((0 == vec4.mV[VX]) && (0 == vec4.mV[VY]) && (0 == vec4.mV[VZ])&& (0 == vec4.mV[VW])));
00085                 LLVector3 vec3(-2.23f,1.01f,42.3f);
00086                 vec4.clearVec();
00087                 vec4.setVec(vec3);
00088                 ensure("5:setVec:Fail to initialize " ,((vec3.mV[VX] == vec4.mV[VX]) && (vec3.mV[VY] == vec4.mV[VY]) && (vec3.mV[VZ] == vec4.mV[VZ])&& (1.f == vec4.mV[VW])));
00089                 F32 w1 = -.234f;
00090                 vec4.zeroVec();
00091                 vec4.setVec(vec3,w1);
00092                 ensure("6:setVec:Fail to initialize " ,((vec3.mV[VX] == vec4.mV[VX]) && (vec3.mV[VY] == vec4.mV[VY]) && (vec3.mV[VZ] == vec4.mV[VZ])&& (w1 == vec4.mV[VW])));
00093                 const F32 vec[4] = {.112f ,23.2f, -4.2f, -.0001f};
00094                 LLVector4 vec4a;
00095                 vec4a.setVec(vec);
00096                 ensure("7:setVec:Fail to initialize " ,((vec[0] == vec4a.mV[VX]) && (vec[1] == vec4a.mV[VY]) && (vec[2] == vec4a.mV[VZ])&& (vec[3] == vec4a.mV[VW])));
00097         }
00098 
00099         template<> template<>
00100         void v4math_object::test<3>()
00101         {
00102                 F32 x = 10.f, y = -2.3f, z = -.023f;
00103                 LLVector4 vec4(x,y,z);
00104                 ensure("magVec:Fail ", is_approx_equal(vec4.magVec(), fsqrtf(x*x + y*y + z*z)));
00105                 ensure("magVecSquared:Fail ", is_approx_equal(vec4.magVecSquared(), (x*x + y*y + z*z)));
00106         }
00107 
00108         template<> template<>
00109         void v4math_object::test<4>()
00110         {
00111                 F32 x = 10.f, y = -2.3f, z = -.023f;
00112                 LLVector4 vec4(x,y,z);
00113                 F32 mag = vec4.normVec();
00114                 mag = 1.f/ mag;
00115                 ensure("1:normVec: Fail " ,is_approx_equal(mag*x,vec4.mV[VX]) && is_approx_equal(mag*y, vec4.mV[VY])&& is_approx_equal(mag*z, vec4.mV[VZ]));
00116                 x = 0.000000001f, y = 0.000000001f, z = 0.000000001f;
00117                 vec4.clearVec();
00118                 vec4.setVec(x,y,z);
00119                 mag = vec4.normVec();
00120                 ensure("2:normVec: Fail " ,is_approx_equal(mag*x,vec4.mV[VX]) && is_approx_equal(mag*y, vec4.mV[VY])&& is_approx_equal(mag*z, vec4.mV[VZ]));
00121         }
00122 
00123         template<> template<>
00124         void v4math_object::test<5>()
00125         {
00126                 F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
00127                 LLVector4 vec4(x,y,z,w);
00128                 vec4.abs();
00129                 ensure("abs:Fail " ,((x == vec4.mV[VX]) && (-y == vec4.mV[VY]) && (-z == vec4.mV[VZ])&& (-w == vec4.mV[VW])));
00130                 vec4.clearVec();
00131                 ensure("isExactlyClear:Fail " ,(TRUE == vec4.isExactlyClear()));
00132                 vec4.zeroVec();
00133                 ensure("isExactlyZero:Fail " ,(TRUE == vec4.isExactlyZero()));
00134         }
00135 
00136         template<> template<>
00137         void v4math_object::test<6>()
00138         {
00139                 F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
00140                 LLVector4 vec4(x,y,z,w),vec4a;
00141                 vec4a = vec4.scaleVec(vec4);
00142                 ensure("scaleVec:Fail " ,(is_approx_equal(x*x, vec4a.mV[VX]) && is_approx_equal(y*y, vec4a.mV[VY]) && is_approx_equal(z*z, vec4a.mV[VZ])&& is_approx_equal(w*w, vec4a.mV[VW])));
00143         }
00144 
00145         template<> template<>
00146         void v4math_object::test<7>()
00147         {
00148                 F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
00149                 LLVector4 vec4(x,y,z,w);
00150                 ensure("1:operator [] failed " ,( x ==  vec4[0]));      
00151                 ensure("2:operator [] failed " ,( y ==  vec4[1]));
00152                 ensure("3:operator [] failed " ,( z ==  vec4[2]));
00153                 ensure("4:operator [] failed " ,( w ==  vec4[3]));
00154                 x = 23.f, y = -.2361f, z = 3.25;
00155                 vec4.setVec(x,y,z);
00156                 F32 &ref1 = vec4[0];
00157                 ensure("5:operator [] failed " ,( ref1 ==  vec4[0]));
00158                 F32 &ref2 = vec4[1];
00159                 ensure("6:operator [] failed " ,( ref2 ==  vec4[1]));
00160                 F32 &ref3 = vec4[2];
00161                 ensure("7:operator [] failed " ,( ref3 ==  vec4[2]));   
00162                 F32 &ref4 = vec4[3];
00163                 ensure("8:operator [] failed " ,( ref4 ==  vec4[3]));
00164         }
00165 
00166         template<> template<>
00167         void v4math_object::test<8>()
00168         {
00169                 F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
00170                 const  F32 val[10] = {1.f,2.f,3.f,.34f,.1f,-.5f,2.f,1.23f,1.234f,.89f};
00171                 LLMatrix4 mat(val);
00172                 LLVector4 vec4(x,y,z,w),vec4a;
00173                 vec4.rotVec(mat);
00174                 vec4a.setVec(x,y,z,w);
00175                 vec4a.rotVec(mat);
00176                 ensure_equals("1:rotVec: Fail " ,vec4a, vec4);
00177                 F32 a = 2.32f, b = -23.2f, c = -34.1112f, d = 1.010112f;
00178                 LLQuaternion q(a,b,c,d);
00179                 LLVector4 vec4b(a,b,c,d),vec4c;
00180                 vec4b.rotVec(q);
00181                 vec4c.setVec(a, b, c, d);
00182                 vec4c.rotVec(q);
00183                 ensure_equals("2:rotVec: Fail " ,vec4b, vec4c);
00184         }
00185         
00186         template<> template<>
00187         void v4math_object::test<9>()
00188         {
00189                 F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
00190                 LLVector4 vec4(x,y,z,w),vec4a;;
00191                 std::ostringstream stream1, stream2;
00192                 stream1 << vec4;
00193                 vec4a.setVec(x,y,z,w);
00194                 stream2 << vec4a;
00195                 ensure("operator << failed",(stream1.str() == stream2.str()));  
00196         }
00197         
00198         template<> template<>
00199         void v4math_object::test<10>()
00200         {
00201                 F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f, w1 = .23f;
00202                 F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f, w2 = 1.3f;
00203                 LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2),vec4b;
00204                 vec4b = vec4a + vec4;
00205                 ensure("1:operator+:Fail to initialize " ,(is_approx_equal(x1+x2,vec4b.mV[VX]) && is_approx_equal(y1+y2,vec4b.mV[VY]) && is_approx_equal(z1+z2,vec4b.mV[VZ])));
00206                 x1 = -2.45f, y1 = 2.1f, z1 = 3.0f;
00207                 vec4.clearVec();
00208                 vec4a.clearVec();
00209                 vec4.setVec(x1,y1,z1);
00210                 vec4a +=vec4;
00211                 ensure_equals("2:operator+=: Fail to initialize", vec4a,vec4);
00212                 vec4a += vec4;
00213                 ensure("3:operator+=:Fail to initialize " ,(is_approx_equal(2*x1,vec4a.mV[VX]) && is_approx_equal(2*y1,vec4a.mV[VY]) && is_approx_equal(2*z1,vec4a.mV[VZ])));
00214         }
00215         template<> template<>
00216         void v4math_object::test<11>()
00217         {
00218                 F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f, w1 = .23f;
00219                 F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f, w2 = 1.3f;
00220                 LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2),vec4b;
00221                 vec4b = vec4a - vec4;
00222                 ensure("1:operator-:Fail to initialize " ,(is_approx_equal(x2-x1,vec4b.mV[VX]) && is_approx_equal(y2-y1,vec4b.mV[VY]) && is_approx_equal(z2-z1,vec4b.mV[VZ])));
00223                 x1 = -2.45f, y1 = 2.1f, z1 = 3.0f;
00224                 vec4.clearVec();
00225                 vec4a.clearVec();
00226                 vec4.setVec(x1,y1,z1);
00227                 vec4a -=vec4;
00228                 ensure_equals("2:operator-=: Fail to initialize" , vec4a,-vec4);
00229                 vec4a -=vec4;
00230                 ensure("3:operator-=:Fail to initialize " ,(is_approx_equal(-2*x1,vec4a.mV[VX]) && is_approx_equal(-2*y1,vec4a.mV[VY]) && is_approx_equal(-2*z1,vec4a.mV[VZ])));
00231         }
00232 
00233         template<> template<>
00234         void v4math_object::test<12>()
00235         {
00236                 F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f;
00237                 F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f;
00238                 LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2);
00239                 F32 res = vec4 * vec4a;
00240                 ensure("1:operator* failed " ,is_approx_equal(res, x1*x2 + y1*y2 + z1*z2));
00241                 vec4a.clearVec();
00242                 F32 mulVal = 4.2f;
00243                 vec4a = vec4 * mulVal;
00244                 ensure("2:operator* failed " ,is_approx_equal(x1*mulVal,vec4a.mV[VX]) && is_approx_equal(y1*mulVal, vec4a.mV[VY])&& is_approx_equal(z1*mulVal, vec4a.mV[VZ]));
00245                 vec4a.clearVec();
00246                 vec4a = mulVal *  vec4 ;
00247                 ensure("3:operator* failed " ,is_approx_equal(x1*mulVal, vec4a.mV[VX]) && is_approx_equal(y1*mulVal, vec4a.mV[VY])&& is_approx_equal(z1*mulVal, vec4a.mV[VZ]));
00248                 vec4 *= mulVal;
00249                 ensure("4:operator*= failed " ,is_approx_equal(x1*mulVal, vec4.mV[VX]) && is_approx_equal(y1*mulVal, vec4.mV[VY])&& is_approx_equal(z1*mulVal, vec4.mV[VZ]));
00250         }
00251 
00252         template<> template<>
00253         void v4math_object::test<13>()
00254         {
00255                 F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f;
00256                 F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f;
00257                 LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2),vec4b;
00258                 vec4b = vec4 % vec4a;
00259                 ensure("1:operator% failed " ,is_approx_equal(y1*z2 - y2*z1, vec4b.mV[VX]) && is_approx_equal(z1*x2 -z2*x1, vec4b.mV[VY]) && is_approx_equal(x1*y2-x2*y1, vec4b.mV[VZ])); 
00260                 vec4 %= vec4a;
00261                 ensure_equals("operator%= failed " ,vec4,vec4b); 
00262         }
00263 
00264         template<> template<>
00265         void v4math_object::test<14>()
00266         {
00267                 F32 x = 1.f, y = 2.f, z = -1.1f,div = 4.2f;
00268                 F32 t = 1.f / div;
00269                 LLVector4 vec4(x,y,z), vec4a;
00270                 vec4a = vec4/div;
00271                 ensure("1:operator/ failed " ,is_approx_equal(x*t, vec4a.mV[VX]) && is_approx_equal(y*t, vec4a.mV[VY])&& is_approx_equal(z*t, vec4a.mV[VZ]));
00272                 x = 1.23f, y = 4.f, z = -2.32f;
00273                 vec4.clearVec();
00274                 vec4a.clearVec();
00275                 vec4.setVec(x,y,z);
00276                 vec4a = vec4/div;
00277                 ensure("2:operator/ failed " ,is_approx_equal(x*t, vec4a.mV[VX]) && is_approx_equal(y*t, vec4a.mV[VY])&& is_approx_equal(z*t, vec4a.mV[VZ]));
00278                 vec4 /= div;
00279                 ensure("3:operator/ failed " ,is_approx_equal(x*t, vec4.mV[VX]) && is_approx_equal(y*t, vec4.mV[VY])&& is_approx_equal(z*t, vec4.mV[VZ]));
00280         }
00281 
00282         template<> template<>
00283         void v4math_object::test<15>()
00284         {
00285                 F32 x = 1.f, y = 2.f, z = -1.1f;
00286                 LLVector4 vec4(x,y,z), vec4a;
00287                 ensure("operator!= failed " ,(vec4 != vec4a));
00288                 vec4a = vec4;
00289                 ensure("operator== failed " ,(vec4 ==vec4a)); 
00290         }
00291 
00292         template<> template<>
00293         void v4math_object::test<16>()
00294         {
00295                 F32 x = 1.f, y = 2.f, z = -1.1f;
00296                 LLVector4 vec4(x,y,z), vec4a;
00297                 vec4a = - vec4;
00298                 ensure("operator- failed " , (vec4 == - vec4a));        
00299         }
00300 
00301         template<> template<>
00302         void v4math_object::test<17>()
00303         {
00304                 F32 x = 1.f, y = 2.f, z = -1.1f,epsilon = .23425f;
00305                 LLVector4 vec4(x,y,z), vec4a(x,y,z);
00306                 ensure("1:are_parallel: Fail " ,(TRUE == are_parallel(vec4a,vec4,epsilon)));
00307                 x = 21.f, y = 12.f, z = -123.1f;
00308                 vec4a.clearVec();
00309                 vec4a.setVec(x,y,z);
00310                 ensure("2:are_parallel: Fail " ,(FALSE == are_parallel(vec4a,vec4,epsilon)));
00311         }
00312 
00313         template<> template<>
00314         void v4math_object::test<18>()
00315         {
00316                 F32 x = 1.f, y = 2.f, z = -1.1f;
00317                 F32 angle1, angle2;
00318                 LLVector4 vec4(x,y,z), vec4a(x,y,z);
00319                 angle1 = angle_between(vec4, vec4a);
00320                 vec4.normVec();
00321                 vec4a.normVec();
00322                 angle2 = acos(vec4 * vec4a);
00323                 ensure_approximately_equals("1:angle_between: Fail " ,angle1,angle2,8);
00324                 F32 x1 = 21.f, y1 = 2.23f, z1 = -1.1f;
00325                 LLVector4 vec4b(x,y,z), vec4c(x1,y1,z1);
00326                 angle1 = angle_between(vec4b, vec4c);
00327                 vec4b.normVec();
00328                 vec4c.normVec();
00329                 angle2 = acos(vec4b * vec4c);
00330                 ensure_approximately_equals("2:angle_between: Fail " ,angle1,angle2,8);
00331         }
00332 
00333         template<> template<>
00334         void v4math_object::test<19>()
00335         {
00336                 F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f, y2 = 1.f, z2 = 1.f;
00337                 F32 val1,val2;
00338                 LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2);
00339                 val1 = dist_vec(vec4,vec4a);
00340                 val2 = fsqrtf((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
00341                 ensure_equals("dist_vec: Fail ",val2, val1);
00342                 val1 = dist_vec_squared(vec4,vec4a);
00343                 val2 =((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
00344                 ensure_equals("dist_vec_squared: Fail ",val2, val1);
00345         }
00346 
00347         template<> template<>
00348         void v4math_object::test<20>()
00349         {
00350                 F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, w1 = -.23f, x2 = 1.3f, y2 = 1.f, z2 = 1.f,w2 = .12f;
00351                 F32 val = 2.3f,val1,val2,val3,val4;
00352                 LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2);
00353                 val1 = x1 + (x2 - x1)* val;
00354                 val2 = y1 + (y2 - y1)* val;
00355                 val3 = z1 + (z2 - z1)* val;
00356                 val4 = w1 + (w2 - w1)* val;
00357                 LLVector4 vec4b = lerp(vec4,vec4a,val);
00358                 ensure("lerp failed", ((val1 ==vec4b.mV[VX])&& (val2 ==vec4b.mV[VY]) && (val3 ==vec4b.mV[VZ])&& (val4 ==vec4b.mV[VW])));        
00359         }
00360 
00361         template<> template<>
00362         void v4math_object::test<21>()
00363         {
00364                 F32 x = 1.f, y = 2.f, z = -1.1f;
00365                 LLVector4 vec4(x,y,z);
00366                 LLVector3 vec3 = vec4to3(vec4);
00367                 ensure("vec4to3 failed", ((x == vec3.mV[VX])&& (y == vec3.mV[VY]) && (z == vec3.mV[VZ])));      
00368                 LLVector4 vec4a = vec3to4(vec3);
00369                 ensure_equals("vec3to4 failed",vec4a,vec4);     
00370         }
00371 
00372         template<> template<>
00373         void v4math_object::test<22>()
00374         {
00375                 F32 x = 1.f, y = 2.f, z = -1.1f;
00376                 LLVector4 vec4(x,y,z);
00377                 LLSD llsd = vec4.getValue();
00378                 LLVector3 vec3(llsd);
00379                 LLVector4 vec4a = vec3to4(vec3);
00380                 ensure_equals("getValue failed",vec4a,vec4);    
00381         }               
00382 }

Generated on Thu Jul 1 06:10:01 2010 for Second Life Viewer by  doxygen 1.4.7