model_brush.h

/*
Copyright (C) 1996-1997 Id Software, Inc.

This program 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 2
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.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifndef MODEL_BRUSH_H
#define MODEL_BRUSH_H

#include "qtypes.h"
#include "qdefs.h"
#include "bspfile.h"

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

BRUSH MODELS

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



//
// in memory representation
//
typedef struct mvertex_s
{
	vec3_t position;
}
mvertex_t;

#define SIDE_FRONT 0
#define SIDE_BACK 1
#define SIDE_ON 2


// plane_t structure
typedef struct mplane_s
{
	union
	{
		struct
		{
			vec3_t normal;
			vec_t dist;
		};
		vec4_t normal_and_dist;
	};
	// for texture axis selection and fast side tests
	int type; // set by PlaneClassify()
	int signbits; // set by PlaneClassify()
}
mplane_t;

#define SHADERSTAGE_SKY 0
#define SHADERSTAGE_NORMAL 1
#define SHADERSTAGE_COUNT 2

//#define SURF_PLANEBACK 2

// indicates that all triangles of the surface should be added to the BIH collision system
#define MATERIALFLAG_MESHCOLLISIONS 0x00000001
// use alpha blend on this material
#define MATERIALFLAG_ALPHA 0x00000002
// use additive blend on this material
#define MATERIALFLAG_ADD 0x00000004
// turn off depth test on this material
#define MATERIALFLAG_NODEPTHTEST 0x00000008
// multiply alpha by r_wateralpha cvar
#define MATERIALFLAG_WATERALPHA 0x00000010
// draw with no lighting
#define MATERIALFLAG_FULLBRIGHT 0x00000020
// drawn as a normal surface (alternative to SKY)
#define MATERIALFLAG_WALL 0x00000040
// this surface shows the sky in its place, alternative to WALL
// skipped if transparent
#define MATERIALFLAG_SKY 0x00000080
// swirling water effect (used with MATERIALFLAG_WALL)
#define MATERIALFLAG_WATERSCROLL 0x00000100
// skips drawing the surface
#define MATERIALFLAG_NODRAW 0x00000200
// probably used only on q1bsp water
#define MATERIALFLAG_LIGHTBOTHSIDES 0x00000400
// use alpha test on this material
#define MATERIALFLAG_ALPHATEST 0x00000800
// treat this material as a blended transparency (as opposed to an alpha test
// transparency), this causes special fog behavior, and disables glDepthMask
#define MATERIALFLAG_BLENDED 0x00001000
// render using a custom blendfunc
#define MATERIALFLAG_CUSTOMBLEND 0x00002000
// do not cast shadows from this material
#define MATERIALFLAG_NOSHADOW 0x00004000
// render using vertex alpha (q3bsp) as texture blend parameter between foreground (normal) skinframe and background skinframe
#define MATERIALFLAG_VERTEXTEXTUREBLEND 0x00008000
// disables GL_CULL_FACE on this texture (making it double sided)
#define MATERIALFLAG_NOCULLFACE 0x00010000
// render with a very short depth range (like 10% of normal), this causes entities to appear infront of most of the scene
#define MATERIALFLAG_SHORTDEPTHRANGE 0x00020000
// render water, comprising refraction and reflection (note: this is always opaque, the shader does the alpha effect)
#define MATERIALFLAG_WATERSHADER 0x00040000
// render refraction (note: this is just a way to distort the background, otherwise useless)
#define MATERIALFLAG_REFRACTION 0x00080000
// render reflection
#define MATERIALFLAG_REFLECTION 0x00100000
// use model lighting on this material (q1bsp lightmap sampling or q3bsp lightgrid, implies FULLBRIGHT is false)
#define MATERIALFLAG_MODELLIGHT 0x00200000
// causes RSurf_GetCurrentTexture to leave alone certain fields
#define MATERIALFLAG_CUSTOMSURFACE 0x00800000
// causes MATERIALFLAG_BLENDED to render a depth pass before rendering, hiding backfaces and other hidden geometry
#define MATERIALFLAG_TRANSDEPTH 0x01000000
// like refraction, but doesn't distort etc.
#define MATERIALFLAG_CAMERA 0x02000000
// disable rtlight on surface - does not disable other types of lighting (LIGHTMAP, MODELLIGHT)
#define MATERIALFLAG_NORTLIGHT 0x04000000
// alphagen vertex - should always be used with MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW (or MATERIALFLAG_ADD instead of MATERIALFLAG_ALPHA)
#define MATERIALFLAG_ALPHAGEN_VERTEX 0x08000000
// use occlusion buffer for corona
#define MATERIALFLAG_OCCLUDE 0x10000000
// use vertex color instead of lighting (e.g. particles and other glowy stuff), use with MATERIALFLAG_FULLBRIGHT
#define MATERIALFLAG_VERTEXCOLOR 0x20000000
// sample the q3bsp lightgrid in the shader rather than relying on MATERIALFLAG_MODELLIGHT
#define MATERIALFLAG_LIGHTGRID 0x40000000
// combined mask of all attributes that require depth sorted rendering
#define MATERIALFLAGMASK_DEPTHSORTED (MATERIALFLAG_BLENDED | MATERIALFLAG_NODEPTHTEST)
// combined mask of all attributes that cause some sort of transparency
#define MATERIALFLAGMASK_TRANSLUCENT (MATERIALFLAG_WATERALPHA | MATERIALFLAG_SKY | MATERIALFLAG_NODRAW | MATERIALFLAG_ALPHATEST | MATERIALFLAG_BLENDED | MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION)

typedef struct medge_s
{
	unsigned int v[2];
}
medge_t;

struct entity_render_s;
struct texture_s;
struct msurface_s;

typedef struct mnode_s
{
	//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;
	// supercontents from all brushes inside this node or leaf
	int combinedsupercontents;

	// this part unique to node
	struct mnode_s *children[2];

	// q1bsp specific
	unsigned int firstsurface;
	unsigned int numsurfaces;
}
mnode_t;

typedef struct mleaf_s
{
	//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;
	// supercontents from all brushes inside this node or leaf
	int combinedsupercontents;

	// this part unique to leaf
	// common
	int clusterindex; // -1 is not in pvs, >= 0 is pvs bit number
	int areaindex; // q3bsp
	int containscollisionsurfaces; // indicates whether the leafsurfaces contains q3 patches
	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 mclipnode_s
{
	int			planenum;
	int			children[2];	// negative numbers are contents
} mclipnode_t;

typedef struct hull_s
{
	mclipnode_t *clipnodes;
	mplane_t *planes;
	int firstclipnode;
	int lastclipnode;
	vec3_t clip_mins;
	vec3_t clip_maxs;
	vec3_t clip_size;
}
hull_t;

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;
	double tracetime; // refreshed to realtime by traceline tests
}
mportal_t;

typedef struct svbspmesh_s
{
	struct svbspmesh_s *next;
	int numverts, maxverts;
	int numtriangles, maxtriangles;
	float *verts;
	int *elements;
}
svbspmesh_t;

typedef struct model_brush_lightstyleinfo_s
{
	int style;
	int value;
	int numsurfaces;
	int *surfacelist;
}
model_brush_lightstyleinfo_t;

typedef struct model_brush_s
{
	// true if this model is a HalfLife .bsp file
	qbool ishlbsp;
	// true if this model is a BSP2rmqe .bsp file (expanded 32bit bsp format for rmqe)
	qbool isbsp2rmqe;
	// true if this model is a BSP2 .bsp file (expanded 32bit bsp format for DarkPlaces, others?)
	qbool isbsp2;
	// true if this model is a Quake2 .bsp file (IBSP38)
	qbool isq2bsp;
	// true if this model is a Quake3 .bsp file (IBSP46)
	qbool isq3bsp;
	// true if this model is a Quake1/Quake2 .bsp file where skymasking capability exists
	qbool skymasking;
	// string of entity definitions (.map format)
	char *entities;

	// if not NULL this is a submodel
	struct model_s *parentmodel;
	// (this is the number of the submodel, an index into submodels)
	int submodel;

	// number of submodels in this map (just used by server to know how many
	// submodels to load)
	int numsubmodels;
	// pointers to each of the submodels
	struct model_s **submodels;

	int num_planes;
	mplane_t *data_planes;

	int num_nodes;
	mnode_t *data_nodes;

	// visible leafs, not counting 0 (solid)
	int num_visleafs;
	// number of actual leafs (including 0 which is solid)
	int num_leafs;
	mleaf_t *data_leafs;

	int num_leafbrushes;
	int *data_leafbrushes;

	int num_leafsurfaces;
	int *data_leafsurfaces;

	int num_portals;
	mportal_t *data_portals;

	int num_portalpoints;
	mvertex_t *data_portalpoints;

	int num_brushes;
	struct q3mbrush_s *data_brushes;

	int num_brushsides;
	struct q3mbrushside_s *data_brushsides;

	// pvs
	int num_pvsclusters;
	int num_pvsclusterbytes;
	unsigned char *data_pvsclusters;
	// example
	//pvschain = model->brush.data_pvsclusters + mycluster * model->brush.num_pvsclusterbytes;
	//if (pvschain[thatcluster >> 3] & (1 << (thatcluster & 7)))

	// collision geometry for q3 curves
	int num_collisionvertices;
	int num_collisiontriangles;
	float *data_collisionvertex3f;
	int *data_collisionelement3i;

	// a mesh containing all shadow casting geometry for the whole model (including submodels), portions of this are referenced by each surface's num_firstshadowmeshtriangle
	struct shadowmesh_s *shadowmesh;

	// a mesh containing all SUPERCONTENTS_SOLID surfaces for this model or submodel, for physics engines to use
	struct shadowmesh_s *collisionmesh;

	// common functions
	int (*SuperContentsFromNativeContents)(int nativecontents);
	int (*NativeContentsFromSuperContents)(int supercontents);
	unsigned char *(*GetPVS)(struct model_s *model, const vec3_t p);
	size_t (*FatPVS)(struct model_s *model, const vec3_t org, vec_t radius, unsigned char **pvsbuffer, mempool_t *pool, qbool merge);
	int (*BoxTouchingPVS)(struct model_s *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs);
	int (*BoxTouchingLeafPVS)(struct model_s *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs);
	int (*BoxTouchingVisibleLeafs)(struct model_s *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs);
	int (*FindBoxClusters)(struct model_s *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist);
	void (*LightPoint)(struct model_s *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal);
	void (*FindNonSolidLocation)(struct model_s *model, const vec3_t in, vec3_t out, vec_t radius);
	mleaf_t *(*PointInLeaf)(struct model_s *model, const vec3_t p);
	// these are actually only found on brushq1, but NULL is handled gracefully
	void (*AmbientSoundLevelsForPoint)(struct model_s *model, const vec3_t p, unsigned char *out, int outsize);
	void (*RoundUpToHullSize)(struct model_s *cmodel, const vec3_t inmins, const vec3_t inmaxs, vec3_t outmins, vec3_t outmaxs);
	// trace a line of sight through this model (returns false if the line if sight is definitely blocked)
	qbool (*TraceLineOfSight)(struct model_s *model, const vec3_t start, const vec3_t end, const vec3_t acceptmins, const vec3_t acceptmaxs);

	char skybox[MAX_QPATH];

	struct skinframe_s *solidskyskinframe;
	struct skinframe_s *alphaskyskinframe;

	qbool supportwateralpha;

	// QuakeWorld
	int qw_md4sum;
	int qw_md4sum2;
}
model_brush_t;

// the first cast is to shut up a stupid warning by clang, the second cast is to make both sides have the same type
#define CHECKPVSBIT(pvs,b) ((b) >= 0 ? (unsigned char) ((pvs)[(b) >> 3] & (1 << ((b) & 7))) : (unsigned char) false)
#define SETPVSBIT(pvs,b) (void) ((b) >= 0 ? (unsigned char) ((pvs)[(b) >> 3] |= (1 << ((b) & 7))) : (unsigned char) false)
#define CLEARPVSBIT(pvs,b) (void) ((b) >= 0 ? (unsigned char) ((pvs)[(b) >> 3] &= ~(1 << ((b) & 7))) : (unsigned char) false)

#endif