display.cpp

Go to the documentation of this file.

//
// Das Tank - Copyright (C) 2006, 2007 Windsor Schmidt <windsor@windsorworld.net>
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
// more details.
//
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc., 59 Temple
// Place, Suite 330, Boston, MA 02111-1307 USA
//


#ifndef STDAFX
#include "stdafx.h"
#endif

GLuint textures[256]; // store references to all the textures used in the game
CAnimation * animations[256]; // store references to all the animations used in the game
static float stripeAlpha; // transparency of big text background stripe displayed in-game

void InitGL(int Width, int Height)               // we call this right after our OpenGL window is created
{
       glViewport(0, 0, Width, Height);
       glClearColor(0.282f, 0.282f, 0.282f, 0.0f);
       glClearDepth(1.0);                                      // enables clearing of the depth buffer
       glDepthFunc(GL_LESS);                                   // the type of depth test to do
       glEnable(GL_DEPTH_TEST);                         // enables depth testing
       glEnable( GL_TEXTURE_2D );                       // enable texture mapping
       glShadeModel(GL_SMOOTH);                         // enables smooth color shading

       glMatrixMode(GL_PROJECTION);
       glLoadIdentity();                                       // reset the projection matrix

       gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f); // calculate window aspect ratio

       glMatrixMode(GL_MODELVIEW);
}


void DrawGLScene(CWorld * ThisWorld)
{
       glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);            // clear the screen and the depth buffer
       glLoadIdentity();                                                                   // reset the view
       glEnable(GL_TEXTURE_2D);
       
       Vector vDistance, vDistanceReverse, vMidpoint;
       float distance;

       // get distance and midpoint between players
       vDistance = ThisWorld->Player[0]->Position - ThisWorld->Player[1]->Position;
       distance = vDistance.Magnitude();
       vMidpoint = vDistance * ThisWorld->fZoomBias;

       // set translate and zoom for drawing game world
       glPushMatrix();

       switch(ThisWorld->iStartingState)
       {
       case STARTINGSTATE_IDLE: // zoom in a little
              glTranslatef(-(ThisWorld->Player[0]->Position.x - vMidpoint.x),
                     -(ThisWorld->Player[0]->Position.y - vMidpoint.y),
                     -25.0f);
              break;

       case STARTINGSTATE_READY: // zoom in on green tank
              glTranslatef(-ThisWorld->Player[1]->Position.x,-ThisWorld->Player[0]->Position.y, -6.0f);
              break;

       case STARTINGSTATE_SET: // zoom in on brown tank
              glTranslatef(-ThisWorld->Player[0]->Position.x,-ThisWorld->Player[0]->Position.y, -6.0f);
              break;

       case STARTINGSTATE_GO: // normal view applies
              glTranslatef(-(ThisWorld->Player[0]->Position.x - vMidpoint.x),
                     -(ThisWorld->Player[0]->Position.y - vMidpoint.y),
                     -20.0f - (distance * 0.8)); // zoom out as players move away from each other
              break;

       case STARTINGSTATE_RUN: // normal view applies
              glTranslatef(-(ThisWorld->Player[0]->Position.x - vMidpoint.x),
                     -(ThisWorld->Player[0]->Position.y - vMidpoint.y),
                     -20.0f - (distance * 0.8)); // zoom out as players move away from each other
                     ThisWorld->fFinalZoom = -20.0f - (distance * 0.8);
              break;

       case STARTINGSTATE_VICTORY: // zoom in on dead player

              ThisWorld->fFinalZoom *= 0.9997;
              ThisWorld->fZoomBias *= 0.9996;

              if(ThisWorld->Player[1]->iHealth <= 0)
              {
                     vMidpoint.Reverse();

                     glTranslatef(-(ThisWorld->Player[1]->Position.x - vMidpoint.x),
                            -(ThisWorld->Player[1]->Position.y - vMidpoint.y),
                            ThisWorld->fFinalZoom); // zoom out as players move away from each other
              }
              else
              {
                     glTranslatef(-(ThisWorld->Player[0]->Position.x - vMidpoint.x),
                            -(ThisWorld->Player[0]->Position.y - vMidpoint.y),
                            ThisWorld->fFinalZoom); // zoom out as players move away from each other
              }
              break;
       }

       DrawTiles(ThisWorld);
       DrawObjects(ThisWorld);
       ThisWorld->DrawEffects();

       glPopMatrix();

       // set translate and zoom for drawing HUD
       glPushMatrix();

       glScalef(.1,.1,1);
       glTranslatef(-((float) PLAYFIELD_SIZE/2), -((float) PLAYFIELD_SIZE/2), -4.2f);      
       DrawHUD(ThisWorld);

       glPopMatrix();
}


