eliminated qbyte type, now uses unsigned char throughout the engine for this purpose
[xonotic/darkplaces.git] / model_brush.h
index 41d42c9..bcb79f1 100644 (file)
@@ -8,7 +8,7 @@ of the License, or (at your option) any later version.
 
 This program 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.  
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 See the GNU General Public License for more details.
 
@@ -18,6 +18,9 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 */
 
+#ifndef MODEL_BRUSH_H
+#define MODEL_BRUSH_H
+
 /*
 ==============================================================================
 
@@ -26,193 +29,666 @@ BRUSH MODELS
 ==============================================================================
 */
 
+#define Q3PATHLENGTH 64
+
 
 //
 // in memory representation
 //
-typedef struct
+typedef struct mvertex_s
 {
-       vec3_t          position;
-} mvertex_t;
+       vec3_t position;
+}
+mvertex_t;
 
-#define        SIDE_FRONT      0
-#define        SIDE_BACK       1
-#define        SIDE_ON         2
+#define SIDE_FRONT 0
+#define SIDE_BACK 1
+#define SIDE_ON 2
 
 
 // plane_t structure
 typedef struct mplane_s
 {
-       vec3_t  normal;
-       float   dist;
-       int             type;                   // for texture axis selection and fast side tests
-       // LordHavoc: faster than id's signbits system
-       int (*BoxOnPlaneSideFunc) (vec3_t emins, vec3_t emaxs, struct mplane_s *p);
-} mplane_t;
+       vec3_t normal;
+       float dist;
+       // for texture axis selection and fast side tests
+       int type;
+       int signbits;
+}
+mplane_t;
+
+#define SHADERSTAGE_SKY 0
+#define SHADERSTAGE_NORMAL 1
+#define SHADERSTAGE_COUNT 2
+
+//#define SURF_PLANEBACK 2
+
+// set for anything to be transparent sorted
+#define MATERIALFLAG_TRANSPARENT 1
+// use alpha blend on this material
+#define MATERIALFLAG_ALPHA 2
+// use additive blend on this material
+#define MATERIALFLAG_ADD 4
+// turn off depth test on this material
+#define MATERIALFLAG_NODEPTHTEST 8
+// multiply alpha by r_wateralpha cvar
+#define MATERIALFLAG_WATERALPHA 16
+// draw with no lighting
+#define MATERIALFLAG_FULLBRIGHT 32
+// drawn as a normal lightmapped wall
+#define MATERIALFLAG_WALL 64
+// swirling water effect
+#define MATERIALFLAG_WATER 128
+// this surface shows the sky
+// skipped if transparent
+#define MATERIALFLAG_SKY 256
+// skips drawing the surface
+#define MATERIALFLAG_NODRAW 512
+// probably used only on q1bsp water
+#define MATERIALFLAG_LIGHTBOTHSIDES 1024
+
+typedef struct medge_s
+{
+       unsigned short v[2];
+}
+medge_t;
+
+struct entity_render_s;
+struct texture_s;
+struct msurface_s;
 
-typedef struct texture_s
+typedef struct mnode_s
 {
-       char                            name[16];
-       unsigned                        width, height;
-       rtexture_t                      *texture;
-       rtexture_t                      *glowtexture;           // LordHavoc: fullbrights on walls
-       int                                     anim_total;                     // total frames in sequence (0 = not animated)
-       struct texture_s        *anim_frames[10];       // LordHavoc: direct pointers to each of the frames in the sequence
-       struct texture_s        *alternate_anims;       // bmodels in frame 1 use these
-       int                                     transparent;            // LordHavoc: transparent texture support
-} texture_t;
+       //this part shared between node and leaf
+       mplane_t *plane; // != NULL
+       struct mnode_s *parent;
+       struct mportal_s *portals;
+       // for bounding box culling
+       vec3_t mins;
+       vec3_t maxs;
 
+       // this part unique to node
+       struct mnode_s *children[2];
 
