main.cpp

Go to the documentation of this file.

/*
 *              This Code Was Created By Jeff Molofee 2000
 *              A HUGE Thanks To Fredric Echols For Cleaning Up
 *              And Optimizing The Base Code, Making It More Flexible!
 *              If You've Found This Code Useful, Please Let Me Know.
 *              Visit My Site At nehe.gamedev.net
 */

#include <windows.h>            // Header File For Windows
#include <gl\gl.h>                      // Header File For The OpenGL32 Library
#include <gl\glu.h>                     // Header File For The GLu32 Library

#include "gl_init.h"        // All initialization code is in here now
#include "renderer.h"
#include "PhysSystem.h"

#include "TglText.h"

Renderer *renderer;
PhysSystem *world;
bool start, mouse_free;
int pause_mode;  


int DrawGLScene(GLvoid)                                                                 // Here's Where We Do All The Drawing
{
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     // Clear Screen And Depth Buffer
    glDisable(GL_LIGHTING);
        glLoadIdentity();                                                                       // Reset The Current Modelview Matrix

    glColor3f(1,1,1);
    TglText tmp_text;
    glTranslatef(0.0f,0.0f,-1.0f);
    glRasterPos2f(-.55, .38);
    tmp_text.glPrint("%f %f %f: %f",world->obj_list[1].qrot_velocity.v.data[0],
                                    world->obj_list[1].qrot_velocity.v.data[1],
                                    world->obj_list[1].qrot_velocity.v.data[2],
                                    world->obj_list[1].qrot_velocity.n);
    glRasterPos2f(-.55, .365);
    tmp_text.glPrint("%f %f %f: %f",world->obj_list[1].center->rot.v.data[0],
                                    world->obj_list[1].center->rot.v.data[1],
                                    world->obj_list[1].center->rot.v.data[2],
                                    world->obj_list[1].center->rot.n);
    glTranslatef(0.0f,0.0f,1.0f);
    glEnable(GL_LIGHTING);

        renderer->Draw();
        if(pause_mode == 0)
        world->UpdateAll();

        return TRUE;                                                                            // Keep Going
}


int WINAPI WinMain(     HINSTANCE       hInstance,                      // Instance
                                        HINSTANCE       hPrevInstance,          // Previous Instance
                                        LPSTR           lpCmdLine,                      // Command Line Parameters
                                        int                     nCmdShow)                       // Window Show State

