outdated: 44.3D Lens Flare With Occlusion Testing

#ifndef AFX_GLFONT_H__F5069B5F_9D05_4832_8200_1EC9B4BFECE6__INCLUDED_
#define AFX_GLFONT_H__F5069B5F_9D05_4832_8200_1EC9B4BFECE6__INCLUDED_

#include <Windows.h>
#include <GL\glew.h>
#include <GL\glut.h>

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class glFont {
public:
    glFont();
    virtual ~glFont();

public:
    GLuint GetListBase(void);
    GLuint GetTexture(void);
    void SetWindowSize(GLint width, GLint height);
    void glPrintf(GLint x, GLint y, GLint set, const char* Format, ...);
    void BuildFont(GLfloat Scale = 1.0f);
    void SetFontTexture(GLuint tex);                    // Texture ID

protected:
    GLdouble m_WindowWidth;
    GLdouble m_WindowHeight;
    GLuint m_ListBase;
    GLuint m_FontTexture;
};


#endif // !AFX_GLFONT_H__F5069B5F_9D05_4832_8200_1EC9B4BFECE6__INCLUDED_

#include "glFont.h"
#include <stdio.h>
#pragma comment(lib, "legacy_stdio_definitions.lib")

glFont::glFont()
{
    m_FontTexture = 0;
    m_ListBase = 0;
}

glFont::~glFont()
{
    if (m_FontTexture != 0) {
        glDeleteTextures(1, &m_FontTexture);
    }
    if (m_ListBase != 0) {
        glDeleteLists(m_ListBase, 256);
    }
}

void glFont::SetFontTexture(GLuint tex)
{
    if (tex != 0) {
        m_FontTexture = tex;
    }
}

void glFont::BuildFont(GLfloat Scale)
{
    float cx;
    float cy;

    m_ListBase = glGenLists(256);
    if (m_FontTexture != 0) {
        glBindTexture(GL_TEXTURE_2D, m_FontTexture);
        for (GLuint loop = 0; loop < 256; ++loop) {
            cx = float(loop % 16) / 16.0f;
            cy = float(loop / 16) / 16.0f;

            glNewList(m_ListBase + loop, GL_COMPILE);            // Building a list
            glBegin(GL_QUADS);
                glTexCoord2f(cx, 1 - cy - 0.0625f);
                glVertex2f(0, 0);
                glTexCoord2f(cx + 0.0625f, 1 - cy - 0.0625f);
                glVertex2f(16 * Scale, 0);
                glTexCoord2f(cx + 0.0625f, 1 - cy);
                glVertex2f(16 * Scale, 16 * Scale);
                glTexCoord2f(cx, 1 - cy);
                glVertex2f(0, 16 * Scale);
            glEnd();
            glTranslatef(10 * Scale, 0, 0);
            glEndList();
        }
    }
}

void glFont::glPrintf(GLint x, GLint y, GLint set, const char* Format, ...)
{
    char text[256];
    va_list ap;

    if (Format == NULL) {
        return;
    }
    va_start(ap, Format);
    vsprintf(text, Format, ap);
    va_end(ap);

    if (set > 1) {
        set = 1;
    }
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);
    glBindTexture(GL_TEXTURE_2D, m_FontTexture);
    glDisable(GL_DEPTH_TEST);
    
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    
    glOrtho(0, m_WindowWidth, 0, m_WindowHeight, -1, 1);           // Set up an ortho screen
    
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();

    glTranslatef(x, y, 0);
    glListBase(m_ListBase - 32 + (128 * set));
    glCallLists(strlen(text), GL_BYTE, text);
    
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();

    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();

    glEnable(GL_DEPTH_TEST);
    glDisable(GL_BLEND);
    glDisable(GL_TEXTURE_2D);
}

void glFont::SetWindowSize(GLint width, GLint height)
{
    m_WindowWidth = width;
    m_WindowHeight = height;
}

GLuint glFont::GetTexture()
{
    GLuint result = m_FontTexture;
    return result;
}

GLuint glFont::GetListBase()
{
    GLuint result = m_ListBase;
    return result;
}

#ifndef AFX_GLVECTOR_H__F526A5CF_89B5_4F20_8F2C_517D83879D35__INCLUDED_
#define AFX_GLVECTOR_H__F526A5CF_89B5_4F20_8F2C_517D83879D35__INCLUDED_

#include <Windows.h>
#include <GL\glew.h>
#include <GL\glut.h>
#include <math.h>

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class glVector {
public:
    glVector();
    virtual ~glVector();

public:
    void operator=(glVector v);
    glVector operator+(glVector v);
    glVector operator*(GLfloat scalar);
    void Normalize(void);
    GLfloat Magnitude(void);
    GLfloat m_Msg;
    void operator*=(GLfloat scalar);
    
    GLfloat i;
    GLfloat j;
    GLfloat k;
};

#endif // !AFX_GLVECTOR_H__F526A5CF_89B5_4F20_8F2C_517D83879D35__INCLUDED_

#include "glVector.h"

glVector::glVector() : i(0), j(0), k(0) {}

glVector::~glVector() {}

void glVector::operator*=(GLfloat scalar)
{
    i *= scalar;
    j *= scalar;
    k *= scalar;
}

GLfloat glVector::Magnitude()
{
    GLfloat result;
    result = GLfloat(sqrt(i * i + j * j + k * k));
    m_Msg = result;
    return result;
}

void glVector::Normalize()
{
    if (m_Msg != 0.0f) {
        i /= m_Msg;
        j /= m_Msg;
        k /= m_Msg;
        Magnitude();
    }
}

glVector glVector::operator*(GLfloat scalar)
{
    glVector r;
    r.i = i * scalar;
    r.j = j * scalar;
    r.k = k * scalar;

    return r;
}

glVector glVector::operator+(glVector v)
{
    glVector r;
    r.i = i + v.i;
    r.j = j + v.j;
    r.k = k + v.k;

    return r;
}

void glVector::operator=(glVector v)
{
    i = v.i;
    j = v.j;
    k = v.k;
    m_Msg = v.m_Msg;
}

#ifndef AFX_GLPOINT_H__ADADC708_0176_471A_8241_5DD4D700BCB2__INCLUDED_
#define AFX_GLPOINT_H__ADADC708_0176_471A_8241_5DD4D700BCB2__INCLUDED_

#include <Windows.h>
#include <GL\glew.h>
#include <GL\glut.h>
#include "glVector.h"

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class glPoint {
public:
    glPoint();
    virtual ~glPoint();

public:
    void operator+=(glPoint p);
    glPoint operator+(glPoint p);
    glVector operator-(glPoint p);
    void operator=(glVector v);
    void operator=(glPoint p);

    GLfloat x;
    GLfloat y;
    GLfloat z;
};


#endif // !AFX_GLPOINT_H__ADADC708_0176_471A_8241_5DD4D700BCB2__INCLUDED_

#include "glPoint.h"

glPoint::glPoint() : x(0), y(0), z(0) {}

glPoint::~glPoint() {}

void glPoint::operator=(glPoint p)
{
    x = p.x;
    y = p.y;
    z = p.z;
}

void glPoint::operator=(glVector v)
{
    x = v.i;
    y = v.j;
    z = v.k;
}

glVector glPoint::operator-(glPoint p)
{
    glVector r;
    r.i = x - p.x;
    r.j = y - p.y;
    r.k = z - p.z;

    return r;
}

glPoint glPoint::operator+(glPoint p)
{
    glPoint r;
    r.x = x + p.x;
    r.y = y + p.y;
    r.z = z + p.z;

    return r;
}

void glPoint::operator+=(glPoint p)
{
    x += p.x;
    y += p.y;
    z += p.z;
}

#ifndef AFX_GLCAMERA_H__8E3CD02E_6D82_437E_80DA_50023C60C146__INCLUDED_
#define AFX_GLCAMERA_H__8E3CD02E_6D82_437E_80DA_50023C60C146__INCLUDED_