-#define        SURF_PLANEBACK          2
-#define        SURF_DRAWSKY            4
-#define SURF_DRAWSPRITE                8
-#define SURF_DRAWTURB          0x10
-#define SURF_DRAWTILED         0x20
-#define SURF_DRAWBACKGROUND    0x40
-//#define SURF_UNDERWATER              0x80
-#define SURF_DRAWNOALPHA       0x100
-#define SURF_DRAWFULLBRIGHT    0x200
-#define SURF_LIGHTBOTHSIDES    0x400
-#define SURF_CLIPSOLID         0x800 // this polygon can obscure other polygons
+       // q1bsp specific
+       unsigned short firstsurface;
+       unsigned short numsurfaces;
+}
+mnode_t;
 
-typedef struct
+typedef struct mleaf_s
 {
-       unsigned short  v[2];
-} medge_t;
+       //this part shared between node and leaf
+       mplane_t *plane; // == NULL
+       struct mnode_s *parent;
+       struct mportal_s *portals;
+       // for bounding box culling
+       vec3_t mins;
+       vec3_t maxs;
+
+       // this part unique to leaf
+       // common
+       int clusterindex; // -1 is not in pvs, >= 0 is pvs bit number
+       int areaindex; // q3bsp
+       int numleafsurfaces;
+       int *firstleafsurface;
+       int numleafbrushes; // q3bsp
+       int *firstleafbrush; // q3bsp
+       unsigned char ambient_sound_level[NUM_AMBIENTS]; // q1bsp
+       int contents; // q1bsp: // TODO: remove (only used temporarily during loading when making collision hull 0)
+       int portalmarkid; // q1bsp // used by see-polygon-through-portals visibility checker
+}
+mleaf_t;
 
-typedef struct
+typedef struct hull_s
 {
-       float           vecs[2][4];
-       texture_t       *texture;
-       int                     flags;
-} mtexinfo_t;
+       dclipnode_t *clipnodes;
+       mplane_t *planes;
+       int firstclipnode;
+       int lastclipnode;
+       vec3_t clip_mins;
+       vec3_t clip_maxs;
+       vec3_t clip_size;
+}
+hull_t;
 
-// LordHavoc: was 7, I added one more for raw lightmap position
-// (xyz st uv l)
-#define        VERTEXSIZE      8
+typedef struct mportal_s
+{
+       struct mportal_s *next; // the next portal on this leaf
+       mleaf_t *here; // the leaf this portal is on
+       mleaf_t *past; // the leaf through this portal (infront)
+       int numpoints;
+       mvertex_t *points;
+       vec3_t mins, maxs; // culling
+       mplane_t plane;
+}
+mportal_t;
 
-typedef struct glpoly_s
+typedef struct svbspmesh_s
 {
-       struct  glpoly_s        *next;
-       int             numverts;
-       float   verts[4][VERTEXSIZE];   // variable sized
-} glpoly_t;
+       struct svbspmesh_s *next;
+       int numverts, maxverts;
+       int numtriangles, maxtriangles;
+       float *verts;
+       int *elements;
+}
+svbspmesh_t;
 
-typedef struct glpolysizeof_s
+typedef struct mlight_s
+{
+       // location of light
+       vec3_t origin;
+       // distance attenuation scale (smaller is a larger light)
+       float falloff;
+       // color and brightness combined
+       vec3_t light;
+       // brightness bias, used for limiting radius without a hard edge
+       float subtract;
+       // spotlight direction
+       vec3_t spotdir;
+       // cosine of spotlight cone angle (or 0 if not a spotlight)
+       float spotcone;
+       // distance bias (larger value is softer and darker)
+       float distbias;
+       // light style controlling this light
+       int style;
+       // maximum extent of the light for shading purposes
+       float lightradius;
+       // maximum extent of the light for culling purposes
+       float cullradius;
+       float cullradius2;
+       /*
+       // surfaces this shines on
+       int numsurfaces;
+       msurface_t **surfaces;
+       // lit area
+       vec3_t mins, maxs;
+       // precomputed shadow volume meshs
+       //svbspmesh_t *shadowvolume;
+       //vec3_t shadowvolumemins, shadowvolumemaxs;
+       shadowmesh_t *shadowvolume;
+       */
+}
+mlight_t;
+
+// Q2 bsp stuff
+
+#define Q2BSPVERSION   38
+
+// leaffaces, leafbrushes, planes, and verts are still bounded by
+// 16 bit short limits
+
+//=============================================================================
+
+#define        Q2LUMP_ENTITIES         0
+#define        Q2LUMP_PLANES                   1
+#define        Q2LUMP_VERTEXES         2
+#define        Q2LUMP_VISIBILITY               3
+#define        Q2LUMP_NODES                    4
+#define        Q2LUMP_TEXINFO          5
+#define        Q2LUMP_FACES                    6
+#define        Q2LUMP_LIGHTING         7
+#define        Q2LUMP_LEAFS                    8
+#define        Q2LUMP_LEAFFACES                9
+#define        Q2LUMP_LEAFBRUSHES      10
+#define        Q2LUMP_EDGES                    11
+#define        Q2LUMP_SURFEDGES                12
+#define        Q2LUMP_MODELS                   13
+#define        Q2LUMP_BRUSHES          14
+#define        Q2LUMP_BRUSHSIDES               15
+#define        Q2LUMP_POP                      16
+#define        Q2LUMP_AREAS                    17
+#define        Q2LUMP_AREAPORTALS      18
+#define        Q2HEADER_LUMPS          19
+
+typedef struct q2dheader_s
 {
-       struct  glpoly_s        *next;
-       int             numverts;
-       int             flags;                  // for SURF_UNDERWATER
-} glpolysizeof_t;
+       int                     ident;
+       int                     version;
+       lump_t          lumps[HEADER_LUMPS];
+} q2dheader_t;
 
