Main Page   Namespace List   Class Hierarchy   Compound List   File List   Compound Members   File Members  

main.cpp File Reference

#include <windows.h>
#include "shared.h"
#include "general.h"
#include "object.h"
#include "camera.h"
#include "vector.h"
#include "vertex.h"
#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 "resource.rh"

Go to the source code of this file.

Functions

void InitGL (int Width, int Height)
void ReSizeGLScene (int Width, int Height)
void DrawGLScene (void)
LRESULT CALLBACK WndProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE, LPSTR, int)

Variables

HGLRC hRC
HDC hDC
HWND hWnd
RECT screen
PAINTSTRUCT ps
float pi = 3.141592
float radian = pi / 180
float epsilon = 0.05
bool key [256]
bool released_key [256]
int currentCamera = 0
int numCameras = 4
float step = 5.0
float lasttime
float multiplier
const int average = 20
float lastmultiplier [average]
int fps
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
POLYGONpolygon = new POLYGON[12]
TEXTUREtexture = new TEXTURE[8]
CAMERAcamera = new CAMERA[numCameras + 1]
CAMERA LastCam
LIGHTlight = new LIGHT[numLights + 1]
float lightColor [3] = {1.0, 1.0, 1.0}
int DialogInUse = 0
int testint
float testfloat
char teststring [64]
GLFONT myFont
float SunPosition [3]


Function Documentation

void DrawGLScene void   
 

Definition at line 103 of file main.cpp.

References LIGHT::Apply(), CheckForCollision(), currentCamera, DrawCone(), DrawCube(), DrawLensFlare(), DrawMyText(), DrawSkybox(), DrawSphere(), DrawTerrain(), CollisionPacket::eRadius, numLights, OBJECT::Position, CollisionPacket::sourcePoint, CollisionPacket::velocity, VECTOR::x, VECTOR::y, and VECTOR::z.

Referenced by WinMain(), and WndProc().

00104 {
00105     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
00106 
00107     LastCam = camera[currentCamera];
00108     camera[currentCamera].Update();
00109 
00110     CollisionPacket cp;
00111     cp.eRadius.x = 1.0;
00112     cp.eRadius.y = 1.0;
00113     cp.eRadius.z = 1.0;
00114     cp.sourcePoint.x = LastCam.Position.x;
00115     cp.sourcePoint.y = LastCam.Position.y;
00116     cp.sourcePoint.z = LastCam.Position.z;
00117     cp.velocity.x = camera[currentCamera].Position.x - LastCam.Position.x;
00118     cp.velocity.y = camera[currentCamera].Position.y - LastCam.Position.y;
00119     cp.velocity.z = camera[currentCamera].Position.z - LastCam.Position.z;
00120 
00121     CheckForCollision(polygon, &camera[currentCamera].Position, &cp);
00122 
00123     camera[currentCamera].Apply();
00124 
00125     int loop;
00126     for(loop = 0; loop <= numLights; loop++)
00127         light[loop].Apply();
00128 
00129 
00130     DrawSkybox(camera, texture);      // Added to general.cpp
00131 //    DrawGrid();
00132     DrawCube(polygon, texture);
00133     DrawCone();
00134     DrawSphere();
00135     DrawTerrain(texture);     
00136     DrawLensFlare();   // Draw the lens flare after all other objects
00137 
00138     DrawMyText();
00139 }

void InitGL int    Width,
int    Height
 

Definition at line 84 of file main.cpp.

References glFontCreate(), InitializeLensFlare(), SetGLCamera(), SetGLLighting(), SetGLMaterial(), SetGLProperties(), SetGLTexture(), SetGLView(), SetGLWorld(), and SunPosition.

Referenced by WndProc().

00085 {
00086     glFeedbackBuffer(4, GL_3D, SunPosition);
00087     SetGLProperties();
00088     SetGLMaterial();
00089     SetGLView(Width, Height);
00090     SetGLLighting();
00091     SetGLWorld(polygon);
00092     SetGLTexture(texture);
00093     SetGLCamera(camera);
00094     glFontCreate(&myFont, "roman.glf", 200);
00095     InitializeLensFlare();  // Initialize and create the flare            
00096 }

