outdated: 32.Picking, Alpha Blending, Alpha Testing, Sorting

#ifndef GL_FRAMEWORK_INCLUDED
#define GL_FRAMEWORK_INCLUDED

#include <windows.h>

typedef struct {                                   // Structure for keyboard stuff
    BOOL keyDown[256];
} Keys;

typedef struct {                                   // Contains information vital to applications 
    HMODULE hInstance;                             // Application Instance
    const char* className;
} Application;

typedef struct {                                   // Window creation info
    Application* application;
    char* title;
    int width;
    int height;
    int bitsPerPixel;
    BOOL isFullScreen;
} GL_WindowInit;

typedef struct {                                   // Contains information vital to a window
    Keys* keys;
    HWND hWnd;                                     // Windows handle
    HDC hDC;                                       // Device context
    HGLRC hRC;                                     // Rendering context
    GL_WindowInit init;
    BOOL isVisible;                                // Window visiable?
    DWORD lastTickCount;                           // Tick counter
} GL_Window;

void TerminateApplication(GL_Window* window);      // Terminate the application

void ToggleFullscreen(GL_Window* window);          // Toggle fullscreen / Windowed mode

BOOL Initialize(GL_Window* window, Keys* keys);

void Deinitialize(void);

void Update(DWORD milliseconds);

void Draw(void);

void Selection(void);

extern int mouse_x;
extern int mouse_y;

#endif

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

#define WM_TOGGLEFULLSCREEN (WM_USER+1)                   // Application define message for toggling 
                                                          // between fulscreen / windowed mode
static BOOL g_isProgramLooping;                           // Window creation loop, for fullscreen / windowed mode
static BOOL g_createFullScreen;                           // If true, then create window

int mouse_x, mouse_y;                                     // The current position of the mouse

void TerminateApplication(GL_Window* window)              // Terminate the application
{
    PostMessage(window->hWnd, WM_QUIT, 0, 0);             // Send a WM_QUIT message
    g_isProgramLooping = FALSE;                           // Stop looping of the program
}

void ToggleFullscreen(GL_Window* window)                  // Toggle fullscreen /windowed mode
{
    PostMessage(window->hWnd, WM_TOGGLEFULLSCREEN, 0, 0); // Send a WM_TOGGLEFULLSCREEN message
}

void ReshapeGL(int width, int height)                     // Reshape the window  when it‘s moved or resized
{
    glViewport(0, 0, (GLsizei)(width), (GLsizei)(height)); // Reset the current viewport
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    // Calcutate the aspect ratio of the window
    gluPerspective(45.0f, (GLfloat)(width) / (GLfloat)(height), 1.0, 100.0f);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

BOOL ChangeScreenResolution(int width, int height, int bitsPerPixel)     // Change the screen resolution
{
    DEVMODE dmScreenSettings;                              // Device mode
    ZeroMemory(&dmScreenSettings, sizeof(DEVMODE));        // Make sure memory is cleared
    dmScreenSettings.dmSize = sizeof(DEVMODE);             // Size of the devmode structure
    dmScreenSettings.dmPelsWidth = width;
    dmScreenSettings.dmPelsHeight = height;
    dmScreenSettings.dmBitsPerPel = bitsPerPixel;
    dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
    if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) {
        return FALSE;                                      // Display change failed
    }
    return TRUE;
}

