// ImageTest.cc
// Ray Tracer Image Tester Codes
// Copyright (C) 1997,1998,1999 Y.Nagatani

#include "raytrace.h"

void Test2 (void)
{
	Triangle	T1 ( 15, -5, -6,  0, 10,  0,  -10,-10,  0),
			T2 (+10,-15,-15, 10,  5,-15,   -3, -5, 10),
			T3 = T1 + Vector (7,-5,-5),
			T4 = T2 + Vector (3,1,3);
	T1 += Vector (-1,0,0);
	T2 += Vector (0,-1,0);
	
	RGB	rgbRefl  (.3, .3, .3);
	RGB	rgbTrans (.0, .0, .0);
	
	T1.setRGB (RGB(.5, .2, .2), rgbRefl, rgbTrans);
	T1.setReflBlur (20, 0.1);
	T2.setRGB (RGB(.3, .1, .3), rgbRefl, rgbTrans);
	T3.setRGB (RGB(.2, .2, .7), rgbRefl, rgbTrans);
	T4.setRGB (RGB(.1, .3, .1), rgbRefl, rgbTrans);
	T4.setReflBlur (20, 0.05);
	
	List	LS;
	LS.setBackGround (RGB (.0, .0, .0));
	LS.setBackGroundDir (Vector (2,-1,-1), RGB (.7,.7,.7), 6);
	
	LS.add (T1);
	LS.add (T2);
	LS.add (T3);
	LS.add (T4);
	
	Spher S (Vector (-7,-7, 8), 4);
	S.setRGB (RGB(.05,.15,.1), RGB(.5,.5,.5), RGB(.5,.5,.5));
	S.setRefraction (1.15);
	LS.add (S);
	
	S = Spher (Vector (15,15,-30), 15);
	S.setRGB (RGB(.15,.1,.05), RGB(.7,.7,.7), RGB(.5,.5,.5));
	LS.add (S);
	
/*	for (int i = 0 ; i < 5 ; i++) {
		for (int j = 0 ; j < 5 ; j++) {
			
			Triangle Ta (-2,-1, 0,  +2,-1, 0,  0,+2, -0.5);
			RGB	rgbSelf (.2, .5,           .2 + 0.3*i/5);
			RGB	rgbRefl (.2, .2 + 0.3*j/5, .2          );
			Triangle Tb (Ta + Vector (3.0,0,-1)*i
					+ Vector (1.5,3,-1)*j
					+ Vector (-9,-9,3));
			LS.add (Tb.setRGB (rgbSelf, rgbRefl));
		}
	}*/
	
	PostScript	PS (Line (0,0,40, 2,2,0),	// center view line
			    Vector (17, 0, 0),		// x direction (width)
			    Vector ( 0,17, 0),		// y direction (height)
			    500, 500);			// Matrix Size
	
	PS.setRecursiveLevel (4);	// 0 is most simple case
	PS.setEps ();			// as EPS
	PS.setShowStatus ();		// show calculating status 
	
	PS.putPrologue (cout);
	PS.put (LS, cout);
	PS.putEpilogue (cout);
}


void Test3 (void)
{
	List	LS;
	LS.setBackGround (RGB ( .0, .0, .0));
	LS.setBackGroundDir (Vector (2,-1,-1), RGB (.7,.7,.7), 4);
	
	Spher S (Vector (-4,0,-3), 8);
	S.setRGB (RGB(.01,.01,.2), RGB(.5,.5,.5), RGB(.9,.9,.9));
	S.setRefraction (1.4);
	LS.add (S);
	
	S = Spher (Vector (3,-4,4), 2);
	S.setRGB (RGB(.01,.2,.01), RGB(.7,.7,.7), RGB(.9,.9,.9));
	S.setRefraction (1.17);
	LS.add (S);
	
	S = Spher (Vector (3,+4,8), 2);
	S.setRGB (RGB(.16,.01,.01), RGB(.4,.4,.4), RGB(.9,.9,.9));
	S.setRefraction (1.5);
	LS.add (S);
	
	int	nMax	= 10;
	Real	rRadi	= 15;
	for (int n = 0 ; n < nMax ; n++) {
		
		Real	f = (Real) n / nMax,
			theta1 = 2.0*M_PI * n / nMax,
			theta2 = 2.0*M_PI * (n+1) / nMax,
			x1 = rRadi*cos(theta1),
			y1 = rRadi*sin(theta1),
			x2 = rRadi*cos(theta2),
			y2 = rRadi*sin(theta2),
			a = (Real) (n % 2);
			
		Triangle Ta (x1,y1,-3, x1,y1,+3, x2,y2,0);
		Ta.setRGB ( RGB(f, 1-f, 0.7*a), 0.7, 0.0);
		LS.add (Ta);
		
		Ta = Triangle (x2,y2,-3, x2,y2,+3, x1,y1,0);
		Ta += Vector (0,0,4);
		f = 1.0 - f;
		Ta.setRGB ( RGB(f, 1-f, 0.7*a), 0.7, 0.0);
		LS.add (Ta);
	}
	nMax = 10;
	for (int n = 0 ; n < nMax ; n++) {
		
		Real	x = -20 + 4*n,
			y = -10 + 2*n;
		
		Vector	V (x,y,-16);
		Triangle Ta (V, V + Vector (3,0,0), V + Vector (1.5,2.4,0));
		Real	a = (Real) ( n    % 2),
			b = (Real) ((n+1) % 2);
		Ta.setRGB ( RGB(a, b, b), 0.4, 0.0);
		LS.add (Ta);
	}
	
	
	
	PostScript	PS (Line (0,0,25, 0,0,15),	// center view line
			    Vector ( 7, 0, 0),		// x direction (width)
			    Vector ( 0, 7, 0),		// y direction (height)
			    500, 500);			// Matrix Size
	
	PS.setRecursiveLevel (4);	// 0 is most simple case
	PS.setEps ();			// as EPS
	PS.setShowStatus ();		// show calculating status 
	
	PS.putPrologue (cout);
	PS.put (LS, cout);
	PS.putEpilogue (cout);
}