#include <windows.h>
#include <GL\glew.h>
#include <gl\glut.h>
#include <math.h>
#include "glVector.h"
#include "glPoint.h"

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class glCamera {
public:
    glCamera();
    virtual ~glCamera();

    BOOL SphereInFrustum(glPoint p, GLfloat Radius);
    BOOL SphereInFrustum(GLfloat x, GLfloat y, GLfloat z, GLfloat Radius);
    BOOL PointInFrustum(GLfloat x, GLfloat y, GLfloat z);
    BOOL PointInFrustum(glPoint p);

    void RenderLensFlare(void);                                  // Render lens flare
    void RenderStreaks(GLfloat r, GLfloat g, GLfloat b, GLfloat a, glPoint p, GLfloat scale);
    void RenderBigGlow(GLfloat r, GLfloat g, GLfloat b, GLfloat a, glPoint p, GLfloat scale);
    void RenderGlow(GLfloat r, GLfloat g, GLfloat b, GLfloat a, glPoint p, GLfloat scale);
    void RenderHalo(GLfloat r, GLfloat g, GLfloat b, GLfloat a, glPoint p, GLfloat scale);

    void UpdateFrustumFaster(void);            // Update the frustum
    void UpdateFrustum(void);

    void ChangeVelocity(GLfloat vel);           // Change volcity and speed
    void ChangeHeading(GLfloat degrees);
    void ChangePitch(GLfloat degrees);
    void SetPrespective(void);

    bool glCamera::IsOccluded(glPoint p);                // Occlusion

    glVector vLightSourceToCamera, vLightSourceToIntersect;
    glPoint ptIntersect, pt;
    GLsizei m_WindowHeight;
    GLsizei m_WindowWidth;
    GLuint m_StreakTexture;
    GLuint m_HaloTexture;
    GLuint m_GlowTexture;
    GLuint m_BigGlowTexture;
    GLfloat m_MaxPointSize;
    GLfloat m_Frustum[6][4];
    glPoint m_LightSourcePos;
    GLfloat m_MaxPitchRate;
    GLfloat m_MaxHeadingRate;
    GLfloat m_HeadingDegrees;
    GLfloat m_PitchDegrees;
    GLfloat m_MaxForwardVelocity;
    GLfloat m_ForwardVelocity;
    glPoint m_Position;
    glVector m_DirectionVector;
};

#endif // !AFX_GLCAMERA_H__8E3CD02E_6D82_437E_80DA_50023C60C146__INCLUDED_

#include "glCamera.h"

glCamera::glCamera()
{
    m_MaxPitchRate             = 0.0f;
    m_MaxHeadingRate           = 0.0f;
    m_HeadingDegrees           = 0.0f;
    m_PitchDegrees             = 0.0f;
    m_MaxForwardVelocity       = 0.0f;
    m_ForwardVelocity          = 0.0f;
    m_LightSourcePos.x         = 0.0f;
    m_LightSourcePos.y         = 0.0f;
    m_LightSourcePos.z         = 0.0f;
    m_GlowTexture              = 0;
    m_BigGlowTexture           = 0;
    m_HaloTexture              = 0;
    m_StreakTexture            = 0;
    m_MaxPointSize             = 0.0f;
}

glCamera::~glCamera()
{
    if (m_GlowTexture != 0) {
        glDeleteTextures(1, &m_GlowTexture);
    }
    if (m_HaloTexture != 0) {
        glDeleteTextures(1, &m_HaloTexture);
    }
    if (m_BigGlowTexture != 0) {
        glDeleteTextures(1, &m_BigGlowTexture);
    }
    if (m_StreakTexture != 0) {
        glDeleteTextures(1, &m_StreakTexture);
    }
}

void glCamera::SetPrespective()
{
    GLfloat Matrix[16];
    glVector v;

    glRotatef(m_HeadingDegrees, 0.0f, 1.0f, 0.0f);
    glRotatef(m_PitchDegrees, 1.0f, 0.0f, 0.0f);

    glGetFloatv(GL_MODELVIEW_MATRIX, Matrix);

    m_DirectionVector.i = Matrix[8];
    m_DirectionVector.j = Matrix[9];
    m_DirectionVector.k = -Matrix[10];

    glLoadIdentity();

    glRotatef(m_PitchDegrees, 1.0f, 0.0f, 0.0f);
    glRotatef(m_HeadingDegrees, 0.0f, 1.0f, 0.0f);

    // Scale the direction by speed
    v = m_DirectionVector;
    v *= m_ForwardVelocity;

    m_Position.x += v.i;
    m_Position.y += v.j;
    m_Position.z += v.k;

    glTranslatef(-m_Position.x, -m_Position.y, -m_Position.z);
}

void glCamera::ChangePitch(GLfloat degrees)
{
    if (fabs(degrees) < fabs(m_MaxPitchRate)) {
        m_PitchDegrees += degrees;
    }
    else {
        if (degrees < 0) {
            m_PitchDegrees -= m_MaxPitchRate;
        }
        else {
            m_PitchDegrees += m_MaxPitchRate;
        }
    }

    if (m_PitchDegrees > 360.0f) {
        m_PitchDegrees -= 360.0f;
    }
    else if (m_PitchDegrees < -360.0f) {
        m_PitchDegrees += 360.0f;
    }
}

void glCamera::ChangeHeading(GLfloat degrees)
{
    if (fabs(degrees) < fabs(m_MaxHeadingRate)) {
        if ((m_PitchDegrees > 90 && m_PitchDegrees < 270) || 
            (m_PitchDegrees < -90 && m_PitchDegrees > -270))
        {
            m_HeadingDegrees -= degrees;
        }
        else {
            m_HeadingDegrees += degrees;
        }
    }
    else {
        if (degrees < 0) {
            if ((m_PitchDegrees > 90 && m_PitchDegrees < 270) ||
                (m_PitchDegrees < -90 && m_PitchDegrees > -270))
            {
                m_HeadingDegrees += m_MaxHeadingRate;
            }
            else {
                m_HeadingDegrees -= m_MaxHeadingRate;
            }
        }
        else {
            if ((m_PitchDegrees > 90 && m_PitchDegrees < 270) ||
                (m_PitchDegrees < -90 && m_PitchDegrees > -270))
            {
                m_HeadingDegrees -= m_MaxHeadingRate;
            }
            else {
                m_HeadingDegrees += m_MaxHeadingRate;
            }
        }
    }

    if (m_HeadingDegrees > 360.0f)
    {
        m_HeadingDegrees -= 360.0f;
    }
    else if (m_HeadingDegrees < -360.0f)
    {
        m_HeadingDegrees += 360.0f;
    }
}

void glCamera::ChangeVelocity(GLfloat vel)
{
    if (fabs(vel) < fabs(m_MaxForwardVelocity)) {
        m_ForwardVelocity += vel;
    }
    else {
        if (vel < 0) {
            m_ForwardVelocity -= -m_MaxForwardVelocity;
        }
        else {
            m_ForwardVelocity += m_MaxForwardVelocity;
        }
    }
}