-typedef struct msurface_s
+typedef struct q2dmodel_s
 {
-       int                     visframe;               // should be drawn when node is crossed
+       float           mins[3], maxs[3];
+       float           origin[3];              // for sounds or lights
+       int                     headnode;
+       int                     firstface, numfaces;    // submodels just draw faces
+                                                                               // without walking the bsp tree
+} q2dmodel_t;
 
-       mplane_t        *plane;
-       int                     flags;
+// planes (x&~1) and (x&~1)+1 are always opposites
 
-       int                     firstedge;      // look up in model->surfedges[], negative numbers
-       int                     numedges;       // are backwards edges
+// contents flags are seperate bits
+// a given brush can contribute multiple content bits
+// multiple brushes can be in a single leaf
 
-       short           texturemins[2];
-       short           extents[2];
+// these definitions also need to be in q_shared.h!
 
-       short           light_s, light_t;       // gl lightmap coordinates
+// lower bits are stronger, and will eat weaker brushes completely
+#define        Q2CONTENTS_SOLID                        1               // an eye is never valid in a solid
+#define        Q2CONTENTS_WINDOW                       2               // translucent, but not watery
+#define        Q2CONTENTS_AUX                  4
+#define        Q2CONTENTS_LAVA                 8
+#define        Q2CONTENTS_SLIME                        16
+#define        Q2CONTENTS_WATER                        32
+#define        Q2CONTENTS_MIST                 64
+#define        Q2LAST_VISIBLE_CONTENTS 64
 
-       glpoly_t        *polys;                         // multiple if warped
+// remaining contents are non-visible, and don't eat brushes
 
-       mtexinfo_t      *texinfo;
+#define        Q2CONTENTS_AREAPORTAL           0x8000
 
-// lighting info
-       int                     dlightframe;
-       int                     dlightbits[8];
+#define        Q2CONTENTS_PLAYERCLIP           0x10000
+#define        Q2CONTENTS_MONSTERCLIP  0x20000
 
-       int                     lightframe; // avoid redundent addition of dlights
-       int                     worldnodeframe; // only render each surface once
+// currents can be added to any other contents, and may be mixed
+#define        Q2CONTENTS_CURRENT_0            0x40000
+#define        Q2CONTENTS_CURRENT_90           0x80000
+#define        Q2CONTENTS_CURRENT_180  0x100000
+#define        Q2CONTENTS_CURRENT_270  0x200000
+#define        Q2CONTENTS_CURRENT_UP           0x400000
+#define        Q2CONTENTS_CURRENT_DOWN 0x800000
 
-       int                     lightmaptexturenum;
-       byte            styles[MAXLIGHTMAPS];
-       unsigned short  cached_light[MAXLIGHTMAPS];     // values currently used in lightmap
-       short           cached_dlight;                          // LordHavoc: if lightmap was lit by dynamic lights, update on frame after end of effect to erase it
-       short           cached_lighthalf;                       // LordHavoc: to cause lightmap to be rerendered when lighthalf changes
-       float           cached_ambient;                         // LordHavoc: rerender lightmaps when r_ambient changes
-       byte            *samples;               // [numstyles*surfsize]
-} msurface_t;
+#define        Q2CONTENTS_ORIGIN                       0x1000000       // removed before bsping an entity
 
