---

main.cpp

Go to the documentation of this file.

// OpenGL & Win32 (Tutorial No.22 - Polygon Selection/Picking)
// Alan Baylis 09/08/2003

#include <windows.h>
#include "shared.h"
#include "general.h"      // (NEW) Added line_plane_collision function by Kevin Kaiser
#include "object.h"
#include "camera.h"
#include "vector.h"
#include "vertex.h" // (NEW) Overloaded the = operator for this class
#include "quat.h"
#include "matrix.h"
#include "texture.h"
#include "locmath.h"
#include "polygon.h"
#include "collision.h"
#include "glfont.h"
#include "flare.h"
#include "console.h"
#include "mmgr.h"
#include "log.h"
#include "selection.h"
#include "resource.rh"

// (NEW) Polygon Selection
int selectedPolygon = -1; // Currently selected polygon index (zero based)

// (NEW) Mouse input
int MouseX;
int MouseY;
int g_iMouseLastX;
int g_iMouseLastY;
int g_iMouseDeltaX;
int g_iMouseDeltaY;
int g_bLeftMouseDrag;
int g_bRightMouseDrag;

// Windows
static HGLRC hRC;
static HDC hDC;
HWND hWnd;
RECT screen;
PAINTSTRUCT ps;

// Math
float pi = 3.141592;
float radian = pi / 180;
float epsilon = 0.05;

// Input
bool key[256];
bool released_key[256];

// Cameras
int currentCamera = 0;
int numCameras = 4;
float step = 5.0;

// Timing
float lasttime;
float multiplier;
const int average = 10;
float lastmultiplier[average];
int fps;

// Lights
int GL_LIGHT[8] = {GL_LIGHT0, GL_LIGHT1, GL_LIGHT2, GL_LIGHT3, GL_LIGHT4, GL_LIGHT5, GL_LIGHT6, GL_LIGHT7};    // Represent GL lights in a convenient array
int currentLight = 0;
int numLights = 0;

// Cube polygons
POLYGON * polygon = new POLYGON[12];

// Texture
TEXTURE * texture = new TEXTURE[8];

// Camera
CAMERA * camera = new CAMERA[numCameras + 1];
CAMERA LastCam;

// Lighting
LIGHT * light = new LIGHT[numLights + 1];
float lightColor[3] = {1.0, 1.0, 1.0};

// Dialogs
int DialogInUse = 0;
int testint;
float testfloat;
char teststring[64];

// Font
GLFONT myFont;

// Flare
float SunPosition[3];

void InitGL(int Width, int Height)
{
    glFeedbackBuffer(4, GL_3D, SunPosition);
    SetGLProperties();
    SetGLMaterial();
    SetGLView(Width, Height);
    SetGLLighting();
    SetGLWorld(polygon);
    SetGLTexture(texture);
    SetGLCamera(camera);
    glFontCreate(&myFont, "roman.glf", 200);
    InitializeLensFlare();            
}

void ReSizeGLScene(int Width, int Height)
{
    SetGLView(Width, Height);
}