{
    start = false;                             // For delaying start until user is ready
    mouse_free = false;
    pause_mode = 1;                         // 0=normal, 1=paused, 2=paused w/ free mouse
    bool mp2 = true;
    MSG         msg;                                                                    // Windows Message Structure
        BOOL    done=FALSE;                                                             // Bool Variable To Exit Loop
    POINT pt;                                       // For Mouse Control
    int mode;                                       // Render Mode
    bool mp = true;                                 // Render Bool
    bool cull = true;
    const int dim[2] = {1024, 768};

        // 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;                                                       // Windowed Mode
        // Create Our OpenGL Window
        if (!CreateGLWindow("BRE",dim[0],dim[1],16,fullscreen))
                return 0;                                                                       // Quit If Window Was Not Created

    renderer = new Renderer(); 
    renderer->Main_Cam->rot = Quaternion(0, 0, 0);
    renderer->Main_Cam->SetPos(glVector (0,0,40));
    renderer->LoadWorld("world2");
    
    world = new PhysSystem;
    world->AddObjects(renderer->object_list);
//    world->obj_list[0].qrot_velocity = Quaternion(0, 0, -1);
//    world->obj_list[0].velocity = glVector(40, 0, 0);
    
    world->physics_timer.Init();

    SetCursorPos(dim[0]/2,dim[1]/2);                // To avoid inital rotations
        while(!done)                                                                    // Loop That Runs While done=FALSE
        {
                if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))       // Is There A Message Waiting?
                {
                        if (msg.message==WM_QUIT)                               // Have We Received A Quit Message?
                        {
                                done=TRUE;                                                      // If So done=TRUE
                        }
                        else                                                                    // If Not, Deal With Window Messages
                        {
                                TranslateMessage(&msg);                         // Translate The Message
                                DispatchMessage(&msg);                          // Dispatch The Message
                        }
                }
                else                                                                            // If There Are No Messages
                {
                        // Draw The Scene.  Watch For ESC Key And Quit Messages From DrawGLScene()
            if ((active && !DrawGLScene()) || keys[VK_ESCAPE])  // Active?  Was There A Quit Received?
                        {
                                done=TRUE;                                                      // ESC or DrawGLScene Signalled A Quit
                        }
                        else                                                                    // Not Time To Quit, Update Screen
                        {
                                SwapBuffers(hDC);                                       // Swap Buffers (Double Buffering)
                        }
            if(pause_mode != 2)
            {
                GetCursorPos(&pt);
                if(pt.x != dim[0]/2)
                    renderer->Control_Point->rot = renderer->Control_Point->rot * Quaternion(float(dim[0]/2 - pt.x)/200.0,glVector(0,1,0));
                if(pt.y != dim[1]/2)
                    renderer->Control_Point->rot = renderer->Control_Point->rot * Quaternion(float(dim[1]/2 - pt.y)/200.0,glVector(1,0,0));
                SetCursorPos(dim[0]/2,dim[1]/2);
            }
    

            if(keys[VK_SPACE] && !mp2)
            {
                world->physics_timer.Init();
                start = !start;
                pause_mode++;
                if(pause_mode > 1)  pause_mode = 0;
                SetCursorPos(dim[0]/2,dim[1]/2);
                mp2=TRUE;
            }
            if(!keys[VK_SPACE])
            {
                if(mp2 && pause_mode != 2)
                    SetCursorPos(dim[0]/2,dim[1]/2);
                mp2=FALSE;
            }

                        if (keys[VK_UP])
                                renderer->Control_Point->Slide(glVector(0,0,-1.8));
            if (keys[VK_DOWN])
                                renderer->Control_Point->Slide(glVector(0,0,1.8));
                        if (keys[VK_RIGHT])
                                renderer->Control_Point->Slide(glVector(1.8,0,0));
                        if (keys[VK_LEFT])
                                renderer->Control_Point->Slide(glVector(-1.8,0,0));

                        if (keys[VK_F1])                                                // Is F1 Being Pressed?
                        {
                                keys[VK_F1]=FALSE;                                      // If So Make Key FALSE
                                KillGLWindow();                                         // Kill Our Current Window
                                fullscreen=!fullscreen;                         // Toggle Fullscreen / Windowed Mode
                                // Recreate Our OpenGL Window
                                if (!CreateGLWindow("BRE",dim[0],dim[1],16,fullscreen))
                                {
                                        return 0;                                               // Quit If Window Was Not Created
                                }
                        }
                        if (keys['M'] && !mp)
                        {
                                mode+=1;
                                if (mode>2)
                                        mode=0;
                                switch (mode)
                                {
                                case 0:
                                        glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
                                        break;
                                case 1:
                                        glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
                                        break;
                                case 2:
                                        glPolygonMode(GL_FRONT_AND_BACK,GL_POINT);
                                }
                                mp=TRUE;
                        }
                        if (!keys['M'])
                        {
                                mp=FALSE;
                        }
                        if (keys['C'])
                        {
                cull = !cull;
                if(cull)
                    glEnable(GL_CULL_FACE);
                else
                    glDisable(GL_CULL_FACE);
            }
/*            if (keys['A'])
                world->obj_list[0].center->rot = world->obj_list[0].center->rot * Quaternion(0.1, 0, 0);
            if (keys['S'])
                world->obj_list[0].center->rot = world->obj_list[0].center->rot * Quaternion(0, .1, 0);
            if (keys['D'])
                world->obj_list[0].center->rot = world->obj_list[0].center->rot * Quaternion(0, 0, .1);
*/
                }
        }

        // Shutdown
        KillGLWindow();                                                                 // Kill The Window
        return (msg.wParam);                                                    // Exit The Program
}

---