path: root/src/qcommon/qfiles.h

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
Copyright (C) 2000-2013 Darklegion Development
Copyright (C) 2015-2019 GrangerHub

This file is part of Tremulous.

Tremulous is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 3 of the License,
or (at your option) any later version.

Tremulous is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Tremulous; if not, see <https://www.gnu.org/licenses/>

===========================================================================
*/

// qfiles.h: quake file formats

#ifndef __QFILES_H__
#define __QFILES_H__

// This file must be identical in the quake and utils directories

#include "q_shared.h"

// Ignore __attribute__ on non-gcc platforms
#ifndef __GNUC__
#ifndef __attribute__
#define __attribute__(x)
#endif
#endif

// surface geometry should not exceed these limits
#define SHADER_MAX_VERTEXES 1000
#define SHADER_MAX_INDEXES (6 * SHADER_MAX_VERTEXES)

// the maximum size of game relative pathnames
#define MAX_QPATH 64

/*
========================================================================

QVM files

========================================================================
*/

#define VM_MAGIC 0x12721444
#define VM_MAGIC_VER2 0x12721445
typedef struct {
    int vmMagic;

    int instructionCount;

    int codeOffset;
    int codeLength;

    int dataOffset;
    int dataLength;
    int litLength;  // ( dataLength - litLength ) should be byteswapped on load
    int bssLength;  // zero filled memory appended to datalength

    //!!! below here is VM_MAGIC_VER2 !!!
    int jtrgLength;  // number of jump table targets
} vmHeader_t;

/*
========================================================================

.MD3 triangle model file format

========================================================================
*/

#define MD3_IDENT (('3' << 24) + ('P' << 16) + ('D' << 8) + 'I')
#define MD3_VERSION 15

// limits
#define MD3_MAX_LODS 3
#define MD3_MAX_TRIANGLES 8192  // per surface
#define MD3_MAX_VERTS 4096  // per surface
#define MD3_MAX_SHADERS 256  // per surface
#define MD3_MAX_FRAMES 1024  // per model
#define MD3_MAX_SURFACES 32  // per model
#define MD3_MAX_TAGS 16  // per frame

// vertex scales
#define MD3_XYZ_SCALE (1.0 / 64)

typedef struct md3Frame_s {
    vec3_t bounds[2];
    vec3_t localOrigin;
    float radius;
    char name[16];
} md3Frame_t;

typedef struct md3Tag_s {
    char name[MAX_QPATH];  // tag name
    vec3_t origin;
    vec3_t axis[3];
} md3Tag_t;

/*
** md3Surface_t
**
** CHUNK                        SIZE
** header                       sizeof( md3Surface_t )
** shaders                      sizeof( md3Shader_t ) * numShaders
** triangles[0]         sizeof( md3Triangle_t ) * numTriangles
** st                           sizeof( md3St_t ) * numVerts
** XyzNormals           sizeof( md3XyzNormal_t ) * numVerts * numFrames
*/
typedef struct {
    int ident;  //

    char name[MAX_QPATH];  // polyset name

    int flags;
    int numFrames;  // all surfaces in a model should have the same

    int numShaders;  // all surfaces in a model should have the same
    int numVerts;

    int numTriangles;
    int ofsTriangles;

    int ofsShaders;  // offset from start of md3Surface_t
    int ofsSt;  // texture coords are common for all frames
    int ofsXyzNormals;  // numVerts * numFrames

    int ofsEnd;  // next surface follows
} md3Surface_t;

typedef struct {
    char name[MAX_QPATH];
    int shaderIndex;  // for in-game use
} md3Shader_t;

typedef struct {
    int indexes[3];
} md3Triangle_t;

typedef struct {
    float st[2];
} md3St_t;

typedef struct {
    short xyz[3];
    short normal;
} md3XyzNormal_t;

typedef struct {
    int ident;
    int version;

    char name[MAX_QPATH];  // model name

    int flags;

    int numFrames;
    int numTags;
    int numSurfaces;

    int numSkins;

    int ofsFrames;  // offset for first frame
    int ofsTags;  // numFrames * numTags
    int ofsSurfaces;  // first surface, others follow

    int ofsEnd;  // end of file
} md3Header_t;

/*
==============================================================================

MDR file format

==============================================================================
*/

