/*

	table.txt
	
	Created by: Jonathan Kipling Knight, Prism Research
	Created on: 25 February 1999

	An example of using NewtonGL in an NTK project.  This file may
	be incorporated, whole or modified, into a NewtonGL project
	without fear of persecution or tar-and-feathering.
	
	This file must be included in an NTK project.  It must
	be processed before the 'table constant is used in the
	project. This file must be preceded in the project by 
	both Math.k and NewtonGL.k files which are included with
	this package.  Before NewtonGL.k, the compile-time statement
	GLUnitUsed:=TRUE; must be put in a file therby allowing the
	protoGL Unit Reference to be defined.

	To use the 'table example, add the statement: AddStepView(table)
	in an appropriate place like :ViewSetupDone().  If this
	line is added in the ViewChildrenSetup() then the 'table view
	will end up being opened twice by the Newton OS.

	This program has been tested on a MP2100 using NewtonGL v0.09.
	It takes up about 87k and takes about 35 seconds to draw
	initially and 17 seconds to redraw.
*/

DefineGlobalConstant('table,
{
	_proto: protoGL, // bring in the prototype
	/*
		if you receive an error when your program is first run,
		most likely you need to increase one of the next two variables.
	*/
	MAX_VERTICES: 25, // maximum number of vertices for any object
	MAX_OBJECTS: 350, // maximum number of objects
	eye: [0,0.5,0.7], // eye coordinates
	tableTop: {w:0.1,l:0.2,t:0.01}, // tabletop dimensions
	thigh: {w:0.02,l:0.08,t:0.02}, // upper table leg dimensions
	shin: {w:0.02,l:0.08,t:0.02}, // lower table leg dimensions
	checkSize: 0.1, // size of squares on floor
	floorX: 10, // # squares on floor in x direction
	floorY: 10, // # squares on floor in y direction
	tablePos: // positions of a corner of the table
	[
		[-0.2,-0.2],
		[-0.2,-0.2],
		[-0.2,-0.2],
		[-0.2,-0.1],
		[-0.2,-0.1],
		[-0.2,-0.1],
	],
	orients: // orientations of the table
	[
		[0,0,0],
		[0,0,0],
		[10,20,0],
		[10,0,20],
		[20,10,10],
		[20,10,10],
	],
	legAngles: // angles of the table legs
	[
		[[0,0,0,0],[0,0,0,0]],
		[[0,0,0,10],[0,0,0,0]],
		[[0,0,0,20],[0,0,0,0]],
		[[0,0,0,30],[0,0,0,0]],
		[[0,0,0,40],[0,0,0,0]],
		[[0,0,0,50],[0,0,0,0]],
	],
	PenDown: func(b1,b2,x,y)
	/*
		this function will be called every time pen touches the screen
	*/
	begin
		if |counter:prism|<Length(tablePos) then
		begin // redisplay next frame
			:glutPostRedisplay();
		end;
		else // close window
			:close();
	end,
	Displayer: func()
	/*
		This function is called each time the window is displayed
	*/
	begin
		local int k := |counter:prism|;

		:glColor3f(0.0,0.0,0.0); // next objects are black
		:DrawFloor(-0.3,-0.3); // draw floor at -0.3,-0.3
		:DrawTorus(0.1,0.1); // Draw doughnut at 0.1,0.1
//		:DrawCone(0,0.1); // draw cone at 0,0.1
		:glColor3f(1.0,0.0,0.0); // next objects are red
		/*
			draw table with parameters
		*/
		:DrawTable(tablePos[k][0],tablePos[k][1],shin.l+thigh.l,
			orients[k][0],orients[k][1],orients[k][2],
			legAngles[k][0],legAngles[k][1]);
		:glFlush(); // start drawing to the screen
		|counter:prism| := k + 1; // increment counter
	end,
	DrawTorus: func(x,y)
	begin
		constant inR := 0.05;
		constant outR := 0.1;

		:glEnable(GL_LIGHTING); // make lighted object
		:glPushMatrix(); // save old matrix
		:glTranslatef(x,y,(outR-inR)/2); // sitting on floor
		:glutSolidTorus(inR,outR,10,10); // draw doughnut
		:glPopMatrix(); // retrieve old matrix
		:glDisable(GL_LIGHTING); // turn off lighting
	end,
	DrawCone: func(x,y)
	begin
		constant base := 0.05;
		constant height := 0.2;

		:glEnable(GL_LIGHTING); // make lighted object
		:glPushMatrix(); // save old matrix
		:glTranslatef(x,y,0); // place cone at x,y,0
		:glutSolidCone(base,height,10,10); // draw cone
		:glPopMatrix(); // retrieve old matrix
		:glDisable(GL_LIGHTING); // turn off lighting
	end,
	DrawLeg: func(x,y,thetaThigh,thetaShin)
	begin
		:glPushMatrix();
		:glTranslatef(x,y,0);
		:glRotatef(thetaThigh,1,0,0);
		// Put hip at origin
		:glTranslatef(thigh.w*0.5,-thigh.t*0.5,-thigh.l*0.5);
		:glScalef(thigh.w,thigh.t,thigh.l);
		:glutSolidCube(1.0);
		:glPopMatrix();
		:glPushMatrix();
		y := y+thigh.l*sin(thetaThigh*kRad)
			-thigh.t*cos(thetaThigh*kRad);
		z := -thigh.l*cos(thetaThigh*kRad)
			-thigh.t*sin(thetaThigh*kRad);
		:glTranslatef(x,y,z);
		if thetaShin>thetaThigh then // knee can't bend backwards
			thetaShin := thetaThigh;
		:glRotatef(thetaShin,1,0,0);
		// Put knee at origin
		:glTranslatef(shin.w*0.5,shin.t*0.5,-shin.l*0.5);
		:glScalef(shin.w,shin.t,shin.l);
		:glutSolidCube(1.0);
		:glPopMatrix();
	end,
	DrawTop: func()
	begin
		:glPushMatrix();
		:glTranslatef(tableTop.w*0.5,tableTop.l*0.5,tableTop.t*0.5);
		:glScalef(tableTop.w,tableTop.l,tableTop.t);
		:glutSolidCube(1.0);
		:glPopMatrix();
	end,
	DrawTable: func(x,y,z,orient,altitude,tilt,thetaThighs,thetaShins)
	begin
		local x1,y1,d,phi;

		:glPushMatrix();
		:glTranslatef(x,y,z);
		:glRotatef(orient,0,0,1); // z-axis rotation
		:glRotatef(tilt,0,1,0); // y-axis rotation
		:glRotatef(altitude,1,0,0); // x-axis rotation
		x1 := 0;
		y1 := thigh.t;
		:DrawLeg(x1,y1,thetaThighs[0],thetaShins[0]);
		x1 := tableTop.w-thigh.w;
		y1 := thigh.t;
		:DrawLeg(x1,y1,thetaThighs[1],thetaShins[1]);
		x1 := 0;
		y1 := tableTop.l;
		:DrawLeg(x1,y1,thetaThighs[2],thetaShins[2]);
		d := sqrt((tableTop.w-thigh.w)*(tableTop.w-thigh.w)+tableTop.l*tableTop.l);
		phi := atan2(tableTop.w-thigh.w,tableTop.l);
		x1 := d*sin(phi);
		y1 := d*cos(phi);
		:DrawLeg(x1,y1,thetaThighs[3],thetaShins[3]);
		:DrawTop();
		:glPopMatrix();
	end,
	DrawFloor: func(x,y)
	begin
		local i,j;

		for i:=0 to floorX-1 by 2 do
		begin
			for j:=0 to floorY-1 do
			begin
				:glRectf(x+(i+(j mod 2))*checkSize,
						y+j*checkSize,
						x+(i+1+(j mod 2))*checkSize,
						y+(j+1)*checkSize);
			end;
		end;
	end,
	Init: func(argc,argv)
	begin
		if argv then // change eye coordinates
		begin
			eye := Clone(eye);
			if Length(argv)>0 then
				eye[0] := argv[0];
			if Length(argv)>1 then
				eye[1] := argv[1];
			if Length(argv)>2 then
				eye[2] := argv[2];
		end;
		// place light source #0 at 1,1,1
		:glEnable(GL_LIGHT0);
		:glLight(GL_LIGHT0,GL_POSITION,[1.0,1.0,1.0,0.0]);
		// define material properties
		:glMaterial(GL_FRONT,GL_SPECULAR,[1,1,1,1]);
		:glMaterial(GL_FRONT,GL_SHININESS,50.0);
		// initialize counter
		DefGlobalVar('|counter:prism|,0);
	end,
	Redraw: func(w,h)
	/*
		This function sets up redrawing the window
	*/
	begin
		:glViewport(0,0,w,h);
		:glClearColor(1.0,0.5,1.0,1.0);
		:glMatrixMode(GL_PROJECTION);
		:glLoadIdentity();
		:glFrustrum(-1.0,1.0,-1.0,1.0,1.5,20.0);
		:glMatrixMode(GL_MODELVIEW);
		:glLoadIdentity();
		:gluLookAt(eye[0],eye[1],eye[2],
					0.0,0.0,0.0,
					0.0,1.0,0.0);
	end,
	main: func(int argc, argv)
	/*
		This function is the entry point to a NewtonGL program.
		It must be named main.
	*/
	begin
		:glutInit(argc,argv); // required line
		:glutInitWindowSize(200,200); // window is 200 by 200 pixels
		:glutInitWindowPosition(10,30); // at x=10, y=30 pixels
		:glutCreateWindow("Dancing Table"); // name the window
		:Init(argc,argv); // call your initializer
		/*
			a display function must be declared
		*/
		:glutDisplayFunc(Displayer); // declare the display function
		:glutReshapeFunc(Redraw); // declare the reshape function
		:glutMouseFunc(PenDown); // declare the pen function
		:glutMainLoop(); // required line, starts the drawing
	end,
	argv: NIL,
	argc: NIL,
});