void Test4 (void)
{
	List	LS;
	LS.setBackGround (RGB ( .1, .1, .05));
	LS.setBackGroundDir (Vector (2,-1,-1), RGB (.5,.6,.7));
	
	Spher S (Vector (0,0,0), 10);
	S.setRGB (RGB(.03,.03,.1), RGB(.5,.5,.5), RGB(.9,.9,.9));
	S.setRefraction (1.3);
	LS.add (S);
	
	S = Spher (Vector (-13,13,-5), 5);
	S.setRGB (RGB(.1,.03,.03), RGB(.8,.8,.8), RGB(.9,.9,.9));
	S.setRefraction (1.5);
	LS.add (S);
	
	S = Spher (Vector (3,+4,8), 2);
	S.setRGB (RGB(.05,.01,.01), RGB(.4,.4,.4), RGB(.9,.9,.9));
	S.setRefraction (1.5);
//	LS.add (S);
	
	List	lsTriCycle;
	int	nMax	= 12;
	Real	rRadi	= 12;
	for (int n = 0 ; n < nMax ; n++) {
		
		Real	f = (Real) n / nMax,
			a = (Real) (n % 2),
			theta1 = 2.0*M_PI * n / nMax,
			theta2 = 2.0*M_PI * (n+1) / nMax,
			x1 = rRadi*cos(theta1),
			y1 = rRadi*sin(theta1),
			x2 = rRadi*cos(theta2),
			y2 = rRadi*sin(theta2);
		
		Vector	V1 (x1,y1,-3), V2 (x1,y1,+3), V3 (x2,y2,0);
		Triangle T (V1, V2, V3);
		
		T.setRGB ( RGB(f, 1-f, 0.7*a), 0.7, 0.0);
		lsTriCycle.add (T);
	}
	Line	Ax (Vector (0,0,0), Vector (1,1,-1));
	Real	phi = -75.0 * 2.0*M_PI/360;
	lsTriCycle.RotateAxesLine (Ax, phi);	
	LS.add (lsTriCycle);
	
	nMax = 16;
	for (int n = 0 ; n < nMax ; n++) {
		
		Real	x = -32 + 4*n,
			y = -16 + 2*n;
			
		
		Vector	V (x,y,-16);
		Triangle Ta (V, V + Vector (3,0,0), V + Vector (1.5,2.4,0));
		Real	a = (Real) ( n    % 2),
			b = (Real) ((n+1) % 2);
		Ta.setRGB ( RGB(a, b, b), 0.4, 0.0);
		LS.add (Ta);
	}
	
	
	
	PostScript	PS (Line (0,0,25, 0,0,15),	// center view line
			    Vector ( 7, 0, 0),		// x direction (width)
			    Vector ( 0, 7, 0),		// y direction (height)
			    500, 500);			// Matrix Size
	
	PS.setRecursiveLevel (4);	// 0 is most simple case
	PS.setEps ();			// as EPS
	PS.setShowStatus ();		// show calculating status 
	
	PS.putPrologue (cout);
	PS.put (LS, cout);
	PS.putEpilogue (cout);
}


