test.cpp

一个纹理地形渲染器

// mathematics regression test

#pragma warning( disable : 4127 )  // conditional expression is constant
#pragma warning( disable : 4100 )  // unreferenced formal parameter
#pragma warning( disable : 4702 )  // unreachable code

#ifndef _DEBUG
#pragma warning( disable : 4189 )  // local variable is initialized but not referenced (because of asserts)
#endif

#include "Matrix.h"
#include "Vector.h"
#include "Complex.h"
#include "Quaternion.h"
#include "Plane.h"
#include "Box.h"
#include "Sphere.h"
#include "Ellipsoid.h"
#include "Intersection.h"

#include <assert.h>

using namespace Mathematics;


void main()
{
	// test vector class

	Vector a(1,2,3);
	Vector b(4,5,6);
	Vector c(7,8,9);

	printf("testing vector negate\n");

	c = a;
	c.negate();
	c.multiply(-1);
	assert(c==a);

	printf("testing vector add\n");

	c = a;
	c.add(b);
	
	printf("testing vector subtract\n");

	c.subtract(b);
	assert(c==a);

	printf("testing vector scalar multiply\n");

	c = a;
	c.multiply(10.0f);
	assert(c.x==10*a.x);
	assert(c.y==10*a.y);
	assert(c.z==10*a.z);
	
	printf("testing vector scalar divide\n");

	c = a;
	c.divide(10.0f);
	assert(Float::equal(c.x,a.x/10));
	assert(Float::equal(c.y,a.y/10));
	assert(Float::equal(c.z,a.z/10));

	printf("testing vector dot product\n");

	Vector i(1,0,0);
	Vector j(0,1,0);
	Vector k(0,0,1);
	assert(i.dot(j)==0);
	assert(j.dot(k)==0);
	assert(k.dot(i)==0);

	i = a;
	i.normalize();
	j = i;
	j.multiply(-1);
	assert(Float::equal(i.dot(j), -1.0f));

	printf("testing vector cross product\n");

	i = Vector(1,0,0);
	j = Vector(0,1,0);
	k = Vector(0,0,1);

	Vector result;
	i.cross(j, result);
	assert(result==k);

	j.cross(k, result);
	assert(result==i);

	k.cross(i, result);
	assert(result==j);

	printf("testing vector length squared\n");

	assert(Float::equal(i.length_squared(), 1));
	assert(Float::equal(j.length_squared(), 1));
	assert(Float::equal(k.length_squared(), 1));

	printf("testing vector length\n");

	c = a;
	c.multiply(10);
	assert(Float::equal(a.length() * 10, c.length()));

	printf("testing vector normalize\n");

	c.normalize();
	assert(Float::equal(c.length(), 1));

	printf("testing vector operators\n");
	{
		Vector u = Vector(1,2,3);
		Vector v = Vector(2,3,4);
		Vector w = Vector(3,4,5);
		Vector zero = Vector(0,0,0);

		const float a = 5;
		const float b = 3;
		const float c = 2;

		assert(u+u==2*u);
		assert(v+v==2*v);
		assert(w+w==2*w);

		assert(a*u + b*v + c*w == u*a + v*b + w*c);
		assert(a*u - b*v - c*w == u*a - v*b - w*c);
		assert(a*(u + v + w) == a*u + a*v + a*w);
		assert(a*(u + v + w) == u*a + v*a + w*a);
		assert(u+(v+w) == (u+v)+w);
		assert(u-(v-w) == (u-v)+w);
		assert(zero - v == -v);

		Vector i(1,0,0);
		Vector j(0,1,0);
		Vector k(0,0,1);
		assert(i*j==k);
		assert(j*k==i);
		assert(k*i==j);
		assert(j*i==-k);
		assert(k*j==-i);
		assert(i*k==-j);

		Vector x = u;
		x += v;
		assert(x==u+v);

		x = u;
		x -= v;
		assert(x==u-v);

		x = i;
		x *= j;
		assert(x==i*j);

		x = u;
		x *= a;
		assert(x==u*a);

		x = u;
		x /= a;
		assert(x==u/a);
	}

	printf("testing vector orthonormal basis");
	{
		Vector u(1,2,3);
		u.normalize();

		Vector v,w;

		Vector::orthonormal_basis(u,v,w);
	}

	// test matrix class

	printf("testing matrix zero\n");

	a = Vector(1,1,1);
	Matrix matrix;
	matrix.zero();
	matrix.transform(a);
	assert(a==Vector(0,0,0));

	printf("testing matrix identity\n");

	a = Vector(8,6,5);
	matrix.zero();
	matrix.transform(a);
	assert(a==Vector(0,0,0));

	printf("testing matrix translate\n");

	a = Vector(1,2,3);
	b = Vector(1,1,1);
	c = a;
	c.add(b);
	matrix.identity();
	matrix.translate(b.x, b.y, b.z);
	matrix.transform(a);
	assert(a==c);

	printf("testing matrix scale\n");

	a = Vector(1,2,3);
	b = a;
	b.multiply(3);
	matrix.scale(3);
	matrix.transform(a);
	assert(a==b);

	a = Vector(1,2,3);
	b = a;
	b.x *= 3;
	b.y *= 4;
	b.z *= 5;
	matrix.diagonal(3,4,5);
	matrix.transform(a);
	assert(a==b);

	printf("testing matrix determinant\n");

	a = Vector(1,2,3);
	matrix = Matrix(a, a, a);
	assert(Float::equal(matrix.determinant(),0));

	b = Vector(3,2,1);
	matrix = Matrix(a, a, b);
	assert(Float::equal(matrix.determinant(),0));

	c = Vector(5,5,6);
	matrix = Matrix(a, b, c);
	assert(!Float::equal(matrix.determinant(),0));

	printf("testing matrix inverse\n");
	
	Matrix product;
	Matrix inverse;
	matrix.inverse(inverse);
	matrix.multiply(inverse, product);
	Matrix identity;
	identity.identity();
	assert(product==identity);
	Matrix output;
	inverse.inverse(output);
	assert(output==matrix);

	printf("testing matrix transpose\n");

	Matrix transpose;
	matrix.transpose(transpose);
	transpose.transpose(output);
	assert(output==matrix);

	printf("testing matrix transform\n");

	Matrix A(matrix);		// Ax = b <-> x = Ainv b
	Vector x(1,2,3);
	A.transform(x, b);
	result = x;
	A.transform(result);
	assert(b==result);
	Matrix Ainv;
	A.inverse(Ainv);
	Vector y;
	Ainv.transform(b, y);
	assert(x==y);

	printf("testing matrix multiply and add\n");

	Matrix B(Vector(1,5,3), Vector(0,1,2), Vector(5,6,10));
	x = Vector(1,2,3);
	Vector AplusB_x, Ax_plus_Bx;
	Matrix AplusB;
	AplusB = A;
	AplusB.add(B);
	AplusB.transform(x,AplusB_x);
	Vector Ax, Bx;
	A.transform(x,Ax);
	B.transform(x,Bx);
	Ax_plus_Bx = Ax;
	Ax_plus_Bx.add(Bx);
	assert(AplusB_x==Ax_plus_Bx);

	printf("testing matrix multiply and subtract\n");

	B = Matrix(Vector(1,5,3), Vector(0,1,2), Vector(5,6,10));
	x = Vector(1,2,3);
	Vector AminusB_x, Ax_minus_Bx;
	Matrix AminusB;
	AminusB = Matrix(A);
	AminusB.subtract(B);
	AminusB.transform(x,AminusB_x);
	A.transform(x,Ax);
	B.transform(x,Bx);
	Ax_minus_Bx = Ax;
	Ax_minus_Bx.subtract(Bx);
	assert(AminusB_x==Ax_minus_Bx);

	printf("testing matrix multiply and scalar multiply\n");

	const float s = 10;
	Vector s_Ax, sA_x;
	Matrix sA = A;
	sA.multiply(s);
	sA.transform(x,sA_x);
	A.transform(x,s_Ax);
	s_Ax.multiply(s);
	assert(s_Ax==sA_x);

	{
		printf("testing matrix rotate\n");

		Vector x(1,2,3);

		Vector axis(2,3,4);
		axis.normalize();

		Matrix R;
		R.rotate(2*Float::pi, axis);
		assert(R*x==x);
		assert(x*R==x);

		const float angle = 0.1f;

		R.rotate(angle, axis);
		Vector _x = R*x;
		R.rotate(angle, -axis);
		_x = R*_x;
		assert(_x==x);

		R.rotate(angle, Vector(1,0,0));
		_x = R*x;
		assert(Float::equal(_x.x,x.x));
		assert(Float::equal(_x.length(), x.length()));

		R.rotate(angle, Vector(0,1,0));
		_x = R*x;
		assert(Float::equal(_x.y,x.y));
		assert(Float::equal(_x.length(), x.length()));

		R.rotate(angle, Vector(0,0,1));
		_x = R*x;
		assert(Float::equal(_x.z,x.z));
		assert(Float::equal(_x.length(), x.length()));
	}

	// test projection matrix

	// test orthogonal matrix

	// test lookat matrix

	printf("testing matrix operators\n");
	{
		Matrix A( 1,0,0,
			      2,1,2,
				  3,2,1 );

		Matrix B( 4,0,0,
			      0,2,0,
				  0,0,3 );

		Matrix C( 5,6,2,
			      2,5,2,
				  1,2,3 );

		const float a = 2;
		const float b = 3;
		const float c = 4;

		Matrix zero;
		zero.zero();

		Matrix identity;
		identity.identity();

		Vector x(1,2,3);
		Vector y(2,3,4);
		Vector z(3,4,5);

		Vector result;
		A.transform(x, result);
		assert(result==A*x);

		assert(B.transpose()*A.transpose()==(A*B).transpose());
		assert(A.transpose()*B.transpose()==(B*A).transpose());

		assert(B.inverse()*A.inverse()==(A*B).inverse());
		assert(A.inverse()*B.inverse()==(B*A).inverse());

		assert(A.inverse()*A==identity);
		assert(A*A.inverse()==identity);
		
		assert(identity.inverse()==identity);

		result = x;
		result *= A;
		assert(result==A*x);

		assert(A*zero==zero);
		assert(zero*A==zero);

		assert(a*A+a*B==a*(A+B));
		assert(a*A-a*B==a*(A-B));

		assert(A*a+B*a==(A+B)*a);
		assert(A*a-B*a==(A-B)*a);
		assert(A/a+B/a==(A+B)/a);
		assert(A/a-B/a==(A-B)/a);

		assert((-A)==-1*A);
		assert(A+(-A)==zero);
		assert(A-(-A)==2*A);