Quake3Bsp.h
上传用户:cxh8989
上传日期:2021-01-22
资源大小:2544k
文件大小:13k
源码类别:

射击游戏

开发平台:

Visual C++

  1. #ifndef _QUAKE3BSP_H
  2. #define _QUAKE3BSP_H
  3. // This is the number that is associated with a face that is of type "polygon"
  4. #define FACE_POLYGON 1
  5. #define TYPE_RAY 0 // This is the type for tracing a RAY
  6. #define TYPE_SPHERE 1 // This is the type for tracing a SPHERE
  7. #define TYPE_BOX 2 // This is the type for tracing a AABB (BOX)
  8. const float kEpsilon =  0.03125f; // This is our small number to compensate for float errors
  9. /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
  10. // We need to have a gravity and jump acceleration for our simple physics
  11. const float kGravity =  9.8f;
  12. const float kJumpAcceleration = 4;
  13. /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
  14. // This is our integer vector structure
  15. struct tVector3i
  16. {
  17. int x, y, z; // The x y and z position of our integer vector
  18. };
  19. // This is our BSP header structure
  20. struct tBSPHeader
  21. {
  22.     char strID[4]; // This should always be 'IBSP'
  23.     int version; // This should be 0x2e for Quake 3 files
  24. }; 
  25. // This is our BSP lump structure
  26. struct tBSPLump
  27. {
  28. int offset; // The offset into the file for the start of this lump
  29. int length; // The length in bytes for this lump
  30. };
  31. // This is our BSP vertex structure
  32. struct tBSPVertex
  33. {
  34.     CVector3 vPosition; // (x, y, z) position. 
  35.     CVector2 vTextureCoord; // (u, v) texture coordinate
  36.     CVector2 vLightmapCoord; // (u, v) lightmap coordinate
  37.     CVector3 vNormal; // (x, y, z) normal vector
  38.     byte color[4]; // RGBA color for the vertex 
  39. };
  40. // This is our BSP face structure
  41. struct tBSPFace
  42. {
  43.     int textureID; // The index into the texture array 
  44.     int effect; // The index for the effects (or -1 = n/a) 
  45.     int type; // 1=polygon, 2=patch, 3=mesh, 4=billboard 
  46.     int startVertIndex; // The starting index into this face's first vertex 
  47.     int numOfVerts; // The number of vertices for this face 
  48.     int startIndex; // The starting index into the indices array for this face
  49.     int numOfIndices; // The number of indices for this face
  50.     int lightmapID; // The texture index for the lightmap 
  51.     int lMapCorner[2]; // The face's lightmap corner in the image 
  52.     int lMapSize[2]; // The size of the lightmap section 
  53.     CVector3 lMapPos; // The 3D origin of lightmap. 
  54.     CVector3 lMapVecs[2]; // The 3D space for s and t unit vectors. 
  55.     CVector3 vNormal; // The face normal. 
  56.     int size[2]; // The bezier patch dimensions. 
  57. };
  58. // This is our BSP texture structure
  59. struct tBSPTexture
  60. {
  61.     char strName[64]; // The name of the texture w/o the extension 
  62.     int flags; // The surface flags (unknown) 
  63.     int textureType; // The type of texture (solid, water, slime, etc..) (type & 1) = 1 (solid)
  64. };
  65. // This is our BSP lightmap structure which stores the 128x128 RGB values
  66. struct tBSPLightmap
  67. {
  68.     byte imageBits[128][128][3];   // The RGB data in a 128x128 image
  69. };
  70. // This stores a node in the BSP tree
  71. struct tBSPNode
  72. {
  73.     int plane; // The index into the planes array 
  74.     int front; // The child index for the front node 
  75.     int back; // The child index for the back node 
  76.     tVector3i min; // The bounding box min position. 
  77.     tVector3i max; // The bounding box max position. 
  78. }; 
  79. // This stores a leaf (end node) in the BSP tree
  80. struct tBSPLeaf
  81. {
  82.     int cluster; // The visibility cluster 
  83.     int area; // The area portal 
  84.     tVector3i min; // The bounding box min position 
  85.     tVector3i max; // The bounding box max position 
  86.     int leafface; // The first index into the face array 
  87.     int numOfLeafFaces; // The number of faces for this leaf 
  88.     int leafBrush; // The first index for into the brushes 
  89.     int numOfLeafBrushes; // The number of brushes for this leaf 
  90. }; 
  91. // This stores a splitter plane in the BSP tree
  92. struct tBSPPlane
  93. {
  94.     CVector3 vNormal; // Plane normal. 
  95.     float d; // The plane distance from origin 
  96. };
  97. // This stores the cluster data for the PVS's
  98. struct tBSPVisData
  99. {
  100. int numOfClusters; // The number of clusters
  101. int bytesPerCluster; // The amount of bytes (8 bits) in the cluster's bitset
  102. byte *pBitsets; // The array of bytes that holds the cluster bitsets
  103. };
  104. // This stores the brush data
  105. struct tBSPBrush 
  106. {
  107. int brushSide; // The starting brush side for the brush 
  108. int numOfBrushSides; // Number of brush sides for the brush
  109. int textureID; // The texture index for the brush
  110. }; 
  111. // This stores the brush side data, which stores indices for the normal and texture ID
  112. struct tBSPBrushSide 
  113. {
  114. int plane; // The plane index
  115. int textureID; // The texture index
  116. }; 
  117. // This is our lumps enumeration
  118. enum eLumps
  119. {
  120.     kEntities = 0, // Stores player/object positions, etc...
  121.     kTextures, // Stores texture information
  122.     kPlanes,     // Stores the splitting planes
  123.     kNodes, // Stores the BSP nodes
  124.     kLeafs, // Stores the leafs of the nodes
  125.     kLeafFaces, // Stores the leaf's indices into the faces
  126.     kLeafBrushes, // Stores the leaf's indices into the brushes
  127.     kModels, // Stores the info of world models
  128.     kBrushes, // Stores the brushes info (for collision)
  129.     kBrushSides, // Stores the brush surfaces info
  130.     kVertices, // Stores the level vertices
  131.     kIndices, // Stores the level indices
  132.     kShaders, // Stores the shader files (blending, anims..)
  133.     kFaces, // Stores the faces for the level
  134.     kLightmaps, // Stores the lightmaps for the level
  135.     kLightVolumes, // Stores extra world lighting information
  136.     kVisData, // Stores PVS and cluster info (visibility)
  137.     kMaxLumps // A constant to store the number of lumps
  138. };
  139. // This is our bitset class for storing which face has already been drawn.
  140. // The bitset functionality isn't really taken advantage of in this version
  141. // since we aren't rendering by leafs and nodes.
  142. class CBitset 
  143. {
  144. public:
  145. // Initialize all the data members
  146.     CBitset() : m_bits(0), m_size(0) {}
  147. // This is our deconstructor
  148. ~CBitset() 
  149. {
  150. // If we have valid memory, get rid of it
  151. if(m_bits) 
  152. {
  153. delete m_bits;
  154. m_bits = NULL;
  155. }
  156. }
  157. // This resizes our bitset to a size so each face has a bit associated with it
  158. void Resize(int count) 
  159. // Get the size of integers we need
  160. m_size = count/32 + 1;
  161. // Make sure we haven't already allocated memory for the bits
  162.         if(m_bits) 
  163. {
  164. delete m_bits;
  165. m_bits = 0;
  166. }
  167. // Allocate the bits and initialize them
  168. m_bits = new unsigned int[m_size];
  169. ClearAll();
  170. }
  171. // This does the binary math to set the desired bit
  172. void Set(int i) 
  173. {
  174. m_bits[i >> 5] |= (1 << (i & 31));
  175. }
  176. // This returns if the desired bit slot is a 1 or a 0
  177. int On(int i) 
  178. {
  179. return m_bits[i >> 5] & (1 << (i & 31 ));
  180. }
  181. // This clears a bit to 0
  182. void Clear(int i) 
  183. {
  184. m_bits[i >> 5] &= ~(1 << (i & 31));
  185. }
  186. // This initializes the bits to 0
  187. void ClearAll() 
  188. {
  189. memset(m_bits, 0, sizeof(unsigned int) * m_size);
  190. }
  191. private:
  192. // Our private bit data that holds the bits and size
  193. unsigned int *m_bits;
  194. int m_size;
  195. };
  196. // This is our Quake3 BSP class
  197. class CQuake3BSP
  198. {
  199. public:
  200. // Our constructor
  201. CQuake3BSP();
  202. // Our deconstructor
  203. ~CQuake3BSP();
  204. // This loads a .bsp file by it's file name (Returns true if successful)
  205. bool LoadBSP(const char *strFileName);
  206. // This renders the level to the screen, currently the camera pos isn't being used
  207. void RenderLevel(const CVector3 &vPos);
  208. // This traces a single ray and checks collision with brushes
  209. CVector3 TraceRay(CVector3 vStart, CVector3 vEnd);
  210. // This traces a sphere along a ray to check for collision with the brushes
  211. CVector3 TraceSphere(CVector3 vStart, CVector3 vEnd, float radius);
  212. // This traces a axis-aligned bounding box (AABB) along a ray to check for collision
  213. CVector3 TraceBox(CVector3 vStart, CVector3 vEnd, CVector3 vMin, CVector3 vMax);
  214. /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
  215. // This function tells us whether or not we are on the ground or still falling
  216. bool IsOnGround() { return m_bGrounded; }
  217. /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
  218. // This tells us if we have just collided
  219. bool Collided()   { return m_bCollided; }
  220. // This destroys the level data
  221. void Destroy();
  222. private:
  223. // This manually changes the gamma levels of an image
  224. void ChangeGamma(byte *pImage, int size, float factor);
  225. // This creates a texture map from the lightmap image bits
  226. void CreateLightmapTexture(UINT &texture, byte *pImageBits, int width, int height);
  227. // This tells us if a cluster is visible or not
  228. int IsClusterVisible(int current, int test);
  229. // This finds a leaf in the BSP tree according to the position passed in
  230. int FindLeaf(const CVector3 &vPos);
  231. /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
  232. // This checks to see if we can step up over a collision (like a step)
  233. CVector3 TryToStep(CVector3 vStart, CVector3 vEnd);
  234. /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
  235. // This traverses the BSP tree to check our movement vector with the brushes
  236. CVector3 Trace(CVector3 vStart, CVector3 vEnd);
  237. // This recursively checks all the nodes until we find leafs that store the brushes
  238. void CheckNode(int nodeIndex, float startRatio, float endRatio, CVector3 vStart, CVector3 vEnd);
  239. // This checks our movement vector against the brush and it's sides
  240. void CheckBrush(tBSPBrush *pBrush, CVector3 vStart, CVector3 vEnd);
  241. // This attaches the correct extension to the file name, if found
  242. void FindTextureExtension(char *strFileName);
  243. // This renders a single face to the screen
  244. void RenderFace(int faceIndex);
  245. int m_numOfVerts; // The number of verts in the model
  246. int m_numOfFaces; // The number of faces in the model
  247. int m_numOfIndices; // The number of indices for the model
  248. int m_numOfTextures; // The number of texture maps
  249. int m_numOfLightmaps; // The number of light maps
  250. int m_numOfNodes; // The number of nodes in the BSP
  251. int m_numOfLeafs; // The number of leafs
  252. int m_numOfLeafFaces; // The number of faces
  253. int m_numOfPlanes; // The number of planes in the BSP
  254. int m_numOfBrushes; // The number of brushes in our world
  255. int m_numOfBrushSides; // The number of brush sides in our world
  256. int m_numOfLeafBrushes; // The number of leaf brushes
  257. int m_traceType; // This stores if we are checking a ray, sphere or a box
  258. float m_traceRatio; // This stores the ratio from our start pos to the intersection pt.
  259. float m_traceRadius; // This stores the sphere's radius for a collision offset
  260. bool m_bCollided; // This tells if we just collided or not
  261. /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
  262. bool m_bGrounded; // This stores whether or not we are on the ground or falling
  263. bool m_bTryStep; // This tells us whether or not we should try to step over something
  264. /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
  265. CVector3 m_vTraceMins; // This stores the minimum values of the AABB (bottom corner)
  266. CVector3 m_vTraceMaxs; // This stores the maximum values of the AABB (top corner)
  267. CVector3 m_vExtents; // This stores the largest length of the box
  268. CVector3 m_vCollisionNormal; // This stores the normal of the plane we collided with
  269. int   *m_pIndices; // The object's indices for rendering
  270. tBSPVertex    *m_pVerts; // The object's vertices
  271. tBSPFace      *m_pFaces; // The faces information of the object
  272. tBSPNode      *m_pNodes; // The nodes in the BSP
  273. tBSPLeaf      *m_pLeafs; // The leafs in the BSP
  274. tBSPPlane     *m_pPlanes; // The planes in the BSP
  275. int           *m_pLeafFaces; // The leaf faces in the BSP
  276. tBSPVisData   m_clusters; // The cluster info for frustum culling and portals (PVS)
  277. tBSPTexture   *m_pTextures; // This stores our texture info for each brush
  278. tBSPBrush   *m_pBrushes; // This is our brushes
  279. tBSPBrushSide *m_pBrushSides; // This holds the brush sides
  280. int   *m_pLeafBrushes;  // The indices into the brush array
  281. UINT m_textures[MAX_TEXTURES]; // The texture array for the world
  282. UINT m_lightmaps[MAX_TEXTURES]; // The lightmap texture array
  283. CBitset m_FacesDrawn; // The bitset for the faces that have/haven't been drawn
  284. };
  285. #endif