void ReSizeGLScene int    Width,
int    Height
 

Definition at line 98 of file main.cpp.

References SetGLView().

Referenced by WndProc().

00099 {
00100     SetGLView(Width, Height);
00101 }

int WINAPI WinMain HINSTANCE    hInstance,
HINSTANCE   ,
LPSTR   ,
int   
 

Definition at line 288 of file main.cpp.

References average, currentCamera, currentLight, DialogInUse, DrawGLScene(), FALSE, GetTimePassed(), hDC, hRC, hWnd, key, lastmultiplier, lasttime, multiplier, numCameras, numLights, released_key, ResetLensFlare(), screen, step, TRUE, and WndProc().

00292 {
00293     MSG        msg;
00294     WNDCLASSEX    wc;
00295 
00296     GetWindowRect(GetDesktopWindow(), &screen);
00297     wc.cbSize = sizeof(WNDCLASSEX);
00298     wc.style            = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_SAVEBITS;
00299     wc.lpfnWndProc        = (WNDPROC) WndProc;
00300     wc.cbClsExtra        = 0;
00301     wc.cbWndExtra        = 0;
00302     wc.hInstance        = hInstance;
00303     wc.hIcon            = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MYICON));
00304     wc.hIconSm          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MYICON));
00305     wc.hCursor            = LoadCursor(NULL, IDC_ARROW);
00306     wc.hbrBackground    = NULL;
00307     wc.lpszMenuName        = NULL;
00308     wc.lpszClassName    = "OpenGL WinClass";
00309 
00310 
00311     if(!RegisterClassEx(&wc))
00312     {
00313         MessageBox(NULL,"Failed To Register The Window Class.","Error",MB_OK|MB_ICONERROR);
00314         return FALSE;
00315     }
00316 
00317     hWnd = CreateWindowEx(
00318     WS_EX_LEFT,
00319     "OpenGL WinClass",
00320     "OpenGL & Win32 Tutorial No.7",
00321     WS_MAXIMIZE |
00322     WS_CLIPCHILDREN |
00323     WS_CLIPSIBLINGS |
00324     WS_POPUPWINDOW |
00325     WS_VISIBLE,
00326     0, 0,
00327     screen.right, screen.bottom,
00328     NULL,
00329     NULL,
00330     hInstance,
00331     NULL);
00332 
00333     if(!hWnd)
00334     {
00335         MessageBox(NULL,"Window Creation Error.","Error",MB_OK|MB_ICONERROR);
00336         return FALSE;
00337     }
00338 
00339     DEVMODE dmScreenSettings;
00340     memset(&dmScreenSettings, 0, sizeof(DEVMODE));
00341     dmScreenSettings.dmSize        = sizeof(DEVMODE);
00342     dmScreenSettings.dmPelsWidth    = screen.right;
00343     dmScreenSettings.dmPelsHeight    = screen.bottom;
00344     dmScreenSettings.dmFields    = DM_PELSWIDTH | DM_PELSHEIGHT;
00345     ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);
00346 
00347 //    ShowWindow(hWnd, SW_HIDE);
00348 //    if(DialogBox(hInstance, "NAMEOFDLG", hWnd, (DLGPROC)NameOfProc) == IDOK) // calls the initialization dialog
00349 //    {
00350         ShowWindow(hWnd, SW_SHOW);
00351         UpdateWindow(hWnd);
00352         SetFocus(hWnd);
00353         wglMakeCurrent(hDC,hRC);
00354         SetCursorPos((int)(screen.right * 0.5), (int)(screen.bottom * 0.5));
00355         ShowCursor(0);
00356 //    }
00357 //    else
00358 //        SendMessage(hWnd, WM_CLOSE, 0, 0);
00359 
00360     while (1)
00361     {
00362         while (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
00363         {
00364             if (GetMessage(&msg, NULL, 0, 0))
00365             {
00366                 TranslateMessage(&msg);
00367                 DispatchMessage(&msg);
00368             }
00369             else
00370             {
00371                 return TRUE;
00372             }
00373         }
00374 
00375         if(!DialogInUse)
00376         {
00377             SetCursorPos((int)(screen.right * 0.5), (int)(screen.bottom * 0.5));
00378             DrawGLScene();
00379             glFlush();
00380               SwapBuffers(hDC);
00381         }
00382 
00383         multiplier = GetTimePassed(lasttime, average, lastmultiplier);
00384         camera[currentCamera].Multiplier = multiplier;
00385         light[currentLight].Multiplier = multiplier;
00386 
00387         if (key['C'] && released_key['C'] == 0)
00388         {
00389             if (currentCamera < numCameras)
00390                 currentCamera++;
00391             else
00392                 currentCamera = 0;
00393             released_key['C'] = 1;
00394         }
00395 
00396         if (!key['C'])
00397             released_key['C'] = 0;
00398 
00399         if (key['R'] && released_key['R'] == 0)
00400         {
00401             ResetLensFlare();
00402             released_key['R'] = 1;
00403         }
00404 
00405         if (!key['R'])
00406             released_key['R'] = 0;
00407 
00408         if (key['L'] && released_key['L'] == 0)
00409         {
00410             if (currentLight < numLights)
00411                 currentLight++;
00412             else
00413                 currentLight = 0;
00414             released_key['L'] = 1;
00415         }
00416 
00417         if (!key['L'])
00418             released_key['L'] = 0;
00419 /*
00420         if (key['I'] && released_key['I'] == 0)
00421         {
00422             DialogInUse = 1;
00423             lightColor[0] = light[currentLight].Ambient[0];
00424             lightColor[1] = light[currentLight].Ambient[1];
00425             lightColor[2] = light[currentLight].Ambient[2];
00426             ShowCursor(1);
00427             GetLightColor();
00428             key['I'] = 0;
00429             ShowCursor(0);
00430             SetCursorPos((int)(screen.right * 0.5), (int)(screen.bottom * 0.5));
00431             light[currentLight].Ambient[0] = lightColor[0];
00432             light[currentLight].Ambient[1] = lightColor[1];
00433             light[currentLight].Ambient[2] = lightColor[2];
00434             light[currentLight].Update();
00435             DialogInUse = 0;
00436         }
00437 
00438         if (!key['I'])
00439             released_key['I'] = 0;
00440 
00441         if (key['O'] && released_key['O'] == 0)
00442         {
00443             DialogInUse = 2;
00444             lightColor[0] = light[currentLight].Diffuse[0];
00445             lightColor[1] = light[currentLight].Diffuse[1];
00446             lightColor[2] = light[currentLight].Diffuse[2];
00447             ShowCursor(1);
00448             GetLightColor();
00449             key['O'] = 0;
00450             ShowCursor(0);
00451             SetCursorPos((int)(screen.right * 0.5), (int)(screen.bottom * 0.5));
00452             light[currentLight].Diffuse[0] = lightColor[0];
00453             light[currentLight].Diffuse[1] = lightColor[1];
00454             light[currentLight].Diffuse[2] = lightColor[2];
00455             light[currentLight].Update();
00456             DialogInUse = 0;
00457         }
00458 
00459         if (!key['O'])
00460             released_key['O'] = 0;
00461 
00462         if (key['P'] && released_key['P'] == 0)
00463         {
00464             DialogInUse = 3;
00465             lightColor[0] = light[currentLight].Specular[0];
00466             lightColor[1] = light[currentLight].Specular[1];
00467             lightColor[2] = light[currentLight].Specular[2];
00468             ShowCursor(1);
00469             GetLightColor();
00470             key['P'] = 0;
00471             ShowCursor(0);
00472             SetCursorPos((int)(screen.right * 0.5), (int)(screen.bottom * 0.5));
00473             light[currentLight].Specular[0] = lightColor[0];
00474             light[currentLight].Specular[1] = lightColor[1];
00475             light[currentLight].Specular[2] = lightColor[2];
00476             light[currentLight].Update();
00477             DialogInUse = 0;
00478         }
00479 */
00480         if (!key['P'])
00481             released_key['P'] = 0;
00482 
00483         if (key['1'])
00484         {
00485             step = 1.0;
00486         }
00487 
00488         if (key['2'])
00489         {
00490             step = 2.0;
00491         }
00492 
00493         if (key['3'])
00494         {
00495             step = 3.0;
00496         }
00497 
00498         if (key['4'])
00499         {
00500             step = 4.0;
00501         }
00502 
00503         if (key['5'])
00504         {
00505             step = 5.0;
00506         }
00507 
00508         if (key['6'])
00509         {
00510             step = 6.0;
00511         }
00512 
00513         if (key['7'])
00514         {
00515             step = 7.0;
00516         }
00517 
00518         if (key['8'])
00519         {
00520             step = 8.0;
00521         }
00522 
00523         if (key['9'])
00524         {
00525             step = 9.0;
00526         }
00527 
00528         if (key['0'])
00529         {
00530             step = 10.0;
00531         }
00532 
00533         if (key[VK_NUMPAD6])
00534         {
00535             light[currentLight].Movement_x += step;
00536         }
00537 
00538         if (key[VK_NUMPAD4])
00539         {
00540             light[currentLight].Movement_x -= step;
00541         }
00542 
00543         if (key[VK_NUMPAD2])
00544         {
00545             light[currentLight].Movement_z += step;
00546         }
00547 
00548         if (key[VK_NUMPAD8])
00549         {
00550             light[currentLight].Movement_z -= step;
00551         }
00552 
00553         if (key[VK_NUMPAD7])
00554         {
00555             light[currentLight].Movement_y += step;
00556         }
00557 
00558         if (key[VK_NUMPAD9])
00559         {
00560             light[currentLight].Movement_y -= step;
00561         }
00562 
00563         if (key[VK_NUMPAD5] && released_key[VK_NUMPAD5] == 0)
00564         {
00565             if (light[currentLight].Positional == FALSE)
00566                 light[currentLight].Positional = TRUE;
00567             else
00568                 light[currentLight].Positional = FALSE;
00569             released_key[VK_NUMPAD5] = 1;
00570         }
00571 
00572         if (!key[VK_NUMPAD5])
00573             released_key[VK_NUMPAD5] = 0;
00574 
00575         if (key[VK_RIGHT])
00576         {
00577             camera[currentCamera].Movement_x += step;
00578         }
00579 
00580         if (key[VK_LEFT])
00581         {
00582             camera[currentCamera].Movement_x -= step;
00583         }
00584 
00585         if (key[VK_DOWN])
00586         {
00587             camera[currentCamera].Movement_z += step;
00588         }
00589 
00590         if (key[VK_UP])
00591         {
00592             camera[currentCamera].Movement_z -= step;
00593         }
00594 
00595         if (key[VK_PRIOR])
00596         {
00597             camera[currentCamera].Movement_y += step;
00598         }
00599 
00600         if (key[VK_NEXT])
00601         {
00602             camera[currentCamera].Movement_y -= step;
00603         }
00604 
00605         if (key[VK_SPACE])
00606         {
00607             camera[currentCamera].Reset();
00608         }
00609 
00610         if (key[VK_ESCAPE] || key['Q'])
00611             SendMessage(hWnd,WM_CLOSE,0,0);
00612     }
00613 }