-// warning: if this is changed, references must be updated in cpu_* assembly files
-typedef struct mnode_s
+#define        Q2CONTENTS_MONSTER              0x2000000       // should never be on a brush, only in game
+#define        Q2CONTENTS_DEADMONSTER  0x4000000
+#define        Q2CONTENTS_DETAIL                       0x8000000       // brushes to be added after vis leafs
+#define        Q2CONTENTS_TRANSLUCENT  0x10000000      // auto set if any surface has trans
+#define        Q2CONTENTS_LADDER                       0x20000000
+
+
+
+#define        Q2SURF_LIGHT            0x1             // value will hold the light strength
+
+#define        Q2SURF_SLICK            0x2             // effects game physics
+
+#define        Q2SURF_SKY              0x4             // don't draw, but add to skybox
+#define        Q2SURF_WARP             0x8             // turbulent water warp
+#define        Q2SURF_TRANS33  0x10
+#define        Q2SURF_TRANS66  0x20
+#define        Q2SURF_FLOWING  0x40    // scroll towards angle
+#define        Q2SURF_NODRAW           0x80    // don't bother referencing the texture
+
+
+
+
+typedef struct q2dnode_s
 {
-// common with leaf
-       int                     contents;               // 0, to differentiate from leafs
+       int                     planenum;
+       int                     children[2];    // negative numbers are -(leafs+1), not nodes
+       short           mins[3];                // for frustom culling
+       short           maxs[3];
+       unsigned short  firstface;
+       unsigned short  numfaces;       // counting both sides
+} q2dnode_t;
 
-       struct mnode_s  *parent;
-       struct mportal_s *portals;
 
-// node specific
-       mplane_t        *plane;
-       struct mnode_s  *children[2];
+typedef struct q2texinfo_s
+{
+       float           vecs[2][4];             // [s/t][xyz offset]
+       int                     flags;                  // miptex flags + overrides
+       int                     value;                  // light emission, etc
+       char            texture[32];    // texture name (textures/*.wal)
+       int                     nexttexinfo;    // for animations, -1 = end of chain
+} q2texinfo_t;
+
+typedef struct q2dleaf_s
+{
+       int                             contents;                       // OR of all brushes (not needed?)
+
+       short                   cluster;
+       short                   area;
 
-       unsigned short          firstsurface;
-       unsigned short          numsurfaces;
-} mnode_t;
+       short                   mins[3];                        // for frustum culling
+       short                   maxs[3];
 
+       unsigned short  firstleafface;
+       unsigned short  numleaffaces;
 
+       unsigned short  firstleafbrush;
+       unsigned short  numleafbrushes;
+} q2dleaf_t;
 
-typedef struct mleaf_s
+typedef struct q2dbrushside_s
 {
-// common with node
-       int                     contents;               // will be a negative contents number
+       unsigned short  planenum;               // facing out of the leaf
+       short   texinfo;
+} q2dbrushside_t;
 
-       struct mnode_s  *parent;
-       struct mportal_s *portals;
+typedef struct q2dbrush_s
+{
+       int                     firstside;
+       int                     numsides;
+       int                     contents;
+} q2dbrush_t;
+
+
+// the visibility lump consists of a header with a count, then
+// byte offsets for the PVS and PHS of each cluster, then the raw
+// compressed bit vectors
+#define        Q2DVIS_PVS      0
+#define        Q2DVIS_PHS      1
+typedef struct q2dvis_s
+{
+       int                     numclusters;
+       int                     bitofs[8][2];   // bitofs[numclusters][2]
+} q2dvis_t;
+
+// each area has a list of portals that lead into other areas
+// when portals are closed, other areas may not be visible or
+// hearable even if the vis info says that it should be
+typedef struct q2dareaportal_s
+{
+       int             portalnum;
+       int             otherarea;
+} q2dareaportal_t;
 
