---

general.cpp

Go to the documentation of this file.

#include <windows.h>
#include "shared.h"
#include "polygon.h"
#include "camera.h"
#include "texture.h"
#include "light.h"
#include "locmath.h"
#include "bspline.h"
#include "glFont.h"
#include "tll.h"
#include "mmgr.h"

extern int numCameras;
extern int cameraMode;
extern int currentCamera;
extern int numLights;
extern int currentLight;
extern int fps;
extern float multiplier;
extern GLFONT myFont;
extern char HaloTypeName[MAX_PATH];
extern char FireTypeName[MAX_PATH];
extern int numSplines;
extern int lookAtPath;
extern int currentSpline;
extern SPLINE* spline;
extern char SplineFileName[MAX_PATH];

void AddSpline(int Number, LinkedList<SPLINE>& SplineList)
{
    SPLINE* spline2 = new SPLINE;
    spline2->Active = 1;
    spline2->Repeat = 1;
    spline2->Degree = 3;
    spline2->NumControl = 7;
    spline2->NumPoints = 100;
    spline2->Control = new VECTOR[100];
    spline2->Output = new VECTOR[1000];
    spline2->StartTime = 5000;
    spline2->EndTime = 25000;
    spline2->CopyOfStartTime = spline2->StartTime;
    spline2->CopyOfEndTime = spline2->EndTime;

    spline2->Red = ((float)(rand()%226) + 30.0) / 255;
    spline2->Green = ((float)(rand()%226) + 30.0) / 255;
    spline2->Blue = ((float)(rand()%226) + 30.0) / 255;

    for (int loop = 0; loop < 100; loop++)
    {
        spline2->Control[loop].x = rand()%60 - 29;  spline2->Control[loop].y = rand()%60 - 29;  spline2->Control[loop].z = rand()%60 - 29;
    }

    spline2->linkPosition = Number;   //Set the link position of the spline
    SplineList.Insert(spline2);       //Insert spline in linked list
}

void DeleteSpline(int Number, LinkedList<SPLINE>& SplineList)
{
    SPLINE* temp = SplineList.Get(Number);
    delete[] temp->Control;
    delete[] temp->Output;
    SplineList.Delete(Number);
    delete temp;
}

int LoadSplines(char* SplineFileName, LinkedList<SPLINE>& SplineList)
{
    const int stringLength = 33;
    char tempString[stringLength];
    FILE* SplineFile;
    SplineFile = fopen(SplineFileName, "rt");
    if (!SplineFile)
    {
        MessageBox(NULL, "Spline File didn't open", "Error", MB_OK | MB_ICONERROR);
        return 0;
    }
    fseek(SplineFile, 0, SEEK_SET);
    int InitialNumSplines = numSplines;
    if (!fgets(tempString, stringLength, SplineFile))
    {
        MessageBox(NULL, "Error reading from the spline data file", "Error", MB_OK | MB_ICONERROR);
        numSplines = InitialNumSplines;
        return FALSE;
    }
    numSplines = atoi(tempString);
    if (InitialNumSplines > numSplines)
    {
        for (int loop = InitialNumSplines - 1; loop >= numSplines; loop--)
        {
            DeleteSpline(loop, SplineList);
        }
    }
    if (numSplines > InitialNumSplines)
    {
        for (int loop = InitialNumSplines; loop < numSplines; loop++)
        {
            AddSpline(loop, SplineList);
        }
    }
    for (int loop = 0; loop < numSplines; loop++)
    {
        spline = SplineList.Get(loop);
        // Active flag
        fgets(tempString, stringLength, SplineFile);
        spline->Active = atoi(tempString);
        // Repeat flag
        fgets(tempString, stringLength, SplineFile);
        spline->Repeat = atoi(tempString);
        // Degree
        fgets(tempString, stringLength, SplineFile);
        spline->Degree = atoi(tempString);
        // NumControl
        fgets(tempString, stringLength, SplineFile);
        spline->NumControl = atoi(tempString);
        // NumPoints
        fgets(tempString, stringLength, SplineFile);
        spline->NumPoints = atoi(tempString);
        // StartTime
        fgets(tempString, stringLength, SplineFile);
        spline->StartTime = atof(tempString);
        // EndTime
        fgets(tempString, stringLength, SplineFile);
        spline->EndTime = atof(tempString);
        // Red
        fgets(tempString, stringLength, SplineFile);
        spline->Red = atof(tempString);
        // Green
        fgets(tempString, stringLength, SplineFile);
        spline->Green = atof(tempString);
        // Blue
        fgets(tempString, stringLength, SplineFile);
        spline->Blue = atof(tempString);

        for (int loop2 = 0; loop2 <= spline->NumControl; loop2++)
        {
            fgets(tempString, stringLength, SplineFile);
            spline->Control[loop2].x = atof(tempString);
            fgets(tempString, stringLength, SplineFile);
            spline->Control[loop2].y = atof(tempString);
            fgets(tempString, stringLength, SplineFile);
            spline->Control[loop2].z = atof(tempString);
        }
        spline->CopyOfStartTime = spline->StartTime;
        spline->CopyOfEndTime = spline->EndTime;
    }

    currentSpline = numSplines - 1;
    if (lookAtPath >= numSplines)
        lookAtPath = numSplines - 1;
    if (fclose(SplineFile))
        MessageBox(NULL, "File didn't close", "Error", MB_OK | MB_ICONERROR);
    return 1;
}

