//-----------------------------------------------------------------------------
// Shogun3D's OpenGL Utility Toolkit framework.
// 
// Disclamer:  Use this code as you see fit, for both personal and/or commercial
//			   usages.  You don't exactly have to give me credit for using this
//			   code in your own projects (although I would appreciate it if you
//			   did), but you could at let me know that this has benefited you
//			   in one way or another, because I didn't write this code just for
//			   myself you know ^^
//
// File:	main.c
// Desc:	This code will hopefully show you how easy it is to create a 3rd 
//			person game :)
// Date:	August 20, 2010
//-----------------------------------------------------------------------------

// Include files 

#ifdef WIN32 // For windows builds
#include <windows.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include <gl\glut.h>
#include <gl\glext.h>


//-----------------------------------------------------------------------------
// 3D vector
//-----------------------------------------------------------------------------
struct Vector3
{
	float x, y, z;
};

//-----------------------------------------------------------------------------
// Third Person Camera structure
//-----------------------------------------------------------------------------
struct ThirdPersonCamera_t
{
	struct Vector3 vecPos;
	struct Vector3 vecRot;
	float fRadius;			// Distance between the camera and the object.
	float fLastX;
	float fLastY;
};

//-----------------------------------------------------------------------------
// Sphere structure
//-----------------------------------------------------------------------------
struct Sphere_t
{
	struct Vector3 position;	// Position in 3D space
	int selected;				// Did OpenGL select this one?
	int dead;					// Is this sphere dead?
	unsigned int death_time;	// How long has this sphere been dead?
								// Respawn after X milliseconds
	float distance;				// Distance between you and the sphere.
	float size;					// The size of the sphere. Decreases during
								// death phase.
};

//-----------------------------------------------------------------------------
// Global variables
//-----------------------------------------------------------------------------
#define sphere_count 20			// Number of spheres in the game
#define respawn_time 5000		// After a sphere is shot dead, respawn after this
								// amount of time.

struct	ThirdPersonCamera_t		camera;
struct	Sphere_t				spheres[sphere_count];
GLuint							floor_tex = 0;
GLuint							select_buffer[sphere_count*4] = {0};
GLint							hits = 0;
float							jump_height = 0.0f;
GLboolean						sniper_mode = GL_FALSE;
GLint							kills = 0;




//-----------------------------------------------------------------------------
// Name: glEnable2D
// Desc: Enabled 2D primitive rendering by setting up the appropriate orthographic
//		 perspectives and matrices.
//-----------------------------------------------------------------------------
void glEnable2D( void )
{
	GLint iViewport[4];

	// Get a copy of the viewport
	glGetIntegerv( GL_VIEWPORT, iViewport );

	// Save a copy of the projection matrix so that we can restore it 
	// when it's time to do 3D rendering again.
	glMatrixMode( GL_PROJECTION );
	glPushMatrix();
	glLoadIdentity();

	// Set up the orthographic projection
	glOrtho( iViewport[0], iViewport[0]+iViewport[2],
			 iViewport[1]+iViewport[3], iViewport[1], -1, 1 );
	glMatrixMode( GL_MODELVIEW );
	glPushMatrix();
	glLoadIdentity();

	// Make sure depth testing and lighting are disabled for 2D rendering until
	// we are finished rendering in 2D
	glPushAttrib( GL_DEPTH_BUFFER_BIT | GL_LIGHTING_BIT );
	glDisable( GL_DEPTH_TEST );
	glDisable( GL_LIGHTING );
}


//-----------------------------------------------------------------------------
// Name: glDisable2D
// Desc: Disables 2D rendering and restores the previous matrix and render states
//		 before they were modified.
//-----------------------------------------------------------------------------
void glDisable2D( void )
{
	glPopAttrib();
	glMatrixMode( GL_PROJECTION );
	glPopMatrix();
	glMatrixMode( GL_MODELVIEW );
	glPopMatrix();
}

