diff options
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/CQ3LevelMesh.h')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/CQ3LevelMesh.h | 491 |
1 files changed, 0 insertions, 491 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/CQ3LevelMesh.h b/libraries/irrlicht-1.8/source/Irrlicht/CQ3LevelMesh.h deleted file mode 100644 index 4d5659b..0000000 --- a/libraries/irrlicht-1.8/source/Irrlicht/CQ3LevelMesh.h +++ /dev/null | |||
@@ -1,491 +0,0 @@ | |||
1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt | ||
2 | // This file is part of the "Irrlicht Engine". | ||
3 | // For conditions of distribution and use, see copyright notice in irrlicht.h | ||
4 | |||
5 | #ifndef __C_Q3_LEVEL_MESH_H_INCLUDED__ | ||
6 | #define __C_Q3_LEVEL_MESH_H_INCLUDED__ | ||
7 | |||
8 | #include "IQ3LevelMesh.h" | ||
9 | #include "IReadFile.h" | ||
10 | #include "IFileSystem.h" | ||
11 | #include "SMesh.h" | ||
12 | #include "SMeshBufferLightMap.h" | ||
13 | #include "IVideoDriver.h" | ||
14 | #include "irrString.h" | ||
15 | #include "ISceneManager.h" | ||
16 | #include "os.h" | ||
17 | |||
18 | namespace irr | ||
19 | { | ||
20 | namespace scene | ||
21 | { | ||
22 | class CQ3LevelMesh : public IQ3LevelMesh | ||
23 | { | ||
24 | public: | ||
25 | |||
26 | //! constructor | ||
27 | CQ3LevelMesh(io::IFileSystem* fs, scene::ISceneManager* smgr, | ||
28 | const quake3::Q3LevelLoadParameter &loadParam); | ||
29 | |||
30 | //! destructor | ||
31 | virtual ~CQ3LevelMesh(); | ||
32 | |||
33 | //! loads a level from a .bsp-File. Also tries to load all | ||
34 | //! needed textures. Returns true if successful. | ||
35 | bool loadFile(io::IReadFile* file); | ||
36 | |||
37 | //! returns the amount of frames in milliseconds. If the amount | ||
38 | //! is 1, it is a static (=non animated) mesh. | ||
39 | virtual u32 getFrameCount() const; | ||
40 | |||
41 | //! Gets the default animation speed of the animated mesh. | ||
42 | /** \return Amount of frames per second. If the amount is 0, it is a static, non animated mesh. */ | ||
43 | virtual f32 getAnimationSpeed() const | ||
44 | { | ||
45 | return FramesPerSecond; | ||
46 | } | ||
47 | |||
48 | //! Gets the frame count of the animated mesh. | ||
49 | /** \param fps Frames per second to play the animation with. If the amount is 0, it is not animated. | ||
50 | The actual speed is set in the scene node the mesh is instantiated in.*/ | ||
51 | virtual void setAnimationSpeed(f32 fps) | ||
52 | { | ||
53 | FramesPerSecond=fps; | ||
54 | } | ||
55 | |||
56 | //! returns the animated mesh based on a detail level. 0 is the | ||
57 | //! lowest, 255 the highest detail. Note, that some Meshes will | ||
58 | //! ignore the detail level. | ||
59 | virtual IMesh* getMesh(s32 frameInMs, s32 detailLevel=255, | ||
60 | s32 startFrameLoop=-1, s32 endFrameLoop=-1); | ||
61 | |||
62 | //! Returns an axis aligned bounding box of the mesh. | ||
63 | //! \return A bounding box of this mesh is returned. | ||
64 | virtual const core::aabbox3d<f32>& getBoundingBox() const; | ||
65 | |||
66 | virtual void setBoundingBox( const core::aabbox3df& box); | ||
67 | |||
68 | //! Returns the type of the animated mesh. | ||
69 | virtual E_ANIMATED_MESH_TYPE getMeshType() const; | ||
70 | |||
71 | //! loads the shader definition | ||
72 | virtual void getShader( io::IReadFile* file ); | ||
73 | |||
74 | //! loads the shader definition | ||
75 | virtual const quake3::IShader * getShader( const c8 * filename, bool fileNameIsValid=true ); | ||
76 | |||
77 | //! returns a already loaded Shader | ||
78 | virtual const quake3::IShader * getShader( u32 index ) const; | ||
79 | |||
80 | |||
81 | //! loads a configuration file | ||
82 | virtual void getConfiguration( io::IReadFile* file ); | ||
83 | //! get's an interface to the entities | ||
84 | virtual quake3::tQ3EntityList & getEntityList(); | ||
85 | |||
86 | //! returns the requested brush entity | ||
87 | virtual IMesh* getBrushEntityMesh(s32 num) const; | ||
88 | |||
89 | //! returns the requested brush entity | ||
90 | virtual IMesh* getBrushEntityMesh(quake3::IEntity &ent) const; | ||
91 | |||
92 | //Link to held meshes? ... | ||
93 | |||
94 | |||
95 | //! returns amount of mesh buffers. | ||
96 | virtual u32 getMeshBufferCount() const | ||
97 | { | ||
98 | return 0; | ||
99 | } | ||
100 | |||
101 | //! returns pointer to a mesh buffer | ||
102 | virtual IMeshBuffer* getMeshBuffer(u32 nr) const | ||
103 | { | ||
104 | return 0; | ||
105 | } | ||
106 | |||
107 | //! Returns pointer to a mesh buffer which fits a material | ||
108 | /** \param material: material to search for | ||
109 | \return Pointer to the mesh buffer or 0 if there is no such mesh buffer. */ | ||
110 | virtual IMeshBuffer* getMeshBuffer( const video::SMaterial &material) const | ||
111 | { | ||
112 | return 0; | ||
113 | } | ||
114 | |||
115 | virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue) | ||
116 | { | ||
117 | return; | ||
118 | } | ||
119 | |||
120 | //! set the hardware mapping hint, for driver | ||
121 | virtual void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX) | ||
122 | { | ||
123 | return; | ||
124 | } | ||
125 | |||
126 | //! flags the meshbuffer as changed, reloads hardware buffers | ||
127 | virtual void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX) | ||
128 | { | ||
129 | return; | ||
130 | } | ||
131 | |||
132 | private: | ||
133 | |||
134 | |||
135 | void constructMesh(); | ||
136 | void solveTJunction(); | ||
137 | void loadTextures(); | ||
138 | scene::SMesh** buildMesh(s32 num); | ||
139 | |||
140 | struct STexShader | ||
141 | { | ||
142 | video::ITexture* Texture; | ||
143 | s32 ShaderID; | ||
144 | }; | ||
145 | |||
146 | core::array< STexShader > Tex; | ||
147 | core::array<video::ITexture*> Lightmap; | ||
148 | |||
149 | enum eLumps | ||
150 | { | ||
151 | kEntities = 0, // Stores player/object positions, etc... | ||
152 | kShaders = 1, // Stores texture information | ||
153 | kPlanes = 2, // Stores the splitting planes | ||
154 | kNodes = 3, // Stores the BSP nodes | ||
155 | kLeafs = 4, // Stores the leafs of the nodes | ||
156 | kLeafFaces = 5, // Stores the leaf's indices into the faces | ||
157 | kLeafBrushes = 6, // Stores the leaf's indices into the brushes | ||
158 | kModels = 7, // Stores the info of world models | ||
159 | kBrushes = 8, // Stores the brushes info (for collision) | ||
160 | kBrushSides = 9, // Stores the brush surfaces info | ||
161 | kVertices = 10, // Stores the level vertices | ||
162 | kMeshVerts = 11, // Stores the model vertices offsets | ||
163 | kFogs = 12, // Stores the shader files (blending, anims..) | ||
164 | kFaces = 13, // Stores the faces for the level | ||
165 | kLightmaps = 14, // Stores the lightmaps for the level | ||
166 | kLightGrid = 15, // Stores extra world lighting information | ||
167 | kVisData = 16, // Stores PVS and cluster info (visibility) | ||
168 | kLightArray = 17, // RBSP | ||
169 | kMaxLumps // A constant to store the number of lumps | ||
170 | }; | ||
171 | |||
172 | enum eBspSurfaceType | ||
173 | { | ||
174 | BSP_MST_BAD, | ||
175 | BSP_MST_PLANAR, | ||
176 | BSP_MST_PATCH, | ||
177 | BSP_MST_TRIANGLE_SOUP, | ||
178 | BSP_MST_FLARE, | ||
179 | BSP_MST_FOLIAGE | ||
180 | |||
181 | }; | ||
182 | |||
183 | struct tBSPHeader | ||
184 | { | ||
185 | s32 strID; // This should always be 'IBSP' | ||
186 | s32 version; // This should be 0x2e for Quake 3 files | ||
187 | }; | ||
188 | tBSPHeader header; | ||
189 | |||
190 | struct tBSPLump | ||
191 | { | ||
192 | s32 offset; | ||
193 | s32 length; | ||
194 | }; | ||
195 | |||
196 | |||
197 | struct tBSPVertex | ||
198 | { | ||
199 | f32 vPosition[3]; // (x, y, z) position. | ||
200 | f32 vTextureCoord[2]; // (u, v) texture coordinate | ||
201 | f32 vLightmapCoord[2]; // (u, v) lightmap coordinate | ||
202 | f32 vNormal[3]; // (x, y, z) normal vector | ||
203 | u8 color[4]; // RGBA color for the vertex | ||
204 | }; | ||
205 | |||
206 | struct tBSPFace | ||
207 | { | ||
208 | s32 textureID; // The index into the texture array | ||
209 | s32 fogNum; // The index for the effects (or -1 = n/a) | ||
210 | s32 type; // 1=polygon, 2=patch, 3=mesh, 4=billboard | ||
211 | s32 vertexIndex; // The index into this face's first vertex | ||
212 | s32 numOfVerts; // The number of vertices for this face | ||
213 | s32 meshVertIndex; // The index into the first meshvertex | ||
214 | s32 numMeshVerts; // The number of mesh vertices | ||
215 | s32 lightmapID; // The texture index for the lightmap | ||
216 | s32 lMapCorner[2]; // The face's lightmap corner in the image | ||
217 | s32 lMapSize[2]; // The size of the lightmap section | ||
218 | f32 lMapPos[3]; // The 3D origin of lightmap. | ||
219 | f32 lMapBitsets[2][3]; // The 3D space for s and t unit vectors. | ||
220 | f32 vNormal[3]; // The face normal. | ||
221 | s32 size[2]; // The bezier patch dimensions. | ||
222 | }; | ||
223 | |||
224 | struct tBSPTexture | ||
225 | { | ||
226 | c8 strName[64]; // The name of the texture w/o the extension | ||
227 | u32 flags; // The surface flags (unknown) | ||
228 | u32 contents; // The content flags (unknown) | ||
229 | }; | ||
230 | |||
231 | struct tBSPLightmap | ||
232 | { | ||
233 | u8 imageBits[128][128][3]; // The RGB data in a 128x128 image | ||
234 | }; | ||
235 | |||
236 | struct tBSPNode | ||
237 | { | ||
238 | s32 plane; // The index into the planes array | ||
239 | s32 front; // The child index for the front node | ||
240 | s32 back; // The child index for the back node | ||
241 | s32 mins[3]; // The bounding box min position. | ||
242 | s32 maxs[3]; // The bounding box max position. | ||
243 | }; | ||
244 | |||
245 | struct tBSPLeaf | ||
246 | { | ||
247 | s32 cluster; // The visibility cluster | ||
248 | s32 area; // The area portal | ||
249 | s32 mins[3]; // The bounding box min position | ||
250 | s32 maxs[3]; // The bounding box max position | ||
251 | s32 leafface; // The first index into the face array | ||
252 | s32 numOfLeafFaces; // The number of faces for this leaf | ||
253 | s32 leafBrush; // The first index for into the brushes | ||
254 | s32 numOfLeafBrushes; // The number of brushes for this leaf | ||
255 | }; | ||
256 | |||
257 | struct tBSPPlane | ||
258 | { | ||
259 | f32 vNormal[3]; // Plane normal. | ||
260 | f32 d; // The plane distance from origin | ||
261 | }; | ||
262 | |||
263 | struct tBSPVisData | ||
264 | { | ||
265 | s32 numOfClusters; // The number of clusters | ||
266 | s32 bytesPerCluster; // Bytes (8 bits) in the cluster's bitset | ||
267 | c8 *pBitsets; // Array of bytes holding the cluster vis. | ||
268 | }; | ||
269 | |||
270 | struct tBSPBrush | ||
271 | { | ||
272 | s32 brushSide; // The starting brush side for the brush | ||
273 | s32 numOfBrushSides; // Number of brush sides for the brush | ||
274 | s32 textureID; // The texture index for the brush | ||
275 | }; | ||
276 | |||
277 | struct tBSPBrushSide | ||
278 | { | ||
279 | s32 plane; // The plane index | ||
280 | s32 textureID; // The texture index | ||
281 | }; | ||
282 | |||
283 | struct tBSPModel | ||
284 | { | ||
285 | f32 min[3]; // The min position for the bounding box | ||
286 | f32 max[3]; // The max position for the bounding box. | ||
287 | s32 faceIndex; // The first face index in the model | ||
288 | s32 numOfFaces; // The number of faces in the model | ||
289 | s32 brushIndex; // The first brush index in the model | ||
290 | s32 numOfBrushes; // The number brushes for the model | ||
291 | }; | ||
292 | |||
293 | struct tBSPFog | ||
294 | { | ||
295 | c8 shader[64]; // The name of the shader file | ||
296 | s32 brushIndex; // The brush index for this shader | ||
297 | s32 visibleSide; // the brush side that ray tests need to clip against (-1 == none | ||
298 | }; | ||
299 | core::array < STexShader > FogMap; | ||
300 | |||
301 | struct tBSPLights | ||
302 | { | ||
303 | u8 ambient[3]; // This is the ambient color in RGB | ||
304 | u8 directional[3]; // This is the directional color in RGB | ||
305 | u8 direction[2]; // The direction of the light: [phi,theta] | ||
306 | }; | ||
307 | |||
308 | void loadTextures (tBSPLump* l, io::IReadFile* file); // Load the textures | ||
309 | void loadLightmaps (tBSPLump* l, io::IReadFile* file); // Load the lightmaps | ||
310 | void loadVerts (tBSPLump* l, io::IReadFile* file); // Load the vertices | ||
311 | void loadFaces (tBSPLump* l, io::IReadFile* file); // Load the faces | ||
312 | void loadPlanes (tBSPLump* l, io::IReadFile* file); // Load the Planes of the BSP | ||
313 | void loadNodes (tBSPLump* l, io::IReadFile* file); // load the Nodes of the BSP | ||
314 | void loadLeafs (tBSPLump* l, io::IReadFile* file); // load the Leafs of the BSP | ||
315 | void loadLeafFaces (tBSPLump* l, io::IReadFile* file); // load the Faces of the Leafs of the BSP | ||
316 | void loadVisData (tBSPLump* l, io::IReadFile* file); // load the visibility data of the clusters | ||
317 | void loadEntities (tBSPLump* l, io::IReadFile* file); // load the entities | ||
318 | void loadModels (tBSPLump* l, io::IReadFile* file); // load the models | ||
319 | void loadMeshVerts (tBSPLump* l, io::IReadFile* file); // load the mesh vertices | ||
320 | void loadBrushes (tBSPLump* l, io::IReadFile* file); // load the brushes of the BSP | ||
321 | void loadBrushSides (tBSPLump* l, io::IReadFile* file); // load the brushsides of the BSP | ||
322 | void loadLeafBrushes(tBSPLump* l, io::IReadFile* file); // load the brushes of the leaf | ||
323 | void loadFogs (tBSPLump* l, io::IReadFile* file); // load the shaders | ||
324 | |||
325 | //bi-quadratic bezier patches | ||
326 | void createCurvedSurface_bezier(SMeshBufferLightMap* meshBuffer, | ||
327 | s32 faceIndex, s32 patchTesselation, s32 storevertexcolor); | ||
328 | |||
329 | void createCurvedSurface_nosubdivision(SMeshBufferLightMap* meshBuffer, | ||
330 | s32 faceIndex, s32 patchTesselation, s32 storevertexcolor); | ||
331 | |||
332 | struct S3DVertex2TCoords_64 | ||
333 | { | ||
334 | core::vector3d<f64> Pos; | ||
335 | core::vector3d<f64> Normal; | ||
336 | video::SColorf Color; | ||
337 | core::vector2d<f64> TCoords; | ||
338 | core::vector2d<f64> TCoords2; | ||
339 | |||
340 | void copy( video::S3DVertex2TCoords &dest ) const; | ||
341 | |||
342 | S3DVertex2TCoords_64() {} | ||
343 | S3DVertex2TCoords_64(const core::vector3d<f64>& pos, const core::vector3d<f64>& normal, const video::SColorf& color, | ||
344 | const core::vector2d<f64>& tcoords, const core::vector2d<f64>& tcoords2) | ||
345 | : Pos(pos), Normal(normal), Color(color), TCoords(tcoords), TCoords2(tcoords2) {} | ||
346 | |||
347 | S3DVertex2TCoords_64 getInterpolated_quadratic(const S3DVertex2TCoords_64& v2, | ||
348 | const S3DVertex2TCoords_64& v3, const f64 d) const | ||
349 | { | ||
350 | return S3DVertex2TCoords_64 ( | ||
351 | Pos.getInterpolated_quadratic ( v2.Pos, v3.Pos, d ), | ||
352 | Normal.getInterpolated_quadratic ( v2.Normal, v3.Normal, d ), | ||
353 | Color.getInterpolated_quadratic ( v2.Color, v3.Color, (f32) d ), | ||
354 | TCoords.getInterpolated_quadratic ( v2.TCoords, v3.TCoords, d ), | ||
355 | TCoords2.getInterpolated_quadratic ( v2.TCoords2, v3.TCoords2, d )); | ||
356 | } | ||
357 | }; | ||
358 | |||
359 | inline void copy( video::S3DVertex2TCoords * dest, const tBSPVertex * source, | ||
360 | s32 vertexcolor ) const; | ||
361 | void copy( S3DVertex2TCoords_64 * dest, const tBSPVertex * source, s32 vertexcolor ) const; | ||
362 | |||
363 | |||
364 | struct SBezier | ||
365 | { | ||
366 | SMeshBufferLightMap *Patch; | ||
367 | S3DVertex2TCoords_64 control[9]; | ||
368 | |||
369 | void tesselate(s32 level); | ||
370 | |||
371 | private: | ||
372 | s32 Level; | ||
373 | |||
374 | core::array<S3DVertex2TCoords_64> column[3]; | ||
375 | |||
376 | }; | ||
377 | SBezier Bezier; | ||
378 | |||
379 | quake3::Q3LevelLoadParameter LoadParam; | ||
380 | |||
381 | tBSPLump Lumps[kMaxLumps]; | ||
382 | |||
383 | tBSPTexture* Textures; | ||
384 | s32 NumTextures; | ||
385 | |||
386 | tBSPLightmap* LightMaps; | ||
387 | s32 NumLightMaps; | ||
388 | |||
389 | tBSPVertex* Vertices; | ||
390 | s32 NumVertices; | ||
391 | |||
392 | tBSPFace* Faces; | ||
393 | s32 NumFaces; | ||
394 | |||
395 | tBSPModel* Models; | ||
396 | s32 NumModels; | ||
397 | |||
398 | tBSPPlane* Planes; | ||
399 | s32 NumPlanes; | ||
400 | |||
401 | tBSPNode* Nodes; | ||
402 | s32 NumNodes; | ||
403 | |||
404 | tBSPLeaf* Leafs; | ||
405 | s32 NumLeafs; | ||
406 | |||
407 | s32 *LeafFaces; | ||
408 | s32 NumLeafFaces; | ||
409 | |||
410 | s32 *MeshVerts; // The vertex offsets for a mesh | ||
411 | s32 NumMeshVerts; | ||
412 | |||
413 | tBSPBrush* Brushes; | ||
414 | s32 NumBrushes; | ||
415 | |||
416 | scene::SMesh** BrushEntities; | ||
417 | |||
418 | scene::SMesh* Mesh[quake3::E_Q3_MESH_SIZE]; | ||
419 | video::IVideoDriver* Driver; | ||
420 | core::stringc LevelName; | ||
421 | io::IFileSystem* FileSystem; // needs because there are no file extenstions stored in .bsp files. | ||
422 | |||
423 | // Additional content | ||
424 | scene::ISceneManager* SceneManager; | ||
425 | enum eToken | ||
426 | { | ||
427 | Q3_TOKEN_UNRESOLVED = 0, | ||
428 | Q3_TOKEN_EOF = 1, | ||
429 | Q3_TOKEN_START_LIST, | ||
430 | Q3_TOKEN_END_LIST, | ||
431 | Q3_TOKEN_ENTITY, | ||
432 | Q3_TOKEN_TOKEN, | ||
433 | Q3_TOKEN_EOL, | ||
434 | Q3_TOKEN_COMMENT, | ||
435 | Q3_TOKEN_MATH_DIVIDE, | ||
436 | Q3_TOKEN_MATH_ADD, | ||
437 | Q3_TOKEN_MATH_MULTIPY | ||
438 | }; | ||
439 | struct SQ3Parser | ||
440 | { | ||
441 | const c8 *source; | ||
442 | u32 sourcesize; | ||
443 | u32 index; | ||
444 | core::stringc token; | ||
445 | eToken tokenresult; | ||
446 | }; | ||
447 | SQ3Parser Parser; | ||
448 | |||
449 | |||
450 | typedef void( CQ3LevelMesh::*tParserCallback ) ( quake3::SVarGroupList *& groupList, eToken token ); | ||
451 | void parser_parse( const void * data, u32 size, tParserCallback callback ); | ||
452 | void parser_nextToken(); | ||
453 | |||
454 | void dumpVarGroup( const quake3::SVarGroup * group, s32 stack ) const; | ||
455 | |||
456 | void scriptcallback_entity( quake3::SVarGroupList *& grouplist, eToken token ); | ||
457 | void scriptcallback_shader( quake3::SVarGroupList *& grouplist, eToken token ); | ||
458 | void scriptcallback_config( quake3::SVarGroupList *& grouplist, eToken token ); | ||
459 | |||
460 | core::array < quake3::IShader > Shader; | ||
461 | core::array < quake3::IShader > Entity; //quake3::tQ3EntityList Entity; | ||
462 | |||
463 | |||
464 | quake3::tStringList ShaderFile; | ||
465 | void InitShader(); | ||
466 | void ReleaseShader(); | ||
467 | void ReleaseEntity(); | ||
468 | |||
469 | |||
470 | s32 setShaderMaterial( video::SMaterial & material, const tBSPFace * face ) const; | ||
471 | s32 setShaderFogMaterial( video::SMaterial &material, const tBSPFace * face ) const; | ||
472 | |||
473 | struct SToBuffer | ||
474 | { | ||
475 | s32 takeVertexColor; | ||
476 | u32 index; | ||
477 | }; | ||
478 | |||
479 | void cleanMeshes(); | ||
480 | void cleanMesh(SMesh *m, const bool texture0important = false); | ||
481 | void cleanLoader (); | ||
482 | void calcBoundingBoxes(); | ||
483 | c8 buf[128]; | ||
484 | f32 FramesPerSecond; | ||
485 | }; | ||
486 | |||
487 | } // end namespace scene | ||
488 | } // end namespace irr | ||
489 | |||
490 | #endif | ||
491 | |||