void SetSplines(LinkedList<SPLINE>& SplineList)
{
    // Seed random number generator
    srand((unsigned)time(NULL));
    
    //Create a new spline
    for (int loop = 0; loop < numSplines; loop++)
    {
        AddSpline(loop, SplineList);
    }
    //Load splines from data file
    LoadSplines(SplineFileName, SplineList);
}

void SetGLLighting(LIGHT* light)         // Loop through and reset all the lights
{
    int temp;
    for (temp = 0; temp <= numLights; temp++)
    {
        light[temp].LightNumber = temp;
        light[temp].Reset();
    }
    glEnable(GL_LIGHTING);
}

void SetGLCamera(CAMERA* camera)          // Loop through and reset all the cameras
{
    int temp;
    for(temp = 0; temp <= numCameras; temp++)
        camera[temp].Reset();
}

void SetGLWorld(POLYGON* polygon)            // Initialize the world data 
{
//Front
    polygon[0].Vertex[0].x = -1.0;
    polygon[0].Vertex[0].y = -1.0;
    polygon[0].Vertex[0].z = -4.0;
    polygon[0].Vertex[1].x = 1.0;
    polygon[0].Vertex[1].y = -1.0;
    polygon[0].Vertex[1].z = -4.0;
    polygon[0].Vertex[2].x = 1.0;
    polygon[0].Vertex[2].y = 1.0;
    polygon[0].Vertex[2].z = -4.0;

    polygon[1].Vertex[0].x = -1.0;
    polygon[1].Vertex[0].y = -1.0;
    polygon[1].Vertex[0].z = -4.0;
    polygon[1].Vertex[1].x = 1.0;
    polygon[1].Vertex[1].y = 1.0;
    polygon[1].Vertex[1].z = -4.0;
    polygon[1].Vertex[2].x = -1.0;
    polygon[1].Vertex[2].y = 1.0;
    polygon[1].Vertex[2].z = -4.0;
//Back
    polygon[2].Vertex[0].x = 1.0;
    polygon[2].Vertex[0].y = -1.0;
    polygon[2].Vertex[0].z = -6.0;
    polygon[2].Vertex[1].x = -1.0;
    polygon[2].Vertex[1].y = -1.0;
    polygon[2].Vertex[1].z = -6.0;
    polygon[2].Vertex[2].x = -1.0;
    polygon[2].Vertex[2].y = 1.0;
    polygon[2].Vertex[2].z = -6.0;

    polygon[3].Vertex[0].x = 1.0;
    polygon[3].Vertex[0].y = -1.0;
    polygon[3].Vertex[0].z = -6.0;
    polygon[3].Vertex[1].x = -1.0;
    polygon[3].Vertex[1].y = 1.0;
    polygon[3].Vertex[1].z = -6.0;
    polygon[3].Vertex[2].x = 1.0;
    polygon[3].Vertex[2].y = 1.0;
    polygon[3].Vertex[2].z = -6.0;
//Left
    polygon[4].Vertex[0].x = -1.0;
    polygon[4].Vertex[0].y = -1.0;
    polygon[4].Vertex[0].z = -6.0;
    polygon[4].Vertex[1].x = -1.0;
    polygon[4].Vertex[1].y = -1.0;
    polygon[4].Vertex[1].z = -4.0;
    polygon[4].Vertex[2].x = -1.0;
    polygon[4].Vertex[2].y = 1.0;
    polygon[4].Vertex[2].z = -4.0;

    polygon[5].Vertex[0].x = -1.0;
    polygon[5].Vertex[0].y = -1.0;
    polygon[5].Vertex[0].z = -6.0;
    polygon[5].Vertex[1].x = -1.0;
    polygon[5].Vertex[1].y = 1.0;
    polygon[5].Vertex[1].z = -4.0;
    polygon[5].Vertex[2].x = -1.0;
    polygon[5].Vertex[2].y = 1.0;
    polygon[5].Vertex[2].z = -6.0;
//Right
    polygon[6].Vertex[0].x = 1.0;
    polygon[6].Vertex[0].y = -1.0;
    polygon[6].Vertex[0].z = -4.0;
    polygon[6].Vertex[1].x = 1.0;
    polygon[6].Vertex[1].y = -1.0;
    polygon[6].Vertex[1].z = -6.0;
    polygon[6].Vertex[2].x = 1.0;
    polygon[6].Vertex[2].y = 1.0;
    polygon[6].Vertex[2].z = -6.0;

    polygon[7].Vertex[0].x = 1.0;
    polygon[7].Vertex[0].y = -1.0;
    polygon[7].Vertex[0].z = -4.0;
    polygon[7].Vertex[1].x = 1.0;
    polygon[7].Vertex[1].y = 1.0;
    polygon[7].Vertex[1].z = -6.0;
    polygon[7].Vertex[2].x = 1.0;
    polygon[7].Vertex[2].y = 1.0;
    polygon[7].Vertex[2].z = -4.0;
//Top
    polygon[8].Vertex[0].x = 1.0;
    polygon[8].Vertex[0].y = 1.0;
    polygon[8].Vertex[0].z = -4.0;
    polygon[8].Vertex[1].x = 1.0;
    polygon[8].Vertex[1].y = 1.0;
    polygon[8].Vertex[1].z = -6.0;
    polygon[8].Vertex[2].x = -1.0;
    polygon[8].Vertex[2].y = 1.0;
    polygon[8].Vertex[2].z = -6.0;

    polygon[9].Vertex[0].x = 1.0;
    polygon[9].Vertex[0].y = 1.0;
    polygon[9].Vertex[0].z = -4.0;
    polygon[9].Vertex[1].x = -1.0;
    polygon[9].Vertex[1].y = 1.0;
    polygon[9].Vertex[1].z = -6.0;
    polygon[9].Vertex[2].x = -1.0;
    polygon[9].Vertex[2].y = 1.0;
    polygon[9].Vertex[2].z = -4.0;
//Bottom
    polygon[10].Vertex[0].x = -1.0;
    polygon[10].Vertex[0].y = -1.0;
    polygon[10].Vertex[0].z = -4.0;
    polygon[10].Vertex[1].x = -1.0;
    polygon[10].Vertex[1].y = -1.0;
    polygon[10].Vertex[1].z = -6.0;
    polygon[10].Vertex[2].x = 1.0;
    polygon[10].Vertex[2].y = -1.0;
    polygon[10].Vertex[2].z = -6.0;

    polygon[11].Vertex[0].x = -1.0;
    polygon[11].Vertex[0].y = -1.0;
    polygon[11].Vertex[0].z = -4.0;
    polygon[11].Vertex[1].x = 1.0;
    polygon[11].Vertex[1].y = -1.0;
    polygon[11].Vertex[1].z = -6.0;
    polygon[11].Vertex[2].x = 1.0;
    polygon[11].Vertex[2].y = -1.0;
    polygon[11].Vertex[2].z = -4.0;

    polygon[0].SetNormal();
    polygon[1].SetNormal();
    polygon[2].SetNormal();
    polygon[3].SetNormal();
    polygon[4].SetNormal();
    polygon[5].SetNormal();
    polygon[6].SetNormal();
    polygon[7].SetNormal();
    polygon[8].SetNormal();
    polygon[9].SetNormal();
    polygon[10].SetNormal();
    polygon[11].SetNormal();
}

