---

main.cpp

Go to the documentation of this file.

// ~~~ OpenGL & Win32 ~~~
// Tutorial No.14 - Potentially Visible Set
// Alan Baylis 14/02/2002

#include <windows.h>
#include "shared.h"
#include "general.h"
#include "listnode.h"
#include "locmath.h"
#include "vector.h"
#include "vertex.h"
#include "quat.h"
#include "matrix.h"
#include "texture.h"
#include "polygon.h"
#include "tll.h"
#include "plane.h"              // Plane class
#include "object.h"
#include "camera.h"
#include "light.h"
#include "collision.h"
#include "glfont.h"
#include "bspline.h"
#include "bsp.h"
#include "portal.h"             // The portal class and routines
#include "pvs.h"                // Added two new PVS functions
#include "tga.h"
#include "lightmap.h"
#include "winfuncs.h"
#include "console.h"
#include "log.h"
#include "mmgr.h"
#include "resource.rh"

// Console
ConsoleWindow Console;

// Windows
static HGLRC hRC;
static HDC hDC;
HWND hWnd;
HINSTANCE g_hInst;
RECT screen;
PAINTSTRUCT ps;
char AppDirectory[MAX_PATH];
float ApplicationStartTime;

// 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 = 30.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};
int currentLight = 0;
int numLights = 0;

// View Frustum Planes
PLANE frustum[6];                 // View frustum planes

// World vertices
int numVertices = 37;
VERTEX* vertex = new VERTEX[numVertices];

// World polygons
int numPolygons = 58;
POLYGON* polygon = new POLYGON[numPolygons];
POLYGON* bsppolygon = new POLYGON[numPolygons];

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

// 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
HWND hWndStartDlg;
int DialogInUse = 0;
char szText[BUFFER_SIZE];

// Font
GLFONT myFont;

// Bounding box variables
float Min_X, Min_Y, Min_Z, Max_X, Max_Y, Max_Z;

// Test variables
int numleavesvisible = 0;         // Number of leaves visible within frustum
int showportals = 0;              // Flag used to toggle the rendering of the portals
int numlistleaves = 0;            // Number of leaves in the LeafList (created in bsp.cpp)
int numlistpartitions = 0;        // Number of partitions in the PartitionList (created in bsp.cpp)
int numcurrentportals = 0;        // Number of portals in the currentleaf

// BSP
int numleaves = 0;                // Total number of leaves in the bsp
int currentleaf = 0;              // Current leaf based on camera position
int numpartitions = 0;            // Total number of partitions in the bsp
bool BuiltBSP = false;
BSP_node* root = new BSP_node;

// Portals
LinkedList<PORTAL> PortalList;    // Portal list
int numportals = 0;               // The number of portals in the PortalList
PORTAL* portal;                   // Global pointer for working with the portals

// Static Lights
int numStaticLights = 9;
StaticLight* staticlight = new StaticLight[numStaticLights];

// Lightmap
int numLightmaps = 0;
Lightmap* lightmap = new Lightmap[numPolygons];

// Splines
int visible = 0;                // Toggle flag for viewing the splines
int numSplines = 0;             // Not zero based
int cameraMode = 2;             // Camera mode (0 = Free, 1 = Look, 2 = Follow)
int currentSpline = 0;          // Current spline to work with or use for a path
int lookAtPath = 0;             // Spline to look at when in Follow mode
char SplineFileName[MAX_PATH];  // filename and path to the spline data
SPLINE* spline;                 // Global pointer for working with the splines from list
LinkedList<SPLINE> SplineList;  // Spline list. Note that you can't make this a pointer.

// Linked Lists of leaf, partition and portal nodes
LinkedList<ListNode> LeafList;
LinkedList<ListNode> PartitionList;
ListNode* listnode;