LRESULT CALLBACK WndProc HWND    hWnd,
UINT    message,
WPARAM    wParam,
LPARAM    lParam
 

Definition at line 141 of file main.cpp.

References CleanupLensFlare(), currentCamera, DrawGLScene(), FALSE, hDC, hRC, hWnd, InitGL(), key, ps, ReSizeGLScene(), screen, and TRUE.

Referenced by WinMain().

00145 {
00146     GLuint    PixelFormat;
00147     static    PIXELFORMATDESCRIPTOR pfd=
00148     {
00149            sizeof(PIXELFORMATDESCRIPTOR),
00150         1,
00151         PFD_DRAW_TO_WINDOW |
00152         PFD_SUPPORT_OPENGL |
00153         PFD_DOUBLEBUFFER,
00154         PFD_TYPE_RGBA,
00155         16,
00156         0, 0, 0, 0, 0, 0,
00157         0,
00158         0,
00159         0,
00160         0, 0, 0, 0,
00161         16,
00162         0,
00163         0,
00164         PFD_MAIN_PLANE,
00165         0,
00166         0, 0, 0
00167     };
00168 
00169 
00170     switch (message)
00171     {
00172         case WM_CREATE:
00173             hDC = GetDC(hWnd);
00174 
00175             PixelFormat = ChoosePixelFormat(hDC, &pfd);
00176 
00177             if (!PixelFormat)
00178             {
00179                    MessageBox(NULL,"Can't find a suitable PixelFormat.","Error",MB_OK|MB_ICONERROR);
00180                 PostQuitMessage(0);
00181                 break;
00182             }
00183 
00184             if(!SetPixelFormat(hDC,PixelFormat,&pfd))
00185             {
00186                 MessageBox(NULL,"Can't set the PixelFormat.","Error",MB_OK|MB_ICONERROR);
00187                 PostQuitMessage(0);
00188                 break;
00189             }
00190 
00191             hRC = wglCreateContext(hDC);
00192             if(!hRC)
00193             {
00194                 MessageBox(NULL,"Can't create a GL Rendering Context.","Error",MB_OK|MB_ICONERROR);
00195                 PostQuitMessage(0);
00196                 break;
00197             }
00198 
00199             if(!wglMakeCurrent(hDC, hRC))
00200             {
00201                 MessageBox(NULL,"Can't activate the GL Rendering Context.","Error",MB_OK|MB_ICONERROR);
00202                 PostQuitMessage(0);
00203                 break;
00204             }
00205             InitGL(screen.right, screen.bottom);
00206         break;
00207 
00208         case WM_SYSCOMMAND:
00209         {
00210             switch (wParam)
00211             {
00212                 case SC_SCREENSAVE:
00213                 case SC_MONITORPOWER:
00214                     return 0;
00215             }
00216             break;
00217         }
00218 
00219         if (DialogInUse)
00220         {
00221             case WM_PAINT:
00222                 BeginPaint(hWnd,&ps);
00223                 DrawGLScene();
00224                 glFlush();
00225                 SwapBuffers(hDC);
00226                 EndPaint(hWnd,&ps);
00227             break;
00228         }
00229 
00230         case WM_DESTROY:
00231         case WM_CLOSE:
00232             delete[] texture;
00233             delete[] polygon;
00234             delete[] camera;
00235             delete[] light;
00236             CleanupLensFlare();     // Delete the memory blocks 
00237 
00238             ChangeDisplaySettings(NULL, 0);
00239             wglMakeCurrent(hDC,NULL);
00240             wglDeleteContext(hRC);
00241             ReleaseDC(hWnd,hDC);
00242 
00243             PostQuitMessage(0);
00244         break;
00245 
00246         case WM_KEYDOWN:
00247             key[wParam] = TRUE;
00248         break;
00249 
00250         case WM_KEYUP:
00251             key[wParam] = FALSE;
00252         break;
00253 
00254         case WM_SIZE:
00255             SetCursorPos((int)(screen.right * 0.5), (int)(screen.bottom * 0.5));
00256             ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));
00257         break;
00258 
00259         case WM_MOUSEMOVE:
00260             camera[currentCamera].Delta_x = float(HIWORD(lParam) - screen.bottom * 0.5) * 10;
00261             camera[currentCamera].Delta_y = float(LOWORD(lParam) - screen.right * 0.5) * 10;
00262         break;
00263 
00264         case WM_LBUTTONDOWN:
00265             camera[currentCamera].Delta_z = -120.0;
00266         break;
00267 
00268         case WM_RBUTTONDOWN:
00269             camera[currentCamera].Delta_z = 120.0;
00270         break;
00271 
00272         case WM_LBUTTONUP:
00273             if (wParam != MK_RBUTTON)
00274                 camera[currentCamera].Delta_z = 0.0;
00275         break;
00276 
00277         case WM_RBUTTONUP:
00278             if (wParam != MK_LBUTTON)
00279                 camera[currentCamera].Delta_z = 0.0;
00280         break;
00281 
00282         default:
00283             return (DefWindowProc(hWnd, message, wParam, lParam));
00284     }
00285 return (0);
00286 }