//-----------------------------------------------------------------------------
// Name: glPrintf
// Desc: Prints a string of chars using GLUT's pre-defined char blitting API.
//-----------------------------------------------------------------------------
void glPrintf( int x, int y, void* font, char* string, ... )
{
	char *c;
	char temp[256];
	va_list ap;

	va_start( ap, string );
	vsprintf( temp, string, ap );
	va_end( ap );

	glEnable2D();

	glRasterPos2i(x,y);

	for (c=temp; *c != '\0'; c++) 
	{
		glutBitmapCharacter(font, *c);
	}

	glDisable2D();
}

//-----------------------------------------------------------------------------
// Name: distance
// Desc: Calculates the distance between two points.
//-----------------------------------------------------------------------------
float distance( const struct Vector3* v1, const struct Vector3* v2 )
{
	float d = 0.0f;
	float x = v2->x - v1->x;
	float y = v2->y - v1->y;
	float z = v2->z - v1->z;

	x *= x;
	y *= y;
	z *= z;

	d = sqrt(x+y+z);

	return d;
}


//-----------------------------------------------------------------------------
// Name: calculate_distances
// Desc: Calulates the distance between each sphere and the camera.
//-----------------------------------------------------------------------------
void calculate_distances( void )
{
	int i;
	struct Vector3 neg_camera;

	// In order to accurately calculate the distance between the spheres and 
	// the camera, the x and z values should be converted to negatives, and
	// the y coordinate should be ignored.  The camera updates the y value 
	// still, but in a 3rd person shooter/adventure style game, the is calc-
	// lations are done seperately from the camera to compensate for jumping
	// and gravity, etc.
	neg_camera.x = camera.vecPos.x * -1.0f;
	neg_camera.y = 0.0f;
	neg_camera.z = camera.vecPos.z * -1.0f;

	for( i = 0; i < sphere_count; i++ )
	{
		spheres[i].distance = distance( &neg_camera, &spheres[i].position );
	}
}


//-----------------------------------------------------------------------------
// Name: texture_create
// Desc: Creates a simple black and white checker board style texture.  Change it
//		 to whatever you like :)
//-----------------------------------------------------------------------------
void texture_create( void )
{
	GLubyte buffer[64][64][4];
	int s, t;

	for( t = 0; t < 64; t++ )
	{
		for( s = 0; s < 64; s++ )
		{
			GLubyte c = ((((t&0x8)==0)^((s&0x8))==0))*255;
			buffer[s][t][0] = c;
			buffer[s][t][1] = c;
			buffer[s][t][2] = c;
			buffer[s][t][3] = 255;
		}
	}

	// Set the pixel alignment to default
	glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );

	// Generate 1 texture ID
	glGenTextures( 1, &floor_tex );

	// Bind this texture so that we can edit it
	glBindTexture( GL_TEXTURE_2D, floor_tex );

	// Create the actual texture with it's dimensions, format and texel data
	glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0,
					GL_RGBA, GL_UNSIGNED_BYTE, buffer );

	// Enable bilinear filtering
	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
}

//-----------------------------------------------------------------------------
// Name: floor_render
// Desc: Renders the floor with the texture created above.
//-----------------------------------------------------------------------------
void floor_render( float size, float y )
{
	// Render the floor at the given height on the Y axis.
	glPushAttrib( GL_ALL_ATTRIB_BITS );

	glPushMatrix();

	glTranslatef( 0.0f, y, 0.0f );

	glDisable( GL_LIGHTING );
	glEnable( GL_TEXTURE_2D );
	glBindTexture( GL_TEXTURE_2D, floor_tex );

	glBegin( GL_QUADS );
	glColor3f( 1.0f, 1.0f, 1.0f );
	glTexCoord2f( 0.0f, 0.0f );		glVertex3f( -size, y, -size );
	glTexCoord2f( 0.0f, 1.0f );		glVertex3f( -size, y, +size );
	glTexCoord2f( 1.0f, 1.0f );		glVertex3f( +size, y, +size );
	glTexCoord2f( 1.0f, 0.0f );		glVertex3f( +size, y, -size );
	glEnd();

	glPopMatrix();

	glPopAttrib();
}