void SetGLProperties()
{
    glCullFace(GL_BACK);
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClearDepth(1.0);
    glDepthFunc(GL_LESS);
    glEnable(GL_DEPTH_TEST);
    glShadeModel(GL_SMOOTH);
    glEnable(GL_NORMALIZE);
    glEnable(GL_CULL_FACE);
}

void SetGLProjection(int Width, int Height)
{
    if (Height==0)
        Height=1;
    glViewport(0, 0, Width, Height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0,(float)Width/(float)Height,0.5,200.0);
}

void SetGLView(int Width, int Height)
{
    SetGLProjection(Width, Height);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void SetGLMaterial()
{
    float mat_ambient[] = { 1.0, 1.0, 1.0, 1.0 };
    float mat_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
    float mat_specular[] = { 0.9, 0.9, 0.9, 1.0 };
    float mat_emission[] = { 0.0, 0.0, 0.0, 1.0 };
    float mat_shininess[] = { 80.0 };

    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
    glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
    glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
}

int SetGLTexture(TEXTURE* texture)
{
    glEnable(GL_TEXTURE_2D);
    sprintf(texture[0].TexName, "%s", "tile.tga");
    if (!texture[0].LoadTGA())
    {
        MessageBox(NULL,"Failed to load tile.tga","Error",MB_OK|MB_ICONERROR);
        return FALSE;
    }
    sprintf(texture[1].TexName, "%s", HaloTypeName);
    if (!texture[1].LoadTGA())
    {
        MessageBox(NULL,"Failed to load halo image","Error",MB_OK|MB_ICONERROR);
        return FALSE;
    }
    sprintf(texture[2].TexName, "%s", FireTypeName);
    if (!texture[2].LoadTGA())
    {
        MessageBox(NULL,"Failed to load fire image","Error",MB_OK|MB_ICONERROR);
        return FALSE;
    }
    return TRUE;
}

void DrawMyText()
{
    glBlendFunc(GL_ONE,  GL_ONE_MINUS_SRC_ALPHA) ;
    glDisable(GL_LIGHTING);
    glColor3f(0.0, 1.0, 0.0);
    glEnable(GL_BLEND);
    glDisable(GL_DEPTH_TEST);
    glPushMatrix();
    glLoadIdentity();
    glFontBegin(&myFont);
    char text[256];
    char text2[256];

    glFontTextOut("Tutorial #10", -37, 27, -70);

    sprintf(text, "FPS = %d", fps);
    glFontTextOut(text, -52, 34, -100);

    sprintf(text, "%s", "Current spline = ");
    strcat(text, itoa(currentSpline + 1, text2, 10));
    glFontTextOut(text, -52, 20, -100);
    sprintf(text, "%s", "Target spline = ");
    strcat(text, itoa(lookAtPath + 1, text2, 10));
    glFontTextOut(text, -52, 18, -100);
    sprintf(text, "%s", "Camera mode = ");
    switch (cameraMode)
    {
    case 0:
    {
         strcat(text, "Free");
        }
    break;

    case 1:
    {
         strcat(text, "Look");
        }
    break;
    
    case 2:
    {
         strcat(text, "Follow");
        }
    break;
    } 
    glFontTextOut(text, -52, 16, -100);
    sprintf(text, "Press M to change camera mode");
    glFontTextOut(text, -52, 14, -100);

    glFontEnd();
    glPopMatrix();
    glEnable(GL_DEPTH_TEST);
    glDisable(GL_BLEND);
    glEnable(GL_LIGHTING);
}

void DrawGrid()
{
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_LIGHTING);
    glPushMatrix();
    glTranslatef(0,-2.0,0);
    float Line = -10;
    int Grid;
    glBegin(GL_LINES);
    for(Grid = 0; Grid <= 20; Grid += 1)
    {
        glColor3f(0.0f,1.0f,0.0f);
        glVertex3f(Line + Grid, 0, -10);
        glVertex3f(Line + Grid, 0, 10);
        glVertex3f(-10, 0, Line + Grid);
        glVertex3f(10, 0, Line + Grid);
    }
    glEnd();
    glPopMatrix();
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_LIGHTING);
}