/*
 * Here are the definitions for Ravensoft's model format of md4. Raven stores their
 * playermodels in .mdr files, in some games, which are pretty much like the md4
 * format implemented by ID soft. It seems like ID's original md4 stuff is not used at all.
 * MDR is being used in EliteForce, JediKnight2 and Soldiers of Fortune2 (I think).
 * So this comes in handy for anyone who wants to make it possible to load player
 * models from these games.
 * This format has bone tags, which is similar to the thing you have in md3 I suppose.
 * Raven has released their version of md3view under GPL enabling me to add support
 * to this codebase. Thanks to Steven Howes aka Skinner for helping with example
 * source code.
 *
 * - Thilo Schulz (arny@ats.s.bawue.de)
 */

#define MDR_IDENT (('5' << 24) + ('M' << 16) + ('D' << 8) + 'R')
#define MDR_VERSION 2
#define MDR_MAX_BONES 128

typedef struct {
    int boneIndex;  // these are indexes into the boneReferences,
    float boneWeight;  // not the global per-frame bone list
    vec3_t offset;
} mdrWeight_t;

typedef struct {
    vec3_t normal;
    vec2_t texCoords;
    int numWeights;
    mdrWeight_t weights[1];  // variable sized
} mdrVertex_t;

typedef struct {
    int indexes[3];
} mdrTriangle_t;

typedef struct {
    int ident;

    char name[MAX_QPATH];  // polyset name
    char shader[MAX_QPATH];
    int shaderIndex;  // for in-game use

    int ofsHeader;  // this will be a negative number

    int numVerts;
    int ofsVerts;

    int numTriangles;
    int ofsTriangles;

    // Bone references are a set of ints representing all the bones
    // present in any vertex weights for this surface.  This is
    // needed because a model may have surfaces that need to be
    // drawn at different sort times, and we don't want to have
    // to re-interpolate all the bones for each surface.
    int numBoneReferences;
    int ofsBoneReferences;

    int ofsEnd;  // next surface follows
} mdrSurface_t;

typedef struct {
    float matrix[3][4];
} mdrBone_t;

typedef struct {
    vec3_t bounds[2];  // bounds of all surfaces of all LOD's for this frame
    vec3_t localOrigin;  // midpoint of bounds, used for sphere cull
    float radius;  // dist from localOrigin to corner
    char name[16];
    mdrBone_t bones[1];  // [numBones]
} mdrFrame_t;

typedef struct {
    unsigned char Comp[24];  // MC_COMP_BYTES is in MatComp.h, but don't want to couple
} mdrCompBone_t;

typedef struct {
    vec3_t bounds[2];  // bounds of all surfaces of all LOD's for this frame
    vec3_t localOrigin;  // midpoint of bounds, used for sphere cull
    float radius;  // dist from localOrigin to corner
    mdrCompBone_t bones[1];  // [numBones]
} mdrCompFrame_t;

typedef struct {
    int numSurfaces;
    int ofsSurfaces;  // first surface, others follow
    int ofsEnd;  // next lod follows
} mdrLOD_t;

typedef struct {
    int boneIndex;
    char name[32];
} mdrTag_t;

typedef struct {
    int ident;
    int version;

    char name[MAX_QPATH];  // model name

    // frames and bones are shared by all levels of detail
    int numFrames;
    int numBones;
    int ofsFrames;  // mdrFrame_t[numFrames]

    // each level of detail has completely separate sets of surfaces
    int numLODs;
    int ofsLODs;

    int numTags;
    int ofsTags;

    int ofsEnd;  // end of file
} mdrHeader_t;

/*
==============================================================================

  .BSP file format

==============================================================================
*/

#define BSP_IDENT (('P' << 24) + ('S' << 16) + ('B' << 8) + 'I')
// little-endian "IBSP"

#define BSP_VERSION 46

// there shouldn't be any problem with increasing these values at the
// expense of more memory allocation in the utilities
#define MAX_MAP_MODELS 0x400
#define MAX_MAP_BRUSHES 0x8000
#define MAX_MAP_ENTITIES 0x800
#define MAX_MAP_ENTSTRING 0x40000
#define MAX_MAP_SHADERS 0x400