//-----------------------------------------------------------------------------
// Name: spheres_init
// Desc: Gives each sphere a random position in 3D space.
//-----------------------------------------------------------------------------
void spheres_init( void )
{
	int i;

	// Give each sphere a random position
	for( i = 0; i < sphere_count; i++ )
	{
		spheres[i].position.x = (float) ( ( rand() % 100 ) + 1 ) - 50;
		spheres[i].position.y = 0.0f;
		spheres[i].position.z = (float) ( ( rand() % 100 ) + 1 ) - 50;
		spheres[i].selected = 0;
		spheres[i].dead = 0;
		spheres[i].death_time = 0;
		spheres[i].distance = 0.0f;
		spheres[i].size = 2.0f;
	}
}

//-----------------------------------------------------------------------------
// Name: spheres_render
// Desc: Renders each sphere in it's random position
//-----------------------------------------------------------------------------
void spheres_render( void )
{
	int i;

	// Render each sphere with a solid green colour
	glColor3f( 0.0f, 1.0f, 0.0f );

	for( i = 0; i < sphere_count; i++ )
	{
		// Is this sphere dead?
		if( spheres[i].dead )
		{
			unsigned int current_time;

			// Slowly decrease the size of the sphere when it's dying
			if( spheres[i].size > 0.0f )
				spheres[i].size -= 0.1f;

			// When time expires, bring the sphere back into play (respawn).
			// The sphere will fall from the sky after the respawn time expires.
			current_time = GetTickCount();
			if( (current_time - spheres[i].death_time) > respawn_time )
			{
				spheres[i].position.x = (float) ( ( rand() % 100 ) + 1 ) - 50;
				spheres[i].position.y = 50.0f;
				spheres[i].position.z = (float) ( ( rand() % 100 ) + 1 ) - 50;
				spheres[i].dead = 0;
				spheres[i].size = 2.0f;
			}
		}

		//if( !spheres[i].dead )
		if( spheres[i].size != 0.0f )
		{
			glPushMatrix();
			glTranslatef( -spheres[i].position.x, spheres[i].position.y, -spheres[i].position.z );
			glutSolidSphere( spheres[i].size, 20, 20 );
			
			// Render a slightly larger purple transparent sphere around
			// selected objects.
			if( spheres[i].selected )
			{
				glPushAttrib( GL_ALL_ATTRIB_BITS );

				glColor4ub( 128, 0, 255, 64 );

				glDisable( GL_COLOR_MATERIAL );
				glDisable( GL_LIGHTING );
			//	glDisable( GL_DEPTH_TEST );
				glDepthMask( GL_FALSE );
				glDisable( GL_TEXTURE_2D );
				glEnable( GL_BLEND );
				glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );

				glutSolidSphere( spheres[i].size * 1.5f, 20, 20 );

				glPopAttrib();
			}

			glPopMatrix();
		}

		// If the sphere is in the sky, let it fall back down to the ground
		if( spheres[i].position.y > 0.0f )
		{
			spheres[i].position.y -= 0.5f;
		}
	}
}


//-----------------------------------------------------------------------------
// Name: draw_axes
// Desc: Draws each axis using a line in the center of 3D space.  Red is X,
//		 green is Y, and blue is Z.  This will help us make sure we are not
//		 upside down.
//-----------------------------------------------------------------------------
void draw_axes( void )
{
	glPushAttrib( GL_ALL_ATTRIB_BITS );
	glDisable( GL_LIGHTING );
	glEnable( GL_LINE_SMOOTH );

	glPushMatrix();
	glTranslatef( 0.0f, 0.0f, 0.0f );

	glBegin( GL_LINES );

	// X Axis (Red)
	glColor3f( 1.0f, 0.0f, 0.0f );
	glVertex3f( 0.0f, 0.0f, 0.0f );
	glVertex3f( 2.0f, 0.0f, 0.0f );

	// Y Axis (Green)
	glColor3f( 0.0f, 1.0f, 0.0f );
	glVertex3f( 0.0f, 0.0f, 0.0f );
	glVertex3f( 0.0f, 2.0f, 0.0f );

	// Z Axis (Blue)
	glColor3f( 0.0f, 0.0f, 1.0f );
	glVertex3f( 0.0f, 0.0f, 0.0f );
	glVertex3f( 0.0f, 0.0f, 2.0f );

	glEnd();

	glPopMatrix();

	glPopAttrib();
}