Variable Documentation

const int average = 20
 

Definition at line 49 of file main.cpp.

Referenced by GetTimePassed(), and WinMain().

CAMERA* camera = new CAMERA[numCameras + 1]
 

Definition at line 65 of file main.cpp.

int currentCamera = 0
 

Definition at line 42 of file main.cpp.

Referenced by DrawGLScene(), DrawSkybox(), WinMain(), and WndProc().

int currentLight = 0
 

Definition at line 55 of file main.cpp.

Referenced by DrawLightSphere(), and WinMain().

int DialogInUse = 0
 

Definition at line 73 of file main.cpp.

Referenced by ColorDialogHook(), and WinMain().

float epsilon = 0.05
 

Definition at line 35 of file main.cpp.

int fps
 

Definition at line 51 of file main.cpp.

Referenced by DrawMyText(), and GetTimePassed().

int GL_LIGHT[8] = {GL_LIGHT0, GL_LIGHT1, GL_LIGHT2, GL_LIGHT3, GL_LIGHT4, GL_LIGHT5, GL_LIGHT6, GL_LIGHT7}
 

Definition at line 54 of file main.cpp.

HDC hDC [static]
 

Definition at line 27 of file main.cpp.

Referenced by WinMain(), and WndProc().

HGLRC hRC [static]
 

