#define SURF_SHADOWCAST 0x1000 // this polygon can cast stencil shadows
#define SURF_SHADOWLIGHT 0x2000 // this polygon can be lit by stencil shadowing
#define SURF_WATERALPHA 0x4000 // this polygon's alpha is modulated by r_wateralpha
+#define SURF_SOLIDCLIP 0x8000 // this polygon blocks movement
#define SURFRENDER_OPAQUE 0
#define SURFRENDER_ALPHA 1
// type of rendering (SURFRENDER_ value)
int rendertype;
- // base texture without fullbrights, never NULL
- rtexture_t *texture;
- // fullbrights texture, NULL if no fullbrights used
- rtexture_t *glowtexture;
- // alpha texture (used for fogging), NULL if opaque
- rtexture_t *fogtexture;
- // detail texture (usually not used if transparent)
- rtexture_t *detailtexture;
- // normalmap for bumpmap shading
- rtexture_t *nmaptexture;
- // color filtering for glossy surfaces
- rtexture_t *glosstexture;
+ // loaded the same as model skins
+ skinframe_t skin;
// shader to use for this texture
Cshader_t *shader;
struct surfmesh_s *chain;
int numverts; // number of vertices in the mesh
int numtriangles; // number of triangles in the mesh
- float *verts; // float[verts*4] vertex locations
- float *svectors; // float[verts*4] direction of 'S' (right) texture axis for each vertex
- float *tvectors; // float[verts*4] direction of 'T' (down) texture axis for each vertex
- float *normals; // float[verts*4] direction of 'R' (out) texture axis for each vertex
+ float *vertex3f; // float[verts*3] vertex locations
+ float *svector3f; // float[verts*3] direction of 'S' (right) texture axis for each vertex
+ float *tvector3f; // float[verts*3] direction of 'T' (down) texture axis for each vertex
+ float *normal3f; // float[verts*3] direction of 'R' (out) texture axis for each vertex
int *lightmapoffsets; // index into surface's lightmap samples for vertex lighting
- float *str; // float[verts*4] texcoords for surface texture
- float *uvw; // float[verts*4] texcoords for lightmap texture
- float *abc; // float[verts*4] texcoords for detail texture
- int *index; // int[tris*3] triangles of the mesh, 3 indices into vertex arrays for each
- int *triangleneighbors; // int[tris*3] neighboring triangle on each edge (-1 if none)
+ float *texcoordtexture2f; // float[verts*2] texcoords for surface texture
+ float *texcoordlightmap2f; // float[verts*2] texcoords for lightmap texture
+ float *texcoorddetail2f; // float[verts*2] texcoords for detail texture
+ int *element3i; // int[tris*3] triangles of the mesh, 3 indices into vertex arrays for each
+ int *neighbor3i; // int[tris*3] neighboring triangle on each edge (-1 if none)
}
surfmesh_t;
// avoid redundent addition of dlights
int lightframe;
+ // avoid multiple collision traces with a surface polygon
+ int colframe;
+
// these are just 3D points defining the outline of the polygon,
// no texcoord info (that can be generated from these)
int poly_numverts;
extern texture_t r_notexture_mip;
struct model_s;
-void Mod_LoadBrushModel (struct model_s *mod, void *buffer);
+void Mod_Q1BSP_Load(struct model_s *mod, void *buffer);
+void Mod_IBSP_Load(struct model_s *mod, void *buffer);
+void Mod_MAP_Load(struct model_s *mod, void *buffer);
void Mod_BrushInit(void);
-void Mod_FindNonSolidLocation(vec3_t pos, struct model_s *mod);
-mleaf_t *Mod_PointInLeaf (const float *p, struct model_s *model);
-int Mod_PointContents (const float *p, struct model_s *model);
-qbyte *Mod_LeafPVS (mleaf_t *leaf, struct model_s *model);
-void Mod_BuildPVSTextureChains(struct model_s *model);
+// 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
+{
+ int ident;
+ int version;
+ lump_t lumps[HEADER_LUMPS];
+} q2dheader_t;
+
+typedef struct
+{
+ 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;
+
+// planes (x&~1) and (x&~1)+1 are always opposites
+
+// contents flags are seperate bits
+// a given brush can contribute multiple content bits
+// multiple brushes can be in a single leaf
+
+// these definitions also need to be in q_shared.h!
+
+// 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
+
+// remaining contents are non-visible, and don't eat brushes
+
+#define Q2CONTENTS_AREAPORTAL 0x8000
+
+#define Q2CONTENTS_PLAYERCLIP 0x10000
+#define Q2CONTENTS_MONSTERCLIP 0x20000
+
+// 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
+
+#define Q2CONTENTS_ORIGIN 0x1000000 // removed before bsping an entity
+
+#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
+{
+ 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;
+
+
+typedef struct
+{
+ 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
+{
+ int contents; // OR of all brushes (not needed?)
+
+ short cluster;
+ short area;
+
+ 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
+{
+ unsigned short planenum; // facing out of the leaf
+ short texinfo;
+} q2dbrushside_t;
+
+typedef struct
+{
+ 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
+{
+ 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
+{
+ int portalnum;
+ int otherarea;
+} q2dareaportal_t;
+
+typedef struct
+{
+ int numareaportals;
+ int firstareaportal;
+} q2darea_t;
#endif
projects / xonotic / darkplaces.git / blobdiff