//-----------------------------------------------------------------------------
// Name: draw_crosshair
// Desc: 
//-----------------------------------------------------------------------------
void draw_crosshair( void )
{
	float fViewport[4];
	float w = 32.0f, h = 32.0f;

	// Get the current viewport. We want to make sure the crosshair
	// is in the center of the screen, even if the window is resized.
	glGetFloatv( GL_VIEWPORT, fViewport ); 

	// Enable 2D rendering
	glEnable2D();

	glBegin( GL_LINES );
		glColor3f( 1.0f, 1.0f, 0.0f );
		glVertex2f( (fViewport[2]/2.0f)-(w/2.0f), fViewport[3]/2.0f );
		glVertex2f( (fViewport[2]/2.0f)+(w/2.0f), fViewport[3]/2.0f );
		glVertex2f( fViewport[2]/2.0f, (fViewport[3]/2.0f)-(h/2.0f) );
		glVertex2f( fViewport[2]/2.0f, (fViewport[3]/2.0f)+(h/2.0f) );
	glEnd();

	// Disable 2D rendering
	glDisable2D();
}

//-----------------------------------------------------------------------------
// Name: show_camera_stats
// Desc: 
//-----------------------------------------------------------------------------
void show_camera_stats( void )
{
	char string[128];

	sprintf( string, "Camera <%f,%f,%f>", camera.vecPos.x, camera.vecPos.y, camera.vecPos.z );
	glPrintf( 30, 30, GLUT_BITMAP_9_BY_15, string );
}

//-----------------------------------------------------------------------------
// Name: show_stats
// Desc: 
//-----------------------------------------------------------------------------
void show_stats( void )
{
	char string[128];

	glColor3f( 0.0f, 0.5f, 1.0f );

	sprintf( string, "Kills: %d", kills );
	glPrintf( 450, 30, GLUT_BITMAP_9_BY_15, string );

	if( sniper_mode )
		sprintf( string, "Sniper Mode: On" );
	else
		sprintf( string, "Sniper Mode: Off" );
	glPrintf( 450, 45, GLUT_BITMAP_9_BY_15, string );
}

//-----------------------------------------------------------------------------
// Name: print_selected_objects
// Desc: 
//-----------------------------------------------------------------------------
void print_selected_objects( void )
{
	int i;

	// List the number of hits
	printf( "Number of hits: %d\n\n", hits );

	// List each the attributes of each object selected
	for( i = 0; i < hits; i++ )
	{
		GLubyte number = select_buffer[i*4];
		GLubyte min_z = select_buffer[i*4+1];
		GLubyte max_z = select_buffer[i*4+2];
		GLubyte name = select_buffer[i*4+3];

		printf( "Number: %d\nMin Z: %d\nMax Z: %d\nName: %d\n\n",
			number, min_z, max_z, name );
	}
}

//-----------------------------------------------------------------------------
// Name: kill_selected_objects
// Desc: Marks all selected objects as dead.
//-----------------------------------------------------------------------------
void kill_selected_objects( void )
{
	int i;

	// Loop through the selection buffer and pick out the selected objects.
	// This effect should be similar to that of an armour piercing sniper rifle.

	for( i = 0; i < hits; i++ )
	{
		GLubyte name = select_buffer[i*4+3];

		spheres[name].dead = 1;
		spheres[name].death_time = GetTickCount();

		// Increment the kill counter
		kills++;
	}
}

