openmohaa/code/qcommon/cm_local.h

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code 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.

Quake III Arena source code 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 Quake III Arena source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

#include "q_shared.h"
#include "qcommon.h"
#include "cm_polylib.h"
#include "cm_terrain.h"

#ifdef __cplusplus
extern "C" {
#endif

#define	MAX_SUBMODELS			1024
#define	BOX_MODEL_HANDLE		(MAX_SUBMODELS-1)
#define CAPSULE_MODEL_HANDLE	510
#define MAX_OBFUSCATIONS		1024

typedef struct {
	cplane_t	*plane;
	int			children[2];		// negative numbers are leafs
} cNode_t;

typedef struct {
	int			cluster;
	int			area;

	intptr_t	firstLeafBrush;
	int			numLeafBrushes;

	intptr_t	firstLeafSurface;
	int			numLeafSurfaces;

	//added for mohaa
	int			firstLeafTerrain;
	int			numLeafTerrains;
} cLeaf_t;

typedef struct cfencemask_s {
	char name[ 64 ];
	int iWidth;
	int iHeight;
	byte *pData;
	struct cfencemask_s *pNext;
} cfencemask_t;

typedef struct {
	char shader[ 64 ];
	int surfaceFlags;
	int contentFlags;
	cfencemask_t *mask;
	float obfuscationWidthDensity;
	float obfuscationHeightDensity;
} cshader_t;

typedef struct cmodel_s {
	vec3_t		mins, maxs;
	cLeaf_t		leaf;			// submodels don't reference the main tree
} cmodel_t;

typedef struct {
	cplane_t			*plane;
	int					surfaceFlags;
	int					shaderNum;

	dsideequation_t		*pEq;
} cbrushside_t;

typedef struct {
	int			shaderNum;		// the shader that determined the contents
	int			contents;
	vec3_t		bounds[2];
	int			numsides;
	cbrushside_t	*sides;
	int			checkcount;		// to avoid repeated testings
} cbrush_t;


typedef struct {
	int			checkcount;				// to avoid repeated testings
	int			surfaceFlags;
	int			contents;

	int			shaderNum;
	int			subdivisions;

	struct patchCollide_s	*pc;
} cPatch_t;

typedef struct {
	int checkcount;
	int surfaceFlags;
	int contents;
	int shaderNum;
	terrainCollide_t tc;
} cTerrain_t;

typedef struct {
	int			floodnum;
	int			floodvalid;
} cArea_t;

// IneQuation
typedef struct {
	int			checkcount;				// to avoid repeated testings

	struct terPatchCollide_s	*tc;
} cterPatch_t;

typedef struct {
	char			name[ MAX_QPATH ];

	int				numShaders;
	cfencemask_t	*fencemasks;
	cshader_t		*shaders;

	int				numSideEquations;
	dsideequation_t	*sideequations;

	int				numBrushSides;
	cbrushside_t	*brushsides;

	int				numPlanes;
	cplane_t		*planes;

	int				numNodes;
	cNode_t			*nodes;

	int				numLeafs;
	cLeaf_t			*leafs;

	int				numLeafBrushes;
	int				*leafbrushes;

	int				numLeafSurfaces;
	int				*leafsurfaces;

	int				numLeafTerrains;
	cTerrain_t		**leafterrains;

	int				numSubModels;
	cmodel_t		*cmodels;

	int				numBrushes;
	cbrush_t		*brushes;

	int				numClusters;
	int				clusterBytes;
	byte			*visibility;
	qboolean		vised;			// if false, visibility is just a single cluster of ffs

	int				numEntityChars;
	char			*entityString;

	int				numAreas;
	cArea_t			*areas;
	int				*areaPortals;	// [ numAreas*numAreas ] reference counts

	int				numSurfaces;
	cPatch_t		**surfaces;			// non-patches will be NULL

	// IneQuation
	int				numTerrain;
	cTerrain_t		*terrain;

	int				floodvalid;
	int				checkcount;					// incremented on each trace
} clipMap_t;


// keep 1/8 unit away to keep the position valid before network snapping
// and to avoid various numeric issues
#define	SURFACE_CLIP_EPSILON	(0.125)

// cm_test.c

// Used for oriented capsule collision detection
typedef struct
{
	qboolean	use;
	float		radius;
	vec3_t		offset;
} sphere_t;

typedef struct {
	vec3_t		start;
	vec3_t		end;
	vec3_t		size[2];	// size of the box being swept through the model
	vec3_t		offsets[8];	// [signbits][x] = either size[0][x] or size[1][x]
	float		maxOffset;	// longest corner length from origin
	vec3_t		extents;	// greatest of abs(size[0]) and abs(size[1])
	vec3_t		bounds[2];	// enclosing box of start and end surrounding by size
	float		height;
	float		radius;
	int			contents;	// ored contents of the model tracing through
	qboolean	isPoint;	// optimized case
	trace_t		trace;		// returned from trace call
} traceWork_t;

typedef struct leafList_s {
	int		count;
	int		maxcount;
	qboolean	overflowed;
	int		*list;
	vec3_t	bounds[2];
	int		lastLeaf;		// for overflows where each leaf can't be stored individually
	void	(*storeLeafs)( struct leafList_s *ll, int nodenum );
} leafList_t;

typedef struct {
    char name[MAX_QPATH];
    float widthDensity;
    float heightDensity;
} obfuscation_t;

extern	clipMap_t	cm;
extern	int			c_pointcontents;
extern	int			c_traces, c_brush_traces, c_patch_traces, c_terrain_patch_traces;
extern	cvar_t		*cm_noAreas;
extern	cvar_t		*cm_noCurves;
extern	cvar_t		*cm_playerCurveClip;
extern	cvar_t		*cm_FCMcacheall;
extern	cvar_t		*cm_FCMdebug;
extern	cvar_t		*cm_ter_usesphere;
extern	sphere_t	sphere;


int CM_BoxBrushes( const vec3_t mins, const vec3_t maxs, cbrush_t **list, int listsize );

void CM_StoreLeafs( leafList_t *ll, int nodenum );
void CM_StoreBrushes( leafList_t *ll, int nodenum );

void CM_BoxLeafnums_r( leafList_t *ll, int nodenum );

cmodel_t	*CM_ClipHandleToModel( clipHandle_t handle );
qboolean CM_BoundsIntersect( const vec3_t mins, const vec3_t maxs, const vec3_t mins2, const vec3_t maxs2 );
qboolean CM_BoundsIntersectPoint( const vec3_t mins, const vec3_t maxs, const vec3_t point );

// cm_patch.c

qboolean CM_PlaneFromPoints( vec4_t plane, vec3_t a, vec3_t b, vec3_t c );
struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, vec3_t *points, float subdivisions );
void CM_TraceThroughPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
qboolean CM_PositionTestInPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
void CM_ClearLevelPatches( void );

// cm_terrain.c
struct terPatchCollide_s *CM_GenerateTerPatchCollide(vec3_t origin, byte heightmap[9][9], baseshader_t *shader);
void CM_TraceThroughTerrainCollide(traceWork_t *tw, terrainCollide_t *tc);
qboolean CM_PositionTestInTerrainCollide( traceWork_t *tw, terrainCollide_t *tc );
qboolean CM_SightTracePointThroughTerrainCollide( void );
qboolean CM_SightTraceThroughTerrainCollide( traceWork_t *tw, terrainCollide_t *tc );

// cm_fencemask.c
cfencemask_t *CM_GetFenceMask( const char *szMaskName );
qboolean CM_TraceThroughFence( traceWork_t *tw, cbrush_t *brush, cbrushside_t *side, float fTraceFraction );

// cm_trace_obfuscation.cpp
obfuscation_t* CM_SetupObfuscationMapping();
void CM_ReleaseObfuscationMapping(obfuscation_t* obfuscation);
void CM_ObfuscationForShader(obfuscation_t* list, const char* shaderName, float* widthDensity, float* heightDensity);

#ifdef __cplusplus
}
#endif