void DrawGLScene(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    LastCam = camera[currentCamera];
    camera[currentCamera].Update();

    CollisionPacket cp;
    cp.eRadius.x = 1.0;
    cp.eRadius.y = 1.0;
    cp.eRadius.z = 1.0;
    cp.sourcePoint.x = LastCam.Position.x;
    cp.sourcePoint.y = LastCam.Position.y;
    cp.sourcePoint.z = LastCam.Position.z;
    cp.velocity.x = camera[currentCamera].Position.x - LastCam.Position.x;
    cp.velocity.y = camera[currentCamera].Position.y - LastCam.Position.y;
    cp.velocity.z = camera[currentCamera].Position.z - LastCam.Position.z;

    CheckForCollision(polygon, &camera[currentCamera].Position, &cp);

    camera[currentCamera].Apply();
    camera[currentCamera].Delta_x = 0.0;                   // Clear camera rotation deltas
    camera[currentCamera].Delta_y = 0.0;
    camera[currentCamera].Delta_z = 0.0;

    int loop;
    for(loop = 0; loop <= numLights; loop++)
        light[loop].Apply();

    DrawSkybox(camera, texture);
    DrawCube(polygon, texture);
    DrawCone();
    DrawSphere();
    DrawTerrain(texture);     
    DrawLensFlare();   // Draw the lens flare after all other objects

// Draw text
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glDisable(GL_LIGHTING);
    glColor3f(0.0, 1.0, 0.0);
    glEnable(GL_BLEND);
    glDisable(GL_DEPTH_TEST);
    glPushMatrix();
    glLoadIdentity();
    glFontBegin(&myFont);
    char text[256];

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

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

    glFontTextOut("Press R to change the lens flare", -52, 30, -100);
    glFontTextOut("Click and hold left mouse button to rotate the camera", -52, 26, -100);
    glFontTextOut("Double click the left mouse button on the cube to select a polygon", -52, 22, -100);
    sprintf(text, "Currently selected polygon = %d", selectedPolygon);
    glFontTextOut(text, -52, 18, -100);

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

LRESULT CALLBACK WndProc(    HWND    hWnd,
                            UINT    message,
                            WPARAM    wParam,
                            LPARAM    lParam)
{
    GLuint    PixelFormat;
    static    PIXELFORMATDESCRIPTOR pfd=
    {
           sizeof(PIXELFORMATDESCRIPTOR),
        1,
        PFD_DRAW_TO_WINDOW |
        PFD_SUPPORT_OPENGL |
        PFD_DOUBLEBUFFER,
        PFD_TYPE_RGBA,
        16,
        0, 0, 0, 0, 0, 0,
        0,
        0,
        0,
        0, 0, 0, 0,
        16,
        0,
        0,
        PFD_MAIN_PLANE,
        0,
        0, 0, 0
    };


    switch (message)
    {
        // (NEW) SelectPolygon function added to selection.cpp
        case WM_LBUTTONDBLCLK:
        {
            int result;
            result = SelectPolygon(hWnd, polygon, 12, LOWORD(lParam), HIWORD(lParam));
            if (result > -1)
                selectedPolygon = result;
        }
        break;

        case WM_CREATE:
            hDC = GetDC(hWnd);

            PixelFormat = ChoosePixelFormat(hDC, &pfd);

            if (!PixelFormat)
            {
                   MessageBox(NULL,"Can't find a suitable PixelFormat.","Error",MB_OK|MB_ICONERROR);
                PostQuitMessage(0);
                break;
            }

            if(!SetPixelFormat(hDC,PixelFormat,&pfd))
            {
                MessageBox(NULL,"Can't set the PixelFormat.","Error",MB_OK|MB_ICONERROR);
                PostQuitMessage(0);
                break;
            }

            hRC = wglCreateContext(hDC);
            if(!hRC)
            {
                MessageBox(NULL,"Can't create a GL Rendering Context.","Error",MB_OK|MB_ICONERROR);
                PostQuitMessage(0);
                break;
            }

            if(!wglMakeCurrent(hDC, hRC))
            {
                MessageBox(NULL,"Can't activate the GL Rendering Context.","Error",MB_OK|MB_ICONERROR);
                PostQuitMessage(0);
                break;
            }
            InitGL(screen.right, screen.bottom);
        break;

        case WM_SYSCOMMAND:
        {
            switch (wParam)
            {
                case SC_SCREENSAVE:
                case SC_MONITORPOWER:
                    return 0;
            }
            break;
        }
/*
        if (DialogInUse)
        {
            case WM_PAINT:
                BeginPaint(hWnd,&ps);
                DrawGLScene();
                glFlush();
                SwapBuffers(hDC);
                EndPaint(hWnd,&ps);
            break;
        }
*/
        case WM_DESTROY:
        case WM_CLOSE:
            delete[] texture;
            delete[] polygon;
            delete[] camera;
            delete[] light;
            CleanupLensFlare();

            ChangeDisplaySettings(NULL, 0);
            wglMakeCurrent(hDC,NULL);
            wglDeleteContext(hRC);
            ReleaseDC(hWnd,hDC);

            PostQuitMessage(0);
        break;

        case WM_KEYDOWN:
            key[wParam] = TRUE;
        break;

        case WM_KEYUP:
            key[wParam] = FALSE;
        break;

        case WM_SIZE:
            SetCursorPos((int)(screen.right * 0.5), (int)(screen.bottom * 0.5));
            ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));
        break;

        case WM_MOUSEMOVE:
        {
            MouseX = LOWORD(lParam);
            MouseY = HIWORD(lParam);
            g_iMouseDeltaX = MouseX - g_iMouseLastX;          // Get mouse deltas
            g_iMouseDeltaY = MouseY - g_iMouseLastY;          // Get mouse deltas
            g_iMouseLastX = MouseX;                           // Set new last mouse position
            g_iMouseLastY = MouseY;                           // Set new last mouse position
            if(g_bLeftMouseDrag)                                  // If mouse flag set
            {
                camera[currentCamera].Delta_x = (float)g_iMouseDeltaY * 15.0;
                camera[currentCamera].Delta_y = (float)g_iMouseDeltaX * 15.0;
            }
            if(g_bRightMouseDrag)                                 // If mouse flag set
            {
                if (fabs(g_iMouseDeltaX) > fabs(g_iMouseDeltaY))
                    camera[currentCamera].Delta_z += (float)g_iMouseDeltaX * 10.0;
                else
                    camera[currentCamera].Movement_z += (float)g_iMouseDeltaY * step;
            }
        }
        break;

        case WM_LBUTTONDOWN:
        {
            g_bLeftMouseDrag = 1;                                 // Set mouse flag
            g_iMouseLastX = LOWORD(lParam);
            g_iMouseLastY = HIWORD(lParam);
            SetCapture(hWnd);                                     // Capture the mouse
        }
        break;

        case WM_RBUTTONDOWN:
        {
            g_bRightMouseDrag = 1;                                // Set mouse flag
            g_iMouseLastX = LOWORD(lParam);                       // Get mouse position
            g_iMouseLastY = HIWORD(lParam);
            SetCapture(hWnd);                                     // Capture the mouse
        }
        break;

        case WM_LBUTTONUP:
        {
            g_bLeftMouseDrag = 0;                                 // Clear mouse flag
            ReleaseCapture();                                     // Release the mouse capture
            camera[currentCamera].Delta_x = 0.0;                  // Clear camera rotation deltas
            camera[currentCamera].Delta_y = 0.0;
        }
        break;

        case WM_RBUTTONUP:
        {
            g_bRightMouseDrag = 0;                                // Clear mouse flag
            ReleaseCapture();                                     // Release the mouse capture
            camera[currentCamera].Delta_z = 0.0;                  // Clear camera rotation deltas
        }
        break;

        default:
            return (DefWindowProc(hWnd, message, wParam, lParam));
    }