void DrawHUD(CWorld * ThisWorld)
{
       glPushMatrix();
       glTranslatef(0,0,0.2);

       glDisable(GL_TEXTURE_2D);
       
       glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

       glEnable (GL_BLEND);

       // left-side health bar
       glColor4f(0.9,0.3,0.2,0.9);
       DrawBarGraph(PLAYFIELD_SIZE + 0.2, PLAYFIELD_SIZE - 1.0,
                             -5.0, 8.0, ThisWorld->Player[1]->iHealth);

       // right-side health bar
       glColor4f(0.2,0.5,0.9,0.9);
       DrawBarGraph(PLAYFIELD_SIZE + 0.2, PLAYFIELD_SIZE - 1.0, 
                             PLAYFIELD_SIZE + 5.0, PLAYFIELD_SIZE - 8.0, ThisWorld->Player[0]->iHealth);

       // left-side transparent health bar background area
       glBegin(GL_QUADS);
       glColor4f(0.0,0.0,0.0,0.25);
       glVertex2f(-5.0, PLAYFIELD_SIZE + 0.2);
       glVertex2f(8.0, PLAYFIELD_SIZE + 0.2);
       glVertex2f(8.0, PLAYFIELD_SIZE - 1.0);
       glVertex2f(-5.0, PLAYFIELD_SIZE - 1.0);

       // right-side transparent health bar background area
       glVertex2f(PLAYFIELD_SIZE + 5.0, PLAYFIELD_SIZE + 0.2);
       glVertex2f(PLAYFIELD_SIZE - 8.0, PLAYFIELD_SIZE + 0.2);
       glVertex2f(PLAYFIELD_SIZE - 8.0, PLAYFIELD_SIZE - 1.0);
       glVertex2f(PLAYFIELD_SIZE + 5.0, PLAYFIELD_SIZE - 1.0);
       glEnd();
       
       glEnable(GL_TEXTURE_2D);
       glBlendFunc(GL_SRC_ALPHA, GL_ZERO);

       // left-side weapon display card
       switch(ThisWorld->Player[1]->iWeapon)
       {
       case WEAPONID_NULL:
              glBindTexture( GL_TEXTURE_2D, GetTexture(TEXID_TANK));
              break;
       case WEAPONID_PEA_SHOT:
              glBindTexture( GL_TEXTURE_2D, GetTexture(TEXID_POWERUP_PS));
              break;
       case WEAPONID_BOUNCY_SHOT:
              glBindTexture( GL_TEXTURE_2D, GetTexture(TEXID_POWERUP_BS));
              break;
       case WEAPONID_SUPER_BULLET:
              glBindTexture( GL_TEXTURE_2D, GetTexture(TEXID_POWERUP_SB));
              break;
       case WEAPONID_LAND_MINE:
              glBindTexture( GL_TEXTURE_2D, GetTexture(TEXID_POWERUP_LM));
              break;
       case WEAPONID_HEAT_SEEKER:
              glBindTexture( GL_TEXTURE_2D, GetTexture(TEXID_POWERUP_HS));
              break;
       }

       glBegin(GL_QUADS);
       glColor3f(1.0,1.0,1.0);
       glTexCoord2d(0.0, 1.0); glVertex2f(-5.0, PLAYFIELD_SIZE - 1.5);
       glTexCoord2d(1.0, 1.0); glVertex2f(-1.0, PLAYFIELD_SIZE - 1.5);
       glTexCoord2d(1.0, 0.0); glVertex2f(-1.0, PLAYFIELD_SIZE - 5.5);
       glTexCoord2d(0.0, 0.0); glVertex2f(-5.0, PLAYFIELD_SIZE - 5.5);
       glEnd();

       // right-side weapon display card
       switch(ThisWorld->Player[0]->iWeapon)
       {
       case WEAPONID_NULL:
              glBindTexture( GL_TEXTURE_2D, GetTexture(TEXID_TANK));
              break;
       case WEAPONID_PEA_SHOT:
              glBindTexture( GL_TEXTURE_2D, GetTexture(TEXID_POWERUP_PS));
              break;
       case WEAPONID_BOUNCY_SHOT:
              glBindTexture( GL_TEXTURE_2D, GetTexture(TEXID_POWERUP_BS));
              break;
       case WEAPONID_SUPER_BULLET:
              glBindTexture( GL_TEXTURE_2D, GetTexture(TEXID_POWERUP_SB));
              break;
       case WEAPONID_LAND_MINE:
              glBindTexture( GL_TEXTURE_2D, GetTexture(TEXID_POWERUP_LM));
              break;
       case WEAPONID_HEAT_SEEKER:
              glBindTexture( GL_TEXTURE_2D, GetTexture(TEXID_POWERUP_HS));
              break;
       }

       glBegin(GL_QUADS);
       glTexCoord2d(1.0, 1.0); glVertex2f(PLAYFIELD_SIZE + 5.0, PLAYFIELD_SIZE - 1.5);
       glTexCoord2d(0.0, 1.0); glVertex2f(PLAYFIELD_SIZE + 1.0, PLAYFIELD_SIZE - 1.5);
       glTexCoord2d(0.0, 0.0); glVertex2f(PLAYFIELD_SIZE + 1.0, PLAYFIELD_SIZE - 5.5);
       glTexCoord2d(1.0, 0.0); glVertex2f(PLAYFIELD_SIZE + 5.0, PLAYFIELD_SIZE - 5.5);
       glEnd();

       glDisable(GL_TEXTURE_2D);
       glDisable(GL_BLEND);

       // left-side HUD border
       glBegin(GL_QUADS);
       glColor3f(0.0,0.0,0.0);
       glVertex2f(-5.0, PLAYFIELD_SIZE + 0.3); // top
       glVertex2f(8.0, PLAYFIELD_SIZE + 0.3);
       glVertex2f(8.0, PLAYFIELD_SIZE + 0.2);
       glVertex2f(-5.0, PLAYFIELD_SIZE + 0.2);
       glVertex2f(-5.0, PLAYFIELD_SIZE - 1.0); // bottom
       glVertex2f(8.0, PLAYFIELD_SIZE - 1.0);
       glVertex2f(8.0, PLAYFIELD_SIZE - 1.1);
       glVertex2f(-5.0, PLAYFIELD_SIZE - 1.1);
       glVertex2f(-5.1, PLAYFIELD_SIZE + 0.3); // left
       glVertex2f(-5.0, PLAYFIELD_SIZE + 0.3);
       glVertex2f(-5.0, PLAYFIELD_SIZE - 1.1);
       glVertex2f(-5.1, PLAYFIELD_SIZE - 1.1);
       glVertex2f(8.0, PLAYFIELD_SIZE + 0.3); // right
       glVertex2f(8.1, PLAYFIELD_SIZE + 0.3);
       glVertex2f(8.1, PLAYFIELD_SIZE - 1.1);
       glVertex2f(8.0, PLAYFIELD_SIZE - 1.1);

       // right-side HUD border
       glVertex2f(PLAYFIELD_SIZE + 5.0, PLAYFIELD_SIZE + 0.3); // top
       glVertex2f(PLAYFIELD_SIZE - 8.0, PLAYFIELD_SIZE + 0.3);
       glVertex2f(PLAYFIELD_SIZE - 8.0, PLAYFIELD_SIZE + 0.2);
       glVertex2f(PLAYFIELD_SIZE + 5.0, PLAYFIELD_SIZE + 0.2);
       glVertex2f(PLAYFIELD_SIZE + 5.0, PLAYFIELD_SIZE - 1.0); // bottom
       glVertex2f(PLAYFIELD_SIZE - 8.0, PLAYFIELD_SIZE - 1.0);
       glVertex2f(PLAYFIELD_SIZE - 8.0, PLAYFIELD_SIZE - 1.1);
       glVertex2f(PLAYFIELD_SIZE + 5.0, PLAYFIELD_SIZE - 1.1);
       glVertex2f(PLAYFIELD_SIZE + 5.1, PLAYFIELD_SIZE + 0.3); // left
       glVertex2f(PLAYFIELD_SIZE + 5.0, PLAYFIELD_SIZE + 0.3);
       glVertex2f(PLAYFIELD_SIZE + 5.0, PLAYFIELD_SIZE - 1.1);
       glVertex2f(PLAYFIELD_SIZE + 5.1, PLAYFIELD_SIZE - 1.1);
       glVertex2f(PLAYFIELD_SIZE - 8.0, PLAYFIELD_SIZE + 0.3); // right
       glVertex2f(PLAYFIELD_SIZE - 8.1, PLAYFIELD_SIZE + 0.3);
       glVertex2f(PLAYFIELD_SIZE - 8.1, PLAYFIELD_SIZE - 1.1);
       glVertex2f(PLAYFIELD_SIZE - 8.0, PLAYFIELD_SIZE - 1.1);

       // left-side HUD background area
       glColor3f(0.25,0.25,0.25);
       glVertex2f(-5.5, PLAYFIELD_SIZE+1);
       glVertex2f(-0.5, PLAYFIELD_SIZE+1);
       glVertex2f(-0.5, -1.0);
       glVertex2f(-5.5, -1.0);

       // right-side HUD background area
       glVertex2f(PLAYFIELD_SIZE + 5.5, PLAYFIELD_SIZE+1);
       glVertex2f(PLAYFIELD_SIZE + 0.5, PLAYFIELD_SIZE+1);
       glVertex2f(PLAYFIELD_SIZE + 0.5, -1.0);
       glVertex2f(PLAYFIELD_SIZE + 5.5, -1.0);

       // left-side HUD background frame
       glColor3f(0.0,0.0,0.0);
       glVertex2f(-10.0, PLAYFIELD_SIZE+1);
       glVertex2f(-0.4, PLAYFIELD_SIZE+1);
       glVertex2f(-0.4, -1.0);
       glVertex2f(-10.0, -1.0);

       // right-side HUD background frame
       glVertex2f(PLAYFIELD_SIZE + 10.0, PLAYFIELD_SIZE+1);
       glVertex2f(PLAYFIELD_SIZE + 0.4, PLAYFIELD_SIZE+1);
       glVertex2f(PLAYFIELD_SIZE + 0.4, -1.0);
       glVertex2f(PLAYFIELD_SIZE + 10.0, -1.0);
       glEnd();


       glPopMatrix();
}