Definition at line 26 of file main.cpp.

Referenced by WinMain(), and WndProc().

HWND hWnd
 

Definition at line 28 of file main.cpp.

Referenced by GetLightColor(), WinMain(), and WndProc().

bool key[256]
 

Definition at line 38 of file main.cpp.

Referenced by WinMain(), and WndProc().

CAMERA LastCam
 

Definition at line 66 of file main.cpp.

float lastmultiplier[average]
 

Definition at line 50 of file main.cpp.

Referenced by GetTimePassed(), and WinMain().

float lasttime
 

Definition at line 47 of file main.cpp.

Referenced by GetTimePassed(), and WinMain().

LIGHT* light = new LIGHT[numLights + 1]
 

Definition at line 69 of file main.cpp.

float lightColor[3] = {1.0, 1.0, 1.0}
 

Definition at line 70 of file main.cpp.

Referenced by GetLightColor().

float multiplier
 

Definition at line 48 of file main.cpp.

Referenced by GetTimePassed(), and WinMain().

GLFONT myFont
 

Definition at line 79 of file main.cpp.

int numCameras = 4
 

Definition at line 43 of file main.cpp.

Referenced by SetGLCamera(), and WinMain().

int numLights = 0
 

Definition at line 56 of file main.cpp.

Referenced by DrawGLScene(), SetGLLighting(), and WinMain().