BOOL CreateWindowGL(GL_Window* window)
{
    DWORD windowStyle = WS_OVERLAPPEDWINDOW;                // Define window style
    DWORD windowExtendedStyle = WS_EX_APPWINDOW;            // Define the window‘s extended style

    ShowCursor(FALSE);
    PIXELFORMATDESCRIPTOR pdf = {
        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 buffering
        PFD_TYPE_RGBA,                                      // Request an RGBA format
        window->init.bitsPerPixel,                          // Select 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 masks ignored
    };
    RECT windowRect = { 0, 0, window->init.width, window->init.height };   // Window coordiantes

    GLuint PixelFormat;

    if (window->init.isFullScreen == TRUE) {
        if (ChangeScreenResolution(window->init.width, window->init.height, window->init.bitsPerPixel) == FALSE)
        {
            // Fullscreen mode failed, run in windowed mode instead
            MessageBox(HWND_DESKTOP, "Mode Switch Failed.\nRuning In Windowed Mode.", 
                "Error", MB_OK | MB_ICONEXCLAMATION);
            window->init.isFullScreen = FALSE;
        }
        else {
            windowStyle = WS_POPUP;                         // Popup window
            windowExtendedStyle |= WS_EX_TOPMOST;
        }
    }
    else {
        // Adjust window, account for window borders
        AdjustWindowRectEx(&windowRect, windowStyle, 0, windowExtendedStyle);
    }
    // Create Opengl window
    window->hWnd = CreateWindowEx(windowExtendedStyle,      // Extended style
        window->init.application->className,                // Class name
        window->init.title,                                 // Window title
        windowStyle,                                        // Window style
        0, 0,                                               // Window X,Y position
        windowRect.right - windowRect.left,                 // Window width
        windowRect.bottom - windowRect.top,                 // Window height
        HWND_DESKTOP,                                       // Desktop is window‘s parent
        0,                                                  // No menu
        window->init.application->hInstance,                // Pass the window instance
        window);

    if (window->hWnd == 0) {                                // Was window creation a success?
        return FALSE;
    }
    window->hDC = GetDC(window->hWnd);
    if (window->hDC == 0) {
        DestroyWindow(window->hWnd);
        window->hWnd = 0;
        return FALSE;
    }
    PixelFormat = ChoosePixelFormat(window->hDC, &pdf);     // Find a compatible pixel format
    if (PixelFormat == 0) {
        ReleaseDC(window->hWnd, window->hDC);               // Release device context
        window->hDC = 0;
        DestroyWindow(window->hWnd);
        window->hWnd = 0;
        return FALSE;
    }
    if (SetPixelFormat(window->hDC, PixelFormat, &pdf) == FALSE) {   // Try to set the pixel format
        ReleaseDC(window->hWnd, window->hDC);
        window->hDC = 0;
        DestroyWindow(window->hWnd);
        window->hWnd = 0;
        return FALSE;
    }
    window->hRC = wglCreateContext(window->hDC);            // Try to get a rendering context
    if (window->hRC == 0) {
        ReleaseDC(window->hWnd, window->hDC);
        window->hDC = 0;
        DestroyWindow(window->hWnd);
        window->hWnd = 0;
        return FALSE;
    }
    // Make the rendering context our current rendering context
    if (wglMakeCurrent(window->hDC, window->hRC) == FALSE) {
        wglDeleteContext(window->hRC);                      //  Delete the rendering context
        window->hRC = 0;
        ReleaseDC(window->hWnd, window->hDC);
        window->hDC = 0;
        DestroyWindow(window->hWnd);
        window->hWnd = 0;
        return FALSE;
    }
    ShowWindow(window->hWnd, SW_NORMAL);                    // Make the window visiable
    window->isVisible = TRUE;
    ReshapeGL(window->init.width, window->init.height);     // Reshape our GL window
    ZeroMemory(window->keys, sizeof(Keys));                 // Clear all keys
    window->lastTickCount = GetTickCount();
    return TRUE;
}

BOOL DestoryWindowGL(GL_Window* window)
{
    if (window->hWnd != 0) {
        if (window->hDC != 0) {
            wglMakeCurrent(window->hDC, 0);                 // Setting current active rendering context to zero
            if (window->hRC != 0) {
                wglDeleteContext(window->hRC);
                window->hRC = 0;
            }
            ReleaseDC(window->hWnd, window->hDC);
            window->hDC = 0;
        }
        DestroyWindow(window->hWnd);
        window->hWnd = 0;
    }
    if (window->init.isFullScreen) {
        ChangeDisplaySettings(NULL, 0);                     // Switch back to desktop resolution
    }
    ShowCursor(TRUE);
    return TRUE;
}

