test.cpp

一个纹理地形渲染器

		Matrix matrix = A;
		matrix += B;
		assert(matrix==A+B);

		matrix = A;
		matrix -= B;
		assert(matrix==A-B);

		matrix = A;
		matrix *= B;
		assert(matrix==A*B);

		matrix = A;
		matrix *= a;
		assert(matrix==A*a);

		matrix = A;
		matrix /= a;
		assert(matrix==A/a);

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

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

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

		assert(a*(A*x) + b*(B*y) + c*(C*z) == (a*A)*x + (b*B)*y + (c*C)*z);
		assert(a*(A*x) - b*(B*y) - c*(C*z) == (a*A)*x - (b*B)*y - (c*C)*z);

		assert(a*(A*x) + b*(B*y) + c*(C*z) == A*(a*x) + B*(b*y) + C*(c*z));
		assert(a*(x*A) - b*(y*B) - c*(z*C) == (a*x)*A - (b*y)*B - (c*z)*C);

		assert(x*A==A.transpose()*x);
		assert(y*B==B.transpose()*y);
		assert(z*C==C.transpose()*z);
	}

	// test quaternion class
	{
		{
			printf("testing quaternion identity\n");

			Vector a(8,6,5);
			Vector b;
			Quaternion quaternion;
			quaternion.identity();
			matrix = quaternion.matrix();
			matrix.transform(a,b);
			assert(b==a);

			Quaternion p(1,2,3,4);
			assert(p*identity==p);
			assert(identity*p==p);

			// todo: test quaternion zero, what properties does it have ?
		}

		printf("testing quaternion add\n");

		Quaternion a(1,2,3,4);
		Quaternion b(2,3,4,5);
		Quaternion c(3,4,5,6);

		const float s = 5;

		Quaternion q;
		q = a;
		q.add(b);
		assert(q.w==a.w+b.w);
		assert(q.x==a.x+b.x);
		assert(q.y==a.y+b.y);
		assert(q.z==a.z+b.z);

		printf("testing quaternion subtract\n");

		q = a;
		q.subtract(b);
		assert(q.w==a.w-b.w);
		assert(q.x==a.x-b.x);
		assert(q.y==a.y-b.y);
		assert(q.z==a.z-b.z);

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

		q = a;
		q.multiply(s);
		assert(q.w==a.w*s);
		assert(q.x==a.x*s);
		assert(q.y==a.y*s);
		assert(q.z==a.z*s);

		printf("testing quaternion scalar divide\n");

		q = a;
		q.divide(s);
		assert(Float::equal(q.w,a.w/s));
		assert(Float::equal(q.x,a.x/s));
		assert(Float::equal(q.y,a.y/s));
		assert(Float::equal(q.z,a.z/s));

		printf("testing quaternion multiply\n");

		q = Quaternion(0,1,0,0);
		q.multiply(q);
		assert(q==Quaternion(-1,0,0,0));

		q = Quaternion(0,0,1,0);
		q.multiply(q);
		assert(q==Quaternion(-1,0,0,0));

		q = Quaternion(0,0,0,1);
		q.multiply(q);
		assert(q==Quaternion(-1,0,0,0));

		q = Quaternion(1,0,0,0);
		q.multiply(q);
		assert(q==Quaternion(1,0,0,0));

		q = Quaternion(0,1,0,0);
		q.multiply(Quaternion(0,0,1,0));
		assert(q==Quaternion(0,0,0,1));

		q = Quaternion(0,0,1,0);
		q.multiply(Quaternion(0,1,0,0));
		assert(q==Quaternion(0,0,0,-1));

		q = Quaternion(0,0,0,1);
		q.multiply(Quaternion(0,1,0,0));
		assert(q==Quaternion(0,0,1,0));

		q = Quaternion(0,1,0,0);
		q.multiply(Quaternion(0,0,0,1));
		assert(q==Quaternion(0,0,-1,0));

		Quaternion result;
		q = Quaternion(0,1,0,0);
		q.multiply(q,result);
		assert(result==Quaternion(-1,0,0,0));

		q = Quaternion(0,0,1,0);
		q.multiply(q,result);
		assert(result==Quaternion(-1,0,0,0));

		q = Quaternion(0,0,0,1);
		q.multiply(q,result);
		assert(result==Quaternion(-1,0,0,0));

		q = Quaternion(1,0,0,0);
		q.multiply(q,result);
		assert(result==Quaternion(1,0,0,0));

		q = Quaternion(0,1,0,0);
		q.multiply(Quaternion(0,0,1,0),result);
		assert(result==Quaternion(0,0,0,1));

		q = Quaternion(0,0,1,0);
		q.multiply(Quaternion(0,1,0,0),result);
		assert(result==Quaternion(0,0,0,-1));

		q = Quaternion(0,0,0,1);
		q.multiply(Quaternion(0,1,0,0),result);
		assert(result==Quaternion(0,0,1,0));

		q = Quaternion(0,1,0,0);
		q.multiply(Quaternion(0,0,0,1),result);
		assert(result==Quaternion(0,0,-1,0));

		printf("testing quaternion conjugate\n");

		assert(a.conjugate().conjugate()==a);

		assert(Float::equal(a.conjugate().w,a.w));
		assert(Float::equal(a.conjugate().x,-a.x));
		assert(Float::equal(a.conjugate().y,-a.y));
		assert(Float::equal(a.conjugate().z,-a.z));

		printf("testing quaternion norm\n");

		Quaternion p, pq;
		p = a;
		q = b;
		p.multiply(q,pq);
		assert(Float::equal(p.norm()*q.norm(),pq.norm()));

		a.conjugate(result);
		assert(result.norm()==a.norm());

		printf("testing quaternion length\n");

		assert(Float::equal(p.length(),Float::sqrt(p.norm())));

		printf("testing quaternion normalize\n");
		{
			Quaternion n = p;
			n.normalize();
			assert(n.normalized());
			assert(n.conjugate()==n.inverse());

			n = q;
			n.normalize();
			assert(n.normalized());
			assert(n.conjugate()==n.inverse());
		}

		printf("testing quaternion inverse\n");

		assert(a.inverse().inverse()==a);

		q.multiply(q.inverse());
		assert(q==1);

		Quaternion q_inv = q.inverse();
		q_inv.multiply(q);
		assert(q_inv==1);

		printf("testing quaternion operators\n");
		{
			Quaternion p(1,2,3,4);
			Quaternion q(2,3,4,5);
			Quaternion r(3,4,5,6);

			const float a = 5;

			assert(p-p==0);
			assert(q-q==0);
			assert(r-r==0);

			assert(p+p==2*p);
			assert(q+q==2*q);
			assert(r+r==2*r);

			assert(p+q==q+p);
			assert(p-q==-(q-p));

			assert(a*p==p*a);
			assert(a*p+a*q+a*r==a*(p+q+r));
			assert(p*a+q*a+r*a==(p+q+r)*a);

			assert(p/a==p*1.0f/a);
			assert(p/a+q/a+r/a==(p+q+r)/a);

			assert(Quaternion(0,1,0,0)*Quaternion(0,1,0,0)==-1);
			assert(Quaternion(0,0,1,0)*Quaternion(0,0,1,0)==-1);
			assert(Quaternion(0,0,0,1)*Quaternion(0,0,0,1)==-1);
			
			assert(Quaternion(0,1,0,0)*Quaternion(0,0,1,0)==Quaternion(0,0,0,1));
			assert(Quaternion(0,0,1,0)*Quaternion(0,1,0,0)==Quaternion(0,0,0,-1));

			assert(Quaternion(0,0,1,0)*Quaternion(0,0,0,1)==Quaternion(0,1,0,0));
			assert(Quaternion(0,0,0,1)*Quaternion(0,0,1,0)==Quaternion(0,-1,0,0));

			assert(Quaternion(0,0,0,1)*Quaternion(0,1,0,0)==Quaternion(0,0,1,0));
			assert(Quaternion(0,1,0,0)*Quaternion(0,0,0,1)==Quaternion(0,0,-1,0));

			assert((p*q).conjugate()==q.conjugate()*p.conjugate());
			assert((q*p).conjugate()==p.conjugate()*q.conjugate());
			assert((q*r).conjugate()==r.conjugate()*q.conjugate());
			assert((p*q).conjugate()==q.conjugate()*p.conjugate());
			assert((p*r).conjugate()==r.conjugate()*p.conjugate());
			assert((r*p).conjugate()==p.conjugate()*r.conjugate());

			assert(p.norm()*q.norm()==(p*q).norm());

			assert(p*p.inverse()==1);
			assert(q*q.inverse()==1);
			assert(r*r.inverse()==1);

			assert(p.inverse()==p.conjugate()/p.norm());
			assert(q.inverse()==q.conjugate()/q.norm());
			assert(r.inverse()==r.conjugate()/r.norm());

			assert((p*q).inverse()==q.inverse()*p.inverse());
			assert((q*p).inverse()==p.inverse()*q.inverse());
			assert((q*r).inverse()==r.inverse()*q.inverse());
			assert((p*q).inverse()==q.inverse()*p.inverse());
			assert((p*r).inverse()==r.inverse()*p.inverse());
			assert((r*p).inverse()==p.inverse()*r.inverse());

			assert(p.w == (p+p.conjugate())/2);
			assert(q.w == (q+q.conjugate())/2);
			assert(r.w == (r+r.conjugate())/2);

			Quaternion t;
			t = p;
			t += q;
			assert(t==p+q);

			t = p;
			t -= q;
			assert(t==p-q);

			t = p;
			t *= q;
			assert(t==p*q);			// todo: decide on definition of quaternion *= quaternion

			t = p;
			t *= a;
			assert(t==p*a);

			t = p;
			t /= a;
			assert(t==p/a);
		}

		printf("testing quaternion dot\n");

		assert(a.dot(b)==(a*b.conjugate()).w);

		// todo: axis angle <-> quaternion conversion

		// todo: quaternion <-> matrix conversion
		
		// todo: euler <-> quaternion conversion
	}

	// test complex class

	printf("testing complex axioms\n");
	{
		Complex a(1,1);
		Complex b(2,3);
		Complex c(-2,-1);
		Complex d(2,1);

		// 1. commutativity of addition
		
		assert(a+b==b+a);				

		// 2. associativity of addition

		assert((a+b)+c==a+(b+c));

		// 3. existence of zero

		assert(a+0==0+a && 0+a==a);
		assert(a*0==0*a && 0*a==0);

		// 4. existence of negatives
        
		assert(a+(-a)==(-a)+a && (-a)+a==0);

		// 5. commutativity of multiplication

		assert(a*b==b*a);

		// 6. associativity of multiplication

		assert((a*b)*c==a*(b*c));

		// 7. existance of identity

		assert(a*Complex(1,0)==Complex(1,0)*a && Complex(1,0)*a==a);

		// 8. existance of multiplicative inverse

		assert(a*a.inverse() == Complex(1,0));

		// 9. distributivity

		assert(a*(b+c)==a*b+a*c);
	}
		
	printf("testing plane primitive\n");
	{
		Plane plane(Vector(0,0,10), Vector(0,0,1));
		assert(Float::equal(plane.distance(Vector(0,0,10)),0));
		assert(Float::equal(plane.distance(Vector(0,0,0)),-10));
		assert(Float::equal(plane.distance(Vector(0,0,20)),10));
		
		assert(plane.normal==Vector(0,0,1));
	}

	printf("testing sphere primitive\n");
	{
		Sphere sphere(Vector(1,2,3), 1);
		assert(Float::equal(sphere.distance(sphere.center), -sphere.radius));
		assert(Float::equal(sphere.distance(sphere.center + Vector(0,0,1)), 0));
		assert(Float::equal(sphere.distance(sphere.center + Vector(0,2,0)), 1));
		assert(Float::equal(sphere.distance(sphere.center + Vector(-1,0,0)), 0));
		assert(Float::equal(sphere.distance(sphere.center + Vector(-5,0,0)), 4));
	}

	printf("testing ellipsoid primitive\n");
	{
		Quaternion quaternion(1,2,3,4);
		quaternion.normalize();
		Matrix matrix = quaternion.matrix();

		Ellipsoid ellipsoid(Vector(1,2,3), 1, 2, 3, quaternion);

		Vector i(1,0,0);
		Vector j(0,1,0);
		Vector k(0,0,1);
		
		Vector a = ellipsoid.matrix * i;
		Vector b = ellipsoid.matrix * j;
		Vector c = ellipsoid.matrix * k ;

	 	assert(Float::equal(ellipsoid.distance(a),0));
		assert(Float::equal(ellipsoid.distance(b),0));
		assert(Float::equal(ellipsoid.distance(c),0));

		assert(Float::equal(ellipsoid.distance(a+(ellipsoid.center-a)/2), -1.0f/2.0f));
		assert(Float::equal(ellipsoid.distance(b+(ellipsoid.center-b)/2), -2.0f/2.0f));
		assert(Float::equal(ellipsoid.distance(c+(ellipsoid.center-c)/2), -3.0f/2.0f));

		assert(Float::equal(ellipsoid.distance(a-(ellipsoid.center-a)/2), 1.0f/2.0f));
		assert(Float::equal(ellipsoid.distance(b-(ellipsoid.center-b)/2), 2.0f/2.0f));
		assert(Float::equal(ellipsoid.distance(c-(ellipsoid.center-c)/2), 3.0f/2.0f));

		// todo: test ellipsoid normal
	}
}