void DrawTiles(CWorld * ThisWorld)
{
       glDisable(GL_BLEND);

       int iX, iY;
       for(iY = 0; iY < MAP_SIZE; iY++)
       {
              for(iX = 0; iX < MAP_SIZE; iX++)
              {
                     glPushMatrix(); // save matrix state
                     glTranslatef(iX * CELL_SIZE + CELL_SIZE / 2, iY * CELL_SIZE + CELL_SIZE / 2, TILEMAP_DISTANCE);
                     glColor3f(1.0,1.0,1.0);
                     glBindTexture( GL_TEXTURE_2D, textures[ThisWorld->tiles[(iY * MAP_SIZE) + iX].iTexture]);
                     glBegin(GL_QUADS);                        // start drawing a polygon (4 sided)
                     glTexCoord2d(0.0,1.0); glVertex3f(-1.0f, 1.0f, 0.0f);   // Top Left
                     glTexCoord2d(1.0,1.0); glVertex3f( 1.0f, 1.0f, 0.0f);   // Top Right
                     glTexCoord2d(1.0,0.0); glVertex3f( 1.0f,-1.0f, 0.0f);   // Bottom Right
                     glTexCoord2d(0.0,0.0); glVertex3f(-1.0f,-1.0f, 0.0f);   // Bottom Left       
                     glEnd();                                         // done with the polygon
                     glPopMatrix();
              }
       }
}


