main.h
上传用户:mywjrx
上传日期:2008-01-23
资源大小:703k
文件大小:7k
源码类别:

射击游戏

开发平台:

Visual C++

  1. #ifndef _MAIN_H
  2. #define _MAIN_H
  3. #include <windows.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <math.h>
  7. #include <fstream>
  8. #include <vector>
  9. #include <glgl.h> // Header File For The OpenGL32 Library
  10. #include <glglu.h> // Header File For The GLu32 Library
  11. #include <glglaux.h>
  12. #include <crtdbg.h>
  13. using namespace std;
  14. #define SCREEN_WIDTH 800 // We want our screen width 800 pixels
  15. #define SCREEN_HEIGHT 600 // We want our screen height 600 pixels
  16. #define SCREEN_DEPTH 16 // We want 16 bits per pixel
  17. //////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
  18. // This file includes all of the model structures that are needed to load
  19. // in a .Md2 file.  When it comes to skeletal animation, we need to add quite
  20. // a bit more variables to these structures.  Not all of the data will be used
  21. // because Quake2 models don't have such a need.  I decided to keep the structures
  22. // the same as the rest of the model loaders on our site so that we could eventually
  23. // use a base class in the future for a library.
  24. #define MAX_TEXTURES 100 // The maximum amount of textures to load
  25. // This is our 3D point class.  This will be used to store the vertices of our model.
  26. class CVector3 
  27. {
  28. public:
  29. float x, y, z;
  30. };
  31. // This is our 2D point class.  This will be used to store the UV coordinates.
  32. class CVector2 
  33. {
  34. public:
  35. float x, y;
  36. };
  37. // This is our face structure.  This is is used for indexing into the vertex 
  38. // and texture coordinate arrays.  From this information we know which vertices
  39. // from our vertex array go to which face, along with the correct texture coordinates.
  40. struct tFace
  41. {
  42. int vertIndex[3]; // indicies for the verts that make up this triangle
  43. int coordIndex[3]; // indicies for the tex coords to texture this face
  44. };
  45. // This holds the information for a material.  It may be a texture map of a color.
  46. // Some of these are not used, but I left them.
  47. struct tMaterialInfo
  48. {
  49. char  strName[255]; // The texture name
  50. char  strFile[255]; // The texture file name (If this is set it's a texture map)
  51. BYTE  color[3]; // The color of the object (R, G, B)
  52. int   texureId; // the texture ID
  53. float uTile; // u tiling of texture  
  54. float vTile; // v tiling of texture
  55. float uOffset;     // u offset of texture
  56. float vOffset; // v offset of texture
  57. } ;
  58. // This holds all the information for our model/scene. 
  59. // You should eventually turn into a robust class that 
  60. // has loading/drawing/querying functions like:
  61. // LoadModel(...); DrawObject(...); DrawModel(...); DestroyModel(...);
  62. struct t3DObject 
  63. {
  64. int  numOfVerts; // The number of verts in the model
  65. int  numOfFaces; // The number of faces in the model
  66. int  numTexVertex; // The number of texture coordinates
  67. int  materialID; // The texture ID to use, which is the index into our texture array
  68. bool bHasTexture; // This is TRUE if there is a texture map for this object
  69. char strName[255]; // The name of the object
  70. CVector3  *pVerts; // The object's vertices
  71. CVector3  *pNormals; // The object's normals
  72. CVector2  *pTexVerts; // The texture's UV coordinates
  73. tFace *pFaces; // The faces information of the object
  74. };
  75. // This holds our model information.  This should also turn into a robust class.
  76. // We use STL's (Standard Template Library) vector class to ease our link list burdens. :)
  77. struct t3DModel 
  78. {
  79. int numOfObjects; // The number of objects in the model
  80. int numOfMaterials; // The number of materials for the model
  81. int *m_glCommandBuffer;
  82. vector<tMaterialInfo> pMaterials; // The list of material information (Textures and colors)
  83. vector<t3DObject> pObject; // The object list for our model
  84. };
  85. //////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
  86. extern bool  g_bFullScreen; // Set full screen as default
  87. extern HWND  g_hWnd; // This is the handle for the window
  88. extern RECT  g_rRect; // This holds the window dimensions
  89. extern HDC   g_hDC; // General HDC - (handle to device context)
  90. extern HGLRC g_hRC; // General OpenGL_DC - Our Rendering Context for OpenGL
  91. extern HINSTANCE g_hInstance; // This holds our window hInstance
  92. // This is our MAIN() for windows
  93. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hprev, PSTR cmdline, int ishow);
  94. // The window proc which handles all of window's messages.
  95. LRESULT CALLBACK WinProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
  96. // This controls our main program loop
  97. WPARAM MainLoop();
  98. // This creates a texture and stores it in the texture array with it's ID.
  99. void CreateTexture(UINT textureArray[], LPSTR strFileName, int textureID);
  100. // This changes the screen to full screen mode
  101. void ChangeToFullScreen();
  102. // This is our own function that makes creating a window modular and easy
  103. HWND CreateMyWindow(LPSTR strWindowName, int width, int height, DWORD dwStyle, bool bFullScreen, HINSTANCE hInstance);
  104. // This allows us to configure our window for OpenGL and backbuffered
  105. bool bSetupPixelFormat(HDC hdc);
  106. // This inits our screen translations and projections
  107. void SizeOpenGLScreen(int width, int height);
  108. // This sets up OpenGL
  109. void InitializeOpenGL(int width, int height);
  110. // This initializes the whole program
  111. void Init(HWND hWnd);
  112. // This draws everything to the screen
  113. void RenderScene();
  114. // This frees all our memory in our program
  115. void DeInit();
  116. #endif 
  117. /////////////////////////////////////////////////////////////////////////////////
  118. //
  119. // * QUICK NOTES * 
  120. //
  121. // This file includes all the structures that you need to hold the model data.
  122. // If you intend to use this code, I would make the model and object structures classes.
  123. // This way you can have a bunch of helper functions like Import(), Translate(), Render()...
  124. //
  125. // * What's An STL (Standard Template Library) Vector? *
  126. // Let me quickly explain the STL vector for those of you who are not familiar with them.
  127. // To use a vector you must include <vector> and use the std namespace: using namespace std;
  128. // A vector is an array based link list.  It allows you to dynamically add and remove nodes.
  129. // This is a template class so it can be a list of ANY type.  To create a vector of type
  130. // "int" you would say:  vector<int> myIntList;
  131. // Now you can add a integer to the dynamic array by saying: myIntList.push_back(10);
  132. // or you can say:  myIntList.push_back(num);.  The more you push back, the larger
  133. // your array gets.  You can index the vector like an array.  myIntList[0] = 0;
  134. // To get rid of a node you use the pop_back() function.  To clear the vector use clear().
  135. // It frees itself so you don't need to worry about it, except if you have data
  136. // structures that need information freed from inside them, like our objects.
  137. //
  138. //
  139. // Ben Humphrey (DigiBen)
  140. // Game Programmer
  141. // DigiBen@GameTutorials.com
  142. // Co-Web Host of www.GameTutorials.com
  143. //
  144. //