int InitGL(int Width, int Height)
{
    CLog::addLine("--- Program Start ---");

    int ReturnValue;

    ApplicationStartTime = (float)GetTickCount();
    cameraMode = 2;

    SetGLProperties();
    SetGLMaterial();
    SetGLLighting(light);
    SetGLCamera(camera);
    SetSplines(SplineList);

    if (!SetGLTexture(texture))
        ReturnValue = 0;
    else
        ReturnValue = 1;

    // Create the font texture
    glFontCreate(&myFont, "roman.glf", 600);

    SetGLWorld(polygon, texture, vertex);

    // Find the bounding box of the data set
    Min_X = polygon[0].Vertex[0].x;
    Min_Y = polygon[0].Vertex[0].y;
    Min_Z = polygon[0].Vertex[0].z;
    Max_X = polygon[0].Vertex[0].x;
    Max_Y = polygon[0].Vertex[0].y;
    Max_Z = polygon[0].Vertex[0].z;
    for (int loop = 0; loop < numPolygons; loop++)
    {
        for (int i = 0; i < 3; i++)
        {
            if (polygon[loop].Vertex[i].x < Min_X )
                Min_X = polygon[loop].Vertex[i].x;
            if (polygon[loop].Vertex[i].y < Min_Y )
                Min_Y = polygon[loop].Vertex[i].y;
            if (polygon[loop].Vertex[i].z < Min_Z )
                Min_Z = polygon[loop].Vertex[i].z;
            if (polygon[loop].Vertex[i].x > Max_X )
                Max_X = polygon[loop].Vertex[i].x;
            if (polygon[loop].Vertex[i].y > Max_Y )
                Max_Y = polygon[loop].Vertex[i].y;
            if (polygon[loop].Vertex[i].z > Max_Z )
                Max_Z = polygon[loop].Vertex[i].z;
        }
    }

    // BSP initialization
    for (int i = 0; i < numPolygons; i++)
        bsppolygon[i] = polygon[i];

    root->nodeid = 0;
    root->leaf = 0;
    root->visible = 0;
    root->numpolys = numPolygons;
    root->nodepolylist = bsppolygon;
    root->nodelightmaplist = lightmap;
    
    BuildBSP(root);
    BuiltBSP = true;

    // Portal Creation
    MakeNodeLists(root);
    MakePortalList();
    AddPortalsToLeaves(root);
    FindTruePortals(root);

    // initialize static lights
    SetStaticLights(staticlight);

    // Create the lightmaps
    CreateBSPLightmaps(root);
    LoadBSPLightmaps(root);

    return ReturnValue;
}

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(&camera[currentCamera].Position, &cp);

    camera[currentCamera].Apply();

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

    currentleaf = FindCurrentLeaf(camera[currentCamera].Position, root);

    ExtractFrustum();  // Calculate the view frustum planes
    CalculatePVS(currentleaf);    // Calculate the visible leaves
    numleavesvisible = CountVisibleLeaves(); // Count the number of portals visible

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
    DrawWorld(root);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

    DrawSplines(SplineList);           // Required to calculate the camera path
    DrawMyText();              // Draw text last
}

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)
    {
        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;
            }
        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_CLOSE:
            delete[] lightmap;
            delete[] staticlight;
            delete[] texture;
            delete[] vertex;
            delete[] camera;
            delete[] light;
            delete[] polygon;

            for (int i = numSplines - 1; i >= 0; i--)
                DeleteSpline(i, SplineList);

            if (BuiltBSP)
                DeleteBSP(root);
            delete root;

            for (int i = numportals; i > 0; i--)
            {
                portal = PortalList.Get(i);
                delete[] portal->Vertex;
            }
            
            glFontDestroy(&myFont);
            
            CLog::addLine("--- End of Program ---");
            Console.Close();

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

        case WM_DESTROY:
            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:
            if (cameraMode == 0)
            {
                camera[currentCamera].Delta_x = float(HIWORD(lParam) - screen.bottom * 0.5) * 10;
                camera[currentCamera].Delta_y = float(LOWORD(lParam) - screen.right * 0.5) * 10;
            }
        break;

        case WM_LBUTTONDOWN:
            camera[currentCamera].Delta_z = -120.0;
        break;

        case WM_RBUTTONDOWN:
            camera[currentCamera].Delta_z = 120.0;
        break;

        case WM_LBUTTONUP:
            if (wParam != MK_RBUTTON)
                camera[currentCamera].Delta_z = 0.0;
        break;

        case WM_RBUTTONUP:
            if (wParam != MK_LBUTTON)
                camera[currentCamera].Delta_z = 0.0;
        break;

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

int WINAPI WinMain(    HINSTANCE    hInstance,
                    HINSTANCE,
                    LPSTR,
                    int)
{
    MSG        msg;
    g_hInst = hInstance;
    GetWindowRect(GetDesktopWindow(), &screen);

    WNDCLASSEX    wc;
    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.14",
    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);

    GetCurrentDirectory(MAX_PATH, AppDirectory);

        Console.Open();

    if(DialogBox(hInstance, "STARTDLG", hWnd, (DLGPROC)StartProc) == IDOK)
    {
        if (!InitGL(screen.right, screen.bottom))
        {
            SendMessage(hWnd, WM_CLOSE, 0, 0);
        }
        else
        {
            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
    {
        delete[] lightmap;
        delete[] staticlight;
        delete[] texture;
        delete[] vertex;
        delete[] camera;
        delete[] light;
        delete[] polygon;
        delete[] bsppolygon;
        delete root;
        PostQuitMessage(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)
        {
            SetCursorPos((int)(screen.right * 0.5), (int)(screen.bottom * 0.5));
            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['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['P'] && released_key['P'] == 0)
        {
            if (showportals)
                showportals = 0;
            else
                showportals = 1;
            released_key['P'] = 1;
        }

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

        if (key['M'] && released_key['M'] == 0)
        {
            if (cameraMode == 2)
                cameraMode = 0;
            else
                cameraMode = 2;
            released_key['M'] = 1;
        }

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

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

        if (key[50])
        {
            step = 20.0;
        }

        if (key[51])
        {
            step = 30.0;
        }

        if (key[52])
        {
            step = 40.0;
        }

        if (key[53])
        {
            step = 50.0;
        }

        if (key[54])
        {
            step = 60.0;
        }

        if (key[55])
        {
            step = 70.0;
        }

        if (key[56])
        {
            step = 80.0;
        }

        if (key[57])
        {
            step = 90.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);
    }
}



                                      

---