// "default" constructor
Camera::Camera(int WindowWidth, int WindowHeight)
{
m_windowWidth = WindowWidth;
m_windowHeight = WindowHeight;
m_pos = vec3D(0, 0, 0);
m_target = vec3D(0, 0, 1);
m_target.normalize();
m_up = vec3D(0, 1, 0);
init();
}
vec3D MathLib3D::createVector(point3D p1, point3D p2){
float x = p2.x-p1.x;
float y = p2.y-p1.y;
float z = p2.z-p1.z;
vec3D returnVec = vec3D(x,y,z);
return(returnVec);
};
void v3dmath_object::test<17>()
{
F64 x1 = 1., y1 = 2., z1 = -1.1;
LLVector3d vec3D(x1,y1,z1), vec3Da;
vec3Da = -vec3D;
ensure("1:operator- failed", (vec3D == - vec3Da));
}
vec3D MathLib3D::vectorMultiply(vec3D vector,float scalar){
float x = vector.x * scalar;
float y = vector.y * scalar;
float z = vector.z * scalar;
vec3D returnVec = vec3D(x,y,z);
return (returnVec);
};
vec3D MathLib3D::normalize(vec3D vector){
float x = vector.x/vector.getMagnitude();
float y = vector.y/vector.getMagnitude();
float z = vector.z/vector.getMagnitude();
vec3D returnVector = vec3D(x,y,z);
return(returnVector);
};
// returns cross product of a vector and an argument
vec3D vec3D::cross(const vec3D& v) const
{
float ax = y * v.z - z * v.y;
float ay = z * v.x - x * v.z;
float az = x * v.y - y * v.x;
return vec3D(ax, ay, az);
}
void v3dmath_object::test<13>()
{
F64 x1 = 1., y1 = 2., z1 = -1.1,div = 4.2;
F64 t = 1.f / div;
LLVector3d vec3D(x1,y1,z1), vec3Da;
vec3Da = vec3D/div;
ensure_approximately_equals(
"1a:operator/ failed",
vec3Da.mdV[VX],
x1*t,
8);
ensure_approximately_equals(
"1b:operator/ failed",
vec3Da.mdV[VY],
y1*t,
8);
ensure_approximately_equals(
"1c:operator/ failed",
vec3Da.mdV[VZ],
z1*t,
8);
x1 = 1.23, y1 = 4., z1 = -2.32;
vec3D.clearVec();
vec3Da.clearVec();
vec3D.setVec(x1,y1,z1);
vec3Da = vec3D/div;
ensure_approximately_equals(
"2a:operator/ failed",
vec3Da.mdV[VX],
x1*t,
8);
ensure_approximately_equals(
"2b:operator/ failed",
vec3Da.mdV[VY],
y1*t,
8);
ensure_approximately_equals(
"2c:operator/ failed",
vec3Da.mdV[VZ],
z1*t,
8);
vec3D /= div;
ensure_approximately_equals(
"3a:operator/= failed",
vec3D.mdV[VX],
x1*t,
8);
ensure_approximately_equals(
"3b:operator/= failed",
vec3D.mdV[VY],
y1*t,
8);
ensure_approximately_equals(
"3c:operator/= failed",
vec3D.mdV[VZ],
z1*t,
8);
}
void v3dmath_object::test<18>()
{
F64 x = 1., y = 2., z = -1.1;
LLVector3d vec3D(x,y,z);
F64 res = (x*x + y*y + z*z) - vec3D.magVecSquared();
ensure("1:magVecSquared:Fail ", ((-F_APPROXIMATELY_ZERO <= res)&& (res <=F_APPROXIMATELY_ZERO)));
res = fsqrtf(x*x + y*y + z*z) - vec3D.magVec();
ensure("2:magVec: Fail ", ((-F_APPROXIMATELY_ZERO <= res)&& (res <=F_APPROXIMATELY_ZERO)));
}
void v3dmath_object::test<15>()
{
F64 x1 = 1., y1 = 2., z1 = -1.1;
LLVector3d vec3D(x1,y1,z1), vec3Da;
std::ostringstream stream1, stream2;
stream1 << vec3D;
vec3Da.setVec(x1,y1,z1);
stream2 << vec3Da;
ensure("1:operator << failed",(stream1.str() == stream2.str()));
}
void v3dmath_object::test<14>()
{
F64 x1 = 1., y1 = 2., z1 = -1.1;
LLVector3d vec3D(x1,y1,z1), vec3Da;
ensure("1:operator!= failed",(TRUE == (vec3D !=vec3Da)));
vec3Da = vec3D;
ensure("2:operator== failed",(vec3D ==vec3Da));
vec3D.clearVec();
vec3Da.clearVec();
x1 = .211, y1 = 21.111, z1 = 23.22;
vec3D.setVec(x1,y1,z1);
vec3Da.setVec(x1,y1,z1);
ensure("3:operator== failed",(vec3D ==vec3Da));
ensure("4:operator!= failed",(FALSE == (vec3D !=vec3Da)));
}
void v3dmath_object::test<6>()
{
F64 x = -2.32, y = 1.212, z = -.12;
LLVector3d vec3D(x,y,z);
vec3D.abs();
ensure("1:abs:Fail ", ((-x == vec3D.mdV[VX]) && (y == vec3D.mdV[VY]) && (-z == vec3D.mdV[VZ])));
ensure("2:isNull():Fail ", (FALSE == vec3D.isNull()));
vec3D.clearVec();
x =.00000001, y = .000001001, z = .000001001;
vec3D.setVec(x,y,z);
ensure("3:isNull():Fail ", (TRUE == vec3D.isNull()));
ensure("4:isExactlyZero():Fail ", (FALSE == vec3D.isExactlyZero()));
x =.0000000, y = .00000000, z = .00000000;
vec3D.setVec(x,y,z);
ensure("5:isExactlyZero():Fail ", (TRUE == vec3D.isExactlyZero()));
}
void v3dmath_object::test<10>()
{
F64 x1 = 1., y1 = 2., z1 = -1.1;
F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
LLVector3d vec3D(x1,y1,z1),vec3Da(x2,y2,z2),vec3Db;
vec3Db = vec3Da - vec3D;
ensure("1:operator-:Fail to initialize ", ((x2-x1 == vec3Db.mdV[VX]) && (y2-y1 == vec3Db.mdV[VY]) && (z2-z1 == vec3Db.mdV[VZ])));
x1 = -2.45, y1 = 2.1, z1 = 3.0;
vec3D.clearVec();
vec3Da.clearVec();
vec3D.setVec(x1,y1,z1);
vec3Da -=vec3D;
ensure("2:operator-=:Fail to initialize ", ((2.45 == vec3Da.mdV[VX]) && (-2.1 == vec3Da.mdV[VY]) && (-3.0 == vec3Da.mdV[VZ])));
vec3Da -= vec3D;
ensure("3:operator-=:Fail to initialize ", ((-2*x1 == vec3Da.mdV[VX]) && (-2*y1 == vec3Da.mdV[VY]) && (-2*z1 == vec3Da.mdV[VZ])));
}
void v3dmath_object::test<9>()
{
F64 x1 = 1.78787878, y1 = 232322.2121, z1 = -12121.121212;
F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
LLVector3d vec3D(x1,y1,z1),vec3Da(x2,y2,z2),vec3Db;
vec3Db = vec3Da+ vec3D;
ensure("1:operator+:Fail to initialize ", ((x1+x2 == vec3Db.mdV[VX]) && (y1+y2 == vec3Db.mdV[VY]) && (z1+z2 == vec3Db.mdV[VZ])));
x1 = -2.45, y1 = 2.1, z1 = 3.0;
vec3D.clearVec();
vec3Da.clearVec();
vec3D.setVec(x1,y1,z1);
vec3Da += vec3D;
ensure_equals("2:operator+=: Fail to initialize", vec3Da,vec3D);
vec3Da += vec3D;
ensure("3:operator+=:Fail to initialize ", ((2*x1 == vec3Da.mdV[VX]) && (2*y1 == vec3Da.mdV[VY]) && (2*z1 == vec3Da.mdV[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 v3dmath_object::test<7>()
{
F64 x = -2.32, y = 1.212, z = -.12;
LLVector3d vec3D(x,y,z);
ensure("1:operator [] failed",( x == vec3D[0]));
ensure("2:operator [] failed",( y == vec3D[1]));
ensure("3:operator [] failed",( z == vec3D[2]));
vec3D.clearVec();
x = 23.23, y = -.2361, z = 3.25;
vec3D.setVec(x,y,z);
F64 &ref1 = vec3D[0];
ensure("4:operator [] failed",( ref1 == vec3D[0]));
F64 &ref2 = vec3D[1];
ensure("5:operator [] failed",( ref2 == vec3D[1]));
F64 &ref3 = vec3D[2];
ensure("6:operator [] failed",( ref3 == vec3D[2]));
}
void v3dmath_object::test<19>()
{
F64 x = 1., y = 2., z = -1.1;
LLVector3d vec3D(x,y,z);
F64 mag = vec3D.normVec();
mag = 1.f/ mag;
ensure_approximately_equals(
"1a:normVec: Fail ",
vec3D.mdV[VX],
x * mag,
8);
ensure_approximately_equals(
"1b:normVec: Fail ",
vec3D.mdV[VY],
y * mag,
8);
ensure_approximately_equals(
"1c:normVec: Fail ",
vec3D.mdV[VZ],
z * mag,
8);
x = 0.000000001, y = 0.000000001, z = 0.000000001;
vec3D.clearVec();
vec3D.setVec(x,y,z);
mag = vec3D.normVec();
ensure_approximately_equals(
"2a:normVec: Fail ",
vec3D.mdV[VX],
x * mag,
8);
ensure_approximately_equals(
"2b:normVec: Fail ",
vec3D.mdV[VY],
y * mag,
8);
ensure_approximately_equals(
"2c:normVec: Fail ",
vec3D.mdV[VZ],
z * mag,
8);
}
void v3dmath_object::test<5>()
{
F64 x = 2.32f, y = 1.212f, z = -.12f;
LLVector3d vec3D(x,y,z);
vec3D.clearVec();
ensure("1:clearVec:Fail to initialize ", ((0 == vec3D.mdV[VX]) && (0 == vec3D.mdV[VY]) && (0 == vec3D.mdV[VZ])));
vec3D.setVec(x,y,z);
ensure("2:setVec:Fail to initialize ", ((x == vec3D.mdV[VX]) && (y == vec3D.mdV[VY]) && (z == vec3D.mdV[VZ])));
vec3D.zeroVec();
ensure("3:zeroVec:Fail to initialize ", ((0 == vec3D.mdV[VX]) && (0 == vec3D.mdV[VY]) && (0 == vec3D.mdV[VZ])));
vec3D.clearVec();
LLVector3 vec3((F32)x,(F32)y,(F32)z);
vec3D.setVec(vec3);
ensure("4:setVec:Fail to initialize ", ((x == vec3D.mdV[VX]) && (y == vec3D.mdV[VY]) && (z == vec3D.mdV[VZ])));
vec3D.clearVec();
const F64 vec[3] = {x,y,z};
vec3D.setVec(vec);
ensure("5:setVec:Fail to initialize ", ((x == vec3D.mdV[VX]) && (y == vec3D.mdV[VY]) && (z == vec3D.mdV[VZ])));
LLVector3d vec3Da;
vec3Da.setVec(vec3D);
ensure_equals("6:setVec: Fail to initialize", vec3D, vec3Da);
}
//cross product
const vec3D vec3D::cross( const vec3D& v ) const
{
//Davis, Snider, "Introduction to vec3D Analysis", p. 44
return vec3D( y*v.z - z*v.y, z*v.x - x*v.z, x*v.y - y*v.x );
}
//subtract
const vec3D vec3D::operator - ( const vec3D& v ) const
{
return vec3D(x - v.x, y - v.y, z - v.z);
}
//add
const vec3D vec3D::operator + ( const vec3D& v ) const
{
return vec3D(x + v.x, y + v.y, z + v.z);
}
//negate
const vec3D vec3D::operator - () const
{
return vec3D( -x, -y, -z );
}
//post-multiply by a float
const vec3D vec3D::operator * ( const float& s ) const
{
return vec3D( x*s, y*s, z*s );
}
//divide
const vec3D vec3D::operator / (float s) const
{
s = 1/s;
return vec3D( s*x, s*y, s*z );
}
void v3dmath_object::test<11>()
{
F64 x1 = 1., y1 = 2., z1 = -1.1;
F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
LLVector3d vec3D(x1,y1,z1),vec3Da(x2,y2,z2);
F64 res = vec3D * vec3Da;
ensure_approximately_equals(
"1:operator* failed",
res,
(x1*x2 + y1*y2 + z1*z2),
8);
vec3Da.clearVec();
F64 mulVal = 4.2;
vec3Da = vec3D * mulVal;
ensure_approximately_equals(
"2a:operator* failed",
vec3Da.mdV[VX],
x1*mulVal,
8);
ensure_approximately_equals(
"2b:operator* failed",
vec3Da.mdV[VY],
y1*mulVal,
8);
ensure_approximately_equals(
"2c:operator* failed",
vec3Da.mdV[VZ],
z1*mulVal,
8);
vec3Da.clearVec();
vec3Da = mulVal * vec3D;
ensure_approximately_equals(
"3a:operator* failed",
vec3Da.mdV[VX],
x1*mulVal,
8);
ensure_approximately_equals(
"3b:operator* failed",
vec3Da.mdV[VY],
y1*mulVal,
8);
ensure_approximately_equals(
"3c:operator* failed",
vec3Da.mdV[VZ],
z1*mulVal,
8);
vec3D *= mulVal;
ensure_approximately_equals(
"4a:operator*= failed",
vec3D.mdV[VX],
x1*mulVal,
8);
ensure_approximately_equals(
"4b:operator*= failed",
vec3D.mdV[VY],
y1*mulVal,
8);
ensure_approximately_equals(
"4c:operator*= failed",
vec3D.mdV[VZ],
z1*mulVal,
8);
}
vec3D _3DMath::crossProduct(vec3D v1, vec3D v2){
return vec3D(v1.y*v2.z-v1.z*v2.y, v1.z*v2.x-v1.x*v2.z, v1.x*v2.y-v1.y*v2.x);
}
