/*
 * Copyright (c) 1996-1999  Silicon Graphics, Inc.  All rights reserved.
 *
 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * IN NO EVENT SHALL SILICON GRAPHICS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
 * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE
 * POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/* polarView.c - show how to combine modeling transformations to 
 *		view objects as though they are encased in a glass ball
 *
 *	F1 key		- print help information
 *	Left Arrow Key	- increment the azimuth angle 
 *	Right Arrow Key	- decrement the azimuth angle
 *	Up Arrow Key	- increment the incidence angle 
 *	Down Arrow Key	- decrement the incidence angle 
 *	t Key       	- increment the twist angle 
 *	T Key       	- decrement the twist angle 
 *	R Key		- reset viewpoint
 *	Escape key 	- exit the program
 */

#include <GL/glut.h>	/* includes gl.h, glu.h */

#include <math.h>
#include <stdio.h>	/* for printf */

#include "axes.h"
#include "shapes.h"

/*  Function Prototypes  */

GLvoid  initgfx( GLvoid );
GLvoid  drawScene( GLvoid );
GLvoid  reshape( GLsizei, GLsizei );
GLvoid  keyboard( GLubyte, GLint, GLint );
GLvoid  specialkeys( GLint, GLint, GLint );

void resetView( GLvoid );
void polarView( GLfloat, GLfloat, GLfloat, GLfloat);

void printHelp( char * );

/* Global Definitions */

#define KEY_ESC	27	/* ascii value for the escape key */

/* Global Variables */

static char *progname;

static GLfloat		beamWidth = 2.0f, beamHeight = 0.4f, beamDepth = 1.0f;
static GLfloat 		nearClip, farClip, distance, twistAngle, incAngle, azimAngle;

void
main( int argc, char *argv[] )
{
	GLsizei width, height;

	glutInit( &argc, argv );

	width = glutGet( GLUT_SCREEN_WIDTH ); 
	height = glutGet( GLUT_SCREEN_HEIGHT );
	glutInitWindowPosition( (width / 2) + 4, height / 4 );
	glutInitWindowSize( (width / 2) - 4, height / 2 );
	glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );
	glutCreateWindow( argv[0] );

	initgfx();

	glutKeyboardFunc( keyboard );
	glutSpecialFunc( specialkeys );
	glutReshapeFunc( reshape );
	glutDisplayFunc( drawScene ); 

	progname = argv[0];
	printHelp( argv[0] );

	glutMainLoop();
}

void
printHelp( char *progname )
{
	fprintf(stdout, "\n%s - combine modeling transformations to \n" 
		"view objects as though encased in a glass ball\n\n"
		"Axes: X - red, Y - green, Z - blue\n\n"
		"F1 Key				- print Help information\n"
		"Left Arrow Key		- increment the azimuth angle\n" 
		"Right Arrow Key	- decrement the azimuth angle\n"
		"Up Arrow Key		- increment the incidence angle\n" 
		"Down Arrow Key		- decrement the incidence angle\n" 
        "<t> Key			- increment the twist angle\n"
        "<T> Key			- decrement the twist angle\n"
		"<R> Key			- reset viewpoint\n"
		"Escape Key			- exit the program\n\n",
		progname);
}

GLvoid
initgfx( GLvoid )
{
	GLfloat maxObjectSize;

	glClearColor( 0.0, 0.0, 0.0, 1.0 );
	glShadeModel( GL_FLAT );
	glEnable( GL_DEPTH_TEST );

	/* Maximum size of all the objects in your scene */
	maxObjectSize = sqrt( ((2*beamWidth) * (2*beamWidth)) +
				((2*beamHeight) * (2*beamHeight)) +
				(beamDepth * beamDepth) );

	/* Set up nearClip and farClip so that                        */ 
	/*    ( farClip - nearClip ) > maxObjectSize,                 */
	/*    and determine the viewing distance (adjust for zooming) */
	nearClip = 1.0;
	farClip = nearClip + 8*maxObjectSize; 
	resetView();
}

GLvoid
reshape( GLsizei width, GLsizei height )
{
	GLdouble			aspect;

	glViewport( 0, 0, width, height );

	aspect = (GLdouble) width / (GLdouble) height;

	glMatrixMode( GL_PROJECTION );
	glLoadIdentity();
	gluPerspective( 45.0, aspect, nearClip, farClip );
	glMatrixMode( GL_MODELVIEW );
}

GLvoid 
keyboard( GLubyte key, GLint x, GLint y )
{
	switch (key) {
	case 'R':
		resetView();
		glutPostRedisplay();
		break;
	case 't':	
		twistAngle = fmod( (twistAngle + 5.0), 360.0 );
		glutPostRedisplay();
		break;

	case 'T':	
		twistAngle = fmod( (twistAngle - 5.0), 360.0 );
		glutPostRedisplay();
		break;
	case KEY_ESC:	/* Exit whenever the Escape key is pressed */
		exit(0);
	}
}

GLvoid 
specialkeys( GLint key, GLint x, GLint y )
{
	switch (key) {
	case GLUT_KEY_F1:	/* print Help */
		printHelp( progname );
		break;

	case GLUT_KEY_LEFT:
		azimAngle = fmod( (azimAngle + 5.0), 360.0 );
		glutPostRedisplay();
 		break;

	case GLUT_KEY_RIGHT:
		azimAngle = fmod( (azimAngle - 5.0), 360.0 );
		glutPostRedisplay();
		break;

	case GLUT_KEY_UP:	
		incAngle = fmod( (incAngle + 5.0), 360.0 );
		glutPostRedisplay();
		break;

	case GLUT_KEY_DOWN:	
		incAngle = fmod( (incAngle - 5.0), 360.0 );
		glutPostRedisplay();
		break;
	}
}

void
resetView( GLvoid )
{
	distance = nearClip + (farClip - nearClip) / 2.0;
	twistAngle = 0.0;	/* rotation of viewing volume (camera) */
	incAngle = 0.0;
	azimAngle = 0.0;
}

void
polarView( GLfloat distance, GLfloat azimuth, GLfloat incidence,
			GLfloat twist)
{
	glTranslatef( 0.0f, 0.0f, -distance);
	glRotatef( -twist, 0.0f, 0.0f, 1.0f);
	glRotatef( -incidence, 1.0f, 0.0f, 0.0f);
	glRotatef( -azimuth, 0.0f, 0.0f, 1.0f);
}

GLvoid
drawScene( GLvoid )
{
	static GLfloat	upperArmColor[] = { 1.0f, 0.0f, 0.0f };
	static GLfloat	lowerArmColor[] = { 0.8f, 0.5f, 0.5f };
	
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

	glPushMatrix();
		polarView( distance, azimAngle, incAngle, twistAngle );
		XYZaxes();

		/* Draw the shoulder at the new origin */
		glTranslatef( 1.0f, 0.0f, 0.0f ); 
    		glColor3fv( upperArmColor );
		WireBox( beamWidth, beamHeight, beamDepth );

		/* Draw the lower arm at the end of the upper arm and 
	 	 * rotate it 45 degrees */
		glTranslatef( 1.0f, 0.0f, 0.0f );
		glRotatef( 45.0f, 0.0f, 0.0f, 1.0f );
		glTranslatef( 1.0f, 0.0f, 0.0f );
    		glColor3fv( lowerArmColor );
		WireBox( beamWidth, beamHeight, beamDepth );
	glPopMatrix();

	glutSwapBuffers();
}