// Process window message callback
LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    // Get the window context
    GL_Window* window = (GL_Window*)(GetWindowLong(hWnd, GWL_USERDATA));
    switch (uMsg) {                                         // Evaluate window message
    case WM_SYSCOMMAND:                                     // Intercept system commands
    {
        switch (wParam) {                                   // Check system calls
        case SC_SCREENSAVE:                                 // Screensaver trying to start?
        case SC_MONITORPOWER:                               // Mointer trying to enter powersave?
        return 0;                                           // Prevent form happening
        }
        break;
    }
    return 0;
    case WM_CREATE:
    {
        CREATESTRUCT* creation = (CREATESTRUCT*)(lParam);   // Store window structure pointer
        window = (GL_Window*)(creation->lpCreateParams);
        SetWindowLong(hWnd, GWL_USERDATA, (LONG)(window));
    }
    return 0;
    
    case WM_CLOSE:
        TerminateApplication(window);
    return 0;

    case WM_SIZE:
        switch (wParam) {
        case SIZE_MINIMIZED:                                 // Was window minimized?
            window->isVisible = FALSE;
            return 0;
        case SIZE_MAXIMIZED:
            window->isVisible = TRUE;
            ReshapeGL(LOWORD(lParam), HIWORD(lParam));
            return 0;
        case SIZE_RESTORED:
            window->isVisible = TRUE;
            ReshapeGL(LOWORD(lParam), HIWORD(lParam));
            return 0;
        }
        break;

    case WM_KEYDOWN:
        if ((wParam >= 0) && (wParam <= 255)) {
            window->keys->keyDown[wParam] = TRUE;            // Set the selected key(wParam) to true
            return 0;
        }
        break;
    
    case WM_KEYUP:
        if ((wParam >= 0) && (wParam <= 255)) {
            window->keys->keyDown[wParam] = FALSE;
            return 0;
        }
        break;
    
    case WM_TOGGLEFULLSCREEN:
        g_createFullScreen = (g_createFullScreen == TRUE) ? FALSE : TRUE;
        PostMessage(hWnd, WM_QUIT, 0, 0);
        break;

    case WM_LBUTTONDOWN:
    {
        mouse_x = LOWORD(lParam);
        mouse_y = HIWORD(lParam);
        Selection();
    }
    break;

    case WM_MOUSEMOVE:
    {
        mouse_x = LOWORD(lParam);
        mouse_y = HIWORD(lParam);
    }
    break;
    }
    return DefWindowProc(hWnd, uMsg, wParam, lParam);        // Pass unhandle message to DefWindowProc
}

BOOL RegisterWindowClass(Application* application)
{
    WNDCLASSEX windowClass;
    ZeroMemory(&windowClass, sizeof(WNDCLASSEX));            // Make sure memory is cleared
    windowClass.cbSize = sizeof(WNDCLASSEX);                 // Size of the windowClass structure
    windowClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;  // Redraws the window for any movement / resizing
    windowClass.lpfnWndProc = (WNDPROC)(WindowProc);         // WindowProc handles message
    windowClass.hInstance = application->hInstance;          // Set the instance
    windowClass.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE);// Class background brush color
    windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);       // Load the arrow pointer
    windowClass.lpszClassName = application->className;      // Sets the application className
    if (RegisterClassEx(&windowClass) == 0) {
        MessageBox(HWND_DESKTOP, "RegisterClassEx Failed!", "Error", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;
    }
    return TRUE;
}