return (0);
}

int WINAPI WinMain(    HINSTANCE    hInstance,
                    HINSTANCE,
                    LPSTR,
                    int)
{
    MSG        msg;
    WNDCLASSEX    wc;

    GetWindowRect(GetDesktopWindow(), &screen);
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style            = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_SAVEBITS;
    wc.lpfnWndProc        = (WNDPROC) WndProc;
    wc.cbClsExtra        = 0;
    wc.cbWndExtra        = 0;
    wc.hInstance        = hInstance;
    wc.hIcon            = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MYICON));
    wc.hIconSm          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MYICON));
    wc.hCursor            = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground    = NULL;
    wc.lpszMenuName        = NULL;
    wc.lpszClassName    = "OpenGL WinClass";


    if(!RegisterClassEx(&wc))
    {
        MessageBox(NULL,"Failed To Register The Window Class.","Error",MB_OK|MB_ICONERROR);
        return FALSE;
    }

    hWnd = CreateWindowEx(
    WS_EX_LEFT,
    "OpenGL WinClass",
    "OpenGL & Win32 Tutorial No.7",
    WS_MAXIMIZE |
    WS_CLIPCHILDREN |
    WS_CLIPSIBLINGS |
    WS_POPUPWINDOW |
    WS_VISIBLE,
    0, 0,
    screen.right, screen.bottom,
    NULL,
    NULL,
    hInstance,
    NULL);

    if(!hWnd)
    {
        MessageBox(NULL,"Window Creation Error.","Error",MB_OK|MB_ICONERROR);
        return FALSE;
    }

    DEVMODE dmScreenSettings;
    memset(&dmScreenSettings, 0, sizeof(DEVMODE));
    dmScreenSettings.dmSize        = sizeof(DEVMODE);
    dmScreenSettings.dmPelsWidth    = screen.right;
    dmScreenSettings.dmPelsHeight    = screen.bottom;
    dmScreenSettings.dmFields    = DM_PELSWIDTH | DM_PELSHEIGHT;
    ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);