float pi = 3.141592
 

Definition at line 33 of file main.cpp.

Referenced by OBJECT::GetXUnit(), OBJECT::GetYUnit(), OBJECT::MoveX(), and OBJECT::MoveY().

POLYGON* polygon = new POLYGON[12]
 

Definition at line 59 of file main.cpp.

Referenced by CheckForCollision(), DrawCube(), and SetGLWorld().

PAINTSTRUCT ps
 

Definition at line 30 of file main.cpp.

Referenced by WndProc().

float radian = pi / 180
 

Definition at line 34 of file main.cpp.

Referenced by OBJECT::Rotate().

bool released_key[256]
 

Definition at line 39 of file main.cpp.

Referenced by WinMain().

RECT screen
 

Definition at line 29 of file main.cpp.

Referenced by DrawLensFlare(), InitializeLensFlare(), WinMain(), and WndProc().

float step = 5.0
 

Definition at line 44 of file main.cpp.

Referenced by WinMain().

float SunPosition[3]
 

Definition at line 82 of file main.cpp.

Referenced by DrawLensFlare(), InitGL(), and InitializeLensFlare().

float testfloat
 

Definition at line 75 of file main.cpp.

int testint
 

Definition at line 74 of file main.cpp.

char teststring[64]
 

Definition at line 76 of file main.cpp.

TEXTURE* texture = new TEXTURE[8]
 

Definition at line 62 of file main.cpp.


Generated on Fri Dec 23 05:21:21 2005 for Skybox by doxygen1.2.15