int WINAPI WinMain(HINSTANCE hIstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    Application application;
    GL_Window window;
    Keys keys;
    BOOL isMessagePumpActive;
    MSG msg;
    DWORD tickCount;

    application.className = "OpenGL";
    application.hInstance = hIstance;

    ZeroMemory(&window, sizeof(GL_Window));
    window.keys = &keys;                                     // Window key structure
    window.init.application = &application;                  // Window application
    window.init.title = "Picking";                           // Window title
    window.init.width = 640;                                 // Window width
    window.init.height = 480;                                // Window height
    window.init.bitsPerPixel = 16;                           // Bits per pixel
    window.init.isFullScreen = TRUE;                         // Fullscreen? (set to TRUE)

    ZeroMemory(&keys, sizeof(Keys));
    if (MessageBox(HWND_DESKTOP, "Would You Like To Run In Fullscreen Mode?", "Start FullScreen?", 
        MB_YESNO | MB_ICONQUESTION) == IDNO)
    {
        window.init.isFullScreen = FALSE;
    }
    if (RegisterWindowClass(&application) == FALSE)
    {
        MessageBox(HWND_DESKTOP, "Error Registering Window Class!", "Error", MB_OK | MB_ICONEXCLAMATION);
        return -1;
    }
    g_isProgramLooping = TRUE;
    g_createFullScreen = window.init.isFullScreen;
    while (g_isProgramLooping) {                             // Loop until WM_QUIT is received
        window.init.isFullScreen = g_createFullScreen;       // Set init param of window creation to fullscreen?
        if (CreateWindowGL(&window) == TRUE) {               // Was window creation successful?
            // At this point we should have a window that is setup to render OpenGL
            if (Initialize(&window, &keys) == FALSE) {
                TerminateApplication(&window);               // Close window, this will handle the shutdown
            }
            else {
                isMessagePumpActive = TRUE;
                while (isMessagePumpActive == TRUE) {
                    // Success creating window. Check for window messages
                    if (PeekMessage(&msg, window.hWnd, 0, 0, PM_REMOVE) != 0) {
                        if (msg.message != WM_QUIT) {
                            DispatchMessage(&msg);
                        }
                        else {
                            isMessagePumpActive = FALSE;     // Terminate the message pump
                        }
                    }
                    else {
                        if (window.isVisible == FALSE) {
                            WaitMessage();                   // Application is minimized wait for a message
                        }
                        else {
                            // Process application loop
                            tickCount = GetTickCount();      // Get the tick count
                            Update(tickCount - window.lastTickCount); // Update the counter
                            window.lastTickCount = tickCount;// Set last count to current count
                            Draw();                          // Draw screen
                            SwapBuffers(window.hDC);
                        }
                    }
                }
            }
            // Application is finished
            Deinitialize();
            DestoryWindowGL(&window);
        }
        else {
            MessageBox(HWND_DESKTOP, "Error Creating OpenGL Window", "Error", MB_OK | MB_ICONEXCLAMATION);
            g_isProgramLooping = FALSE;
        }
    }
    UnregisterClass(application.className, application.hInstance);    // UnRegister window class
    return 0;
}

#include <windows.h>
#include <math.h>
#include <stdio.h>
#include <stdarg.h>
#include <gl/glew.h>
#include <GL\glut.h>
#include <time.h>
#include "Previous.h"

#pragma comment( lib, "winmm.lib" )                                // Search for winMM library while linking
#pragma comment(lib, "legacy_stdio_definitions.lib")

#ifndef CDS_FULLSCREEN 
#define CDS_FULLSCREEN 4
#endif

void DrawTargets();

GL_Window* g_window;
Keys* g_keys;

GLuint base;                                                 // Front display list
GLuint roll;                                                 // Rolling clouds
GLint level = 1;                                             // Current level
GLint miss;                                                  // Missed Targets
GLint kills;                                                 // Level kill counter
GLint score;                                                 // Current score
bool game;                                                   // Game over?

typedef int(*compfn)(const void*, const void*);              // Typedef for compare function

struct objects {
    GLuint rot;                                              // Rotation
    bool hit;                                                // Object hit
    GLuint frame;                                             // Current explosion fram
    GLuint dir;                                              // Object Direction
    GLuint texid;                                            // Texture ID
    GLfloat x;                                               // Object X position
    GLfloat y;                                               // Object Y position
    GLfloat spin;                                            // Object spin
    GLfloat distance;                                        // Object distance
};

typedef struct {
    GLubyte* imageData;
    GLuint bpp;                                              // Image color depth in bits per pixel
    GLuint width;
    GLuint height;
    GLuint texID;
} TextureImage;

TextureImage textures[10];

objects object[30];

struct dimension {
    GLfloat w;                                                  // Width
    GLfloat h;                                                  // Height
};

// Size of each object : Blueface,      Bucket,       Targets,       Coke,          Vase
dimension size[5] = { {1.0f, 1.0f},{ 1.0f, 1.0f },{ 1.0f, 1.0f },{0.5f, 1.0f}, {0.75f, 1.5f} };