void DrawObjects(CWorld * ThisWorld)
{
       // draw world objects
       CObject * Current = ThisWorld->Objects;

       glEnable(GL_BLEND);
       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
       
       glAlphaFunc ( GL_GREATER, 0.1 ) ;
    glEnable ( GL_ALPHA_TEST ) ;

       while(Current != NULL)
       {
              if(Current->bVisible)
              {
                     Current->Draw();
              }
              Current = Current->Next; // move down the list
       }
}

void UpdateAnimation(CWorld * ThisWorld)
{
       CObject * Current = ThisWorld->Objects;
       int frames = 0;
       
       while(Current != NULL)
       {
              if(Current->bAnimating) // if the current object has an animation in progress
              {      
                     // if this object has elapsed it's animation speed timeout
                     if(ThisWorld->iCurrentTime > (Current->iAnimTimeStamp + Current->iNormalAnimSpeed))
                     {
                            // if we're on the last frame
                            if(Current->iCurrentFrame == (animations[Current->iNormalAnim]->iTotalFrames - 2))
                            {
                                   // stop animating
                                   if(Current->bAnimCycle == ANIM_CYCLE_ONESHOT)
                                   {
                                          Current->bAnimating = false;
                                          Current->iCurrentFrame = 0;
                                   }
                                   // or just cycle
                                   if(Current->bAnimCycle == ANIM_CYCLE_CYCLE)
                                   {
                                          Current->iCurrentFrame = 0;
                                   }
                            }
                            else // otherwise just advance the frame
                            {
                                   Current->iCurrentFrame ++;
                            }

                            // reset the time stamp
                            Current->iAnimTimeStamp = ThisWorld->iCurrentTime;
                     }
              }
              Current = Current->Next; // move down the list
       }
}


