3rd Person Shooter Programming Tutorial (OpenGL)

//-----------------------------------------------------------------------------
// 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;
}