bool LoadTGA(TextureImage* texture, char* filename)
{
    GLubyte TGAheader[12] = { 0,0,2,0,0,0,0,0,0,0,0,0 };// Uncompressed TGA header
    GLubyte TGAcompare[12];                             // Used to compare TGA header
    GLubyte header[6];                                  // First 6 useful bytes from the header
    GLuint bytesPerPixel;                               // Holds number of bytes per pixel used in the TGA file
    GLuint imageSize;                                    // Used to store the image size when setting aside ram
    GLuint temp;                                        // Temporary variable
    GLuint type = GL_RGBA;                              // Set the default GL mode to RGBA (32 bpp)

    FILE* file = fopen(filename, "rb");
    if (file == NULL || fread(TGAcompare, 1, sizeof(TGAcompare), file) != sizeof(TGAcompare) ||
        memcmp(TGAheader, TGAcompare, sizeof(TGAheader)) != 0 ||
        fread(header, 1, sizeof(header), file) != sizeof(header))
    {
        if (file == NULL) {
            return FALSE;
        }
        else {
            fclose(file);
            return FALSE;
        }
    }

    texture->width = header[1] * 256 + header[0];
    texture->height = header[3] * 256 + header[2];

    if (texture->width <= 0 || texture->height <= 0 || (header[4] != 24 && header[4] != 32)) {
        fclose(file);
        return FALSE;
    }
    texture->bpp = header[4];
    bytesPerPixel = texture->bpp / 8;
    imageSize = texture->width * texture->height * bytesPerPixel;
    texture->imageData = (GLubyte*)malloc(imageSize);

    if (texture->imageData == NULL || fread(texture->imageData, 1, imageSize, file) != imageSize) {
        if (texture->imageData != NULL) {
            free(texture->imageData);
        }
        fclose(file);
        return  FALSE;
    }
    for (GLuint i = 0; i < int(imageSize); i += bytesPerPixel) {
        temp = texture->imageData[i];
        texture->imageData[i] = texture->imageData[i + 2];
        texture->imageData[i + 2] = temp;
    }
    fclose(file);
    glGenTextures(1, &texture[0].texID);

    glBindTexture(GL_TEXTURE_2D, texture[0].texID);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    if (texture[0].bpp == 24) {
        type = GL_RGB;
    }
    glTexImage2D(GL_TEXTURE_2D, 0, type, texture[0].width, texture[0].height, 0, type, 
        GL_UNSIGNED_BYTE, texture[0].imageData);
    return true;
}

GLvoid BuildFont(GLvoid)
{
    base = glGenLists(95);
    glBindTexture(GL_TEXTURE_2D, textures[9].texID);
    for (int loop = 0; loop < 95; ++loop) {
        float cx = float(loop % 16) / 16.0f;
        float cy = float(loop / 16) / 8.0f;

        glNewList(base + loop, GL_COMPILE);
            glBegin(GL_QUADS);
                glTexCoord2f(cx, 1.0f - cy - 0.120f);
                glVertex2i(0, 0);
                glTexCoord2f(cx + 0.0625f, 1.0f - cy - 0.120f);
                glVertex2i(16, 0);
                glTexCoord2f(cx + 0.0625f, 1.0f - cy);
                glVertex2i(16, 16);
                glTexCoord2f(cx, 1.0f - cy); glVertex2i(0, 16);
            glEnd();
            glTranslated(10, 0, 0);
        glEndList();
    }
}

GLvoid glPrint(GLint x, GLint y, const char *string, ...)
{
    char text[256];
    va_list    ap;                                              // Pointer to list of arguments

    if (string == NULL) {
        return;
    }

    va_start(ap, string);                                    // Parses the string for variables
    vsprintf(text, string, ap);                              // And converts symbols to actual numbers
    va_end(ap);                                              // Results are stored in text

    glBindTexture(GL_TEXTURE_2D, textures[9].texID);
    glPushMatrix();
    glLoadIdentity();
    glTranslated(x, y, 0);
    glListBase(base - 32);
    glCallLists(strlen(text), GL_UNSIGNED_BYTE, text);       // Draws the display list text
    glPopMatrix();
}

int Compare(struct objects* elem1, struct objects* elem2)
{
    if (elem1->distance < elem2->distance) {
        return -1;
    }
    else if (elem1->distance > elem2->distance) {
        return 1;
    }
    else {
        return 0;
    }
}