//    ShowWindow(hWnd, SW_HIDE);
//    if(DialogBox(hInstance, "NAMEOFDLG", hWnd, (DLGPROC)NameOfProc) == IDOK) // calls the initialization dialog
//    {
        ShowWindow(hWnd, SW_SHOW);
        UpdateWindow(hWnd);
        SetFocus(hWnd);
        wglMakeCurrent(hDC,hRC);
        SetCursorPos((int)(screen.right * 0.5), (int)(screen.bottom * 0.5));
//        ShowCursor(0);
//    }
//    else
//        SendMessage(hWnd, WM_CLOSE, 0, 0);

    while (1)
    {
        while (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
        {
            if (GetMessage(&msg, NULL, 0, 0))
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
            else
            {
                return TRUE;
            }
        }

        if(!DialogInUse)
        {
            DrawGLScene();
            glFlush();
            SwapBuffers(hDC);
        }

        multiplier = GetTimePassed(lasttime, average, lastmultiplier);
        camera[currentCamera].Multiplier = multiplier;
        light[currentLight].Multiplier = multiplier;

        if (key['C'] && released_key['C'] == 0)
        {
            if (currentCamera < numCameras)
                currentCamera++;
            else
                currentCamera = 0;
            released_key['C'] = 1;
        }

        if (!key['C'])
            released_key['C'] = 0;

        if (key['R'] && released_key['R'] == 0)
        {
            ResetLensFlare();
            released_key['R'] = 1;
        }

        if (!key['R'])
            released_key['R'] = 0;

        if (key['L'] && released_key['L'] == 0)
        {
            if (currentLight < numLights)
                currentLight++;
            else
                currentLight = 0;
            released_key['L'] = 1;
        }

        if (!key['L'])
            released_key['L'] = 0;
/*
        if (key['I'] && released_key['I'] == 0)
        {
            DialogInUse = 1;
            lightColor[0] = light[currentLight].Ambient[0];
            lightColor[1] = light[currentLight].Ambient[1];
            lightColor[2] = light[currentLight].Ambient[2];
            ShowCursor(1);
            GetLightColor();
            key['I'] = 0;
            ShowCursor(0);
            SetCursorPos((int)(screen.right * 0.5), (int)(screen.bottom * 0.5));
            light[currentLight].Ambient[0] = lightColor[0];
            light[currentLight].Ambient[1] = lightColor[1];
            light[currentLight].Ambient[2] = lightColor[2];
            light[currentLight].Update();
            DialogInUse = 0;
        }

        if (!key['I'])
            released_key['I'] = 0;

        if (key['O'] && released_key['O'] == 0)
        {
            DialogInUse = 2;
            lightColor[0] = light[currentLight].Diffuse[0];
            lightColor[1] = light[currentLight].Diffuse[1];
            lightColor[2] = light[currentLight].Diffuse[2];
            ShowCursor(1);
            GetLightColor();
            key['O'] = 0;
            ShowCursor(0);
            SetCursorPos((int)(screen.right * 0.5), (int)(screen.bottom * 0.5));
            light[currentLight].Diffuse[0] = lightColor[0];
            light[currentLight].Diffuse[1] = lightColor[1];
            light[currentLight].Diffuse[2] = lightColor[2];
            light[currentLight].Update();
            DialogInUse = 0;
        }

        if (!key['O'])
            released_key['O'] = 0;

        if (key['P'] && released_key['P'] == 0)
        {
            DialogInUse = 3;
            lightColor[0] = light[currentLight].Specular[0];
            lightColor[1] = light[currentLight].Specular[1];
            lightColor[2] = light[currentLight].Specular[2];
            ShowCursor(1);
            GetLightColor();
            key['P'] = 0;
            ShowCursor(0);
            SetCursorPos((int)(screen.right * 0.5), (int)(screen.bottom * 0.5));
            light[currentLight].Specular[0] = lightColor[0];
            light[currentLight].Specular[1] = lightColor[1];
            light[currentLight].Specular[2] = lightColor[2];
            light[currentLight].Update();
            DialogInUse = 0;
        }
*/
        if (!key['P'])
            released_key['P'] = 0;

        if (key['1'])
        {
            step = 1.0;
        }

        if (key['2'])
        {
            step = 2.0;
        }

        if (key['3'])
        {
            step = 3.0;
        }

        if (key['4'])
        {
            step = 4.0;
        }

        if (key['5'])
        {
            step = 5.0;
        }

        if (key['6'])
        {
            step = 6.0;
        }

        if (key['7'])
        {
            step = 7.0;
        }

        if (key['8'])
        {
            step = 8.0;
        }

        if (key['9'])
        {
            step = 9.0;
        }

        if (key['0'])
        {
            step = 10.0;
        }

        if (key[VK_NUMPAD6])
        {
            light[currentLight].Movement_x += step;
        }

        if (key[VK_NUMPAD4])
        {
            light[currentLight].Movement_x -= step;
        }

        if (key[VK_NUMPAD2])
        {
            light[currentLight].Movement_z += step;
        }

        if (key[VK_NUMPAD8])
        {
            light[currentLight].Movement_z -= step;
        }

        if (key[VK_NUMPAD7])
        {
            light[currentLight].Movement_y += step;
        }

        if (key[VK_NUMPAD9])
        {
            light[currentLight].Movement_y -= step;
        }

        if (key[VK_NUMPAD5] && released_key[VK_NUMPAD5] == 0)
        {
            if (light[currentLight].Positional == FALSE)
                light[currentLight].Positional = TRUE;
            else
                light[currentLight].Positional = FALSE;
            released_key[VK_NUMPAD5] = 1;
        }

        if (!key[VK_NUMPAD5])
            released_key[VK_NUMPAD5] = 0;

        if (key[VK_RIGHT])
        {
            camera[currentCamera].Movement_x += step;
        }

        if (key[VK_LEFT])
        {
            camera[currentCamera].Movement_x -= step;
        }

        if (key[VK_DOWN])
        {
            camera[currentCamera].Movement_z += step;
        }

        if (key[VK_UP])
        {
            camera[currentCamera].Movement_z -= step;
        }

        if (key[VK_PRIOR])
        {
            camera[currentCamera].Movement_y += step;
        }

        if (key[VK_NEXT])
        {
            camera[currentCamera].Movement_y -= step;
        }

        if (key[VK_SPACE])
        {
            camera[currentCamera].Reset();
        }

        if (key[VK_ESCAPE] || key['Q'])
            SendMessage(hWnd,WM_CLOSE,0,0);
    }
}



                                      

---