void glCamera::UpdateFrustum()
{
    GLfloat clip[16];
    GLfloat proj[16];
    GLfloat modl[16];
    GLfloat t;

    // Get current matrix
    glGetFloatv(GL_PROJECTION_MATRIX, proj);
    glGetFloatv(GL_MODELVIEW_MATRIX, modl);

    // Multiply
    clip[0] = modl[0] * proj[0] + modl[1] * proj[4] + modl[2] * proj[8] + modl[3] * proj[12];
    clip[1] = modl[0] * proj[1] + modl[1] * proj[5] + modl[2] * proj[9] + modl[3] * proj[13];
    clip[2] = modl[0] * proj[2] + modl[1] * proj[6] + modl[2] * proj[10] + modl[3] * proj[14];
    clip[3] = modl[0] * proj[3] + modl[1] * proj[7] + modl[2] * proj[11] + modl[3] * proj[15];

    clip[4] = modl[4] * proj[0] + modl[5] * proj[4] + modl[6] * proj[8] + modl[7] * proj[12];
    clip[5] = modl[4] * proj[1] + modl[5] * proj[5] + modl[6] * proj[9] + modl[7] * proj[13];
    clip[6] = modl[4] * proj[2] + modl[5] * proj[6] + modl[6] * proj[10] + modl[7] * proj[14];
    clip[7] = modl[4] * proj[3] + modl[5] * proj[7] + modl[6] * proj[11] + modl[7] * proj[15];

    clip[8] = modl[8] * proj[0] + modl[9] * proj[4] + modl[10] * proj[8] + modl[11] * proj[12];
    clip[9] = modl[8] * proj[1] + modl[9] * proj[5] + modl[10] * proj[9] + modl[11] * proj[13];
    clip[10] = modl[8] * proj[2] + modl[9] * proj[6] + modl[10] * proj[10] + modl[11] * proj[14];
    clip[11] = modl[8] * proj[3] + modl[9] * proj[7] + modl[10] * proj[11] + modl[11] * proj[15];

    clip[12] = modl[12] * proj[0] + modl[13] * proj[4] + modl[14] * proj[8] + modl[15] * proj[12];
    clip[13] = modl[12] * proj[1] + modl[13] * proj[5] + modl[14] * proj[9] + modl[15] * proj[13];
    clip[14] = modl[12] * proj[2] + modl[13] * proj[6] + modl[14] * proj[10] + modl[15] * proj[14];
    clip[15] = modl[12] * proj[3] + modl[13] * proj[7] + modl[14] * proj[11] + modl[15] * proj[15];

    // Extract the numbers for the right plane
    m_Frustum[0][0] = clip[3] - clip[0];
    m_Frustum[0][1] = clip[7] - clip[4];
    m_Frustum[0][2] = clip[11] - clip[8];
    m_Frustum[0][3] = clip[15] - clip[12];

    // Normal
    t = GLfloat(sqrt(m_Frustum[0][0] * m_Frustum[0][0] + m_Frustum[0][1] * m_Frustum[0][1] +
        m_Frustum[0][2] * m_Frustum[0][2]));
    m_Frustum[0][0] /= t;
    m_Frustum[0][1] /= t;
    m_Frustum[0][2] /= t;
    m_Frustum[0][3] /= t;

    // Extract the numbers for the left plane
    m_Frustum[1][0] = clip[3] + clip[0];
    m_Frustum[1][1] = clip[7] + clip[4];
    m_Frustum[1][2] = clip[11] + clip[8];
    m_Frustum[1][3] = clip[15] + clip[12];

    // Normal
    t = GLfloat(sqrt(m_Frustum[1][0] * m_Frustum[1][0] + m_Frustum[1][1] * m_Frustum[1][1] +
        m_Frustum[1][2] * m_Frustum[1][2]));
    m_Frustum[1][0] /= t;
    m_Frustum[1][1] /= t;
    m_Frustum[1][2] /= t;
    m_Frustum[1][3] /= t;

    // Extract the numbers for the bottm plane
    m_Frustum[2][0] = clip[3] + clip[1];
    m_Frustum[2][1] = clip[7] + clip[5];
    m_Frustum[2][2] = clip[11] + clip[9];
    m_Frustum[2][3] = clip[15] + clip[13];

    // Normal
    t = GLfloat(sqrt(m_Frustum[2][0] * m_Frustum[2][0] + m_Frustum[2][1] * m_Frustum[2][1] +
        m_Frustum[2][2] * m_Frustum[2][2]));
    m_Frustum[2][0] /= t;
    m_Frustum[2][1] /= t;
    m_Frustum[2][2] /= t;
    m_Frustum[2][3] /= t;

    // Extract the numbers for the top plane
    m_Frustum[3][0] = clip[3] - clip[1];
    m_Frustum[3][1] = clip[7] - clip[5];
    m_Frustum[3][2] = clip[11] - clip[9];
    m_Frustum[3][3] = clip[15] - clip[13];

    // Normal
    t = GLfloat(sqrt(m_Frustum[3][0] * m_Frustum[3][0] + m_Frustum[3][1] * m_Frustum[3][1] +
        m_Frustum[3][2] * m_Frustum[3][2]));
    m_Frustum[3][0] /= t;
    m_Frustum[3][1] /= t;
    m_Frustum[3][2] /= t;
    m_Frustum[3][3] /= t;

    // Extract the numbers for the far plane
    m_Frustum[4][0] = clip[3] - clip[2];
    m_Frustum[4][1] = clip[7] - clip[6];
    m_Frustum[4][2] = clip[11] - clip[10];
    m_Frustum[4][3] = clip[15] - clip[14];

    // Normal
    t = GLfloat(sqrt(m_Frustum[4][0] * m_Frustum[4][0] + m_Frustum[4][1] * m_Frustum[4][1] +
        m_Frustum[4][2] * m_Frustum[4][2]));
    m_Frustum[4][0] /= t;
    m_Frustum[4][1] /= t;
    m_Frustum[4][2] /= t;
    m_Frustum[4][3] /= t;

    // Extract the numbers for the near plane
    m_Frustum[5][0] = clip[3] + clip[2];
    m_Frustum[5][1] = clip[7] + clip[6];
    m_Frustum[5][2] = clip[11] + clip[10];
    m_Frustum[5][3] = clip[15] + clip[14];

    // Normal
    t = GLfloat(sqrt(m_Frustum[5][0] * m_Frustum[5][0] + m_Frustum[5][1] * m_Frustum[5][1] +
        m_Frustum[5][2] * m_Frustum[5][2]));
    m_Frustum[5][0] /= t;
    m_Frustum[5][1] /= t;
    m_Frustum[5][2] /= t;
    m_Frustum[5][3] /= t;
}

void glCamera::UpdateFrustumFaster()
{
    GLfloat clip[16];
    GLfloat proj[16];
    GLfloat modl[16];
    GLfloat t;

    glGetFloatv(GL_PROJECTION_MATRIX, proj);
    glGetFloatv(GL_MODELVIEW_MATRIX, modl);

    // Multiply
    // This function will only work if you do not rotate or translate your projection matrix
    clip[0] = modl[0] * proj[0];
    clip[1] = modl[1] * proj[5];
    clip[2] = modl[2] * proj[10] + modl[3] * proj[14];
    clip[3] = modl[2] * proj[11];

    clip[4] = modl[4] * proj[0];
    clip[5] = modl[5] * proj[5];
    clip[6] = modl[6] * proj[10] + modl[7] * proj[14];
    clip[7] = modl[6] * proj[11];

    clip[8] = modl[8] * proj[0];
    clip[9] = modl[9] * proj[5];
    clip[10] = modl[10] * proj[10] + modl[11] * proj[14];
    clip[11] = modl[10] * proj[11];

    clip[12] = modl[12] * proj[0];
    clip[13] = modl[13] * proj[5];
    clip[14] = modl[14] * proj[10] + modl[15] * proj[14];
    clip[15] = modl[14] * proj[11];

    // Extract the numbers for the right plane
    m_Frustum[0][0] = clip[3] - clip[0];
    m_Frustum[0][1] = clip[7] - clip[4];
    m_Frustum[0][2] = clip[11] - clip[8];
    m_Frustum[0][3] = clip[15] - clip[12];

    // Normal
    t = GLfloat(sqrt(m_Frustum[0][0] * m_Frustum[0][0] + m_Frustum[0][1] * m_Frustum[0][1] +
        m_Frustum[0][2] * m_Frustum[0][2]));
    m_Frustum[0][0] /= t;
    m_Frustum[0][1] /= t;
    m_Frustum[0][2] /= t;
    m_Frustum[0][3] /= t;

    // Extract the numbers for the left plane
    m_Frustum[1][0] = clip[3] + clip[0];
    m_Frustum[1][1] = clip[7] + clip[4];
    m_Frustum[1][2] = clip[11] + clip[8];
    m_Frustum[1][3] = clip[15] + clip[12];

    // Normal
    t = GLfloat(sqrt(m_Frustum[1][0] * m_Frustum[1][0] + m_Frustum[1][1] * m_Frustum[1][1] +
        m_Frustum[1][2] * m_Frustum[1][2]));
    m_Frustum[1][0] /= t;
    m_Frustum[1][1] /= t;
    m_Frustum[1][2] /= t;
    m_Frustum[1][3] /= t;

    // Extract the numbers for the bottm plane
    m_Frustum[2][0] = clip[3] + clip[1];
    m_Frustum[2][1] = clip[7] + clip[5];
    m_Frustum[2][2] = clip[11] + clip[9];
    m_Frustum[2][3] = clip[15] + clip[13];

    // Normal
    t = GLfloat(sqrt(m_Frustum[2][0] * m_Frustum[2][0] + m_Frustum[2][1] * m_Frustum[2][1] +
        m_Frustum[2][2] * m_Frustum[2][2]));
    m_Frustum[2][0] /= t;
    m_Frustum[2][1] /= t;
    m_Frustum[2][2] /= t;
    m_Frustum[2][3] /= t;

    // Extract the numbers for the top plane
    m_Frustum[3][0] = clip[3] - clip[1];
    m_Frustum[3][1] = clip[7] - clip[5];
    m_Frustum[3][2] = clip[11] - clip[9];
    m_Frustum[3][3] = clip[15] - clip[13];

    // Normal
    t = GLfloat(sqrt(m_Frustum[3][0] * m_Frustum[3][0] + m_Frustum[3][1] * m_Frustum[3][1] +
        m_Frustum[3][2] * m_Frustum[3][2]));
    m_Frustum[3][0] /= t;
    m_Frustum[3][1] /= t;
    m_Frustum[3][2] /= t;
    m_Frustum[3][3] /= t;

    // Extract the numbers for the far plane
    m_Frustum[4][0] = clip[3] - clip[2];
    m_Frustum[4][1] = clip[7] - clip[6];
    m_Frustum[4][2] = clip[11] - clip[10];
    m_Frustum[4][3] = clip[15] - clip[14];

    // Normal
    t = GLfloat(sqrt(m_Frustum[4][0] * m_Frustum[4][0] + m_Frustum[4][1] * m_Frustum[4][1] +
        m_Frustum[4][2] * m_Frustum[4][2]));
    m_Frustum[4][0] /= t;
    m_Frustum[4][1] /= t;
    m_Frustum[4][2] /= t;
    m_Frustum[4][3] /= t;

    // Extract the numbers for the near plane
    m_Frustum[5][0] = clip[3] + clip[2];
    m_Frustum[5][1] = clip[7] + clip[6];
    m_Frustum[5][2] = clip[11] + clip[10];
    m_Frustum[5][3] = clip[15] + clip[14];

    // Normal
    t = GLfloat(sqrt(m_Frustum[5][0] * m_Frustum[5][0] + m_Frustum[5][1] * m_Frustum[5][1] +
        m_Frustum[5][2] * m_Frustum[5][2]));
    m_Frustum[5][0] /= t;
    m_Frustum[5][1] /= t;
    m_Frustum[5][2] /= t;
    m_Frustum[5][3] /= t;
}