//-----------------------------------------------------------------------------
// Name: kill_closest_selected_object
// Desc: Marks the closest selected object as dead.
//-----------------------------------------------------------------------------
void kill_closest_selected_object( void )
{
	int i = 0;
	GLubyte name;

	// If we only have one object selected, just kill that one.
	if( hits == 1 )
	{
		name = select_buffer[i*4+3];
		spheres[name].dead = 1;
		spheres[name].death_time = GetTickCount();
		kills++;
	}
	else
	{
		float d = spheres[select_buffer[i*4+3]].distance;
		int closest = 0;

		// Find the object with the shortest distance
		/*for( i = 1; i < hits; i++ )
		{
			name = select_buffer[i*4+3];

			if( d > spheres[name].distance )
			{
				d = spheres[name].distance;
				closest = name;
			}
		}

		spheres[closest].dead = 1;
		spheres[closest].death_time = GetTickCount();*/

		for( i = 0; i < hits; i++ )
		{
			name = select_buffer[i*4+3];
			d = min( d, spheres[name].distance );
		}

		// Now set the closest sphere as dead
		for( i = 0; i < hits; i++ )
		{
			name = select_buffer[i*4+3];

			if( spheres[name].distance == d )
			{
				spheres[name].dead = 1;
				spheres[name].death_time = GetTickCount();
				kills++;
				break;
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Name: draw_lazer_from_player_to_nearest_target
// Desc: Draws an orange antialiased line from the player to the nearest targeted
//		 object.
//-----------------------------------------------------------------------------
void draw_lazer_from_player_to_nearest_target( void )
{
	int i = 0;
	GLubyte name;
	struct Vector3 p1, p2;

	// Don't do anything if there is no target in the crosshair
	if( !hits )
		return;

	// Set the first point relative to the camera's position
	p1.x = camera.vecPos.x;
	p1.y = 0.0f; //camera.vecPos.y;
	p1.z = camera.vecPos.z;

	// If we only have one object selected, then we know where to aim
	// the lazer.
	if( hits == 1 )
	{
		name = select_buffer[i*4+3];
		p2.x = -spheres[name].position.x;
		p2.y = -spheres[name].position.y;
		p2.z = -spheres[name].position.z;
	}
	else
	{
		float d = spheres[select_buffer[i*4+3]].distance;

		for( i = 0; i < hits; i++ )
		{
			name = select_buffer[i*4+3];
			d = min( d, spheres[name].distance );
		}

		// Now target the closest sphere with the lazer
		for( i = 0; i < hits; i++ )
		{
			name = select_buffer[i*4+3];

			if( spheres[name].distance == d )
			{
				name = select_buffer[i*4+3];
				p2.x = -spheres[name].position.x;
				p2.y = -spheres[name].position.y;
				p2.z = -spheres[name].position.z;
				break;
			}
		}
	}

	// Draw the lazer as an orange line
	glPushAttrib( GL_ALL_ATTRIB_BITS );
	glDisable( GL_LIGHTING );
	glDisable( GL_BLEND );

	//glEnable( GL_LINE_SMOOTH );
	glLineWidth( 1.5f );

	glBegin( GL_LINES );
	glColor3f( 1.0f, 0.5f, 0.0f );
	glVertex3fv( (float*) &p1 );
	glVertex3fv( (float*) &p2 );
	glEnd();

	glPopAttrib();
}

//-----------------------------------------------------------------------------
// Name: do_selection
// Desc: 
//-----------------------------------------------------------------------------
void do_selection( int select_x, int select_y, int preselect )
{ 
	GLint iViewport[4];
	float fViewport[4];
	int i;

	// Set the selection buffer and specify it's size
	glSelectBuffer( sphere_count*4, select_buffer );

	// Get a copy of the current viewport
	glGetIntegerv( GL_VIEWPORT, iViewport );
	glGetFloatv( GL_VIEWPORT, fViewport );

	// Switch into selection mode
	glRenderMode( GL_SELECT );

	// Clear the name stack
	glInitNames();
	// Give the stack at least one name or else it will generate an error
	glPushName(0);

	// Save the projection matrix
	glMatrixMode( GL_PROJECTION );
	glPushMatrix();
	glLoadIdentity();

	// Restrict the rendering area to the given point using gluPickMatrix
	gluPickMatrix( select_x, select_y, 1.0f, 1.0f, iViewport );
	gluPerspective( 45.0f, (GLdouble) fViewport[2]/fViewport[3], 0.1f, 500.0f );

	// Now render selectable objects to the screen
	glMatrixMode( GL_MODELVIEW );
//	glutSwapBuffers();

	
	// Render each sphere with a solid green colour
	glColor3f( 0.0f, 1.0f, 0.0f );

	for( i = 0; i < sphere_count; i++ )
	{
	//	if( !spheres[i].dead )
		if( spheres[i].size != 0.0f )
		{
			glPushMatrix();
			glLoadName(i);
			glTranslatef( -spheres[i].position.x, spheres[i].position.y, -spheres[i].position.z );
			glutSolidSphere( spheres[i].size, 20, 20 );
			glPopMatrix();
		}
	}

	glPopName();

	// Restore the projection matrix
	glMatrixMode( GL_PROJECTION );
	glPopMatrix();

	// Get the number of hits (the number of objects drawn within that 
	// specified area) and return to render mode
	hits = glRenderMode( GL_RENDER );

	// Don't do anything except mark objects as selected in preselect mode
	if( preselect )
	{
		// Go through the list of objects and deselect them all
		for( i = 0; i < sphere_count; i++ )
			spheres[i].selected = 0;

		// Now mark all selected objects
		for( i = 0; i < hits; i++ )
		{
			GLubyte name = select_buffer[i*4+3];
			char string[64];

			spheres[name].selected = 1;

			// For debugging purposes, display the distance between you and
			// each selected object.
			sprintf( string, "Name: %d  Distance %f", name, spheres[name].distance );
			glPrintf( 30, 45+(i*20), GLUT_BITMAP_9_BY_15, string );
		}

		draw_lazer_from_player_to_nearest_target();
	}
	else
	{
		// Show the number of selected objects in the console (optional)
		print_selected_objects();

		// Kill selected object(s)
		if( sniper_mode )
			kill_selected_objects();
		else
			kill_closest_selected_object();
	}

	// Return to the modelview matrix
	glMatrixMode( GL_MODELVIEW );
}


//-----------------------------------------------------------------------------
// Name: glh_extension_supported
// Desc: Checks the list of OpenGL extensions supported by this videocard/driver
//		 to see if it's supported.  This function was borrowed from the NVIDIA
//		 SDK (v9.5).  I was too lazy to write my own extension checking function :)
//		 See glh_extensions.h
//-----------------------------------------------------------------------------
int glh_extension_supported( const char *extension )
{
    static const GLubyte *extensions = NULL;
    const GLubyte *start;
    GLubyte *where, *terminator;
    
    // Extension names should not have spaces. 
    where = (GLubyte *) strchr( extension, ' ');
    if ( where || *extension == '\0')
      return 0;
    
    if ( !extensions )
      extensions = glGetString( GL_EXTENSIONS );

    // It takes a bit of care to be fool-proof about parsing the
    // OpenGL extensions string.  Don't be fooled by sub-strings,
    // etc.
    start = extensions;
    for (;;) 
    {
        where = (GLubyte *) strstr( (const char *) start, extension );
        if ( !where )
            break;
        terminator = where + strlen( extension );
        if ( where == start || *(where - 1) == ' ' ) 
        {
            if ( *terminator == ' ' || *terminator == '\0' ) 
            {
                return 1;
            }
        }
        start = terminator;
    }
    return 0;
}

//-----------------------------------------------------------------------------
// Name: InitScene
// Desc: Initializes extensions, textures, render states, etc. before rendering
//-----------------------------------------------------------------------------
int InitScene( void )
{
	//
	// Set default render states
	//

	// Enable depth testing 
	glEnable( GL_DEPTH_TEST );
	glDepthFunc( GL_LEQUAL );
	glClearDepth( 1.0f );

	// Enable lighting
	glEnable( GL_LIGHTING );
	glEnable( GL_LIGHT0 );
	
	// Enable colour material
	glEnable( GL_COLOR_MATERIAL );

	// Disable texture mapping (for now)
	glDisable( GL_TEXTURE_2D );

	// Disable blending
	glDisable( GL_BLEND );

	// Disable dithering
	glDisable( GL_DITHER );

	// Enable culling (counter clock wise)
	glEnable( GL_CULL_FACE );
	glCullFace( GL_CCW );

	// Enable fog
//	glEnable( GL_FOG );

	// Enable perspective correction and polygon smoothing
	glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
	glHint( GL_POLYGON_SMOOTH_HINT, GL_NICEST );

	//
	// Initialize scene objects and geometry
	//

	texture_create();
	spheres_init();

	memset( &camera, 0, sizeof( struct ThirdPersonCamera_t ) );
	camera.fRadius = 10.0f;

	//
	// Misc
	// 

	srand( time( NULL ) );

	return GL_TRUE;
}

//-----------------------------------------------------------------------------
// Name: DisplayFunction
// Desc: Our display function used to render our graphics in the main loop of
//		 our GLUT application.
//-----------------------------------------------------------------------------
void DisplayFunction( void )
{
	int iViewport[4];

	// Clear the screen and depth buffer
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
	// Reset matrices to default position, scale, and rotation
	glLoadIdentity();

	// Position the camera behind our character and render it
	glTranslatef( 0.0f, -2.0f, -camera.fRadius );
	glRotatef( camera.vecRot.x, 1.0f, 0.0f, 0.0f );
	glColor3f( 1.0f, 0.0f, 0.0f );
	glutSolidCube( 3.0f );

	// Rotate the camera as necessary
	glRotatef( camera.vecRot.y, 0.0f, 1.0f, 0.0f );
	glTranslatef( -camera.vecPos.x, 0.0f, -camera.vecPos.z );

	// Calculate distances
	calculate_distances();

	// Do pre-selection
	glGetIntegerv( GL_VIEWPORT, iViewport );
	do_selection( iViewport[2]/2, iViewport[3]/2, TRUE );

	// Render the floor
	floor_render( 50.0f, -0.75f );

	// Render spheres
	spheres_render();

	// Draw each axis
	draw_axes();

	// Draw the crosshair
	draw_crosshair();

	// Show camera's statistics
	glColor3f( 0.0f, 0.0f, 1.0f );
	show_camera_stats();

	// Show other stats
	show_stats();

	// Display graphics to the user
	glutSwapBuffers();
}


//-----------------------------------------------------------------------------
// Name: IdleFunction
// Desc: The function that is executed whenever the program is idle
//-----------------------------------------------------------------------------
void IdleFunction( void )
{
	// Continue to display graphics even when messages aren't
	// being processed.
	glutPostRedisplay();
}

//-----------------------------------------------------------------------------
// Name: KeyboardFunction
// Desc: Handles keyboard input
//-----------------------------------------------------------------------------
void KeyboardFunction( GLubyte k, int x, int y )
{
	static float fRotSpeed = 1.0f;

	if (k=='q')
    {
		camera.vecRot.x += fRotSpeed;
		if (camera.vecRot.x > 360) camera.vecRot.x -= 360;
    }
    if (k=='z')
    {
		camera.vecRot.x -= fRotSpeed;
		if (camera.vecRot.x < -360) camera.vecRot.x += 360;
    }

	
	if (k=='c')
    {
		camera.vecRot.y += fRotSpeed;
		if (camera.vecRot.y > 360) camera.vecRot.y -= 360;
    }
    if (k=='v')
    {
		camera.vecRot.y -= fRotSpeed;
		if (camera.vecRot.y < -360) camera.vecRot.y += 360;
    }

    if (k=='w')
    {
		float xrotrad, yrotrad;
		yrotrad = (camera.vecRot.y / 180.0f * 3.141592654f);
		xrotrad = (camera.vecRot.x / 180.0f * 3.141592654f); 
		camera.vecPos.x += (float)(sin(yrotrad));
		camera.vecPos.z -= (float)(cos(yrotrad));
		camera.vecPos.y -= (float)(sin(xrotrad));
    }
    if (k=='s')
    {
		float xrotrad, yrotrad;
		yrotrad = (camera.vecRot.y / 180.0f * 3.141592654f);
		xrotrad = (camera.vecRot.x / 180.0f * 3.141592654f); 
		camera.vecPos.x -= (float)(sin(yrotrad));
		camera.vecPos.z += (float)(cos(yrotrad));
		camera.vecPos.y += (float)(sin(xrotrad));
    }
    if (k=='d')
    {
		float yrotrad;
		yrotrad = (camera.vecRot.y / 180.0f * 3.141592654f);
		camera.vecPos.x += (float)(cos(yrotrad)) * 0.5f;
		camera.vecPos.z += (float)(sin(yrotrad)) * 0.5f;
    }
    if (k =='a')
    {
		float yrotrad;
		yrotrad = (camera.vecRot.y / 180.0f * 3.141592654f);
		camera.vecPos.x -= (float)(cos(yrotrad)) * 0.5f;
		camera.vecPos.z -= (float)(sin(yrotrad)) * 0.5f;
    }

	// Has escape been pressed?
	if( k == 27 )
	{
		exit(0);
	}

	// If not, then continue rendering
	glutPostRedisplay();
}

//-----------------------------------------------------------------------------
// Name: MouseFunction
// Desc: Handles mouse input (movement)
//-----------------------------------------------------------------------------
void MouseFunction( int x, int y )
{
	int diffx = x - camera.fLastX;
	int diffy = y - camera.fLastY;

	camera.fLastX = x;
	camera.fLastY = y;

	camera.vecRot.x += (float) diffy;
	camera.vecRot.y += (float) diffx;

	if( camera.vecRot.x < -30.0f )
		camera.vecRot.x = -30.0f;
	if( camera.vecRot.x > 90.0f )
		camera.vecRot.x = 90.0f;

}

//-----------------------------------------------------------------------------
// Name: MouseClickFunction
// Desc: Handles mouse input (clicks)
//-----------------------------------------------------------------------------
void MouseClickFunction( int button, int state, int x, int y )
{
	int iViewport[4];
	int center_x;
	int center_y;

	if( ( button == GLUT_LEFT_BUTTON ) && ( state == GLUT_DOWN ) )
	{
		glGetIntegerv( GL_VIEWPORT, iViewport );

		center_x = iViewport[2]/2;
		center_y = iViewport[3]/2;

		printf( "\nCenter X: %d\nCenter Y: %d\n\n", center_x, center_y );
		do_selection( center_x, center_y, FALSE );
	}

	if( ( button == GLUT_RIGHT_BUTTON ) && ( state == GLUT_DOWN ) )
		sniper_mode = !sniper_mode;
}

//-----------------------------------------------------------------------------
// Name: ReshapeFunction
// Desc: Changes the viewport when the window is resized
//-----------------------------------------------------------------------------
void ReshapeFunction( GLsizei width, GLsizei height )
{
	// Prevent divide by zero exception
	if( !height ) height = 1;

	// Reset viewport
	glViewport( 0, 0, width, height );
	glMatrixMode( GL_PROJECTION );
	glLoadIdentity();

	// Reset perspective
	gluPerspective( 45.0f, (GLdouble) width/height, 0.1f, 500.0f );
	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity();
}


//-----------------------------------------------------------------------------
// Name: main
// Desc: Program entry point.
//-----------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
	// Initialize OpenGL via GLUT library
	glutInit( &argc, argv );
	glutInitWindowSize( 640, 480 );
	glutInitDisplayMode( GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGBA );
	glutCreateWindow( "Meta-Balls!" );
//	glutFullScreen();

	// Initialize scene objects and properties
	InitScene();

	// Set our input/output functions and begin the main loop
	glutIdleFunc( IdleFunction );
	glutDisplayFunc( DisplayFunction );
	glutKeyboardFunc( KeyboardFunction );
	glutReshapeFunc( ReshapeFunction );
	glutMouseFunc( MouseClickFunction );
	glutPassiveMotionFunc( MouseFunction );
	glutMainLoop();

	return 0;
}