void DrawCube(POLYGON* polygon, TEXTURE* texture)
{
        float mat_ambient[] = { 0.8, 0.8, 0.8, 1.0 };
        float mat_diffuse[] = { 0.8, 0.8, 0.8, 1.0 };
        glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
        glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);

        glBindTexture(GL_TEXTURE_2D, texture[0].TexID);

        glPushMatrix();
    glBegin(GL_TRIANGLES);
        // Front Face
            glNormal3fv(&polygon[0].Vertex[0].nx);
        glTexCoord2f(0.0f, 0.0f); glVertex3fv(&polygon[0].Vertex[0].x);
        glTexCoord2f(1.0f, 0.0f); glVertex3fv(&polygon[0].Vertex[1].x);
        glTexCoord2f(1.0f, 1.0f); glVertex3fv(&polygon[0].Vertex[2].x);

        glTexCoord2f(0.0f, 0.0f); glVertex3fv(&polygon[1].Vertex[0].x);
        glTexCoord2f(1.0f, 1.0f); glVertex3fv(&polygon[1].Vertex[1].x);
        glTexCoord2f(0.0f, 1.0f); glVertex3fv(&polygon[1].Vertex[2].x);
        // Back Face
            glNormal3fv(&polygon[2].Vertex[0].nx);
        glTexCoord2f(0.0f, 0.0f); glVertex3fv(&polygon[2].Vertex[0].x);
        glTexCoord2f(1.0f, 0.0f); glVertex3fv(&polygon[2].Vertex[1].x);
        glTexCoord2f(1.0f, 1.0f); glVertex3fv(&polygon[2].Vertex[2].x);

        glTexCoord2f(0.0f, 0.0f); glVertex3fv(&polygon[3].Vertex[0].x);
        glTexCoord2f(1.0f, 1.0f); glVertex3fv(&polygon[3].Vertex[1].x);
        glTexCoord2f(0.0f, 1.0f); glVertex3fv(&polygon[3].Vertex[2].x);
        // Top Face
            glNormal3fv(&polygon[4].Vertex[0].nx);
        glTexCoord2f(0.0f, 0.0f); glVertex3fv(&polygon[4].Vertex[0].x);
        glTexCoord2f(1.0f, 0.0f); glVertex3fv(&polygon[4].Vertex[1].x);
        glTexCoord2f(1.0f, 1.0f); glVertex3fv(&polygon[4].Vertex[2].x);

        glTexCoord2f(0.0f, 0.0f); glVertex3fv(&polygon[5].Vertex[0].x);
        glTexCoord2f(1.0f, 1.0f); glVertex3fv(&polygon[5].Vertex[1].x);
        glTexCoord2f(0.0f, 1.0f); glVertex3fv(&polygon[5].Vertex[2].x);
        // Bottom Face
            glNormal3fv(&polygon[6].Vertex[0].nx);
        glTexCoord2f(0.0f, 0.0f); glVertex3fv(&polygon[6].Vertex[0].x);
        glTexCoord2f(1.0f, 0.0f); glVertex3fv(&polygon[6].Vertex[1].x);
        glTexCoord2f(1.0f, 1.0f); glVertex3fv(&polygon[6].Vertex[2].x);

        glTexCoord2f(0.0f, 0.0f); glVertex3fv(&polygon[7].Vertex[0].x);
        glTexCoord2f(1.0f, 1.0f); glVertex3fv(&polygon[7].Vertex[1].x);
        glTexCoord2f(0.0f, 1.0f); glVertex3fv(&polygon[7].Vertex[2].x);
        // Right face
            glNormal3fv(&polygon[8].Vertex[0].nx);
        glTexCoord2f(0.0f, 0.0f); glVertex3fv(&polygon[8].Vertex[0].x);
        glTexCoord2f(1.0f, 0.0f); glVertex3fv(&polygon[8].Vertex[1].x);
        glTexCoord2f(1.0f, 1.0f); glVertex3fv(&polygon[8].Vertex[2].x);

        glTexCoord2f(0.0f, 0.0f); glVertex3fv(&polygon[9].Vertex[0].x);
        glTexCoord2f(1.0f, 1.0f); glVertex3fv(&polygon[9].Vertex[1].x);
        glTexCoord2f(0.0f, 1.0f); glVertex3fv(&polygon[9].Vertex[2].x);
        // Left Face
            glNormal3fv(&polygon[10].Vertex[0].nx);
        glTexCoord2f(0.0f, 0.0f); glVertex3fv(&polygon[10].Vertex[0].x);
        glTexCoord2f(1.0f, 0.0f); glVertex3fv(&polygon[10].Vertex[1].x);
        glTexCoord2f(1.0f, 1.0f); glVertex3fv(&polygon[10].Vertex[2].x);

        glTexCoord2f(0.0f, 0.0f); glVertex3fv(&polygon[11].Vertex[0].x);
        glTexCoord2f(1.0f, 1.0f); glVertex3fv(&polygon[11].Vertex[1].x);
        glTexCoord2f(0.0f, 1.0f); glVertex3fv(&polygon[11].Vertex[2].x);
    glEnd();
        glPopMatrix();
}