BOOL glCamera::SphereInFrustum(glPoint p, GLfloat Radius)
{
    for (int i = 0; i < 6; ++i) {
        if (m_Frustum[i][0] * p.x + m_Frustum[i][1] * p.y + m_Frustum[i][2] * p.z + m_Frustum[i][3] <= -Radius) {
            return FALSE;
        }
    }
    return TRUE;
}

BOOL glCamera::PointInFrustum(glPoint p)
{
    for (int i = 0; i < 6; ++i) {
        if (m_Frustum[i][0] * p.x + m_Frustum[i][1] * p.y + m_Frustum[i][2] * p.z + m_Frustum[i][3] <= 0) {
            return FALSE;
        }
    }
    return TRUE;
}

BOOL glCamera::SphereInFrustum(GLfloat x, GLfloat y, GLfloat z, GLfloat Radius)
{
    for (int i = 0; i < 6; ++i) {
        if (m_Frustum[i][0] * x + m_Frustum[i][1] * y + m_Frustum[i][2] * z + m_Frustum[i][3] <= -Radius) {
            return FALSE;
        }
    }
    return TRUE;
}

BOOL glCamera::PointInFrustum(GLfloat x, GLfloat y, GLfloat z)
{
    for (int i = 0; i < 6; ++i) {
        if (m_Frustum[i][0] * x + m_Frustum[i][1] * y + m_Frustum[i][2] * z + m_Frustum[i][3] <= 0) {
            return FALSE;
        }
    }
    return TRUE;
}

bool glCamera::IsOccluded(glPoint p)
{
    GLint viewport[4];
    GLdouble mvmatrix[16], projmatrix[16];
    GLdouble winx, winy, winz;
    GLdouble flareZ;                            // The transformed flare Z
    GLfloat bufferZ;                            // The read Z from the buffer

    glGetIntegerv(GL_VIEWPORT, viewport);
    glGetDoublev(GL_MODELVIEW_MATRIX, mvmatrix);
    glGetDoublev(GL_PROJECTION_MATRIX, projmatrix);

    // This asks OGL to guess the 2D position of a 3D point inside the viewport
    gluProject(p.x, p.y, p.z, mvmatrix, projmatrix, viewport, &winx, &winy, &winz);
    flareZ = winz;

    glReadPixels(winx, winy, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &bufferZ);

    // If the buffer Z is lower than our flare guessed Z then don‘t draw
    if (bufferZ < flareZ) {
        return true;
    }
    else {
        return false;
    }
}

void glCamera::RenderLensFlare()
{
    GLfloat Length = 0.0f;

    if (SphereInFrustum(m_LightSourcePos, 1.0f) == TRUE) {
        // Lets compute the vector that points to the camera from the light source
        vLightSourceToCamera = m_Position - m_LightSourcePos;

        Length = vLightSourceToCamera.Magnitude();
        ptIntersect = m_DirectionVector * Length;

        ptIntersect += m_Position;

        // Lets compute the vector that points to the Intersect point from the light source
        vLightSourceToIntersect = ptIntersect - m_LightSourcePos;
        Length = vLightSourceToIntersect.Magnitude();
        vLightSourceToIntersect.Normalize();

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE);
        glDisable(GL_DEPTH_TEST);
        glEnable(GL_TEXTURE_2D);

        if (!IsOccluded(m_LightSourcePos)) {
            RenderBigGlow(0.60f, 0.60f, 0.8f, 1.0f, m_LightSourcePos, 16.0f);
            RenderStreaks(0.60f, 0.60f, 0.8f, 1.0f, m_LightSourcePos, 16.0f);
            
            RenderGlow(0.8f, 0.8f, 1.0f, 0.5f, m_LightSourcePos, 3.5f);
            /* Lets compute a point that is 20% away from the light source 
            *  in the direction of the intersection point.
            */
            pt = vLightSourceToIntersect * (Length * 0.1f);
            pt += m_LightSourcePos;

            RenderGlow(0.9f, 0.6f, 0.4f, 0.5f, pt, 0.6f);
            /* Lets compute a point that is 30% away from the light source 
            *  in the direction of the intersection point
            */
            pt = vLightSourceToIntersect * (Length * 0.15f);
            pt += m_LightSourcePos;

            RenderHalo(0.8f, 0.5f, 0.6f, 0.5f, pt, 1.7f);

            pt = vLightSourceToIntersect * (Length * 0.175f);  // 35%
            pt += m_LightSourcePos;

            RenderHalo(0.9f, 0.2f, 0.1f, 0.5f, pt, 0.83f);
            pt = vLightSourceToIntersect * (Length * 0.285f);  // 57%
            pt += m_LightSourcePos;

            RenderHalo(0.7f, 0.7f, 0.4f, 0.5f, pt, 1.6f);

            pt = vLightSourceToIntersect * (Length * 0.2755f);  // 55.1%
            pt += m_LightSourcePos;

            RenderGlow(0.9f, 0.9f, 0.2f, 0.5f, pt, 0.8f);

            pt = vLightSourceToIntersect * (Length * 0.4775f);  // 95.5%
            pt += m_LightSourcePos;

            RenderGlow(0.93f, 0.82f, 0.73f, 0.5f, pt, 1.0f);

            pt = vLightSourceToIntersect * (Length * 0.49f);    // 98%
            pt += m_LightSourcePos;

            RenderHalo(0.7f, 0.6f, 0.5f, 0.5f, pt, 1.4f);

            pt = vLightSourceToIntersect * (Length * 0.65f);  // 130%
            pt += m_LightSourcePos;

            RenderGlow(0.7f, 0.8f, 0.3f, 0.5f, pt, 1.8f);

            pt = vLightSourceToIntersect * (Length * 0.63f);  // 126%
            pt += m_LightSourcePos;

            RenderGlow(0.4f, 0.3f, 0.2f, 0.5f, pt, 1.4f);

            pt = vLightSourceToIntersect * (Length * 0.8f);  // 160%
            pt += m_LightSourcePos;

            RenderHalo(0.8f, 0.5f, 0.1f, 0.5f, pt, 0.6f);

            pt = vLightSourceToIntersect * (Length * 1.0f);  // 200%
            pt += m_LightSourcePos;

            RenderGlow(0.5f, 0.5f, 0.7f, 0.5f, pt, 1.7f);

            pt = vLightSourceToIntersect * (Length * 0.975f);  // 195%
            pt += m_LightSourcePos;

            RenderHalo(0.4f, 0.1f, 0.9f, 0.5f, pt, 2.0f);
        }
        glDisable(GL_BLEND);
        glEnable(GL_DEPTH_TEST);
        glDisable(GL_TEXTURE_2D);
    }
}

void glCamera::RenderHalo(GLfloat r, GLfloat g, GLfloat b, GLfloat a, glPoint p, GLfloat scale)
{
    glPoint q[4];

    q[0].x = p.x - scale;
    q[0].y = p.y - scale;

    q[1].x = p.x - scale;
    q[1].y = p.y + scale;

    q[2].x = p.x + scale;
    q[2].y = p.y - scale;

    q[3].x = p.x + scale;
    q[3].y = p.y + scale;

    glPushMatrix();
    glTranslatef(p.x, p.y, p.z);
    glRotatef(-m_HeadingDegrees, 0.0f, 1.0f, 0.0f);
    glRotatef(-m_PitchDegrees, 1.0f, 0.0f, 0.0f);
    glBindTexture(GL_TEXTURE_2D, m_HaloTexture);
    glColor4f(r, g, b, a);

    glBegin(GL_TRIANGLE_STRIP);
        glTexCoord2f(0.0f, 0.0f);
        glVertex2f(q[0].x, q[0].y);
        glTexCoord2f(0.0f, 1.0f);
        glVertex2f(q[1].x, q[1].y);
        glTexCoord2f(1.0f, 0.0f);
        glVertex2f(q[2].x, q[2].y);
        glTexCoord2f(1.0f, 1.0f);
        glVertex2f(q[3].x, q[3].y);
    glEnd();
    glPopMatrix();
}