-// leaf specific
-//     int                     visframe;               // visible if current (r_framecount)
-//     int                     worldnodeframe; // used by certain worldnode variants to avoid processing the same leaf twice in a frame
-       int                     portalmarkid;   // used by polygon-through-portals visibility checker
+typedef struct q2darea_s
+{
+       int             numareaportals;
+       int             firstareaportal;
+} q2darea_t;
+
+
+//Q3 bsp stuff
+
+#define Q3BSPVERSION   46
+
+#define        Q3LUMP_ENTITIES         0 // entities to spawn (used by server and client)
+#define        Q3LUMP_TEXTURES         1 // textures used (used by faces)
+#define        Q3LUMP_PLANES           2 // planes used (used by bsp nodes)
+#define        Q3LUMP_NODES            3 // bsp nodes (used by bsp nodes, bsp leafs, rendering, collisions)
+#define        Q3LUMP_LEAFS            4 // bsp leafs (used by bsp nodes)
+#define        Q3LUMP_LEAFFACES        5 // array of ints indexing faces (used by leafs)
+#define        Q3LUMP_LEAFBRUSHES      6 // array of ints indexing brushes (used by leafs)
+#define        Q3LUMP_MODELS           7 // models (used by rendering, collisions)
+#define        Q3LUMP_BRUSHES          8 // brushes (used by effects, collisions)
+#define        Q3LUMP_BRUSHSIDES       9 // brush faces (used by brushes)
+#define        Q3LUMP_VERTICES         10 // mesh vertices (used by faces)
+#define        Q3LUMP_TRIANGLES        11 // mesh triangles (used by faces)
+#define        Q3LUMP_EFFECTS          12 // fog (used by faces)
+#define        Q3LUMP_FACES            13 // surfaces (used by leafs)
+#define        Q3LUMP_LIGHTMAPS        14 // lightmap textures (used by faces)
+#define        Q3LUMP_LIGHTGRID        15 // lighting as a voxel grid (used by rendering)
+#define        Q3LUMP_PVS                      16 // potentially visible set; bit[clusters][clusters] (used by rendering)
+#define        Q3HEADER_LUMPS          17
+
+typedef struct q3dheader_s
+{
+       int                     ident;
+       int                     version;
+       lump_t          lumps[HEADER_LUMPS];
+} q3dheader_t;
 
-       // for bounding box culling
-       vec3_t          mins;
-       vec3_t          maxs;
+typedef struct q3dtexture_s
+{
+       char name[Q3PATHLENGTH];
+       int surfaceflags;
+       int contents;
+}
+q3dtexture_t;
 
-       // LordHavoc: leaf based dynamic lighting
-       int                     dlightbits[8];
-       int                     dlightframe;
+// note: planes are paired, the pair of planes with i and i ^ 1 are opposites.
+typedef struct q3dplane_s
+{
+       float normal[3];
+       float dist;
+}
+q3dplane_t;
 
-       byte            *compressed_vis;
+typedef struct q3dnode_s
+{
+       int planeindex;
+       int childrenindex[2];
+       int mins[3];
+       int maxs[3];
+}
+q3dnode_t;
 
-       msurface_t      **firstmarksurface;
-       int                     nummarksurfaces;
-       byte            ambient_sound_level[NUM_AMBIENTS];
-} mleaf_t;
+typedef struct q3dleaf_s
+{
+       int clusterindex; // pvs index
+       int areaindex; // area index
+       int mins[3];
+       int maxs[3];
+       int firstleafface;
+       int numleaffaces;
+       int firstleafbrush;
+       int numleafbrushes;
+}
+q3dleaf_t;
 
-typedef struct
+typedef struct q3dmodel_s
 {
-       dclipnode_t     *clipnodes;
-       mplane_t        *planes;
-       int                     firstclipnode;
-       int                     lastclipnode;
-       vec3_t          clip_mins;
-       vec3_t          clip_maxs;
-} hull_t;
+       float mins[3];
+       float maxs[3];
+       int firstface;
+       int numfaces;
+       int firstbrush;
+       int numbrushes;
+}
+q3dmodel_t;
 
-typedef struct mportal_s
+typedef struct q3dbrush_s
 {
-       struct mportal_s *next; // the next portal on this leaf
-       mleaf_t *here; // the leaf this portal is on
-       mleaf_t *past; // the leaf through this portal (infront)
-       mvertex_t *points;
-       int numpoints;
-       mplane_t plane;
-       int visframe; // is this portal visible this frame?
+       int firstbrushside;
+       int numbrushsides;
+       int textureindex;
 }