void DrawLightSphere(LIGHT* light)
{
    float mat_ambient[] = { 1.0, 0.2, 0.1, 1.0 };
    float mat_diffuse[] = { 1.0, 0.2, 0.1, 1.0 };
    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
    glDisable(GL_TEXTURE_2D);
    glPushMatrix();
    glTranslatef(light[currentLight].Position.x, light[currentLight].Position.y, light[currentLight].Position.z);
    GLUquadricObj * sphere = gluNewQuadric();
    gluQuadricOrientation(sphere, GLU_OUTSIDE);
    gluSphere(sphere,0.3,20,20);
    glPopMatrix();
    glEnable(GL_TEXTURE_2D);
}

void DrawGreenSphere()
{
    float mat_ambient[] = { 0.2, 1.0, 0.1, 1.0 };
    float mat_diffuse[] = { 0.2, 1.0, 0.1, 1.0 };
    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
    glDisable(GL_TEXTURE_2D);
    glPushMatrix();
    glTranslatef(-2.0, -2.0, -8.0);
    GLUquadricObj * sphere = gluNewQuadric();
    gluQuadricOrientation(sphere, GLU_OUTSIDE);
    gluSphere(sphere,0.3,20,20);
    glPopMatrix();
    glEnable(GL_TEXTURE_2D);
}