void glCamera::RenderGlow(GLfloat r, GLfloat g, GLfloat b, GLfloat a, glPoint p, GLfloat scale)
{
    glPoint q[4];

    q[0].x = p.x - scale;
    q[0].y = p.y - scale;

    q[1].x = p.x - scale;
    q[1].y = p.y + scale;

    q[2].x = p.x + scale;
    q[2].y = p.y - scale;

    q[3].x = p.x + scale;
    q[3].y = p.y + scale;

    glPushMatrix();
    glTranslatef(p.x, p.y, p.z);
    glRotatef(-m_HeadingDegrees, 0.0f, 1.0f, 0.0f);
    glRotatef(-m_PitchDegrees, 1.0f, 0.0f, 0.0f);
    glBindTexture(GL_TEXTURE_2D, m_GlowTexture);
    glColor4f(r, g, b, a);

    glBegin(GL_TRIANGLE_STRIP);
        glTexCoord2f(0.0f, 0.0f);
        glVertex2f(q[0].x, q[0].y);
        glTexCoord2f(0.0f, 1.0f);
        glVertex2f(q[1].x, q[1].y);
        glTexCoord2f(1.0f, 0.0f);
        glVertex2f(q[2].x, q[2].y);
        glTexCoord2f(1.0f, 1.0f);
        glVertex2f(q[3].x, q[3].y);
    glEnd();
    glPopMatrix();
}

void glCamera::RenderBigGlow(GLfloat r, GLfloat g, GLfloat b, GLfloat a, glPoint p, GLfloat scale)
{
    glPoint q[4];

    q[0].x = p.x - scale;
    q[0].y = p.y - scale;

    q[1].x = p.x - scale;
    q[1].y = p.y + scale;

    q[2].x = p.x + scale;
    q[2].y = p.y - scale;

    q[3].x = p.x + scale;
    q[3].y = p.y + scale;

    glPushMatrix();
    glTranslatef(p.x, p.y, p.z);
    glRotatef(-m_HeadingDegrees, 0.0f, 1.0f, 0.0f);
    glRotatef(-m_PitchDegrees, 1.0f, 0.0f, 0.0f);
    glBindTexture(GL_TEXTURE_2D, m_BigGlowTexture);
    glColor4f(r, g, b, a);

    glBegin(GL_TRIANGLE_STRIP);
        glTexCoord2f(0.0f, 0.0f);
        glVertex2f(q[0].x, q[0].y);
        glTexCoord2f(0.0f, 1.0f);
        glVertex2f(q[1].x, q[1].y);
        glTexCoord2f(1.0f, 0.0f);
        glVertex2f(q[2].x, q[2].y);
        glTexCoord2f(1.0f, 1.0f);
        glVertex2f(q[3].x, q[3].y);
    glEnd();
    glPopMatrix();
}

void glCamera::RenderStreaks(GLfloat r, GLfloat g, GLfloat b, GLfloat a, glPoint p, GLfloat scale)
{
    glPoint q[4];

    q[0].x = p.x - scale;
    q[0].y = p.y - scale;

    q[1].x = p.x - scale;
    q[1].y = p.y + scale;

    q[2].x = p.x + scale;
    q[2].y = p.y - scale;

    q[3].x = p.x + scale;
    q[3].y = p.y + scale;

    glPushMatrix();
    glTranslatef(p.x, p.x, p.z);
    glRotatef(-m_HeadingDegrees, 0.0f, 1.0f, 0.0f);
    glRotatef(-m_PitchDegrees, 1.0f, 0.0f, 0.0f);
    glBindTexture(GL_TEXTURE_2D, m_StreakTexture);
    glColor4f(r, g, b, a);

    glBegin(GL_TRIANGLE_STRIP);
        glTexCoord2f(0.0f, 0.0f);
        glVertex2f(q[0].x, q[0].y);
        glTexCoord2f(0.0f, 1.0f);
        glVertex2f(q[1].x, q[1].y);
        glTexCoord2f(1.0f, 0.0f);
        glVertex2f(q[2].x, q[2].y);
        glTexCoord2f(1.0f, 1.0f);
        glVertex2f(q[3].x, q[3].y);
    glEnd();
    glPopMatrix();
}

#include <windows.h>
#include <stdio.h>
#include <math.h>
#include <gl/glew.h>
#include <gl/glut.h>
#include <GL/GLUAX.H>
#include <mmsystem.h>
#include "glFont.h"
#include "glCamera.h"

#pragma comment(lib, "legacy_stdio_definitions.lib")
/*
*  Every OpenGL program is linked to a Rendering Context.
*  A Rendering Context is what links OpenGL calls to the Device Context.
*  In order for your program to draw to a Window you need to create a Device Context.
*  The DC connects the Window to the GDI (Graphics Device Interface).
*/

HGLRC     hRC = NULL;         // Permanent rendering context
HDC       hDC = NULL;         // Private GDI device context
HWND      hWnd = NULL;        // Holds our window handle
HINSTANCE hInstance;          // Holds the instance of the application

/*
*  It‘s important to make this global so that each procedure knows if
*  the program is running in fullscreen mode or not.
*/

bool keys[256];         // Array used for the keyboard routine
bool active = TRUE;     // Window active flag set to TRUE by default
bool fullscreen = TRUE; // Fullscreen flag set to fullscreen mode by default
bool infoOn = FALSE;
int gFrames = 0;
DWORD gStartTime;
DWORD gCurrentTime;
GLfloat gFPS;
glFont gFont;
glCamera gCamera;

GLUquadricObj* qobj;
GLint cylList;

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration for WndProc

void DrawGLInfo(void);
void CheckKeys(void);

bool LoadTexture(LPSTR szFileName, GLuint& texid)
{
    HBITMAP hBMP;               // Handle
    BITMAP BMP;                 // Bitmap structure

    glGenTextures(1, &texid);
    hBMP = (HBITMAP)LoadImage(GetModuleHandle(NULL), szFileName, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_LOADFROMFILE);
    
    if (!hBMP) {
        return FALSE;
    }
    GetObject(hBMP, sizeof(BMP), &BMP);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);        // Pixel storage mode

    glBindTexture(GL_TEXTURE_2D, texid);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, 3, BMP.bmWidth, BMP.bmHeight, 0, GL_BGR_EXT, GL_UNSIGNED_BYTE, BMP.bmBits);
    DeleteObject(hBMP);

    return TRUE;
}

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)   // Resize and initialize the GL window
{
    gCamera.m_WindowHeight = height;
    gCamera.m_WindowWidth = width;

    if (height == 0) {                                // Prevent a divide by zero by
        height = 1;                                   // Making height equal one
    }

    glViewport(0, 0, width, height);                  // Reset the current viewport

    /*
    *  The following lines set the screen up for a perspective view.
    *  Meaning things in the distance get smaller. This creates a realistic looking scene.
    *  The perspective is calculated with a 45 degree viewing angle based on
    *  the windows width and height. The 0.1f, 100.0f is the starting point and
    *  ending point for how deep we can draw into the screen.
    *
    *  The projection matrix is responsible for adding perspective to our scene.
    *  glLoadIdentity() restores the selected matrix to it‘s original state.
    *  The modelview matrix is where our object information is stored.
    *   Lastly we reset the modelview matrix.
    */

    glMatrixMode(GL_PROJECTION);                      // Select the projection matrix
    glLoadIdentity();                                 // Reset the projection matrix

                                                      // Calculate the aspect ratio of the window
    gluPerspective(45.0f, (GLfloat)width / (GLfloat)height, 1.0f, 1000.0f);

    glMatrixMode(GL_MODELVIEW);                       // Seclet the modelview matrix
    glLoadIdentity();                                 // Reset the modelview matrix
}

int InitGL(GLvoid)                                    // All setup for OpenGL goes here
{
    GLuint tex = 0;
    /*
    *  Smooth shading blends colors nicely across a polygon, and smoothes out lighting.
    */

    glShadeModel(GL_SMOOTH);                          // Enables smooth shading
    glClearColor(0.0f, 0.0f, 0.0f, 0.5f);             // Black background

    glClearDepth(1.0f);                               // Depth buffer setup

    glDepthFunc(GL_LEQUAL);
    glEnable(GL_DEPTH_TEST);

    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);   // Really nice perspective calculations

    LoadTexture("Art/Font.bmp", tex);
    if (tex != 0) {
        gFont.SetFontTexture(tex);
        gFont.SetWindowSize(1024, 768);
        gFont.BuildFont(1.0f);
    }
    else {
        MessageBox(NULL, "Failed to load font texture.", "Error", MB_OK);
    }

    gCamera.m_MaxHeadingRate = 1.0f;
    gCamera.m_MaxPitchRate = 1.0f;
    gCamera.m_HeadingDegrees = 0.0f;

    LoadTexture("Art/HardGlow2.bmp", gCamera.m_GlowTexture);
    if (gCamera.m_GlowTexture == 0) {
        MessageBox(NULL, "Failed to load Hard Glow texture.", "Error", MB_OK);
        return(FALSE);
    }

    LoadTexture("Art/BigGlow3.bmp", gCamera.m_BigGlowTexture);
    if (gCamera.m_BigGlowTexture == 0) {
        MessageBox(NULL, "Failed to load Big Glow texture.", "Error", MB_OK);
        return(FALSE);
    }

    LoadTexture("Art/Halo3.bmp", gCamera.m_HaloTexture);
    if (gCamera.m_HaloTexture == 0) {
        MessageBox(NULL, "Failed to load Halo texture.", "Error", MB_OK);
        return(FALSE);
    }

    LoadTexture("Art/Streaks4.bmp", gCamera.m_StreakTexture);
    if (gCamera.m_StreakTexture == 0) {
        MessageBox(NULL, "Failed to load Streaks texture.", "Error", MB_OK);
        return(FALSE);
    }

    cylList = glGenLists(1);
    qobj = gluNewQuadric();
    gluQuadricDrawStyle(qobj, GLU_FILL);
    gluQuadricNormals(qobj, GLU_SMOOTH);
    glNewList(cylList, GL_COMPILE);
        glEnable(GL_COLOR_MATERIAL);
        glColor3f(0.0f, 0.0f, 1.0f);
        glEnable(GL_LIGHT0);
        glEnable(GL_LIGHTING);
        glTranslatef(0.0f, 0.0f, -2.0f);