void InitStripeAlpha(void)
{
       stripeAlpha = 1;
}


void DrawStripe(float top, float bottom, float alpha)
{
       if(stripeAlpha > 0)
       {
       glPushMatrix();
       glLoadIdentity();                         // reset the view
       glDisable(GL_TEXTURE_2D);
       glEnable(GL_BLEND);
       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
       glColor4f(1, 1, 1, stripeAlpha);
       glTranslatef(0,0,-3.0f);
       glBegin(GL_QUADS);                        // start drawing a polygon (4 sided)
       glVertex3f(-10, bottom, 0.0f);     // Top Left
       glVertex3f( 10, bottom, 0.0f);     // Top Right
       glVertex3f( 10, top, 0.0f);        // Bottom Right
       glVertex3f(-10, top, 0.0f);        // Bottom Left       
       glEnd();                                         // done with the polygon
       glPopMatrix();
       stripeAlpha-=.002;
       }
}


void DrawBarGraph(float top, float bottom, float left, float right, float fillPercent)
{
       float diff, fillTo;

       diff = right - left;
       
       fillTo = (diff / 100) * fillPercent;

       glBegin(GL_QUADS);
       glVertex2f(left, top);
       glVertex2f(left + fillTo, top);
       glVertex2f(left + fillTo, bottom);
       glVertex2f(left, bottom);
       glEnd();
}