GLvoid InitObject(int num)
{
    object[num].rot = 1;                                     // Clockwise rotation
    object[num].frame = 0;                                    // Reset the explosion fram
    object[num].hit = FALSE;                                 // Reset object hit status
    object[num].texid = rand() % 5;
    object[num].distance = -(float(rand() % 4001) / 100.0f);
    object[num].y = -1.5f + (float(rand() % 451) / 100.0f);
    object[num].x = ((object[num].distance - 15.0f) / 2.0f) - (5 * level) - float(rand() % (5 * level));
    object[num].dir = (rand() % 2);

    if (object[num].dir == 0) {
        object[num].rot = 2;
        object[num].x = -object[num].x;
    }
    if (object[num].texid == 0) {                            // Blue face
        object[num].y = -2.0f;
    }
    if (object[num].texid == 1) {                            // Bucket
        object[num].dir = 3;
        object[num].x = float(rand() % int(object[num].distance - 10.0f)) + 
            ((object[num].distance - 10.0f) / 2.0f);
        object[num].y = 4.5f;
    }
    if (object[num].texid == 2) {                            // Target
        object[num].dir = 2;
        object[num].x = float(rand() % int(object[num].distance - 10.0f)) + 
            ((object[num].distance - 10.0f) / 2.0f);
        object[num].y = -3.0f - float(rand() % (5 * level));
    }
    qsort((void*)&object, level, sizeof(struct objects), (compfn)Compare);
}

BOOL Initialize(GL_Window* window, Keys* keys)
{
    g_window = window;
    g_keys = keys;
    srand((unsigned)time(NULL));
    if ((!LoadTGA(&textures[0], "Data/BlueFace.tga")) ||     // Load the blueface texture
        (!LoadTGA(&textures[1], "Data/Bucket.tga")) ||       // Load the bucket texture
        (!LoadTGA(&textures[2], "Data/Target.tga")) ||       // Load the target Texture
        (!LoadTGA(&textures[3], "Data/Coke.tga")) ||         // Load the coke texture
        (!LoadTGA(&textures[4], "Data/Vase.tga")) ||         // Load the vase texture
        (!LoadTGA(&textures[5], "Data/Explode.tga")) ||      // Load the explosion texture
        (!LoadTGA(&textures[6], "Data/Ground.tga")) ||       // Load the ground texture
        (!LoadTGA(&textures[7], "Data/Sky.tga")) ||          // Load the sky texture
        (!LoadTGA(&textures[8], "Data/Crosshair.tga")) ||    // Load the crosshair texture
        (!LoadTGA(&textures[9], "Data/Font.tga")))           // Load the crosshair texture
    {
        return FALSE;
    }
    BuildFont();
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClearDepth(1.0f);
    glDepthFunc(GL_LEQUAL);
    glEnable(GL_DEPTH_TEST);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);       // Enable alpha blending
    glEnable(GL_BLEND);
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_CULL_FACE);

    for (int loop = 0; loop < 30; ++loop) {
        InitObject(loop);
    }
    return TRUE;
}

void Deinitialize(void)
{
    glDeleteLists(base, 95);
}

void Selection(void)
{
    GLuint buffer[512];                                      // Set up a selection buffer
    GLint hits;                                              // The number of objects that we selected

    if (game) {
        return;
    }
    PlaySound("data/shot.wav", NULL, SND_ASYNC);
    GLint viewport[4];                                       // x, y, length, width
    
    // This sets the array <viewport> to the size and location of the screen relative to the window
    glGetIntegerv(GL_VIEWPORT, viewport);
    glSelectBuffer(512, buffer);                             // Tell opengl to use our array for selection
    
    // Puts opengl in selection mode. Nothing will be draw. Object ID‘s and extents are stored in the buffer
    (void)glRenderMode(GL_SELECT);
    glInitNames();                                           // Name stack
    glPushName(0);

    glMatrixMode(GL_PROJECTION);                             // Selects the projection matrix
    glPushMatrix();
    glLoadIdentity();

    // This create a matrix that will zoom up to a small portion of the screen, where the mouse is.
    gluPickMatrix((GLdouble)mouse_x, (GLdouble)(viewport[3] - mouse_y), 1.0f, 1.0f, viewport);

    // Apply the perspective matrix
    gluPerspective(45.0f, (GLfloat)(viewport[2] - viewport[0]) / (GLfloat)(viewport[3] - viewport[1]), 
        0.1f, 100.0f);
    glMatrixMode(GL_MODELVIEW);
    DrawTargets();                                           // Render the targets to the selection buffer
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    hits = glRenderMode(GL_RENDER);

    if (hits > 0) {
        int choose = buffer[3];
        int depth = buffer[1];
        for (int loop = 1; loop < hits; ++loop) {
            if (buffer[loop * 4 + 1] < GLuint(depth)) {
                choose = buffer[loop * 4 + 3];
                depth = buffer[loop * 4 + 1];
            }
        }
        if (!object[choose].hit) {
            object[choose].hit = TRUE;
            score += 1;
            kills += 1;
            if (kills > level * 5) {
                miss = 0;
                kills = 0;
                level += 1;
                if (level > 30) {
                    level = 30;
                }
            }
        }
    }
}