#define MAX_MAP_AREAS 0x100  // MAX_MAP_AREA_BYTES in q_shared must match!
#define MAX_MAP_FOGS 0x100
#define MAX_MAP_PLANES 0x20000
#define MAX_MAP_NODES 0x20000
#define MAX_MAP_BRUSHSIDES 0x20000
#define MAX_MAP_LEAFS 0x20000
#define MAX_MAP_LEAFFACES 0x20000
#define MAX_MAP_LEAFBRUSHES 0x40000
#define MAX_MAP_PORTALS 0x20000
#define MAX_MAP_LIGHTING 0x800000
#define MAX_MAP_LIGHTGRID 0x800000
#define MAX_MAP_VISIBILITY 0x200000

#define MAX_MAP_DRAW_SURFS 0x20000
#define MAX_MAP_DRAW_VERTS 0x80000
#define MAX_MAP_DRAW_INDEXES 0x80000

// key / value pair sizes in the entities lump
#define MAX_KEY 32
#define MAX_VALUE 1024

// the editor uses these predefined yaw angles to orient entities up or down
#define ANGLE_UP -1
#define ANGLE_DOWN -2

#define LIGHTMAP_WIDTH 128
#define LIGHTMAP_HEIGHT 128

#define MAX_WORLD_COORD (128 * 1024)
#define MIN_WORLD_COORD (-128 * 1024)
#define WORLD_SIZE (MAX_WORLD_COORD - MIN_WORLD_COORD)

//=============================================================================

typedef struct {
    int fileofs, filelen;
} lump_t;

#define LUMP_ENTITIES 0
#define LUMP_SHADERS 1
#define LUMP_PLANES 2
#define LUMP_NODES 3
#define LUMP_LEAFS 4
#define LUMP_LEAFSURFACES 5
#define LUMP_LEAFBRUSHES 6
#define LUMP_MODELS 7
#define LUMP_BRUSHES 8
#define LUMP_BRUSHSIDES 9
#define LUMP_DRAWVERTS 10
#define LUMP_DRAWINDEXES 11
#define LUMP_FOGS 12
#define LUMP_SURFACES 13
#define LUMP_LIGHTMAPS 14
#define LUMP_LIGHTGRID 15
#define LUMP_VISIBILITY 16
#define HEADER_LUMPS 17

typedef struct {
    int ident;
    int version;

    lump_t lumps[HEADER_LUMPS];
} dheader_t;

typedef struct {
    float mins[3], maxs[3];
    int firstSurface, numSurfaces;
    int firstBrush, numBrushes;
} dmodel_t;

typedef struct {
    char shader[MAX_QPATH];
    int surfaceFlags;
    int contentFlags;
} dshader_t;

// planes x^1 is allways the opposite of plane x

typedef struct {
    float normal[3];
    float dist;
} dplane_t;

typedef struct {
    int planeNum;
    int children[2];  // negative numbers are -(leafs+1), not nodes
    int mins[3];  // for frustom culling
    int maxs[3];
} dnode_t;

typedef struct {
    int cluster;  // -1 = opaque cluster (do I still store these?)
    int area;

    int mins[3];  // for frustum culling
    int maxs[3];

    int firstLeafSurface;
    int numLeafSurfaces;

    int firstLeafBrush;
    int numLeafBrushes;
} dleaf_t;

typedef struct {
    int planeNum;  // positive plane side faces out of the leaf
    int shaderNum;
} dbrushside_t;

typedef struct {
    int firstSide;
    int numSides;
    int shaderNum;  // the shader that determines the contents flags
} dbrush_t;

typedef struct {
    char shader[MAX_QPATH];
    int brushNum;
    int visibleSide;  // the brush side that ray tests need to clip against (-1 == none)
} dfog_t;

typedef struct {
    vec3_t xyz;
    float st[2];
    float lightmap[2];
    vec3_t normal;
    byte color[4];
} drawVert_t;

#define drawVert_t_cleared(x) drawVert_t(x) = {{0, 0, 0}, {0, 0}, {0, 0}, {0, 0, 0}, {0, 0, 0, 0}}

typedef enum { MST_BAD, MST_PLANAR, MST_PATCH, MST_TRIANGLE_SOUP, MST_FLARE } mapSurfaceType_t;

typedef struct {
    int shaderNum;
    int fogNum;
    int surfaceType;

    int firstVert;
    int numVerts;

    int firstIndex;
    int numIndexes;

    int lightmapNum;
    int lightmapX, lightmapY;
    int lightmapWidth, lightmapHeight;

    vec3_t lightmapOrigin;
    vec3_t lightmapVecs[3];  // for patches, [0] and [1] are lodbounds

    int patchWidth;
    int patchHeight;
} dsurface_t;

#endif