void InitTextures()
{
       textures[TEXID_DIRT] = LoadTextureTGA("tex\\tile_dirt.tga", 1);
       textures[TEXID_GRASS] = LoadTextureTGA("tex\\tile_grass.tga", 1);
       textures[TEXID_SAND] = LoadTextureTGA("tex\\tile_sand.tga", 1);
       textures[TEXID_MUD] = LoadTextureTGA("tex\\tile_mud.tga", 1);
       textures[TEXID_WATER] = LoadTextureTGA("tex\\tile_water.tga", 1);
       textures[TEXID_LAVA] = LoadTextureTGA("tex\\tile_lava.tga", 1);
       textures[TEXID_ICE] = LoadTextureTGA("tex\\tile_ice.tga", 1);
       textures[TEXID_TARMAC] = LoadTextureTGA("tex\\tile_tarmac.tga", 1);


       textures[TEXID_TANK] = LoadTextureTGA("tex\\tank01.tga", 1);
       textures[TEXID_PEA_SHOT] = LoadTextureTGA("tex\\pea_shot.tga", 1);
       textures[TEXID_BOUNCY_SHOT] = LoadTextureTGA("tex\\bouncy_shot.tga", 1);
       textures[TEXID_SUPER_BULLET] = LoadTextureTGA("tex\\super_bullet.tga", 1);
       textures[TEXID_LAND_MINE] = LoadTextureTGA("tex\\land_mine.tga", 1);
       textures[TEXID_HEAT_SEEKER] = LoadTextureTGA("tex\\heat_seeker.tga", 1);
       textures[TEXID_POWERUP_HEALTH] = LoadTextureTGA("tex\\health_crate.tga", 1);
       textures[TEXID_POWERUP_PS] = LoadTextureTGA("tex\\PS_crate.tga", 1);
       textures[TEXID_POWERUP_BS] = LoadTextureTGA("tex\\BS_crate.tga", 1);
       textures[TEXID_POWERUP_SB] = LoadTextureTGA("tex\\SB_crate.tga", 1);
       textures[TEXID_POWERUP_LM] = LoadTextureTGA("tex\\LM_crate.tga", 1);
       textures[TEXID_POWERUP_HS] = LoadTextureTGA("tex\\HS_crate.tga", 1);
       textures[TEXID_TNT_BLOCK] = LoadTextureTGA("tex\\TNT_crate.tga", 1);
       textures[TEXID_WALL_BLOCK] = LoadTextureTGA("tex\\wallblock.tga", 1);
       textures[TEXID_CRATE] = LoadTextureTGA("tex\\crate.tga", 1);
       textures[TEXID_MENUBACK] = LoadTextureTGA("tex\\menuback.tga", 1);
       textures[TEXID_EZRAS_HEAD] = LoadTextureTGA("tex\\ezras_head.tga", 1);
       
       animations[ANIMID_TANKROLL] = new CAnimation(1.0, 3, true);
       animations[ANIMID_TANKROLL]->ipFrameTex[0] = LoadTextureTGA("tex\\tank01.tga", 1);
       animations[ANIMID_TANKROLL]->ipFrameTex[1] = LoadTextureTGA("tex\\tank02.tga", 1);
       animations[ANIMID_TANKROLL]->ipFrameTex[2] = LoadTextureTGA("tex\\tank03.tga", 1);

       animations[ANIMID_GREENTANKEXPLODE] = new CAnimation(1.0, 4, true);
       animations[ANIMID_GREENTANKEXPLODE]->ipFrameTex[0] = LoadTextureTGA("tex\\g_tankexplode01.tga", 1);
       animations[ANIMID_GREENTANKEXPLODE]->ipFrameTex[1] = LoadTextureTGA("tex\\g_tankexplode02.tga", 1);
       animations[ANIMID_GREENTANKEXPLODE]->ipFrameTex[2] = LoadTextureTGA("tex\\g_tankexplode03.tga", 1);
       animations[ANIMID_GREENTANKEXPLODE]->ipFrameTex[3] = LoadTextureTGA("tex\\g_tankexplode04.tga", 1);

       animations[ANIMID_BROWNTANKEXPLODE] = new CAnimation(1.0, 4, true);
       animations[ANIMID_BROWNTANKEXPLODE]->ipFrameTex[0] = LoadTextureTGA("tex\\b_tankexplode01.tga", 1);
       animations[ANIMID_BROWNTANKEXPLODE]->ipFrameTex[1] = LoadTextureTGA("tex\\b_tankexplode02.tga", 1);
       animations[ANIMID_BROWNTANKEXPLODE]->ipFrameTex[2] = LoadTextureTGA("tex\\b_tankexplode03.tga", 1);
       animations[ANIMID_BROWNTANKEXPLODE]->ipFrameTex[3] = LoadTextureTGA("tex\\b_tankexplode04.tga", 1);

       animations[ANIMID_CRATECRUSH] = new CAnimation(0.7, 3, true);
       animations[ANIMID_CRATECRUSH]->ipFrameTex[0] = LoadTextureTGA("tex\\cratecrush01.tga", 1);
       animations[ANIMID_CRATECRUSH]->ipFrameTex[1] = LoadTextureTGA("tex\\cratecrush02.tga", 1);
       animations[ANIMID_CRATECRUSH]->ipFrameTex[2] = LoadTextureTGA("tex\\cratecrush03.tga", 1);

       animations[ANIMID_EXPLOSION] = new CAnimation(1.0, 3, true);
       animations[ANIMID_EXPLOSION]->ipFrameTex[0] = LoadTextureTGA("tex\\explosion01.tga", 1);
       animations[ANIMID_EXPLOSION]->ipFrameTex[1] = LoadTextureTGA("tex\\explosion02.tga", 1);
       animations[ANIMID_EXPLOSION]->ipFrameTex[2] = LoadTextureTGA("tex\\explosion03.tga", 1);

       animations[ANIMID_GREEN_HOP_IN] = new CAnimation(0.45, 24, false);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[0] = LoadTextureTGA("tex\\g_hopin01.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[1] = LoadTextureTGA("tex\\g_hopin02.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[2] = LoadTextureTGA("tex\\g_hopin03.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[3] = LoadTextureTGA("tex\\g_hopin04.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[4] = LoadTextureTGA("tex\\g_hopin05.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[5] = LoadTextureTGA("tex\\g_hopin06.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[6] = LoadTextureTGA("tex\\g_hopin07.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[7] = LoadTextureTGA("tex\\g_hopin08.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[8] = LoadTextureTGA("tex\\g_hopin09.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[9] = LoadTextureTGA("tex\\g_hopin10.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[10] = LoadTextureTGA("tex\\g_hopin11.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[11] = LoadTextureTGA("tex\\g_hopin12.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[12] = LoadTextureTGA("tex\\g_hopin13.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[13] = LoadTextureTGA("tex\\g_hopin14.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[14] = LoadTextureTGA("tex\\g_hopin15.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[15] = LoadTextureTGA("tex\\g_hopin16.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[16] = LoadTextureTGA("tex\\g_hopin17.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[17] = LoadTextureTGA("tex\\g_hopin18.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[18] = LoadTextureTGA("tex\\g_hopin19.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[19] = LoadTextureTGA("tex\\g_hopin20.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[20] = LoadTextureTGA("tex\\g_hopin21.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[21] = LoadTextureTGA("tex\\g_hopin22.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[22] = LoadTextureTGA("tex\\g_hopin23.tga", 1);
       animations[ANIMID_GREEN_HOP_IN]->ipFrameTex[23] = LoadTextureTGA("tex\\g_hopin24.tga", 1);

       animations[ANIMID_BROWN_HOP_IN] = new CAnimation(0.45, 24, false);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[0] = LoadTextureTGA("tex\\b_hopin01.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[1] = LoadTextureTGA("tex\\b_hopin02.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[2] = LoadTextureTGA("tex\\b_hopin03.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[3] = LoadTextureTGA("tex\\b_hopin04.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[4] = LoadTextureTGA("tex\\b_hopin05.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[5] = LoadTextureTGA("tex\\b_hopin06.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[6] = LoadTextureTGA("tex\\b_hopin07.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[7] = LoadTextureTGA("tex\\b_hopin08.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[8] = LoadTextureTGA("tex\\b_hopin09.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[9] = LoadTextureTGA("tex\\b_hopin10.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[10] = LoadTextureTGA("tex\\b_hopin11.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[11] = LoadTextureTGA("tex\\b_hopin12.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[12] = LoadTextureTGA("tex\\b_hopin13.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[13] = LoadTextureTGA("tex\\b_hopin14.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[14] = LoadTextureTGA("tex\\b_hopin15.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[15] = LoadTextureTGA("tex\\b_hopin16.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[16] = LoadTextureTGA("tex\\b_hopin17.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[17] = LoadTextureTGA("tex\\b_hopin18.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[18] = LoadTextureTGA("tex\\b_hopin19.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[19] = LoadTextureTGA("tex\\b_hopin20.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[20] = LoadTextureTGA("tex\\b_hopin21.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[21] = LoadTextureTGA("tex\\b_hopin22.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[22] = LoadTextureTGA("tex\\b_hopin23.tga", 1);
       animations[ANIMID_BROWN_HOP_IN]->ipFrameTex[23] = LoadTextureTGA("tex\\b_hopin24.tga", 1);

}


GLuint GetTexture(int texID)
{
       return textures[texID];
}

GLuint GetFrame(int animID, int frame)
{
       return animations[animID]->ipFrameTex[frame];
}

int GetTotalFrames(int animID)
{
       return animations[animID]->iTotalFrames;
}

CAnimation * GetAnimation(int animID)
{
       return animations[animID];
}

GLuint LoadTextureRAW( const char * filename, int wrap )
{
    GLuint texture;
    int width, height;
    BYTE * data;
    FILE * file;

    // open texture data
    fopen_s(&file, filename, "rb" );
    if ( file == NULL ) return 0;

    // allocate buffer
    width = 256;
    height = 256;
    data = (BYTE *) malloc( width * height * 3 );

    // read texture data
    fread( data, width * height * 3, 1, file );
    fclose( file );

    // allocate a texture name
    glGenTextures( 1, &texture );

    // select our current texture
    glBindTexture( GL_TEXTURE_2D, texture );

    // select modulate to mix texture with color for shading
    glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );

    // when texture area is small, bilinear filter the closest mipmap
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    // when texture area is large, bilinear filter the first mipmap
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );

    // if wrap is true, the texture wraps over at the edges (repeat)
    //       ... false, the texture ends at the edges (clamp)
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
                     wrap ? GL_REPEAT : GL_CLAMP );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
                     wrap ? GL_REPEAT : GL_CLAMP );

    // build our texture mipmaps
    gluBuild2DMipmaps( GL_TEXTURE_2D, 3, width, height,
                       GL_RGB, GL_UNSIGNED_BYTE, data );

    // free buffer
    free( data );

    return texture;
}


GLenum texFormat;

int checkSize (int x) // make sure its a power of 2
{
    if (x == 2        || x == 4 || 
        x == 8        || x == 16 || 
        x == 32  || x == 64 ||
        x == 128 || x == 256 || x == 512)
        return 1;
    else return 0;
}

unsigned char *getRGBA (FILE *s, int size) // reads in RGBA data for a 32bit image
{
    unsigned char *rgba;
    unsigned char temp;
    int bread;
    int i;

    rgba = (unsigned char *) malloc (size * 4); 

    if (rgba == NULL)
        return 0;

    bread = (int) fread (rgba, sizeof (unsigned char), size * 4, s); 

    /* TGA is stored in BGRA, make it RGBA */
    if (bread != size * 4)
    {
        free (rgba);
        return 0;
    }

    for (i = 0; i < size * 4; i += 4 )
    {
        temp = rgba[i];
        rgba[i] = rgba[i + 2];
        rgba[i + 2] = temp;
    }

    texFormat = GL_RGBA;
    return rgba;
}

unsigned char *getRGB (FILE *s, int size) // reads in RGB data for a 24bit image
{
    unsigned char *rgb;
    unsigned char temp;
    int bread;
    int i;

    rgb = (unsigned char *) malloc (size * 3); 

    if (rgb == NULL)
        return 0;

    bread = (int) fread (rgb, sizeof (unsigned char), size * 3, s);

    if (bread != size * 3)
    {
        free (rgb);
        return 0;
    }

    /* TGA is stored in BGR, make it RGB */
    for (i = 0; i < size * 3; i += 3)
    {
        temp = rgb[i];
        rgb[i] = rgb[i + 2];
        rgb[i + 2] = temp;
    }

    texFormat = GL_RGB;

    return rgb;
}

unsigned char *getGray (FILE *s, int size) // gets the grayscale image data used as an alpha channel
{
    unsigned char *grayData;
    int bread;

    grayData = (unsigned char *) malloc (size);

    if (grayData == NULL)
        return 0;

    bread = (int) fread (grayData, sizeof (unsigned char), size, s);

    if (bread != size)
    {
        free (grayData);
        return 0;
    }

    texFormat = GL_ALPHA;

    return grayData;
}

char *getData (FILE *s, int sz, int iBits) // gets the image data for the specified bit depth
{
    if (iBits == 32)
        return (char *) getRGBA (s, sz);
    else if (iBits == 24)
        return (char *) getRGB (s, sz);   
    else if (iBits == 8)
        return (char *) getGray (s, sz);
       return 0;
}

int returnError (FILE *s, int error) // called when there is an error loading the .tga file
{
    fclose (s);
    return error;
}

GLuint LoadTextureTGA (const char *filename, int wrap)
{
    unsigned char type[4];
    unsigned char info[7];
    unsigned char *imageData = NULL;
    int imageWidth, imageHeight;
    int imageBits, size;
    FILE *s;
       GLuint texture = NULL;

    if ((fopen_s(&s, filename, "r+bt")))
        return TGA_FILE_NOT_FOUND;

    fread (&type, sizeof (char), 3, s); // read in colormap info and image type, byte 0 ignored
    fseek (s, 12, SEEK_SET);                     // seek past the header and useless info
    fread (&info, sizeof (char), 6, s);

    if (type[1] != 0 || (type[2] != 2 && type[2] != 3))
        returnError (s, TGA_BAD_IMAGE_TYPE);

    imageWidth = info[0] + info[1] * 256; 
    imageHeight = info[2] + info[3] * 256;
    imageBits =      info[4]; 

    size = imageWidth * imageHeight; 

    /* make sure dimension is a power of 2 */
    if (!checkSize (imageWidth) || !checkSize (imageHeight))
        returnError (s, TGA_BAD_DIMENSION);

    /* make sure we are loading a supported type */
    if (imageBits != 32 && imageBits != 24 && imageBits != 8)
        returnError (s, TGA_BAD_BITS);

    imageData = (unsigned char *) getData (s, size, imageBits);

    /* no image data */
    if (imageData == NULL)
        returnError (s, TGA_BAD_DATA);

    fclose (s);

       glGenTextures( 1, &texture );
       glBindTexture( GL_TEXTURE_2D, texture );

    glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap ? GL_REPEAT : GL_CLAMP );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap ? GL_REPEAT : GL_CLAMP );
    gluBuild2DMipmaps( GL_TEXTURE_2D, 4, imageWidth, imageHeight, GL_RGBA, GL_UNSIGNED_BYTE, imageData );

       free(imageData);

       return texture;
}

void DrawCircle(float radius)
{
       glBegin(GL_LINE_LOOP);
       for (int i=0; i < 360; i+=20)
       {
              float degInRad = DegreesToRadians(i);
              glVertex2f(cos(degInRad)*radius,sin(degInRad)*radius);
       }
       glEnd();
}

void DrawDisc(float radius)
{
       glBegin(GL_POLYGON);
       for (int i=0; i < 360; i+=20)
       {
              float degInRad = DegreesToRadians(i);
              glVertex2f(cos(degInRad)*radius,sin(degInRad)*radius);
       }
       glEnd();
}

void DrawStar(float radius)
{
       float degInRad;

       glBegin(GL_LINES);
       for (int i=0; i < 360; i+=20)
       {
              degInRad = DegreesToRadians(i);
              glVertex2f(cos(degInRad)*radius,sin(degInRad)*radius);
              glVertex2f(cos(degInRad + 0.1)*(radius*1.1),sin(degInRad+ 0.1)*(radius*1.1));
       }
       glEnd();
}

 

Copyright Windsor Schmidt 2006 - All rights reserved.