void Update(DWORD milliseconds)
{
    if (g_keys->keyDown[VK_ESCAPE]) {
        TerminateApplication(g_window);
    }
    if (g_keys->keyDown[‘ ‘] && game) {
        for (int loop = 0; loop < 30; ++loop) {
            InitObject(loop);
        }
        game = FALSE;
        score = 0; 
        level = 1;
        kills = 0;
        miss = 0;
    }
    if (g_keys->keyDown[VK_F1]) {
        ToggleFullscreen(g_window);
    }
    roll -= milliseconds * 0.00005f;                         // Roll the clouds
    for (int loop = 0; loop < level; ++loop)
    {
        if (object[loop].rot == 1)                           // If Rotation is clockwise
            object[loop].spin -= 0.2f * (float(loop + milliseconds));    // Spin clockwise

        if (object[loop].rot == 2)                           // If rotation is counter clockwise
            object[loop].spin += 0.2f * (float(loop + milliseconds));    // Spin counter clockwise

        if (object[loop].dir == 1)                           // If direction is right
            object[loop].x += 0.012f * float(milliseconds);    // Move right

        if (object[loop].dir == 0)                           // If direction is left
            object[loop].x -= 0.012f * float(milliseconds);    // Move left

        if (object[loop].dir == 2)                           // If direction is up
            object[loop].y += 0.012f * float(milliseconds);    // Move up

        if (object[loop].dir == 3)                           // If direction isdown
            object[loop].y -= 0.0025f * float(milliseconds);   // Move down
        // If we are to far left, direction is left and the object was not hit
        if ((object[loop].x < (object[loop].distance - 15.0f) / 2.0f) && (object[loop].dir == 0) && 
            !object[loop].hit)
        {
            miss += 1;                                       // Increase miss
            object[loop].hit = TRUE;
        }

        if ((object[loop].x > -(object[loop].distance - 15.0f) / 2.0f) && (object[loop].dir == 1) && 
            !object[loop].hit)
        {
            miss += 1;
            object[loop].hit = TRUE;
        }

        if ((object[loop].y < -2.0f) && (object[loop].dir == 3) && !object[loop].hit) {
            miss += 1;
            object[loop].hit = TRUE;
        }

        if ((object[loop].y > 4.5f) && (object[loop].dir == 2)) {
            object[loop].dir = 3;
        }
    }
}

void Object(float width, float height, GLuint texid)
{
    glBindTexture(GL_TEXTURE_2D, textures[texid].texID);
    glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-width, -height, 0.0f);
        glTexCoord2f(1.0f, 0.0f); glVertex3f(width, -height, 0.0f);
        glTexCoord2f(1.0f, 1.0f); glVertex3f(width, height, 0.0f);
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-width, height, 0.0f);
    glEnd();
}

void Explosion(int num)
{
    float ex = (float)((object[num].frame / 4) % 4) / 4.0f;
    float ey = (float)((object[num].frame / 4) / 4) / 4.0f;

    glBindTexture(GL_TEXTURE_2D, textures[5].texID);
    glBegin(GL_QUADS);
        glTexCoord2f(ex, 1.0f - (ey));
        glVertex3f(-1.0f, -1.0f, 0.0f);
        glTexCoord2f(ex + 0.25f, 1.0f - (ey));
        glVertex3f(1.0f, -1.0f, 0.0f);
        glTexCoord2f(ex + 0.25f, 1.0f - (ey + 0.25f));
        glVertex3f(1.0f, 1.0f, 0.0f);
        glTexCoord2f(ex, 1.0f - (ey + 0.25f));
        glVertex3f(-1.0f, 1.0f, 0.0f);
    glEnd();

    object[num].frame += 1;
    if (object[num].frame > 63)
    {
        InitObject(num);
    }
}