-mportal_t;
+q3dbrush_t;
+
+typedef struct q3dbrushside_s
+{
+       int planeindex;
+       int textureindex;
+}
+q3dbrushside_t;
+
+typedef struct q3dvertex_s
+{
+       float origin3f[3];
+       float texcoord2f[2];
+       float lightmap2f[2];
+       float normal3f[3];
+       unsigned char color4ub[4];
+}
+q3dvertex_t;
+
+typedef struct q3dmeshvertex_s
+{
+       int offset; // first vertex index of mesh
+}
+q3dmeshvertex_t;
+
+typedef struct q3deffect_s
+{
+       char shadername[Q3PATHLENGTH];
+       int brushindex;
+       int unknown; // I read this is always 5 except in q3dm8 which has one effect with -1
+}
+q3deffect_t;
+
+#define Q3FACETYPE_POLYGON 1 // common
+#define Q3FACETYPE_PATCH 2 // common
+#define Q3FACETYPE_MESH 3 // common
+#define Q3FACETYPE_FLARE 4 // rare (is this ever used?)
+
+typedef struct q3dface_s
+{
+       int textureindex;
+       int effectindex; // -1 if none
+       int type; // Q3FACETYPE
+       int firstvertex;
+       int numvertices;
+       int firstelement;
+       int numelements;
+       int lightmapindex; // -1 if none
+       int lightmap_base[2];
+       int lightmap_size[2];
+       union
+       {
+               struct
+               {
+                       // corrupt or don't care
+                       int blah[14];
+               }
+               unknown;
+               struct
+               {
+                       // Q3FACETYPE_POLYGON
+                       // polygon is simply a convex polygon, renderable as a mesh
+                       float lightmap_origin[3];
+                       float lightmap_vectors[2][3];
+                       float normal[3];
+                       int unused1[2];
+               }
+               polygon;
+               struct
+               {
+                       // Q3FACETYPE_PATCH
+                       // patch renders as a bezier mesh, with adjustable tesselation
+                       // level (optionally based on LOD using the bbox and polygon
+                       // count to choose a tesselation level)
+                       // note: multiple patches may have the same bbox to cause them to
+                       // be LOD adjusted together as a group
+                       int unused1[3];
+                       float mins[3]; // LOD bbox
+                       float maxs[3]; // LOD bbox
+                       int unused2[3];
+                       int patchsize[2]; // dimensions of vertex grid
+               }
+               patch;
+               struct
+               {
+                       // Q3FACETYPE_MESH
+                       // mesh renders as simply a triangle mesh
+                       int unused1[3];
+                       float mins[3];
+                       float maxs[3];
+                       int unused2[5];
+               }
+               mesh;
+               struct
+               {
+                       // Q3FACETYPE_FLARE
+                       // flare renders as a simple sprite at origin, no geometry
+                       // exists, nor does it have a radius, a cvar controls the radius
+                       // and another cvar controls distance fade
+                       // (they were not used in Q3 I'm told)
+                       float origin[3];
+                       int unused1[11];
+               }
+               flare;
+       }
+       specific;
+}
+q3dface_t;
+
+typedef struct q3dlightmap_s
+{
+       unsigned char rgb[128*128*3];
+}
+q3dlightmap_t;
+
+typedef struct q3dlightgrid_s
+{
+       unsigned char ambientrgb[3];
+       unsigned char diffusergb[3];
+       unsigned char diffusepitch;
+       unsigned char diffuseyaw;
+}
+q3dlightgrid_t;
+
+typedef struct q3dpvs_s
+{
+       int numclusters;
+       int chainlength;
+       // unsigned char chains[];
+       // containing bits in 0-7 order (not 7-0 order),
+       // pvschains[mycluster * chainlength + (thatcluster >> 3)] & (1 << (thatcluster & 7))
+}
+q3dpvs_t;
+
+// surfaceflags from bsp
+#define Q3SURFACEFLAG_NODAMAGE 1
+#define Q3SURFACEFLAG_SLICK 2
+#define Q3SURFACEFLAG_SKY 4
+#define Q3SURFACEFLAG_LADDER 8
+#define Q3SURFACEFLAG_NOIMPACT 16
+#define Q3SURFACEFLAG_NOMARKS 32
+#define Q3SURFACEFLAG_FLESH 64
+#define Q3SURFACEFLAG_NODRAW 128
+#define Q3SURFACEFLAG_HINT 256
+#define Q3SURFACEFLAG_SKIP 512
+#define Q3SURFACEFLAG_NOLIGHTMAP 1024
+#define Q3SURFACEFLAG_POINTLIGHT 2048
+#define Q3SURFACEFLAG_METALSTEPS 4096
+#define Q3SURFACEFLAG_NOSTEPS 8192
+#define Q3SURFACEFLAG_NONSOLID 16384
+#define Q3SURFACEFLAG_LIGHTFILTER 32768
+#define Q3SURFACEFLAG_ALPHASHADOW 65536
+#define Q3SURFACEFLAG_NODLIGHT 131072
+#define Q3SURFACEFLAG_DUST 262144
+
+// surfaceparms from shaders
+#define Q3SURFACEPARM_ALPHASHADOW 1
+#define Q3SURFACEPARM_AREAPORTAL 2
+#define Q3SURFACEPARM_CLUSTERPORTAL 4
+#define Q3SURFACEPARM_DETAIL 8
+#define Q3SURFACEPARM_DONOTENTER 16
+#define Q3SURFACEPARM_FOG 32
+#define Q3SURFACEPARM_LAVA 64
+#define Q3SURFACEPARM_LIGHTFILTER 128
+#define Q3SURFACEPARM_METALSTEPS 256
+#define Q3SURFACEPARM_NODAMAGE 512
+#define Q3SURFACEPARM_NODLIGHT 1024
+#define Q3SURFACEPARM_NODRAW 2048
+#define Q3SURFACEPARM_NODROP 4096
+#define Q3SURFACEPARM_NOIMPACT 8192
+#define Q3SURFACEPARM_NOLIGHTMAP 16384
+#define Q3SURFACEPARM_NOMARKS 32768
+#define Q3SURFACEPARM_NOMIPMAPS 65536
+#define Q3SURFACEPARM_NONSOLID 131072
+#define Q3SURFACEPARM_ORIGIN 262144
+#define Q3SURFACEPARM_PLAYERCLIP 524288
+#define Q3SURFACEPARM_SKY 1048576
+#define Q3SURFACEPARM_SLICK 2197152
+#define Q3SURFACEPARM_SLIME 4194304
+#define Q3SURFACEPARM_STRUCTURAL 8388608
+#define Q3SURFACEPARM_TRANS 16777216
+#define Q3SURFACEPARM_WATER 33554432
+#define Q3SURFACEPARM_POINTLIGHT 67108864
+
+// various flags from shaders
+#define Q3TEXTUREFLAG_TWOSIDED 1
+#define Q3TEXTUREFLAG_ADDITIVE 2
+#define Q3TEXTUREFLAG_NOMIPMAPS 4
+#define Q3TEXTUREFLAG_NOPICMIP 8
+#define Q3TEXTUREFLAG_AUTOSPRITE 16
+#define Q3TEXTUREFLAG_AUTOSPRITE2 32
+#define Q3TEXTUREFLAG_ALPHATEST 64
+
+typedef struct q3mbrush_s
+{
+       struct colbrushf_s *colbrushf;
+       int numbrushsides;
+       struct q3mbrushside_s *firstbrushside;
+       struct texture_s *texture;
+}
+q3mbrush_t;
+
+typedef struct q3mbrushside_s
+{
+       struct mplane_s *plane;
+       struct texture_s *texture;
+}
+q3mbrushside_t;
+
+#define CHECKPVSBIT(pvs,b) ((b) >= 0 ? ((pvs)[(b) >> 3] & (1 << ((b) & 7))) : false)
+#define SETPVSBIT(pvs,b) ((b) >= 0 ? ((pvs)[(b) >> 3] |= (1 << ((b) & 7))) : false)
+#define CLEARPVSBIT(pvs,b) ((b) >= 0 ? ((pvs)[(b) >> 3] &= ~(1 << ((b) & 7))) : false)
 
-extern void CL_ParseEntityLump(char *entdata);
-extern rtexture_t *r_notexture;
-extern texture_t r_notexture_mip;
+#endif
 
-struct model_s;
-extern void Mod_LoadBrushModel (struct model_s *mod, void *buffer);
-extern void Mod_BrushInit(void);