void DrawSphere()
{
    float mat_ambient[] = { 0.8, 0.5, 0.1, 1.0 };
    float mat_diffuse[] = { 0.8, 0.5, 0.1, 1.0 };
    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);

    glDisable(GL_TEXTURE_2D);
    glPushMatrix();
    glTranslatef(-3.0f,-1.0f,-8.0f);
    GLUquadricObj * sphere = gluNewQuadric();
    gluQuadricOrientation(sphere, GLU_OUTSIDE);
    gluSphere(sphere,1.0,50,50);
    glPopMatrix();
    glEnable(GL_TEXTURE_2D);
}

void DrawCone()
{
    float mat_ambient[] = { 0.1, 0.5, 1.0, 1.0 };
    float mat_diffuse[] = { 0.1, 0.5, 1.0, 1.0 };
    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);

    glDisable(GL_TEXTURE_2D);
    glDisable(GL_CULL_FACE);
    glPushMatrix();
    glTranslatef(3.0f,-2.0f,-8.0f);
    glRotatef(-90,1,0,0);
    GLUquadricObj * cylinder = gluNewQuadric();
    gluQuadricOrientation(cylinder, GLU_OUTSIDE);
    gluCylinder(cylinder,1.0,0.0,2.0,20,20);
    glPopMatrix();
    glEnable(GL_CULL_FACE);
    glEnable(GL_TEXTURE_2D);
}

float GetTimePassed(float& lasttime, int average, float* lastmultiplier)
{
    float timeoffset;
    float currenttime;
/*
If the program has just started, set last tickcount to the current tickcount.
This prevents the program from thinking that several hours have passed since the last frame.
*/
    if (lasttime == 0)
        lasttime = (float)GetTickCount();
        // Get the current time
    currenttime = (float)GetTickCount();
        // Calculate the offset
    timeoffset = currenttime - lasttime;
    // If timeoffset less than 1/120 of a second (in milliseconds) then set to minimum offset
    if (timeoffset < 8.333333)
    {
        timeoffset = 8.333333;
        currenttime = lasttime + timeoffset;
    }
    // Put the current time in the lasttime variable
        lasttime = currenttime;
    // return the time offset in seconds per frame
        multiplier = timeoffset / 1000;
    for (int loop = 0; loop < average - 1; loop++)
    {
        lastmultiplier[loop] = lastmultiplier[loop + 1];
    }
    lastmultiplier[average - 1] = multiplier;
    for (int loop = 0; loop < average - 1; loop++)
        multiplier += lastmultiplier[loop];
    multiplier /= (float)average; 
        if (multiplier)
        fps = (int)(1.0 / multiplier);
    return multiplier;
}

