---

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 "mmgr.h"

extern int numCameras;
extern int numLights;
extern int currentLight;
extern int fps;
extern float multiplier;

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

void SetGLTexture(TEXTURE* texture)            // This function will be rewritten later
{
    sprintf(texture[0].TexName, "%s", "tile.tga");
    texture[0].LoadTGA();
}

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

---