void TestSimple (void)
{
	List	LS;
	LS.setBackGround (RGB ( .0, .0, .0));
	LS.setBackGroundDir (Vector (2,-1,-1), RGB (.5,.6,.7), 4);
	
	
	Real	rT = 10;
	Real	rRefrac = 1.15;
	Spher S (Vector (-rT/2,0,0), 5);
	S.setRGB (RGB(.03,.03,.1), RGB(.8,.8,.8), RGB(.9,.9,.9));
	S.setRefraction (rRefrac);
	LS.add (S);
	
	S = Spher (Vector (+rT/2,0,0), 5);
	S.setRGB (RGB(.03,.1,.03), RGB(.8,.8,.8), RGB(.9,.9,.9));
	S.setRefraction (rRefrac);
	LS.add (S);
	
	S = Spher (Vector (0,rT*sqrt(3)/2,0), 5);
	S.setRGB (RGB(.1,.03,.03), RGB(.8,.8,.8), RGB(.9,.9,.9));
	S.setRefraction (rRefrac);
	LS.add (S);
	
	S = Spher (Vector (0,rT/sqrt(3)/2,rT*sqrt(2.0/3)), 5);
	S.setRGB (RGB(.1,.1,.1), RGB(.75,.75,.75), RGB(.9,.9,.9));
	S.setRefraction (rRefrac);
	LS.add (S);
	
	rT = 10;
	Triangle	T (-rT/2,0,0, +rT/2,0,0, 0,rT/2*sqrt(3),0);
	T.setRGB (RGB(.7,.2,.1), RGB(.7,.7,.7), 0);
	T += Vector (0,0,-5.001);
	LS.add (T);
	
	LS.RotateAxesLine (Line(Vector (0,0,0), Vector (1,0,0)),
			   -61.0*M_PI/180);
	LS.RotateAxesLine (Line(Vector (0,0,0), Vector (0,1,0)),
			   +32.0*M_PI/180);
	LS += Vector (0,-3,0);
	
	PostScript	PS (Line (0,0,40, 0,0,0),	// center view line
			    Vector (12, 0, 0),		// x direction (width)
			    Vector ( 0,12, 0),		// y direction (height)
			    500, 500);			// Matrix Size
	
	PS.setRecursiveLevel (6);	// 0 is most simple case
	PS.setEps ();			// as EPS
	PS.setShowStatus ();		// show calculating status 
	
	if (False) {
		PS.putPrologue (cout);
		PS.put (LS, cout);
		PS.putEpilogue (cout);
	} else{
		PS.putAsPPMRaw (LS, cout);
	}
}


void TestSimple2 (void) // Total Blur Test
{
	List	LS;
	LS.setBackGround (RGB ( .0, .02, .06));
	LS.setBackGroundDir (Vector (0,0,-1), RGB (.7,.7,.7), 4);
	
	Spher S (Vector (-5,0,0), 5);
	S.setRGB (RGB(.03,.03,.1), RGB(.5,.5,.5), RGB(.9,.9,.9));
	S.setRefraction (1.15);
	LS.add (S);
	
	S = Spher (Vector (+5,0,0), 5);
	S.setRGB (RGB(.03,.1,.03), RGB(.8,.8,.8), RGB(.9,.9,.9));
	S.setRefraction (1.15);
	LS.add (S);
	
	Real	rT = 14;
	Triangle	T (-rT/2,0,0, +rT/2,0,0, 0,rT/2*sqrt(3),0);
	T.setRGB (RGB(.0,.0,.0), RGB(.7,.7,.7), 0);
	T.setTotalBlur (RGB (6,0.5,0.5), 30);
	T += Vector (0,0,-7);
	LS.add (T);
	
	LS.RotateAxesLine (Line(Vector (0,0,0), Vector (0,1,0)),
			   -30.0*M_PI/180);
	LS.RotateAxesLine (Line(Vector (0,0,0), Vector (1,0,0)),
			   +40.0*M_PI/180);
	
	PostScript	PS (Line (0,0,25, 0,0,15),	// center view line
			    Vector ( 7, 0, 0),		// x direction (width)
			    Vector ( 0, 7, 0),		// y direction (height)
			    512, 512);			// Matrix Size
	
	PS.setRecursiveLevel (4);	// 0 is most simple case
	PS.setEps ();			// as EPS
	PS.setShowStatus ();		// show calculating status
	
	if (False) {
		PS.putPrologue (cout);
		PS.put (LS, cout);
		PS.putEpilogue (cout);
	} else{
		PS.putAsPPMRaw (LS, cout);
	}
}


int main (int nArgc, char *pszArgv[])
{
	Check_rRand ();
//	Test1 ();
//	Test2 ();
//	Test3 ();
//	Test4 ();
	TestSimple ();
//	TestSimple2 ();
}