//        gluCylinder(qobj, 0.5f, 0.5f, 4.0f, 15, 5);
        glDisable(GL_LIGHTING);
        glDisable(GL_LIGHT0);
        glDisable(GL_COLOR_MATERIAL);
    glEndList();

    gStartTime = timeGetTime();

    return TRUE;
}
/*
*  For now all we will do is clear the screen to the color we previously decided on,
*  clear the depth buffer and reset the scene. We wont draw anything yet.
*/
int DrawGLScene(GLvoid)                                  // Here‘s where we do all the drawing
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  // Clear the screen and the depth buffer
    glLoadIdentity();
    glTranslatef(0.0f, 0.0f, -1.0f);

    gCamera.m_LightSourcePos.z = gCamera.m_Position .z - 50.0f;

    // Pulsing colors based on text position
    // glColor3f(1.0f * float(cos(cnt1)), 1.0f * float(sin(cnt2)), 1.0f - 0.5f * float(cos(cnt1 + cnt2)));
    // Position the text on the screen
    // glRasterPos2f(-0.45f + 0.05f * float(cos(cnt1)), 0.35f * float(sin(cnt2)));
    
    glPushMatrix();
        glLoadIdentity();
        glTranslatef(0.0f, 0.0f, -20.0f);
        glRotatef(timeGetTime() / 50.0f, 0.3f, 0.0f, 0.0f);
        glRotatef(timeGetTime() / 50.0f, 0.0f, 0.5f, 0.0f);
        glCallList(cylList);
    glPopMatrix();
    
    gCamera.SetPrespective();
    gCamera.RenderLensFlare();
    gCamera.UpdateFrustumFaster();

    if (infoOn == TRUE) {
        DrawGLInfo();
    }
    CheckKeys();

    return TRUE;                                         // everthing went OK
}
/*
*  The job of KillGLWindow() is to release the Rendering Context,
*  the Device Context and finally the Window Handle.
*/