bool CheckClipPlanes(CAMERA Camera, VECTOR Vect)
{
  float ProjectionMatrix[16];
  float ModelViewMatrix[16];
  float A, B, C, Distance;
  int Counter = 0;
  glGetFloatv(GL_PROJECTION_MATRIX, ProjectionMatrix);
  glGetFloatv(GL_MODELVIEW_MATRIX, ModelViewMatrix);

  MultMatrix(ProjectionMatrix, ModelViewMatrix);

  //right clipping plane
  A = ProjectionMatrix[0] - ProjectionMatrix[3];
  B = ProjectionMatrix[4] - ProjectionMatrix[7];
  C = ProjectionMatrix[8] - ProjectionMatrix[11];

  Distance = -1 * (A * (-Camera.Position.x + Vect.x) + B * 

(-Camera.Position.y + Vect.y) + C * (-Camera.Position.z + 

Vect.z));
  if (Distance > 0)
    Counter++;

  //left clipping plane
  A = ProjectionMatrix[0] + ProjectionMatrix[3];
  B = ProjectionMatrix[4] + ProjectionMatrix[7];
  C = ProjectionMatrix[8] + ProjectionMatrix[11];

  Distance = A * (-Camera.Position.x + Vect.x) + B * 

(-Camera.Position.y + Vect.y) + C * (-Camera.Position.z + Vect.z);
  if (Distance > 0)
    Counter++;

  //top clipping plane
  A = ProjectionMatrix[1] - ProjectionMatrix[3];
  B = ProjectionMatrix[5] - ProjectionMatrix[7];
  C = ProjectionMatrix[9] - ProjectionMatrix[11];

  Distance = -1 * (A * (-Camera.Position.x + Vect.x) + B * 

(-Camera.Position.y + Vect.y) + C * (-Camera.Position.z + 

Vect.z));
  if (Distance > 0)
    Counter++;

  //bottom clipping plane
  A = ProjectionMatrix[1] + ProjectionMatrix[3];
  B = ProjectionMatrix[5] + ProjectionMatrix[7];
  C = ProjectionMatrix[9] + ProjectionMatrix[11];

  Distance = A * (-Camera.Position.x + Vect.x) + B * 

(-Camera.Position.y + Vect.y) + C * (-Camera.Position.z + Vect.z);
  if (Distance > 0)
    Counter++;

  // near clipping plane (might not be necessary when the near 
  // frustrum plane is close, but just in case)
  A = ProjectionMatrix[2] - ProjectionMatrix[3];
  B = ProjectionMatrix[6] - ProjectionMatrix[7];
  C = ProjectionMatrix[10] - ProjectionMatrix[11];

  Distance = A * (-Camera.Position.x + Vect.x) + B * 

(-Camera.Position.y + Vect.y) + C * (-Camera.Position.z + Vect.z);
  if (Distance > 0)
    Counter++;

  // far clipping plane (the equation didn't work for the far plane, 
  // so I'll just use a distance test)
  VECTOR Vect2;
  Vect2.x = Vect.x - Camera.Position.x;
  Vect2.y = Vect.y - Camera.Position.y;
  Vect2.z = Vect.z - Camera.Position.z;
  if (MagnitudeVector(Vect2) < 200)
    Counter++;

  if (Counter == 6)
    return 1;
  else
    return 0;
}

//  A halo type billboard that always faces the camera
void DrawHalo(TEXTURE* texture, LIGHT* light, CAMERA* camera)
{
    float halfwidth = 2;
    float halfheight = 2;

    MATRIX mat;
    glGetFloatv(GL_MODELVIEW_MATRIX, mat.Element);

    VECTOR right;
    right.x = mat.Element[0];
    right.y = mat.Element[4];
    right.z = mat.Element[8];
    right.Normalize();
    right.x *= halfwidth;
    right.y *= halfwidth;
    right.z *= halfwidth;

    VECTOR up;
    up.x = mat.Element[1];
    up.y = mat.Element[5];
    up.z = mat.Element[9];
    up.Normalize();
    up.x *= halfheight;
    up.y *= halfheight;
    up.z *= halfheight;

/*
   If you are using a quake style camera that doesn't roll
   then you can use the following commented code to make a conventional
   billboard remain vertical. If you are using a camera with 6DOF however,
   then this will not work.
*/

/*
    up.x = 0.0;
    up.z = 0.0;
    right.y = 0.0;
//*/

    float mat_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
    float mat_diffuse[] = { 0.8, 0.8, 0.8, 1.0 };
    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_ALPHA_TEST);
    glAlphaFunc(GL_GREATER, 0);
    glDisable(GL_LIGHTING);
    glColor4f(1.0, 1.0, 1.0, 1.0);
    glBindTexture(GL_TEXTURE_2D, texture[1].TexID);
    glPopMatrix();
        glBegin(GL_QUADS);
            glTexCoord2f(0.0f, 0.0f); glVertex3f(light[currentLight].Position.x + (-right.x - up.x), light[currentLight].Position.y + (-right.y - up.y), light[currentLight].Position.z + (-right.z - up.z));
            glTexCoord2f(1.0f, 0.0f); glVertex3f(light[currentLight].Position.x + (right.x - up.x), light[currentLight].Position.y + (right.y - up.y), light[currentLight].Position.z + (right.z - up.z));
            glTexCoord2f(1.0f, 1.0f); glVertex3f(light[currentLight].Position.x + (right.x + up.x), light[currentLight].Position.y + (right.y + up.y), light[currentLight].Position.z + (right.z + up.z));
            glTexCoord2f(0.0f, 1.0f); glVertex3f(light[currentLight].Position.x + (up.x - right.x), light[currentLight].Position.y + (up.y - right.y), light[currentLight].Position.z + (up.z - right.z));
        glEnd();
    glPopMatrix();
    glEnable(GL_LIGHTING);
    glDisable(GL_ALPHA);
    glDisable(GL_BLEND);
}

