//===========================================================================//
// File:	vector.tst                                                          //
// Project: MUNGA           Brick: Math Library                              //
// Contents: Verify code for vector classes                                    //
//---------------------------------------------------------------------------//
//   Date    Who  Modification                                               //
// --------  ---  ---------------------------------------------------------- //
// 11/19/94  JMA  Initial coding.                                            //
//---------------------------------------------------------------------------//
// Copyright (C) 1994-1995, Virtual World Entertainment, Inc.                //
// All Rights reserved worldwide                                             //
// This unpublished sourcecode is PROPRIETARY and CONFIDENTIAL               //
//===========================================================================//

#include "StuffHeaders.hpp"

//
//###########################################################################
//###########################################################################
//
bool
	Vector3D::TestClass()
{
	SPEW((GROUP_STUFF_TEST, "Starting Vector3D test..."));

	const Vector3D
		a(Identity);
	Vector3D
		b;
	const Vector3D
		c(1.0f,2.0f,3.0f);
	Vector3D
		d(2.0f,3.0f,1.0f);

	Verify(!a.x && !a.y && !a.z);
#if 0
	Verify(c.x == 1.0f && c.y == 2.0f && c.z == 3.0f);

	Verify(c[2] == c.z);
	Verify(a[1] == a.y);
#endif

	Verify(Small_Enough(a));
//	Verify(!a);

	b = c;
#if 0
	Verify(b.x == c.x && b.y == c.y && b.z == c.z);
#endif
	Verify(Close_Enough(b,c));
	Verify(b == c);
	Verify(a != b);

	b.Negate(c);
	Verify(b == Vector3D(-c.x,-c.y,-c.z));

	b.Add(c,d);
	Verify(b == Vector3D(c.x+d.x,c.y+d.y,c.z+d.z));
	b = c;
	b += d;
	Verify(b == Vector3D(c.x+d.x,c.y+d.y,c.z+d.z));

	b.Subtract(d,c);
	Verify(b == Vector3D(d.x-c.x,d.y-c.y,d.z-c.z));
	b = d;
	b -= c;
	Verify(b == Vector3D(d.x-c.x,d.y-c.y,d.z-c.z));

	Scalar f = c*d;
#if 0
	Verify(f == c.x*d.x + c.y*d.y + c.z*d.z);
#endif

	Vector3D x;
	x.Cross(Right, Up);
	#if defined(LEFT_HANDED_COORDINATES)
		#error Right handed coordinate dependancy!
	#endif
	Verify(x == Backward);

{ // jcem
    Vector3D a, b, c;

    a.Cross(Forward, Up);
    Verify(a == Right);
    b.Cross(Up, Right);
    Verify(b == Forward);
    c.Cross(Right, Forward);
    Verify(c == Up);

    // conclusion
    // for Right Handed Coord
    // F :  0, 0, 1
    // U :  0, 1, 0
    // R : -1, 0, 0
    // F * U -> R
    // U * R -> F
    // R * F -> U
}
	b.Cross(c,d);
	Verify(b == Vector3D(c.y*d.z-c.z*d.y,c.z*d.x-c.x*d.z,c.x*d.y-c.y*d.x));

	f = 2.0f;
	b.Multiply(c,f);
	Verify(b == Vector3D(f*c.x,f*c.y,f*c.z));
	b = c;
	b *= f;
	Verify(b == Vector3D(f*c.x,f*c.y,f*c.z));

	b.Multiply(c,d);
	Verify(b == Vector3D(c.x*d.x,c.y*d.y,c.z*d.z));
	b = c;
	b *= d;
	Verify(b == Vector3D(c.x*d.x,c.y*d.y,c.z*d.z));

	b.Divide(c,f);
	Verify(b == Vector3D(c.x/f,c.y/f,c.z/f));
	b = c;
	b /= f;
	Verify(b == Vector3D(c.x/f,c.y/f,c.z/f));

	b.Divide(c,d);
	Verify(b == Vector3D(c.x/d.x,c.y/d.y,c.z/d.z));
	b = c;
	b /= d;
	Verify(b == Vector3D(c.x/d.x,c.y/d.y,c.z/d.z));

	AffineMatrix4D
		m(true);
	EulerAngles
		r(Pi_Over_4,0.0f,0.0f);
	m.BuildRotation(r);
	b.Multiply(c,m);
	Verify(b == Vector3D(c.x,c.y*m(1,1)+c.z*m(2,1),c.y*m(1,2)+c.z*m(2,2)));
	b = c;
	b *= m;
	Verify(b == Vector3D(c.x,c.y*m(1,1)+c.z*m(2,1),c.y*m(1,2)+c.z*m(2,2)));

	Verify(!a.GetLengthSquared());
	f = c.GetLengthSquared();
	Verify(f == c.x*c.x + c.y*c.y + c.z*c.z);
	f = c.GetLength();
	Verify(Close_Enough(f,Sqrt(c.x*c.x + c.y*c.y + c.z*c.z)));
	b.Normalize(c);
	Verify(b == Vector3D(c.x/f, c.y/f, c.z/f));

	b.Combine(c,2.0f,d,2.0f);
	Verify(b == Vector3D(2.0f*(c.x+d.x),2.0f*(c.y+d.y),2.0f*(c.z+d.z)));

	b.Lerp(c,d,0.5f);
	Verify(b == Vector3D(0.5f*(c.x+d.x),0.5f*(c.y+d.y),0.5f*(c.z+d.z)));

	return true;
}
