allow 64 directories, no longer 8
[divverent/netradiant.git] / tools / quake3 / common / qfiles.h
1 /*
2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 #ifndef __QFILES_H__
23 #define __QFILES_H__
24
25 //
26 // qfiles.h: quake file formats
27 // This file must be identical in the quake and utils directories
28 //
29
30 // surface geometry should not exceed these limits
31 #define SHADER_MAX_VERTEXES     1000
32 #define SHADER_MAX_INDEXES      (6*SHADER_MAX_VERTEXES)
33
34
35 // the maximum size of game reletive pathnames
36 #define MAX_QPATH               64
37
38 /*
39 ========================================================================
40
41 QVM files
42
43 ========================================================================
44 */
45
46 #define VM_MAGIC        0x12721444
47 typedef struct {
48         int             vmMagic;
49
50         int             instructionCount;
51
52         int             codeOffset;
53         int             codeLength;
54
55         int             dataOffset;
56         int             dataLength;
57         int             litLength;                      // ( dataLength - litLength ) should be byteswapped on load
58         int             bssLength;                      // zero filled memory appended to datalength
59 } vmHeader_t;
60
61
62 /*
63 ========================================================================
64
65 PCX files are used for 8 bit images
66
67 ========================================================================
68 */
69
70 typedef struct {
71     char        manufacturer;
72     char        version;
73     char        encoding;
74     char        bits_per_pixel;
75     unsigned short      xmin,ymin,xmax,ymax;
76     unsigned short      hres,vres;
77     unsigned char       palette[48];
78     char        reserved;
79     char        color_planes;
80     unsigned short      bytes_per_line;
81     unsigned short      palette_type;
82     char        filler[58];
83     unsigned char       data;                   // unbounded
84 } pcx_t;
85
86
87 /*
88 ========================================================================
89
90 TGA files are used for 24/32 bit images
91
92 ========================================================================
93 */
94
95 typedef struct _TargaHeader {
96         unsigned char   id_length, colormap_type, image_type;
97         unsigned short  colormap_index, colormap_length;
98         unsigned char   colormap_size;
99         unsigned short  x_origin, y_origin, width, height;
100         unsigned char   pixel_size, attributes;
101 } TargaHeader;
102
103
104
105 /*
106 ========================================================================
107
108 .MD3 triangle model file format
109
110 ========================================================================
111 */
112
113 #define MD3_IDENT                       (('3'<<24)+('P'<<16)+('D'<<8)+'I')
114 #define MD3_VERSION                     15
115
116 // limits
117 #define MD3_MAX_LODS            4
118 #define MD3_MAX_TRIANGLES       8192    // per surface
119 #define MD3_MAX_VERTS           4096    // per surface
120 #define MD3_MAX_SHADERS         256             // per surface
121 #define MD3_MAX_FRAMES          1024    // per model
122 #define MD3_MAX_SURFACES        32              // per model
123 #define MD3_MAX_TAGS            16              // per frame
124
125 // vertex scales
126 #define MD3_XYZ_SCALE           (1.0/64)
127
128 typedef struct md3Frame_s {
129         vec3_t          bounds[2];
130         vec3_t          localOrigin;
131         float           radius;
132         char            name[16];
133 } md3Frame_t;
134
135 typedef struct md3Tag_s {
136         char            name[MAX_QPATH];        // tag name
137         vec3_t          origin;
138         vec3_t          axis[3];
139 } md3Tag_t;
140
141 /*
142 ** md3Surface_t
143 **
144 ** CHUNK                        SIZE
145 ** header                       sizeof( md3Surface_t )
146 ** shaders                      sizeof( md3Shader_t ) * numShaders
147 ** triangles[0]         sizeof( md3Triangle_t ) * numTriangles
148 ** st                           sizeof( md3St_t ) * numVerts
149 ** XyzNormals           sizeof( md3XyzNormal_t ) * numVerts * numFrames
150 */
151 typedef struct {
152         int             ident;                          // 
153
154         char    name[MAX_QPATH];        // polyset name
155
156         int             flags;
157         int             numFrames;                      // all surfaces in a model should have the same
158
159         int             numShaders;                     // all surfaces in a model should have the same
160         int             numVerts;
161
162         int             numTriangles;
163         int             ofsTriangles;
164
165         int             ofsShaders;                     // offset from start of md3Surface_t
166         int             ofsSt;                          // texture coords are common for all frames
167         int             ofsXyzNormals;          // numVerts * numFrames
168
169         int             ofsEnd;                         // next surface follows
170 } md3Surface_t;
171
172 typedef struct {
173         char                    name[MAX_QPATH];
174         int                             shaderIndex;    // for in-game use
175 } md3Shader_t;
176
177 typedef struct {
178         int                     indexes[3];
179 } md3Triangle_t;
180
181 typedef struct {
182         float           st[2];
183 } md3St_t;
184
185 typedef struct {
186         short           xyz[3];
187         short           normal;
188 } md3XyzNormal_t;
189
190 typedef struct {
191         int                     ident;
192         int                     version;
193
194         char            name[MAX_QPATH];        // model name
195
196         int                     flags;
197
198         int                     numFrames;
199         int                     numTags;                        
200         int                     numSurfaces;
201
202         int                     numSkins;
203
204         int                     ofsFrames;                      // offset for first frame
205         int                     ofsTags;                        // numFrames * numTags
206         int                     ofsSurfaces;            // first surface, others follow
207
208         int                     ofsEnd;                         // end of file
209 } md3Header_t;
210
211 /*
212 ==============================================================================
213
214 MD4 file format
215
216 ==============================================================================
217 */
218
219 #define MD4_IDENT                       (('4'<<24)+('P'<<16)+('D'<<8)+'I')
220 #define MD4_VERSION                     1
221 #define MD4_MAX_BONES           128
222
223 typedef struct {
224         int                     boneIndex;              // these are indexes into the boneReferences,
225         float              boneWeight;          // not the global per-frame bone list
226 } md4Weight_t;
227
228 typedef struct {
229   vec3_t    vertex;
230         vec3_t          normal;
231         float           texCoords[2];
232         int                     numWeights;
233         md4Weight_t     weights[1];             // variable sized
234 } md4Vertex_t;
235
236 typedef struct {
237         int                     indexes[3];
238 } md4Triangle_t;
239
240 typedef struct {
241         int                     ident;
242
243         char            name[MAX_QPATH];        // polyset name
244         char            shader[MAX_QPATH];
245         int                     shaderIndex;            // for in-game use
246
247         int                     ofsHeader;                      // this will be a negative number
248
249         int                     numVerts;
250         int                     ofsVerts;
251
252         int                     numTriangles;
253         int                     ofsTriangles;
254
255         // Bone references are a set of ints representing all the bones
256         // present in any vertex weights for this surface.  This is
257         // needed because a model may have surfaces that need to be
258         // drawn at different sort times, and we don't want to have
259         // to re-interpolate all the bones for each surface.
260         int                     numBoneReferences;
261         int                     ofsBoneReferences;
262
263         int                     ofsEnd;                         // next surface follows
264 } md4Surface_t;
265
266 typedef struct {
267         float           matrix[3][4];
268 } md4Bone_t;
269
270 typedef struct {
271         vec3_t          bounds[2];                      // bounds of all surfaces of all LOD's for this frame
272         vec3_t          localOrigin;            // midpoint of bounds, used for sphere cull
273         float           radius;                         // dist from localOrigin to corner
274         char            name[16];
275         md4Bone_t       bones[1];                       // [numBones]
276 } md4Frame_t;
277
278 typedef struct {
279         int                     numSurfaces;
280         int                     ofsSurfaces;            // first surface, others follow
281         int                     ofsEnd;                         // next lod follows
282 } md4LOD_t;
283
284 typedef struct {
285         int                     ident;
286         int                     version;
287
288         char            name[MAX_QPATH];        // model name
289
290         // frames and bones are shared by all levels of detail
291         int                     numFrames;
292         int                     numBones;
293         int                     ofsFrames;                      // md4Frame_t[numFrames]
294
295         // each level of detail has completely separate sets of surfaces
296         int                     numLODs;
297         int                     ofsLODs;
298
299         int                     ofsEnd;                         // end of file
300 } md4Header_t;
301
302
303 /*
304 ==============================================================================
305
306   .BSP file format
307
308 ==============================================================================
309 */
310
311
312 #define BSP_IDENT       (('P'<<24)+('S'<<16)+('B'<<8)+'I')
313                 // little-endian "IBSP"
314
315 //#define BSP_VERSION                   46
316 #define Q3_BSP_VERSION                  46
317 #define WOLF_BSP_VERSION                47
318
319 // there shouldn't be any problem with increasing these values at the
320 // expense of more memory allocation in the utilities
321 #define MAX_MAP_MODELS          0x400
322 #define MAX_MAP_BRUSHES         0x8000
323 #define MAX_MAP_ENTITIES        0x800
324 #define MAX_MAP_ENTSTRING       0x40000
325 #define MAX_MAP_SHADERS         0x400
326
327 #define MAX_MAP_AREAS           0x100   // MAX_MAP_AREA_BYTES in q_shared must match!
328 #define MAX_MAP_FOGS            0x100
329 #define MAX_MAP_PLANES          0x20000
330 #define MAX_MAP_NODES           0x20000
331 #define MAX_MAP_BRUSHSIDES      0x40000 //%     0x20000 /* ydnar */
332 #define MAX_MAP_LEAFS           0x20000
333 #define MAX_MAP_LEAFFACES       0x20000
334 #define MAX_MAP_LEAFBRUSHES 0x40000
335 #define MAX_MAP_PORTALS         0x20000
336 #define MAX_MAP_LIGHTING        0x800000
337 #define MAX_MAP_LIGHTGRID       0x800000
338 #define MAX_MAP_VISIBILITY      0x200000
339
340 #define MAX_MAP_DRAW_SURFS      0x20000
341 #define MAX_MAP_DRAW_VERTS      0x80000
342 #define MAX_MAP_DRAW_INDEXES    0x80000
343
344
345 // key / value pair sizes in the entities lump
346 #define MAX_KEY                         32
347 #define MAX_VALUE                       1024
348
349 // the editor uses these predefined yaw angles to orient entities up or down
350 #define ANGLE_UP                        -1
351 #define ANGLE_DOWN                      -2
352
353 #define LIGHTMAP_WIDTH          128
354 #define LIGHTMAP_HEIGHT         128
355
356 #define MIN_WORLD_COORD         (-65536)
357 #define MAX_WORLD_COORD         (65536)
358 #define WORLD_SIZE                      (MAX_WORLD_COORD - MIN_WORLD_COORD)
359
360 //=============================================================================
361
362
363 typedef struct {
364         int             fileofs, filelen;
365 } lump_t;
366
367 #define LUMP_ENTITIES           0
368 #define LUMP_SHADERS            1
369 #define LUMP_PLANES                     2
370 #define LUMP_NODES                      3
371 #define LUMP_LEAFS                      4
372 #define LUMP_LEAFSURFACES       5
373 #define LUMP_LEAFBRUSHES        6
374 #define LUMP_MODELS                     7
375 #define LUMP_BRUSHES            8
376 #define LUMP_BRUSHSIDES         9
377 #define LUMP_DRAWVERTS          10
378 #define LUMP_DRAWINDEXES        11
379 #define LUMP_FOGS                       12
380 #define LUMP_SURFACES           13
381 #define LUMP_LIGHTMAPS          14
382 #define LUMP_LIGHTGRID          15
383 #define LUMP_VISIBILITY         16
384 #define HEADER_LUMPS            17
385
386 typedef struct {
387         int                     ident;
388         int                     version;
389
390         lump_t          lumps[HEADER_LUMPS];
391 } dheader_t;
392
393 typedef struct {
394         float           mins[3], maxs[3];
395         int                     firstSurface, numSurfaces;
396         int                     firstBrush, numBrushes;
397 } dmodel_t;
398
399 typedef struct {
400         char            shader[MAX_QPATH];
401         int                     surfaceFlags;
402         int                     contentFlags;
403 } dshader_t;
404
405 // planes x^1 is allways the opposite of plane x
406
407 typedef struct {
408         float           normal[3];
409         float           dist;
410 } dplane_t;
411
412 typedef struct {
413         int                     planeNum;
414         int                     children[2];    // negative numbers are -(leafs+1), not nodes
415         int                     mins[3];                // for frustom culling
416         int                     maxs[3];
417 } dnode_t;
418
419 typedef struct {
420         int                     cluster;                        // -1 = opaque cluster (do I still store these?)
421         int                     area;
422
423         int                     mins[3];                        // for frustum culling
424         int                     maxs[3];
425
426         int                     firstLeafSurface;
427         int                     numLeafSurfaces;
428
429         int                     firstLeafBrush;
430         int                     numLeafBrushes;
431 } dleaf_t;
432
433 typedef struct {
434         int                     planeNum;                       // positive plane side faces out of the leaf
435         int                     shaderNum;
436 } dbrushside_t;
437
438 typedef struct {
439         int                     firstSide;
440         int                     numSides;
441         int                     shaderNum;              // the shader that determines the contents flags
442 } dbrush_t;
443
444 typedef struct {
445         char            shader[MAX_QPATH];
446         int                     brushNum;
447         int                     visibleSide;    // the brush side that ray tests need to clip against (-1 == none)
448 } dfog_t;
449
450 typedef struct {
451         vec3_t          xyz;
452         float           st[2];
453         float           lightmap[2];
454         vec3_t          normal;
455         byte            color[4];
456 } drawVert_t;
457
458 typedef enum {
459         MST_BAD,
460         MST_PLANAR,
461         MST_PATCH,
462         MST_TRIANGLE_SOUP,
463         MST_FLARE
464 } mapSurfaceType_t;
465
466 typedef struct {
467         int                     shaderNum;
468         int                     fogNum;
469         int                     surfaceType;
470
471         int                     firstVert;
472         int                     numVerts;
473
474         int                     firstIndex;
475         int                     numIndexes;
476
477         int                     lightmapNum;
478         int                     lightmapX, lightmapY;
479         int                     lightmapWidth, lightmapHeight;
480
481         vec3_t          lightmapOrigin;
482         vec3_t          lightmapVecs[3];        // for patches, [0] and [1] are lodbounds
483
484         int                     patchWidth;
485         int                     patchHeight;
486 } dsurface_t;
487
488
489 #endif