VA_X.dll file version 10.4.1624.0  built 2007.12.07
DevEnv.exe version 8.0.50727.762
msenv.dll version 8.0.50727.762
Font: Courier New 13(Pixels)
Comctl32.dll version 6.0.2900.2982
Windows XP 5.1 Build 2600 Service Pack 2
2 processors

Platform: Win32
Stable Includes:
C:\\Code\\MSVS8\\VC\\include;
C:\\Code\\MSVS8\\VC\\atlmfc\\include;
C:\\Code\\PSDK8\\Include;
C:\\Code\\DXSDK\\Include;
C:\\Code\\MSVS8\\SDK\\v2.0\\include;

Other Includes:

Stable Source Directories:
C:\\Code\\MSVS8\\VC\\atlmfc\\src\\mfc;
C:\\Code\\MSVS8\\VC\\atlmfc\\src\\mfcm;
C:\\Code\\MSVS8\\VC\\atlmfc\\src\\atl;
C:\\Code\\MSVS8\\VC\\crt\\src;

class CMatrix  
{
public:
	bool Equals(const CMatrix& m1);
	CMatrix& Transpose();
	CMatrix& Invert() { Invert(4); return *this; }
	CMatrix& Invert3() { Invert(3); return *this; }
	CMatrix& LookAt(const CVector& vEye, const CVector& vAt, const CVector& vUp);
	CMatrix& Multiply(const CMatrix& m1, const CMatrix& m2);
	CMatrix& MultiplyRev(const CMatrix& m1, const CMatrix& m2) { return Multiply(m2, m1); }
	CMatrix& Identity();
	CMatrix& RotationZ(float a);
	CMatrix& RotationY(float a);
	CMatrix& RotationX(float a);
	CMatrix& Rotation(const CVector& v, float phi);
	CMatrix& Translation(float x, float y, float z);
	CMatrix& Translation(const CVector& v) { return Translation(v.x, v.y, v.z); }
	CMatrix& Scaling(float sx, float sy, float sz);
//	CMatrix();
	CMatrix& FromGL(GLenum mode);
	CMatrix& Ortho3();
	CMatrix& FromQuaternion(const CQuaternion& quat);
	void ToGL();
	void MultGL();

	void Dump();

	bool operator== (const CMatrix& m2) const;
	bool operator!= (const CMatrix& m2) const;


	union {
		struct {
			float _11, _12, _13, _14;
			float _21, _22, _23, _24;
			float _31, _32, _33, _34;
			float _41, _42, _43, _44;

		};
		float data[16];
		float m[4][4];
	};

protected:
	void Invert(int size);
};

class CVector  
{
public:
	// Constructors
	CVector() {}
	CVector(float ax, float ay, float az) { x = ax; y = ay; z = az; }
	CVector(const CVector& v) { x = v.x; y = v.y; z = v.z; }
	CVector(float* v) { x = v[0]; y = v[1]; z = v[2]; }

	// Operators
	CVector& operator=  (const CVector& v);
	CVector& operator+= (const CVector& v);
	CVector& operator-= (const CVector& v);
	CVector& operator*= (const CVector& v);
	CVector& operator*= (float f);
	CVector& operator/= (float f);
	CVector& operator*= (const CMatrix& m);

	bool operator== (const CVector& v2) const;
	bool operator!= (const CVector& v2) const;
	bool operator<= (const CVector& v2) const;
	bool operator>= (const CVector& v2) const;

	bool Normalize();
	float MagnitudeSquared();
	float Magnitude();

	static float Dot(const CVector& v1, const CVector& v2);
	void Cross(const CVector& v1, const CVector& v2);
	float Transform(const CVector& v, const CMatrix& m);
	float Transform3(const CVector& v, const CMatrix& m);

	CVector& EulerFromMatrix(const CMatrix& m);

	void Dump() const;

	CString FormatNitro() const;

	union {
		struct {
			float x, y, z;
		};
		float c[3];
	};
};

#ifdef CHEAT_TO_HELP_VA
#define ANONYMOUS_STRUCT ANONYMOUS_STRUCT
#else
#define ANONYMOUS_STRUCT
#endif

class CVector  
{
public:
	CVector() {}
	static float Dot(const CVector& v1, const CVector& v2);

	union {
		struct ANONYMOUS_STRUCT {
			float x, y, z;
		};
		float c[3];
	};
};

static void testVectorMembers()
{
	CVector foo;
	foo.x = 1.1;
	foo.z = 2.2;
}

class CMatrix  
{
public:
	union {
		struct ANONYMOUS_STRUCT {
			float _11, _12, _13, _14;
			float _21, _22, _23, _24;
			float _31, _32, _33, _34;
			float _41, _42, _43, _44;
		};
		float data[16];
		float m[4][4];
	};

protected:
	void Invert(int size);
};

static void testClassHere()
{
	CMatrix foo;
	foo;
}