//  A fire type billboard that rotates to face the camera but remains vertical
void DrawFire(TEXTURE* texture, LIGHT* light, CAMERA* camera)
{
    float halfwidth = 1.0;
    float halfheight = 2.0;
    VECTOR FirePosition(3.0, -2.0 + halfheight, -8.0);
//  Get the vector from the billboard position to the camera
    VECTOR A;
    A.x = (camera[currentCamera].Position.x - FirePosition.x);
    A.y = (camera[currentCamera].Position.y - FirePosition.y);
    A.z = (camera[currentCamera].Position.z - FirePosition.z);
    A.Normalize();
// Set a vector to the standard up vector
    VECTOR B;
    B.x = (0);
    B.y = (1);
    B.z = (0);
    B.Normalize();
// Take the cross product of these vectors to find a vector perpendicular to the camera
    VECTOR C = CrossVector(A, B);
    C.Normalize();

// Negate the perpendicular vector to make the billboard face the front
    VECTOR right;
    right.x = -C.x * halfwidth;
    right.y = -C.y * halfwidth;
    right.z = -C.z * halfwidth;

    VECTOR up;
    up.x = 0;
    up.y = 1 * halfheight;
    up.z = 0;

// Continue as normal
    float mat_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
    float mat_diffuse[] = { 0.8, 0.8, 0.8, 1.0 };
    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_ALPHA_TEST);
    glAlphaFunc(GL_GREATER, 0);
    glDisable(GL_LIGHTING);
    glColor4f(1.0, 1.0, 1.0, 1.0);
    glBindTexture(GL_TEXTURE_2D, texture[2].TexID);
    glPopMatrix();
        glBegin(GL_QUADS);
            glTexCoord2f(0.0f, 0.0f); glVertex3f(FirePosition.x + (-right.x - up.x), FirePosition.y + (-right.y - up.y), FirePosition.z + (-right.z - up.z));
            glTexCoord2f(1.0f, 0.0f); glVertex3f(FirePosition.x + (right.x - up.x), FirePosition.y + (right.y - up.y), FirePosition.z + (right.z - up.z));
            glTexCoord2f(1.0f, 1.0f); glVertex3f(FirePosition.x + (right.x + up.x), FirePosition.y + (right.y + up.y), FirePosition.z + (right.z + up.z));
            glTexCoord2f(0.0f, 1.0f); glVertex3f(FirePosition.x + (up.x - right.x), FirePosition.y + (up.y - right.y), FirePosition.z + (up.z - right.z));
        glEnd();
    glPopMatrix();
    glEnable(GL_LIGHTING);
    glDisable(GL_ALPHA);
    glDisable(GL_BLEND);
}

void DrawBillboards(TEXTURE* texture, LIGHT* light, CAMERA* camera)
{
// Draw depth sorted billboards
    VECTOR FirePosition(3.0, -2.0, -8.0);

    VECTOR VectorToCone;
    VectorToCone.x = FirePosition.x - camera[currentCamera].Position.x;
    VectorToCone.y = FirePosition.y - camera[currentCamera].Position.y;
    VectorToCone.z = FirePosition.z - camera[currentCamera].Position.z;
    float FireDistance = VectorToCone.GetMagnitude();

    VECTOR VectorToLight;
    VectorToLight.x = light[currentLight].Position.x - camera[currentCamera].Position.x;
    VectorToLight.y = light[currentLight].Position.y - camera[currentCamera].Position.y;
    VectorToLight.z = light[currentLight].Position.z - camera[currentCamera].Position.z;
    float LightDistance = VectorToLight.GetMagnitude();

    if(LightDistance < FireDistance)
    {
        DrawFire(texture, light, camera);
        DrawHalo(texture, light, camera);
    }
    else
    {
        DrawHalo(texture, light, camera);
        DrawFire(texture, light, camera);
    }
}

---