void v3math_object::test<33>() { F32 x = -202.23412f, y = 123.2312f, z = -89.f; LLVector3 vec(x,y,z); vec.snap(2); 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])); }
void v4math_object::test<3>() { F32 x = 10.f, y = -2.3f, z = -.023f; LLVector4 vec4(x,y,z); ensure("magVec:Fail ", is_approx_equal(vec4.magVec(), fsqrtf(x*x + y*y + z*z))); ensure("magVecSquared:Fail ", is_approx_equal(vec4.magVecSquared(), (x*x + y*y + z*z))); }
void v3math_object::test<8>() { F32 x = 2.32f, y = 1.212f, z = -.12f; LLVector3 vec3(x,y,z); ensure("1:magVecSquared:Fail ", is_approx_equal(vec3.magVecSquared(), (x*x + y*y + z*z))); ensure("2:magVec:Fail ", is_approx_equal(vec3.magVec(), fsqrtf(x*x + y*y + z*z))); }
void v3color_object::test<4>() { F32 r = 2.3436212f, g = 1231.f, b = 4.7849321232f; LLColor3 llcolor3(r,g,b); ensure("magVecSquared:Fail ", is_approx_equal(llcolor3.magVecSquared(), (r*r + g*g + b*b))); ensure("magVec:Fail ", is_approx_equal(llcolor3.magVec(), fsqrtf(r*r + g*g + b*b))); }
void v2math_object::test<13>() { F32 x1 = 1.f, y1 = 2.f,x2 = 2.332f, y2 = -1.23f; F32 val1, val2; LLVector2 vec2(x1, y1), vec3(x2, y2); vec2 +=vec3; val1 = x1+x2; val2 = y1+y2; ensure("1:operator+= failed",(val1 == vec2.mV[VX]) && (val2 == vec2.mV[VY])); vec2.setVec(x1, y1); vec2 -=vec3; val1 = x1-x2; val2 = y1-y2; ensure("2:operator-= failed",(val1 == vec2.mV[VX]) && (val2 == vec2.mV[VY])); vec2.clearVec(); vec3.clearVec(); x1 = -21.000466f, y1 = 2.98382f,x2 = 0.332f, y2 = -01.23f; vec2.setVec(x1, y1); vec3.setVec(x2, y2); vec2 +=vec3; val1 = x1+x2; val2 = y1+y2; ensure("3:operator+= failed",(val1 == vec2.mV[VX]) && (val2 == vec2.mV[VY])); vec2.setVec(x1, y1); vec2 -=vec3; val1 = x1-x2; val2 = y1-y2; ensure("4:operator-= failed", is_approx_equal(val1, vec2.mV[VX]) && is_approx_equal(val2, vec2.mV[VY])); }
void v4color_object::test<6>() { F32 r = 0x20, g = 0xFFFF, b = 0xFF; LLColor4 llcolor4(r,g,b); ensure("magVecSquared:Fail ", is_approx_equal(llcolor4.magVecSquared(), (r*r + g*g + b*b))); ensure("magVec:Fail ", is_approx_equal(llcolor4.magVec(), fsqrtf(r*r + g*g + b*b))); }
void v2math_object::test<3>() { F32 x = 2.2345f, y = 3.5678f ; LLVector2 vec2(x,y); ensure("magVecSquared:Fail ", is_approx_equal(vec2.magVecSquared(), (x*x + y*y))); ensure("magVec:Fail ", is_approx_equal(vec2.magVec(), fsqrtf(x*x + y*y))); }
void v4coloru_object::test<7>() { U8 r = 0x12, g = 0xFF, b = 0xAF; LLColor4U llcolor4u(r,g,b); ensure("magVecSquared:Fail ", is_approx_equal(llcolor4u.magVecSquared(), (F32)(r*r + g*g + b*b))); ensure("magVec:Fail ", is_approx_equal(llcolor4u.magVec(), fsqrtf(r*r + g*g + b*b))); }
void v4math_object::test<6>() { F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f; LLVector4 vec4(x,y,z,w),vec4a; vec4a = vec4.scaleVec(vec4); 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]))); }
void v4color_object::test<18>() { F32 r1 = 0x20, g1 = 0xFFFF, b1 = 0xFF, val = 0x20; F32 r2 = 0xABF, g2 = 0xFB, b2 = 0xFFF; LLColor4 llcolor4a(r1,g1,b1),llcolor4b(r2,g2,b2),llcolor4c; llcolor4c = lerp(llcolor4a,llcolor4b,val); ensure("lerp:Fail ", (is_approx_equal(r1 + (r2 - r1)* val,llcolor4c.mV[VX]) && is_approx_equal(g1 + (g2 - g1)* val,llcolor4c.mV[VY]) && is_approx_equal(b1 + (b2 - b1)* val,llcolor4c.mV[VZ]))); }
void v4math_object::test<13>() { F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f; F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f; LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2),vec4b; vec4b = vec4 % vec4a; 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])); vec4 %= vec4a; ensure_equals("operator%= failed " ,vec4,vec4b); }
void v3color_object::test<16>() { F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f; LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2); llcolor3a *= llcolor3; ensure("1:operator*= failed",is_approx_equal(r1*r2 ,llcolor3a.mV[0]) && is_approx_equal(g1*g2,llcolor3a.mV[1])&& is_approx_equal(b1*b2,llcolor3a.mV[2])); F32 mulVal = 4.332f; llcolor3 *=mulVal; ensure("2:operator*= failed",is_approx_equal(r1*mulVal ,llcolor3.mV[0]) && is_approx_equal(g1*mulVal,llcolor3.mV[1])&& is_approx_equal(b1*mulVal,llcolor3.mV[2])); }
void v3color_object::test<19>() { F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f; LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2); F32 val = distVec(llcolor3,llcolor3a); ensure("distVec failed ", is_approx_equal(fsqrtf((r1-r2)*(r1-r2) + (g1-g2)*(g1-g2) + (b1-b2)*(b1-b2)) ,val)); F32 val1 = distVec_squared(llcolor3,llcolor3a); ensure("distVec_squared failed ", is_approx_equal(((r1-r2)*(r1-r2) + (g1-g2)*(g1-g2) + (b1-b2)*(b1-b2)) ,val1)); }
void v4color_object::test<7>() { F32 r = 0x20, g = 0xFFFF, b = 0xFF; LLColor4 llcolor4(r,g,b); F32 vecMag = llcolor4.normVec(); F32 mag = fsqrtf(r*r + g*g + b*b); F32 oomag = 1.f / mag; F32 val1 = r * oomag, val2 = g * oomag, val3 = b * oomag; ensure("1:normVec failed ", (is_approx_equal(val1, llcolor4.mV[0]) && is_approx_equal(val2, llcolor4.mV[1]) && is_approx_equal(val3, llcolor4.mV[2]) && is_approx_equal(vecMag, mag))); }
void v3color_object::test<14>() { F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f; LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2); llcolor3a += llcolor3; ensure("1:operator+= failed",is_approx_equal(r1+r2 ,llcolor3a.mV[0]) && is_approx_equal(g1+g2,llcolor3a.mV[1])&& is_approx_equal(b1+b2,llcolor3a.mV[2])); llcolor3.setVec(r1,g1,b1); llcolor3a.setVec(r2,g2,b2); llcolor3a += llcolor3; ensure("2:operator+= failed",is_approx_equal(r1+r2 ,llcolor3a.mV[0]) && is_approx_equal(g1+g2,llcolor3a.mV[1])&& is_approx_equal(b1+b2,llcolor3a.mV[2])); }
void v4color_object::test<13>() { F32 r1 = 0x20, g1 = 0xFFFF, b1 = 0xFF; F32 r2 = 0xABF, g2 = 0xFB, b2 = 0xFFF; LLColor4 llcolor4a(r1,g1,b1),llcolor4b(r2,g2,b2),llcolor4c; llcolor4c = llcolor4a - llcolor4b; ensure("operator-:Fail to subtract the values ", (is_approx_equal(r1-r2,llcolor4c.mV[VX]) && is_approx_equal(g1-g2,llcolor4c.mV[VY]) && is_approx_equal(b1-b2,llcolor4c.mV[VZ]))); llcolor4a -= llcolor4b; ensure("operator-=:Fail to subtract the values ", (is_approx_equal(r1-r2,llcolor4a.mV[VX]) && is_approx_equal(g1-g2,llcolor4a.mV[VY]) && is_approx_equal(b1-b2,llcolor4a.mV[VZ]))); }
void v4color_object::test<12>() { F32 r1 = 0x20, g1 = 0xFFFF, b1 = 0xFF; F32 r2 = 0xABF, g2 = 0xFB, b2 = 0xFFF; LLColor4 llcolor4a(r1,g1,b1),llcolor4b(r2,g2,b2),llcolor4c; llcolor4c = llcolor4b + llcolor4a; ensure("operator+:Fail to Add the values ", (is_approx_equal(r1+r2,llcolor4c.mV[VX]) && is_approx_equal(g1+g2,llcolor4c.mV[VY]) && is_approx_equal(b1+b2,llcolor4c.mV[VZ]))); llcolor4b += llcolor4a; ensure("operator+=:Fail to Add the values ", (is_approx_equal(r1+r2,llcolor4b.mV[VX]) && is_approx_equal(g1+g2,llcolor4b.mV[VY]) && is_approx_equal(b1+b2,llcolor4b.mV[VZ]))); }
void v3color_object::test<9>() { F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f; LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2),llcolor3b; llcolor3b = llcolor3 - llcolor3a ; ensure("1:operator- failed",is_approx_equal(r1-r2 ,llcolor3b.mV[0]) && is_approx_equal(g1-g2,llcolor3b.mV[1])&& is_approx_equal(b1-b2,llcolor3b.mV[2])); r1 = -.235f, g1 = -24.32f, b1 = 2.13f, r2 = -2.3f, g2 = 1.f, b2 = 34.21f; llcolor3.setVec(r1,g1,b1); llcolor3a.setVec(r2,g2,b2); llcolor3b = llcolor3 - llcolor3a; ensure("2:operator- failed",is_approx_equal(r1-r2 ,llcolor3b.mV[0]) && is_approx_equal(g1-g2,llcolor3b.mV[1])&& is_approx_equal(b1-b2,llcolor3b.mV[2])); }
void v4math_object::test<4>() { F32 x = 10.f, y = -2.3f, z = -.023f; LLVector4 vec4(x,y,z); F32 mag = vec4.normVec(); mag = 1.f/ mag; 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])); x = 0.000000001f, y = 0.000000001f, z = 0.000000001f; vec4.clearVec(); vec4.setVec(x,y,z); mag = vec4.normVec(); 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])); }
void llquat_test_object_t::test<9>() { //test case for LLQuaternion operator*(const LLQuaternion &a, const LLQuaternion &b) fn LLQuaternion quat1(1.0f, 2.5f, 3.5f, 5.5f); LLQuaternion quat2(4.0f, 3.0f, 5.0f, 1.0f); LLQuaternion result = quat1 * quat2; ensure("1. LLQuaternion Operator* failed", (21.0f == result.mQ[0]) && (10.0f == result.mQ[1]) && (38.0f == result.mQ[2]) && (-23.5f == result.mQ[3])); LLQuaternion quat3(2341.340f, 2352.345f, 233.25f, 7645.5f); LLQuaternion quat4(674.067f, 893.0897f, 578.0f, 231.0f); result = quat3 * quat4; ensure("2. LLQuaternion Operator* failed", (4543086.5f == result.mQ[0]) && (8567578.0f == result.mQ[1]) && (3967591.25f == result.mQ[2]) && is_approx_equal(-2047783.25f, result.mQ[3])); //inline LLQuaternion operator+(const LLQuaternion &a, const LLQuaternion &b)fn. result = quat1 + quat2; ensure("3. LLQuaternion operator+ failed", (5.0f == result.mQ[0]) && (5.5f == result.mQ[1]) && (8.5f == result.mQ[2]) && (6.5f == result.mQ[3])); result = quat3 + quat4; ensure( "4. LLQuaternion operator+ failed", is_approx_equal(3015.407227f, result.mQ[0]) && is_approx_equal(3245.434570f, result.mQ[1]) && (811.25f == result.mQ[2]) && (7876.5f == result.mQ[3])); //inline LLQuaternion operator-(const LLQuaternion &a, const LLQuaternion &b) fn result = quat1 - quat2; ensure( "5. LLQuaternion operator-(const LLQuaternion &a, const LLQuaternion &b) failed", (-3.0f == result.mQ[0]) && (-0.5f == result.mQ[1]) && (-1.5f == result.mQ[2]) && (4.5f == result.mQ[3])); result = quat3 - quat4; ensure( "6. LLQuaternion operator-(const LLQuaternion &a, const LLQuaternion &b) failed", is_approx_equal(1667.273071f, result.mQ[0]) && is_approx_equal(1459.255249f, result.mQ[1]) && (-344.75f == result.mQ[2]) && (7414.50f == result.mQ[3])); }
void v2math_object::test<4>() { F32 x =-2.0f, y = -3.0f ; LLVector2 vec2(x,y); ensure_equals("abs():Fail", vec2.abs(), TRUE); ensure("abs() x", is_approx_equal(vec2.mV[VX], 2.f)); ensure("abs() y", is_approx_equal(vec2.mV[VY], 3.f)); ensure("isNull():Fail ", FALSE == vec2.isNull()); //Returns TRUE if vector has a _very_small_ length x =.00000001f, y = .000001001f; vec2.setVec(x, y); ensure("isNull(): Fail ", TRUE == vec2.isNull()); }
void v4color_object::test<15>() { F32 r = 0x20, g = 0xFFFF, b = 0xFF,a = 0x30; F32 div = 12.345f; LLColor4 llcolor4a(r,g,b,a),llcolor4b; llcolor4b = llcolor4a % div;//chnage only alpha value nor r,g,b; ensure("1operator%:Fail ", (is_approx_equal(r,llcolor4b.mV[VX]) && is_approx_equal(g,llcolor4b.mV[VY]) && is_approx_equal(b,llcolor4b.mV[VZ])&& is_approx_equal(div*a,llcolor4b.mV[VW]))); llcolor4b = div % llcolor4a; ensure("2operator%:Fail ", (is_approx_equal(r,llcolor4b.mV[VX]) && is_approx_equal(g,llcolor4b.mV[VY]) && is_approx_equal(b,llcolor4b.mV[VZ])&& is_approx_equal(div*a,llcolor4b.mV[VW]))); llcolor4a %= div; ensure("operator%=:Fail ", (is_approx_equal(a*div,llcolor4a.mV[VW]))); }
void v3math_object::test<32>() { F32 x =12.3524f, y = -342.f,z = 4.126341f; LLVector3 vec3(x,y,z); F32 mag = vec3.normVec(); mag = 1.f/ mag; F32 val1 = x* mag, val2 = y* mag, val3 = z* mag; ensure("1:normVec: Fail ", is_approx_equal(val1, vec3.mV[VX]) && is_approx_equal(val2, vec3.mV[VY]) && is_approx_equal(val3, vec3.mV[VZ])); x = 0.000000001f, y = 0.f, z = 0.f; vec3.clearVec(); vec3.setVec(x,y,z); mag = vec3.normVec(); val1 = x* mag, val2 = y* mag, val3 = z* mag; ensure("2:normVec: Fail ", (mag == 0.) && (0. == vec3.mV[VX]) && (0. == vec3.mV[VY])&& (0. == vec3.mV[VZ])); }
void llquat_test_object_t::test<22>() { //test case for void LLQuaternion::getEulerAngles(F32 *roll, F32 *pitch, F32 *yaw) const fn F32 roll = -12.0f; F32 pitch = -22.43f; F32 yaw = 11.0f; LLQuaternion llquat; llquat.getEulerAngles(&roll, &pitch, &yaw); ensure( "LLQuaternion::getEulerAngles(F32 *roll, F32 *pitch, F32 *yaw) failed", is_approx_equal(0.000f, llquat.mQ[0]) && is_approx_equal(0.000f, llquat.mQ[1]) && is_approx_equal(0.000f, llquat.mQ[2]) && is_approx_equal(1.000f, llquat.mQ[3])); }
void m3math_test_object_t::test<9>() { LLMatrix3 llmat_obj1; LLQuaternion llmat_quat; LLVector3 llmat1(2.0f, 1.0f, 6.0f); LLVector3 llmat2(1.0f, 1.0f, 3.0f); LLVector3 llmat3(1.0f, 7.0f, 5.0f); llmat_obj1.setRows(llmat1, llmat2, llmat3); llmat_quat = llmat_obj1.quaternion(); ensure("LLMatrix3::quaternion failed ", is_approx_equal(-0.66666669f, llmat_quat.mQ[0]) && is_approx_equal(-0.83333337f, llmat_quat.mQ[1]) && is_approx_equal(0.0f, llmat_quat.mQ[2]) && is_approx_equal(1.5f, llmat_quat.mQ[3])); }
void v4math_object::test<11>() { F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f, w1 = .23f; F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f, w2 = 1.3f; LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2),vec4b; vec4b = vec4a - vec4; 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]))); x1 = -2.45f, y1 = 2.1f, z1 = 3.0f; vec4.clearVec(); vec4a.clearVec(); vec4.setVec(x1,y1,z1); vec4a -=vec4; ensure_equals("2:operator-=: Fail to initialize" , vec4a,-vec4); vec4a -=vec4; 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]))); }
void v3dmath_object::test<12>() { F64 x1 = 1., y1 = 2., z1 = -1.1; F64 x2 = 1.2, y2 = 2.5, z2 = 1.; F64 val1, val2, val3; LLVector3d vec3D(x1,y1,z1),vec3Da(x2,y2,z2), vec3Db; vec3Db = vec3D % vec3Da; val1 = y1*z2 - y2*z1; val2 = z1*x2 -z2*x1; val3 = x1*y2-x2*y1; ensure("1:operator% failed",(val1 == vec3Db.mdV[VX]) && (val2 == vec3Db.mdV[VY]) && (val3 == vec3Db.mdV[VZ])); vec3D %= vec3Da; ensure("2:operator%= failed", is_approx_equal(vec3D.mdV[VX],vec3Db.mdV[VX]) && is_approx_equal(vec3D.mdV[VY],vec3Db.mdV[VY]) && is_approx_equal(vec3D.mdV[VZ],vec3Db.mdV[VZ]) ); }
void v3color_object::test<5>() { F32 r = 2.3436212f, g = 1231.f, b = 4.7849321232f; F32 val1, val2,val3; LLColor3 llcolor3(r,g,b); F32 vecMag = llcolor3.normVec(); F32 mag = fsqrtf(r*r + g*g + b*b); F32 oomag = 1.f / mag; val1 = r * oomag; val2 = g * oomag; val3 = b * oomag; ensure("1:normVec failed ", (is_approx_equal(val1, llcolor3.mV[0]) && is_approx_equal(val2, llcolor3.mV[1]) && is_approx_equal(val3, llcolor3.mV[2]) && is_approx_equal(vecMag, mag))); r = .000000000f, g = 0.f, b = 0.0f; llcolor3.setVec(r,g,b); vecMag = llcolor3.normVec(); ensure("2:normVec failed should be 0. ", (0. == llcolor3.mV[0] && 0. == llcolor3.mV[1] && 0. == llcolor3.mV[2] && vecMag == 0.)); }
void v2math_object::test<14>() { F32 x1 =1.f, y1 = 2.f; F32 val1, val2, mulVal = 4.332f; LLVector2 vec2(x1, y1); vec2 /=mulVal; val1 = x1 / mulVal; val2 = y1 / mulVal; ensure("1:operator/= failed", is_approx_equal(val1, vec2.mV[VX]) && is_approx_equal(val2, vec2.mV[VY])); vec2.clearVec(); x1 = .213f, y1 = -2.34f, mulVal = -.23f; vec2.setVec(x1, y1); vec2 /=mulVal; val1 = x1 / mulVal; val2 = y1 / mulVal; ensure("2:operator/= failed", is_approx_equal(val1, vec2.mV[VX]) && is_approx_equal(val2, vec2.mV[VY])); }
void v4color_object::test<17>() { F32 r = 0x20, g = 0xFFFF, b = 0xFF; LLColor4 llcolor4a(r,g,b),llcolor4b; LLColor3 llcolor3 = vec4to3(llcolor4a); ensure("vec4to3:Fail to convert vec4 to vec3 ", (is_approx_equal(llcolor3.mV[VX],llcolor4a.mV[VX]) && is_approx_equal(llcolor3.mV[VY],llcolor4a.mV[VY]) && is_approx_equal(llcolor3.mV[VZ],llcolor4a.mV[VZ]))); llcolor4b = vec3to4(llcolor3); ensure_equals("vec3to4:Fail to convert vec3 to vec4 ", llcolor4b, llcolor4a); }