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