void DrawTargets(void)
{
    glLoadIdentity();
    glTranslatef(0.0f, 0.0f, -10.0f);
    for (int loop = 0; loop < level; ++loop) {
        glLoadName(loop);                                    // Assign object a name (ID)
        glPushMatrix();
        glTranslatef(object[loop].x, object[loop].y, object[loop].distance);
        if (object[loop].hit) {
            Explosion(loop);
        }
        else {
            glRotatef(object[loop].spin, 0.0f, 0.0f, 1.0f);
            Object(size[object[loop].texid].w, size[object[loop].texid].h, object[loop].texid);
        }
        glPopMatrix();
    }
}

void Draw(void)                                              // Draw scene
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();

    glPushMatrix();
    glBindTexture(GL_TEXTURE_2D, textures[7].texID);
    glBegin(GL_QUADS);
    glTexCoord2f(1.0f, roll / 1.5f + 1.0f); glVertex3f(28.0f, +7.0f, -50.0f);
    glTexCoord2f(0.0f, roll / 1.5f + 1.0f); glVertex3f(-28.0f, +7.0f, -50.0f);
    glTexCoord2f(0.0f, roll / 1.5f + 0.0f); glVertex3f(-28.0f, -3.0f, -50.0f);
    glTexCoord2f(1.0f, roll / 1.5f + 0.0f); glVertex3f(28.0f, -3.0f, -50.0f);

    glTexCoord2f(1.5f, roll + 1.0f); glVertex3f(28.0f, +7.0f, -50.0f);
    glTexCoord2f(0.5f, roll + 1.0f); glVertex3f(-28.0f, +7.0f, -50.0f);
    glTexCoord2f(0.5f, roll + 0.0f); glVertex3f(-28.0f, -3.0f, -50.0f);
    glTexCoord2f(1.5f, roll + 0.0f); glVertex3f(28.0f, -3.0f, -50.0f);

    glTexCoord2f(1.0f, roll / 1.5f + 1.0f); glVertex3f(28.0f, +7.0f, 0.0f);
    glTexCoord2f(0.0f, roll / 1.5f + 1.0f); glVertex3f(-28.0f, +7.0f, 0.0f);
    glTexCoord2f(0.0f, roll / 1.5f + 0.0f); glVertex3f(-28.0f, +7.0f, -50.0f);
    glTexCoord2f(1.0f, roll / 1.5f + 0.0f); glVertex3f(28.0f, +7.0f, -50.0f);

    glTexCoord2f(1.5f, roll + 1.0f); glVertex3f(28.0f, +7.0f, 0.0f);
    glTexCoord2f(0.5f, roll + 1.0f); glVertex3f(-28.0f, +7.0f, 0.0f);
    glTexCoord2f(0.5f, roll + 0.0f); glVertex3f(-28.0f, +7.0f, -50.0f);
    glTexCoord2f(1.5f, roll + 0.0f); glVertex3f(28.0f, +7.0f, -50.0f);
    glEnd();

    glBindTexture(GL_TEXTURE_2D, textures[6].texID);
    glBegin(GL_QUADS);
    glTexCoord2f(7.0f, 4.0f - roll); glVertex3f(27.0f, -3.0f, -50.0f);
    glTexCoord2f(0.0f, 4.0f - roll); glVertex3f(-27.0f, -3.0f, -50.0f);
    glTexCoord2f(0.0f, 0.0f - roll); glVertex3f(-27.0f, -3.0f, 0.0f);
    glTexCoord2f(7.0f, 0.0f - roll); glVertex3f(27.0f, -3.0f, 0.0f);
    glEnd();

    DrawTargets();
    glPopMatrix();

    // Crosshair (In Ortho View)
    RECT window;                                             // Storage For Window Dimensions
    GetClientRect(g_window->hWnd, &window);                  // Get Window Dimensions
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    glOrtho(0, window.right, 0, window.bottom, -1, 1);
    glMatrixMode(GL_MODELVIEW);
    glTranslated(mouse_x, window.bottom - mouse_y, 0.0f);
    Object(16, 16, 8);                                       // Crosshair

    glPrint(240, 450, "Productions");
    glPrint(10, 10, "Level: %i", level);
    glPrint(250, 10, "Score: %i", score);

    if (miss > 9) {
        miss = 9;
        game = TRUE;
    }

    if (game) {
        glPrint(490, 10, "GAME OVER");
    }
    else {
        glPrint(490, 10, "Morale: %i/10", 10 - miss);
    }

    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);

    glFlush();                                               // Flush the GL rendering pipeline
}