GLvoid KillGLWindow(GLvoid)                              // Properly kill the window
{
    if (fullscreen) {                                    // Are we in fullscreen mode

        /*
        *  We use ChangeDisplaySettings(NULL,0) to return us to our original desktop.
        *  After we‘ve switched back to the desktop we make the cursor visible again.
        */

        ChangeDisplaySettings(NULL, 0);                  // if so switch back to the desktop
        ShowCursor(TRUE);                                // Show mouse pointer
    }

    if (hRC) {                                           // Do we have a rendering context
        if (!wglMakeCurrent(NULL, NULL)) {                // Are we able to release the DC and RC contexts
            MessageBox(NULL, "Release of DC and RC failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
        }

        if (!wglDeleteContext(hRC)) {                     // Are we able to delete the RC
            MessageBox(NULL, "Release rendering context failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
            hRC = NULL;                                  // Set RC to NULL
        }

        if (hDC && !ReleaseDC(hWnd, hDC)) {              // Are we able to release the DC
            MessageBox(NULL, "Release device context failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
            hDC = NULL;                                  // Set DC to NULL
        }
        if (hWnd && !DestroyWindow(hWnd)) {              // Are we able to destroy the window
            MessageBox(NULL, "Could not release hWnd.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
            hWnd = NULL;                                 // Set hWnd to NULL
        }

        if (!UnregisterClass("OpenGL", hInstance)) {     // Are we able to unregister class
            MessageBox(NULL, "Could not register class.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
            hInstance = NULL;                            // Set hInstance to NULL
        }
    }
}

/*
* The next section of code creates our OpenGL Window.
*/

BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
    /*
    * Find  a pixel format that matches the one we want
    */
    GLuint PixelFormat;                                  // Holds the result after serching for a match

    /*
    * Before you create a window, you MUST register a Class for the window
    */
    WNDCLASS wc;                                         // Windows class structure

    /*
    *  dwExStyle and dwStyle will store the Extended and normal Window Style Information.
    */
    DWORD dwExStyle;                                     // Window extend style
    DWORD dwStyle;                                       // Window style

    RECT WindowRect;                                     // Grabs rectangle upper left/lower right values
    WindowRect.left = (long)0;                           // Set left value to 0
    WindowRect.right = (long)width;                      // Set right value to requested width
    WindowRect.top = (long)0;                            // Set top value to 0
    WindowRect.bottom = (long)height;                    // Set bottom value to requested height

    fullscreen = fullscreenflag;                         // Set the global fullscreen flag

    /*
    *  The style CS_HREDRAW and CS_VREDRAW force the Window to redraw whenever it is resized.
    *  CS_OWNDC creates a private DC for the Window. Meaning the DC is not shared across applications.
    *  WndProc is the procedure that watches for messages in our program.
    *  No extra Window data is used so we zero the two fields. Then we set the instance.
    *  Next we set hIcon to NULL meaning we don‘t want an ICON in the Window,
    *  and for a mouse pointer we use the standard arrow. The background color doesn‘t matter
    *  (we set that in GL). We don‘t want a menu in this Window so we set it to NULL,
    *  and the class name can be any name you want. I‘ll use "OpenGL" for simplicity.
    */
    hInstance = GetModuleHandle(NULL);                   // Grab an instance for our window
    wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;       // Redraw on move, and own DC for window
    wc.lpfnWndProc = (WNDPROC)WndProc;                   // WndProc handles message
    wc.cbClsExtra = 0;                                   // No extra window date
    wc.cbWndExtra = 0;                                   // No extra window date
    wc.hInstance = hInstance;                            // set the instance
    wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);              // Load the default icon
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);            // Load the arrow pointer
    wc.hbrBackground = NULL;                             // No background requried for GL
    wc.lpszMenuName = NULL;                              // We don‘t want a menu
    wc.lpszClassName = "OpenGL";                         // set the class name

    if (!RegisterClass(&wc)) {                           // Attempt to register the window class
        MessageBox(NULL, "Failed to register the window class.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                                    // Exit and return false
    }

    if (fullscreen) {                                    // attempt fullsreen model

        /*
        *  There are a few very important things you should keep in mind when switching to full screen mode.
        *  Make sure the width and height that you use in fullscreen mode is the same as
        *  the width and height you plan to use for your window, and most importantly,
        *  set fullscreen mode BEFORE you create your window.
        */
        DEVMODE dmScreenSettings;                        // Device mode
        memset(&dmScreenSettings, 0, sizeof(dmScreenSettings)); // Make sure memory‘s cleared
        dmScreenSettings.dmSize = sizeof(dmScreenSettings);     // Size of devmode structure
        dmScreenSettings.dmPelsWidth = width;            // Select window width
        dmScreenSettings.dmPelsHeight = height;          // Select window height
        dmScreenSettings.dmBitsPerPel = bits;            // Select bits per pixel
        dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

        /*
        *  In the line below ChangeDisplaySettings tries to switch to a mode that matches
        *  what we stored in dmScreenSettings. I use the parameter CDS_FULLSCREEN when switching modes,
        *  because it‘s supposed to remove the start bar at the bottom of the screen,
        *  plus it doesn‘t move or resize the windows on your desktop when you switch to
        *  fullscreen mode and back.
        */
        //Try to set selected mode and get results. Note: CDS_FULLSCREEN gets rid of start bar
        if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) {
            //If the mode fails, offer two options. Quit or run in a window
            if (MessageBox(NULL, "The requested fullscreen mode is not supported by\n your video card. Use"
                "windowed mode instead?", "GL", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
            {
                fullscreen = FALSE;                       // Select windowed mode (fullscreen=FLASE)
            }
            else {
                // Pop up a message box letting user know the programe is closing.
                MessageBox(NULL, "Program will now close.", "ERROR", MB_OK | MB_ICONSTOP);
                return FALSE;                             // Exit and return FALSE
            }
        }
    }

    if (fullscreen) {                                     // Are we still in fullscreen mode

        /*
        *  If we are still in fullscreen mode we‘ll set the extended style to WS_EX_APPWINDOW,
        *  which force a top level window down to the taskbar once our window is visible.
        *  For the window style we‘ll create a WS_POPUP window.
        *  This type of window has no border around it, making it perfect for fullscreen mode.

        *  Finally, we disable the mouse pointer. If your program is not interactive,
        *  it‘s usually nice to disable the mouse pointer when in fullscreen mode. It‘s up to you though.
        */
        dwExStyle = WS_EX_APPWINDOW;                      // Window extended style
        dwStyle = WS_POPUP;                               // Window style
        ShowCursor(FALSE);                                // Hide mosue pointer 
    }
    else {

        /*
        *  If we‘re using a window instead of fullscreen mode,
        *  we‘ll add WS_EX_WINDOWEDGE to the extended style. This gives the window a more 3D look.
        *  For style we‘ll use WS_OVERLAPPEDWINDOW instead of WS_POPUP.
        *  WS_OVERLAPPEDWINDOW creates a window with a title bar, sizing border,
        *  window menu, and minimize / maximize buttons.
        */
        dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;   // Window extended style
        dwStyle = WS_OVERLAPPEDWINDOW;                    // Window style
    }

    /*
    *  By using the AdjustWindowRectEx command none of our OpenGL scene will be covered up by the borders,
    *  instead, the window will be made larger to account for the pixels needed to draw the window border.
    *  In fullscreen mode, this command has no effect.
    */
    AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);  // Adjust window to true resqusted

    /*
    *  WS_CLIPSIBLINGS and WS_CLIPCHILDREN are both REQUIRED for OpenGL to work properly.
    *  These styles prevent other windows from drawing over or into our OpenGL Window.
    */
    if (!(hWnd = CreateWindowEx(dwExStyle,                // Extended style for the window
        "OpenGL",                                         // Class name
        title,                                            // Window title
        WS_CLIPSIBLINGS |                                 // Requried window style
        WS_CLIPCHILDREN |                                 // Requried window style
        dwStyle,                                          // Select window style
        0, 0,                                             // Window position
        WindowRect.right - WindowRect.left,               // Calculate adjusted window width
        WindowRect.bottom - WindowRect.top,               // Calculate adjusted window height
        NULL,                                             // No parent window
        NULL,                                             // No menu
        hInstance,                                        // Instance
        NULL)))                                           // Don‘t pass anything to WM_CREATE
    {
        KillGLWindow();                                   //Reset the display
        MessageBox(NULL, "Window creation error.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                                     // Retrurn FALSE;
    }

    /*
    *  aside from the stencil buffer and the (slow) accumulation buffer
    */
    static PIXELFORMATDESCRIPTOR pfd =                    // pfd tells windows how we want things to be 
    {
        sizeof(PIXELFORMATDESCRIPTOR),                    // Size of this pixel format descriptor
        1,                                                // Version number
        PFD_DRAW_TO_WINDOW |                              // Format must support window
        PFD_SUPPORT_OPENGL |                              // Format must support OpenGL
        PFD_DOUBLEBUFFER,                                 // Must support double buffer
        PFD_TYPE_RGBA,                                    // Request an RGBA format
        bits,                                             // Select our color depth
        0, 0, 0, 0, 0, 0,                                 // Color bits ignored
        0,                                                // No alpha buffer
        0,                                                // shift bit ignored
        0,                                                // No accumulation buffer
        0, 0, 0, 0,                                       // Accumulation bits ignored
        16,                                               // 16Bits Z_Buffer (depth buffer)
        0,                                                // No stencil buffer
        0,                                                // No auxiliary buffer
        PFD_MAIN_PLANE,                                   // Main drawing layer
        0,                                                // Reserved
        0, 0, 0                                           // Layer makes ignored
    };

    if (!(hDC = GetDC(hWnd))) {                           // Did we get a device context
        KillGLWindow();                                   // Reset the display
        MessageBox(NULL, "Can‘t create a GL device context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                                     // Return FALSE
    }

    if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd))) {  // Did window find a matching pixel format
        KillGLWindow();                                   // Reset the display
        MessageBox(NULL, "Can‘t find a suitable pixelformat.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                                     // Return FALSE;
    }

    if (!SetPixelFormat(hDC, PixelFormat, &pfd)) {        // Are we able to set the pixel format
        KillGLWindow();                                   // Reset the display
        MessageBox(NULL, "Can‘t set the pixelformat.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                                     // Return FALSE;
    }

    if (!(hRC = wglCreateContext(hDC))) {                 // Are we able to rendering context
        KillGLWindow();                                   // Reset the display
        MessageBox(NULL, "Can‘t create a GL rendering context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                                     // Return FASLE;
    }

    if (!wglMakeCurrent(hDC, hRC)) {                      // Try to activate the rendering context
        KillGLWindow();                                   // Reset the display
        MessageBox(NULL, "Can‘t activate the GL rendering context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                                     // Return FALSE    
    }

    /*
    *  ReSizeGLScene passing the screen width and height to set up our perspective OpenGL screen.
    */
    ShowWindow(hWnd, SW_SHOW);                            // Show the window
    SetForegroundWindow(hWnd);                            // slightly higher priority
    SetFocus(hWnd);                                       // Sets keyboard focus to the window
    ReSizeGLScene(width, height);                         // Set up our perspective GL screen

    /*
    *  we can set up lighting, textures, and anything else that needs to be setup in InitGL().
    */
    if (!InitGL()) {                                      // Initialize our newly created GL window
        KillGLWindow();                                   // Reset the display
        MessageBox(NULL, "Initialize Failed.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                                     // Return FALSE
    }
    return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd,                       // Handle for this window
    UINT uMsg,                                            // Message for this window
    WPARAM wParam,                                        // Additional message information
    LPARAM lParam)                                        // Additional message information
{
    switch (uMsg) {                                       // Check for window message
    case WM_ACTIVATE: {                               // Check minimization state
        if (!HIWORD(wParam)) {
            active = TRUE;                            // Program is active
        }
        else {
            active = FALSE;                           // Program is no longer active
        }
        return 0;                                     // Return to the message loop
    }
    case WM_SYSCOMMAND: {                             // Intercept system commands
        switch (wParam) {                             // Check system calls
        case SC_SCREENSAVE:                       // Screensaver trying to start
        case SC_MONITORPOWER:                     // Monitor trying to enter powersave
            return 0;                                 // Prevent form happening
        }
        break;                                        // Exit
    }
    case WM_CLOSE: {                                  // Did we receive a close message
        PostQuitMessage(0);                           // Send a quit message
        return 0;
    }
    case WM_KEYDOWN: {                                // Is a key being held down
        keys[wParam] = TRUE;                          // if so, mark it as TRUE
        return 0;                                     // Jump back
    }
    case WM_KEYUP: {                                  // Has a key been released
        keys[wParam] = FALSE;                         // if so, mark it as FALSE
        return 0;                                     // Jump back
    }
    case WM_SIZE: {                                   // Resize the OpenGL window
        ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));   // LoWord = width HiWord = height
        return 0;                                     // Jump back
    }
    }
    return DefWindowProc(hWnd, uMsg, wParam, lParam);     // Pass all unhandled message to DefWindwProc
}

int WINAPI WinMain(HINSTANCE hInstance,                   // Instance
    HINSTANCE hPrevInstance,                              // Previous instance
    LPSTR lpCmdLine,                                      // Command line parameters
    int nCmdShow)                                         // Window show state
{
    MSG msg;                                              // Window message structure
    BOOL done = FALSE;                                    // Bool variable to exit loop
    
    // Ask the user which screen mode they prefer
    if (MessageBox(NULL, "Would you like to run in fullscreen mode?",
        "Start fullscreen?", MB_YESNO | MB_ICONQUESTION) == IDNO)
    {
        fullscreen = FALSE;                               // Window mode
    }
    // Create our OpenGL window
    if (!CreateGLWindow("3D Shapes", 640, 480, 16, fullscreen)) {  // (Modified)
        return 0;                                         // Quit if window was not create
    }

    while (!done) {                                       // Loop that runs until donw = TRUE
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {   // Is there a message wating
            if (msg.message == WM_QUIT) {                 // Havw we received a quit message
                done = TRUE;                              // if so done  = TRUE
            }
            else {                                        // If not, deal with window message
                TranslateMessage(&msg);                   // Translate message
                DispatchMessage(&msg);                    // Dispatch message
            }
        }
        else {
            // Draw the scene. Watch for ESC key and quit message from DrawGLScene()
            if (active) {                                 // Program active
                if (keys[VK_ESCAPE]) {                    // Was ESC pressed
                    done = TRUE;                          // ESC signalled a quit
                }
                else {                                    // Not time to quit, update screen
                    DrawGLScene();                        // Draw scene
                    SwapBuffers(hDC);                     // Swap buffers (double buffering)
                }
            }

            /*
            *  It allows us to press the F1 key to switch from fullscreen mode to
            *  windowed mode or windowed mode to fullscreen mode.
            */
            if (keys[VK_F1]) {                            // Is F1 being pressed
                keys[VK_F1] = FALSE;                      // If so make key FASLE
                KillGLWindow();                           // Kill our current window
                fullscreen = !fullscreen;                 // Toggle fullscreen / window mode
                                                          //Recreate our OpenGL window(modified)
                if (!CreateGLWindow("3D Shapes", 640, 480, 16, fullscreen)) {
                    return 0;                             // Quit if window was not create
                }
            }
        }
    }

    gluDeleteQuadric(qobj);
    glDeleteLists(cylList, 1);

    // Shutdown
    KillGLWindow();
    return msg.wParam;
}

void DrawGLInfo(void)
{
    GLfloat modelMatrix[16];             // The model view matrix
    GLfloat projMatrix[16];              // The projection matrix
    GLfloat DiffTime;                    // The difference in time
    char String[64];                     // A temporary string to use to format information

    glGetFloatv(GL_PROJECTION_MATRIX, projMatrix);
    glGetFloatv(GL_MODELVIEW_MATRIX, modelMatrix);

    glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
    // The cameras position
    sprintf(String, "m_Position............. = %.02f, %.02f, %.02f", 
        gCamera.m_Position.x, gCamera.m_Position.y, gCamera.m_Position.z);
    gFont.glPrintf(10, 720, 1, String);
    // The cameras direction
    sprintf(String, "m_DirectionVector...... = %.02f, %.02f, %.02f", 
        gCamera.m_DirectionVector.i, gCamera.m_DirectionVector.j, gCamera.m_DirectionVector.k);
    gFont.glPrintf(10, 700, 1, String);
    // The light sources position
    sprintf(String, "m_LightSourcePos....... = %.02f, %.02f, %.02f", 
        gCamera.m_LightSourcePos.x, gCamera.m_LightSourcePos.y, gCamera.m_LightSourcePos.z);
    gFont.glPrintf(10, 680, 1, String);
    // The intersection point
    sprintf(String, "ptIntersect............ = %.02f, %.02f, %.02f", 
        gCamera.ptIntersect.x, gCamera.ptIntersect.y, gCamera.ptIntersect.x);
    gFont.glPrintf(10, 660, 1, String);
    // The vector that points from the light source to the camera
    sprintf(String, "vLightSourceToCamera... = %.02f, %.02f, %.02f", 
        gCamera.vLightSourceToCamera.i, gCamera.vLightSourceToCamera.j, gCamera.vLightSourceToCamera.k);
    gFont.glPrintf(10, 640, 1, String);
    // The vector that points from the light source to the intersection point
    sprintf(String, "vLightSourceToIntersect = %.02f, %.02f, %.02f", 
        gCamera.vLightSourceToIntersect.i, gCamera.vLightSourceToIntersect.j, gCamera.vLightSourceToIntersect.k);
    gFont.glPrintf(10, 620, 1, String);
    // The below matrix is the model view matrix
    sprintf(String, "GL_MODELVIEW_MATRIX");
    gFont.glPrintf(10, 580, 1, String);
    // The model view matrix
    sprintf(String, "%.02f, %.02f, %.02f, %.02f", 
        modelMatrix[0], modelMatrix[1], modelMatrix[2], modelMatrix[3]);
    gFont.glPrintf(10, 560, 1, String);
    
    sprintf(String, "%.02f, %.02f, %.02f, %.02f", 
        modelMatrix[4], modelMatrix[5], modelMatrix[6], modelMatrix[7]);
    gFont.glPrintf(10, 540, 1, String);

    sprintf(String, "%.02f, %.02f, %.02f, %.02f", 
        modelMatrix[8], modelMatrix[9], modelMatrix[10], modelMatrix[11]);
    gFont.glPrintf(10, 520, 1, String);

    sprintf(String, "%.02f, %.02f, %.02f, %.02f", 
        modelMatrix[12], modelMatrix[13], modelMatrix[14], modelMatrix[15]);
    gFont.glPrintf(10, 500, 1, String);

    // The below matrix is the projection matrix
    sprintf(String, "GL_PROJECTION_MATRIX");
    gFont.glPrintf(10, 460, 1, String);

    // The projection view matrix
    sprintf(String, "%.02f, %.02f, %.02f, %.02f", 
        projMatrix[0], projMatrix[1], projMatrix[2], projMatrix[3]);
    gFont.glPrintf(10, 440, 1, String);

    sprintf(String, "%.02f, %.02f, %.02f, %.02f", 
        projMatrix[4], projMatrix[5], projMatrix[6], projMatrix[7]);
    gFont.glPrintf(10, 420, 1, String);

    sprintf(String, "%.02f, %.02f, %.03f, %.03f", 
        projMatrix[8], projMatrix[9], projMatrix[10], projMatrix[11]);
    gFont.glPrintf(10, 400, 1, String);

    sprintf(String, "%.02f, %.02f, %.03f, %.03f", 
        projMatrix[12], projMatrix[13], projMatrix[14], projMatrix[15]);
    gFont.glPrintf(10, 380, 1, String);

    // The below values are the Frustum clipping planes
    gFont.glPrintf(10, 320, 1, "FRUSTUM CLIPPING PLANES");

    // The clipping plane
    sprintf(String, "%.02f, %.02f, %.02f, %.02f", 
        gCamera.m_Frustum[0][0], gCamera.m_Frustum[0][1], gCamera.m_Frustum[0][2], gCamera.m_Frustum[0][3]);
    gFont.glPrintf(10, 300, 1, String);

    sprintf(String, "%.02f, %.02f, %.02f, %.02f", 
        gCamera.m_Frustum[1][0], gCamera.m_Frustum[1][1], gCamera.m_Frustum[1][2], gCamera.m_Frustum[1][3]);
    gFont.glPrintf(10, 280, 1, String);

    sprintf(String, "%.02f, %.02f, %.02f, %.02f", 
        gCamera.m_Frustum[2][0], gCamera.m_Frustum[2][1], gCamera.m_Frustum[2][2], gCamera.m_Frustum[2][3]);
    gFont.glPrintf(10, 260, 1, String);

    sprintf(String, "%.02f, %.02f, %.02f, %.02f",
        gCamera.m_Frustum[3][0], gCamera.m_Frustum[3][1], gCamera.m_Frustum[3][2], gCamera.m_Frustum[3][3]);
    gFont.glPrintf(10, 240, 1, String);

    sprintf(String, "%.02f, %.02f, %.02f, %.02f", 
        gCamera.m_Frustum[4][0], gCamera.m_Frustum[4][1], gCamera.m_Frustum[4][2], gCamera.m_Frustum[4][3]);
    gFont.glPrintf(10, 220, 1, String);

    sprintf(String, "%.02f, %.02f, %.02f, %.02f", 
        gCamera.m_Frustum[5][0], gCamera.m_Frustum[5][1], gCamera.m_Frustum[5][2], gCamera.m_Frustum[5][3]);
    gFont.glPrintf(10, 200, 1, String);

    if (gFrames >= 100) {
        gCurrentTime = timeGetTime();
        DiffTime = GLfloat(gCurrentTime - gStartTime);
        gFPS = (gFrames / DiffTime) * 1000.0f;
        gStartTime = gCurrentTime;
        gFrames = 1;
    }
    else {
        gFrames++;
    }

    sprintf(String, "FPS %.02f", gFPS);
    gFont.glPrintf(10, 160, 1, String);
}

void CheckKeys(void)
{
    if (keys[‘S‘] == TRUE) {
        gCamera.ChangePitch(-0.05f);
    }

    if (keys[‘W‘] == TRUE) {
        gCamera.ChangePitch(0.05f);
    }

    if (keys[‘A‘] == TRUE) {
        gCamera.ChangeHeading(0.05f);
    }

    if (keys[‘D‘] == TRUE) {
        gCamera.ChangeHeading(-0.05f);
    }

    if (keys[‘Z‘] == TRUE) {
        gCamera.m_ForwardVelocity = 0.02f;
    }

    if (keys[‘C‘] == TRUE) {
        gCamera.m_ForwardVelocity = -0.02f;
    }

    if (keys[‘X‘] == TRUE) {
        gCamera.m_ForwardVelocity = 0.0f;
    }

    if (keys[‘1‘] == TRUE) {
        infoOn = TRUE;
    }

    if (keys[‘2‘] == TRUE) {
        infoOn = FALSE;
    }
}