/*
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.
*/
/*
	TODO:
		Lightmaps - skip ssbump stuff properly. currently extra lightstyles are screwed.
		Ent Lighting - leafs have some list of light 'cubes' that define lighting, allowing for ents to get backlit etc properly.
		Areaportals - the server 'needs' a way to specify areaportals on a per-player basis. for now the gamecode will have to explicitly force-open most of the portals in the game (map_noareas can be used as a workaround).
		Static Props - these are solid, but use the visible mesh for collisions instead of the special/simpler collision mesh. This makes it a bit easier to climb up them, which may be a gameplay issue.
		Detail Props - we don't attempt to handle these. They need manual batching or something (eg clutter-shader stuff). Their loss should not affect gameplay much as they can be disabled in HL2 too.
		Dynamic Lighting - r_dynamic not enabled.
		Realtime Lighting - screwed. Doesn't light all world surfaces for some reason.
		RBE(Bullet) - probably screwed.
		Skyboxes - doesn't handle the whole per-face skies nor weird hdr encoding.
		Fog - no fog here... this results in issues where the pvs provides distance culling.
		Load Times - materials are loaded on a single thread. this gets slow.
		Materials - all kinds of screwed.
		Portal2 Gels - we need to repurpose stainmap code or something.
		Refraction - this stuff is horribly expensive.
*/

#include "../plugin.h"
#include "quakedef.h"
#ifdef HAVE_CLIENT
#include "glquake.h"
#endif
#include "com_mesh.h"
#include "com_bih.h"

static plugfsfuncs_t		*filefuncs;
static plugmodfuncs_t		*modfuncs;
static plugthreadfuncs_t	*threadfuncs;

#define Q_strncpyz Q_strlcpy
float VectorNormalize2(const vec3_t in,vec3_t out) {float l = sqrt(DotProduct(in,in)); if (l) l = 1.0/l; VectorScale(in,l,out); return l;}
#define VectorNormalize(v) VectorNormalize2(v,v)
fte_inlinebody float M_LinearToSRGB(float x, float mag);
vec3_t vec3_origin;
static refdef_t *refdef;

static vec3_t modelorg;
static qbyte *frustumvis;
static int vbsp_nodesequence; //to track which nodes need walking
static int vbsp_surfsequence; //so we don't draw the same surface if its found multiple ways

r_qrenderer_t qrenderer = QR_OPENGL;

#define	MAX_VBSP_AREAS		MAX_Q2MAP_AREAS
#define SURF_OFFNODE		SURF_DRAWBACKGROUND	//might as well just reuse that.

static cvar_t *hl2_novis;
static cvar_t *hl2_displacement_scale;
static cvar_t *hl2_favour_ldr;
static cvar_t *map_noareas;
static cvar_t *map_autoopenportals;
static cvar_t *hl2_contents_remap;

char *Q_strlwr(char *s)
{
	char *ret=s;
	while(*s)
	{
		if (*s >= 'A' && *s <= 'Z')
			*s=*s-'A'+'a';
		s++;
	}

	return ret;
}

void AddPointToBounds (const vec3_t v, vec3_t mins, vec3_t maxs)
{
	int		i;
	vec_t	val;

	for (i=0 ; i<3 ; i++)
	{
		val = v[i];
		if (val < mins[i])
			mins[i] = val;
		if (val > maxs[i])
			maxs[i] = val;
	}
}

void ClearBounds (vec3_t mins, vec3_t maxs)
{
	mins[0] = mins[1] = mins[2] = FLT_MAX;
	maxs[0] = maxs[1] = maxs[2] = -FLT_MAX;
}


/*
==================
BoxOnPlaneSide

Returns 1, 2, or 1 + 2
==================
*/
int VARGS BoxOnPlaneSide (const vec3_t emins, const vec3_t emaxs, const mplane_t *p)
{
	float	dist1, dist2;
	int		sides;

// general case
	switch (p->signbits)
	{
	default:
	case 0:
dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
dist2 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
		break;
	case 1:
dist1 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
		break;
	case 2:
dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
dist2 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
		break;
	case 3:
dist1 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
		break;
	case 4:
dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
dist2 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
		break;
	case 5:
dist1 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
		break;
	case 6:
dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
dist2 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
		break;
	case 7:
dist1 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
		break;
	}

	sides = 0;
	if (dist1 >= p->dist)
		sides = 1;
	if (dist2 < p->dist)
		sides |= 2;

	return sides;
}


#define Host_Error Sys_Errorf

enum hllumps_e
{	//note how this order matches q1 so well...
	//and yet the format is disturbingly similar to q2... huh... :P
	VLUMP_ENTITIES		= LUMP_ENTITIES,
	VLUMP_PLANES		= LUMP_PLANES,
	VLUMP_TEXTURES		= LUMP_TEXTURES,
	VLUMP_VERTEXES		= LUMP_VERTEXES,
	VLUMP_VISIBILITY	= LUMP_VISIBILITY,
	VLUMP_NODES			= LUMP_NODES,
	VLUMP_TEXINFO		= LUMP_TEXINFO,
	VLUMP_FACES_LDR		= LUMP_FACES,
	VLUMP_LIGHTING_LDR	= LUMP_LIGHTING,
//	VLUMP_FOO			= 9,//LUMP_CLIPNODES
	VLUMP_LEAFS			= LUMP_LEAFS,
//	VLUMP_FOO			= 11,//LUMP_MARKSURFACES
	VLUMP_EDGES			= LUMP_EDGES,
	VLUMP_SURFEDGES		= LUMP_SURFEDGES,
	VLUMP_MODELS		= LUMP_MODELS,
//	VLUMP_FOO			= 15,
	VLUMP_LEAFFACES		= 16,
	VLUMP_LEAFBRUSHES	= 17,
	VLUMP_BRUSHES		= 18,
	VLUMP_BRUSHSIDES	= 19,
	VLUMP_AREAS			= 20,
	VLUMP_AREAPORTALS	= 21,
//	VLUMP_FOO			= 22,
//	VLUMP_FOO			= 23,
//	VLUMP_FOO			= 24,
//	VLUMP_FOO			= 25,
	VLUMP_DISP_INFO		= 26,
//	VLUMP_FOO			= 27,
//	VLUMP_FOO			= 28,
//	VLUMP_FOO			= 29,
//	VLUMP_FOO			= 30,
//	VLUMP_FOO			= 31,
	VLUMP_DISP_LMALPHA	= 32,
	VLUMP_DISP_VERTS	= 33,
	VLUMP_DISP_LMCOORDS	= 34,
	VLUMP_GAMELUMP		= 35,
//	VLUMP_FOO			= 36,
//	VLUMP_FOO			= 37,
//	VLUMP_FOO			= 38,
//	VLUMP_FOO			= 39,

	VLUMP_ZIPFILE		= 40,
	VLUMP_AREAPORTALVERTS = 41,
//	VLUMP_FOO			= 42,
	VLUMP_STRINGDATA	= 43,
	VLUMP_STRINGOFFSETS	= 44,
//	VLUMP_FOO			= 45,
//	VLUMP_FOO			= 46,
//	VLUMP_FOO			= 47,
	VLUMP_DISP_TRIFLAGS	= 48,
//	VLUMP_FOO			= 49,
//	VLUMP_FOO			= 50,
	VLUMP_LEAFLIGHTI_HDR= 51,	//indexes into VLUMP_LEAFLIGHTV_HDR, two shorts per leaf.
	VLUMP_LEAFLIGHTI_LDR= 52,
	VLUMP_LIGHTING_HDR	= 53,
//	VLUMP_FOO			= 54,
	VLUMP_LEAFLIGHTV_HDR= 55,
	VLUMP_LEAFLIGHTV_LDR= 56,
//	VLUMP_FOO			= 57,
	VLUMP_FACES_HDR		= 58,
//	VLUMP_FOO			= 59,
//	VLUMP_FOO			= 60,
//	VLUMP_FOO			= 61,
//	VLUMP_FOO			= 62,
//	VLUMP_FOO			= 63,
	HL2_MAXLUMPS 		= 64
};
typedef struct {
	unsigned int fileofs;
	unsigned int filelen;
	unsigned int foo[2];
} vlump_t;
typedef struct {
	unsigned int magic;
	unsigned int version;
	vlump_t lumps[HL2_MAXLUMPS];
} dvbspheader_t;

typedef struct
{
	int		numareaportals;
	int		firstareaportal;
} carea_t;
typedef struct
{
	int		floodnum;			// if two areas have equal floodnums, they are connected
	int		floodvalid;			// flags the area as having been visited (sequence numbers matching prv->floodvalid)
} careaflood_t;
typedef struct cmodel_s
{
	vec3_t		mins, maxs;
	vec3_t		origin;		// for sounds or lights
	mnode_t		*headnode;
	mleaf_t		*headleaf;
	int		numsurfaces;
	int		firstsurface;

	int firstbrush;
	int num_brushes;
} cmodel_t;
typedef struct dispinfo_s
{
    struct msurface_s *surf;
    vec3_t aamin;
    vec3_t aamax;
    pvscache_t pvs; //which pvs clusters this displacement is visible in...
    unsigned int contents;
    unsigned int width;
    unsigned int height;
    vecV_t *xyz;    //(width+1)*(height+1)
    index_t *idx;   //width*height*6;
    size_t numindexes;
    struct dispvert_s
    {
        vec3_t norm;
        vec2_t st;
        float alpha;
    } *verts;
    //unsigned short *flags;

    q2csurface_t csurface;  //collision info for q2 gamecode.
} dispinfo_t;

typedef struct vbspinfo_s
{
	struct
	{
		qbyte *vis;
		pvsbuffer_t visbuf;
		int viewcluster[2];
	} vcache;

	int				numbrushsides;
	q2cbrushside_t *brushsides;

	q2mapsurface_t	*surfaces;
	dispinfo_t		**surfdisp;

	int				numleafbrushes;
	q2cbrush_t		**leafbrushes;

	int				numcmodels;
	cmodel_t		*cmodels;

	int				numbrushes;
	q2cbrush_t		*brushes;

	int				numvisibility;
	q2dvis_t		*vis;
	qbyte			*phscalced;

	struct vbsptexinfo_s
	{
		vec4_t lmvecs[2];
	} *texinfo;

	int				numareas;
	int				floodvalid;
	careaflood_t	areaflood[MAX_VBSP_AREAS];
	//areas have a list of portals that open into other areas.
	carea_t			*areas;	//indexes into q2areaportals for flooding
	size_t			numareaportals;
	q2dareaportal_t	*areaportals;

	//and this is the state that is actually changed. booleans.
	qbyte			portalopen[MAX_Q2MAP_AREAPORTALS];	//memset will work if it's a qbyte, really it should be a qboolean
	mplane_t		**portalplane;
	qbyte			portalquerying[MAX_Q2MAP_AREAPORTALS];
	mesh_t			*portalpoly;		//[numq2areaportals]
	int				*occlusionqueries; //[numq2areaportals]

	struct mleaflight_s
	{
		struct leaflightpoint_s
		{
			vec3_t rgb[6];
			qbyte x, y, z;
		} *point;
		int count;
	} *leaflight;

	size_t numdisplacements;
	dispinfo_t *displacements;

	size_t numstaticprops;
	struct staticprop_s
	{
		float fademindist;
		float fademaxdist;
		qboolean solid;
		struct bihtransform_s transform;
		vec3_t	lightorg;
		entity_t ent;
	} *staticprops;

	unsigned int contentsremap[32];
	int summed;	//for the main thread to wait on.
} vbspinfo_t;

static q2mapsurface_t	nullsurface;

static int		VBSP_NumInlineModels (model_t *model);
static cmodel_t	*VBSP_InlineModel (model_t *model, char *name);
static void VBSP_FinalizeBrush(q2cbrush_t *brush);
static void	FloodAreaConnections (vbspinfo_t	*prv);

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

					MAP LOADING

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

static unsigned int VBSP_TranslateContentBits(vbspinfo_t *prv, unsigned int source)
{
	unsigned int ret = 0;
	if (source & 0x0000ffff)
	{
		if (source & 0x0000000f)
		{
			if (source & 0x00000001)	ret |= prv->contentsremap[ 0];
			if (source & 0x00000002)	ret |= prv->contentsremap[ 1];
			if (source & 0x00000004)	ret |= prv->contentsremap[ 2];
			if (source & 0x00000008)	ret |= prv->contentsremap[ 3];
		}
		if (source & 0x000000f0)
		{
			if (source & 0x00000010)	ret |= prv->contentsremap[ 4];
			if (source & 0x00000020)	ret |= prv->contentsremap[ 5];
			if (source & 0x00000040)	ret |= prv->contentsremap[ 6];
			if (source & 0x00000080)	ret |= prv->contentsremap[ 7];
		}
		if (source & 0x000000f00)
		{
			if (source & 0x00000100)	ret |= prv->contentsremap[ 8];
			if (source & 0x00000200)	ret |= prv->contentsremap[ 9];
			if (source & 0x00000400)	ret |= prv->contentsremap[10];
			if (source & 0x00000800)	ret |= prv->contentsremap[11];
		}
		if (source & 0x000000f00)
		{
			if (source & 0x000001000)	ret |= prv->contentsremap[12];
			if (source & 0x000002000)	ret |= prv->contentsremap[13];
			if (source & 0x000004000)	ret |= prv->contentsremap[14];
			if (source & 0x000008000)	ret |= prv->contentsremap[15];
		}
	}
	if (source & 0xffff0000)
	{
		if (source & 0x000f0000)
		{
			if (source & 0x00010000)	ret |= prv->contentsremap[16];
			if (source & 0x00020000)	ret |= prv->contentsremap[17];
			if (source & 0x00040000)	ret |= prv->contentsremap[18];
			if (source & 0x00080000)	ret |= prv->contentsremap[19];
		}
		if (source & 0x00f00000)
		{
			if (source & 0x00100000)	ret |= prv->contentsremap[20];
			if (source & 0x00200000)	ret |= prv->contentsremap[21];
			if (source & 0x00400000)	ret |= prv->contentsremap[22];
			if (source & 0x00800000)	ret |= prv->contentsremap[23];
		}
		if (source & 0x0f000000)
		{
			if (source & 0x01000000)	ret |= prv->contentsremap[24];
			if (source & 0x02000000)	ret |= prv->contentsremap[25];
			if (source & 0x04000000)	ret |= prv->contentsremap[26];
			if (source & 0x08000000)	ret |= prv->contentsremap[27];
		}
		if (source & 0xf0000000)
		{
			if (source & 0x10000000)	ret |= prv->contentsremap[28];
			if (source & 0x20000000)	ret |= prv->contentsremap[29];
			if (source & 0x40000000)	ret |= prv->contentsremap[30];
			if (source & 0x80000000)	ret |= prv->contentsremap[31];
		}
	}
	return ret;
}
static void VBSP_TranslateContentBits_Setup(vbspinfo_t *prv)
{
	size_t i, j;
	char contname[64];
	const char *contremap = hl2_contents_remap->string;
	static const struct {
		const char *name;
		unsigned int contents;
	} knowncontents[] =
	{
		{"empty", FTECONTENTS_EMPTY},
		{"solid", FTECONTENTS_SOLID},
		{"window", FTECONTENTS_WINDOW},
		{"lava", FTECONTENTS_LAVA},
		{"slime", FTECONTENTS_SLIME},
		{"water", FTECONTENTS_WATER},
		{"ladder", FTECONTENTS_LADDER},
		{"playerclip", FTECONTENTS_PLAYERCLIP},
		{"monsterclip", FTECONTENTS_MONSTERCLIP},
		{"clip", FTECONTENTS_PLAYERCLIP|FTECONTENTS_MONSTERCLIP},
		{"body", FTECONTENTS_BODY},
		{"corpse", FTECONTENTS_CORPSE},
		{"detail", FTECONTENTS_DETAIL},
		{"sky", FTECONTENTS_SKY},
		{"Q2SOLID", Q2CONTENTS_SOLID},
		{"Q2WINDOW", Q2CONTENTS_WINDOW},
		{"Q2AUX", Q2CONTENTS_AUX},
		{"Q2LAVA", Q2CONTENTS_LAVA},
		{"Q2SLIME", Q2CONTENTS_SLIME},
		{"Q2WATER", Q2CONTENTS_WATER},
		{"Q2MIST", Q2CONTENTS_MIST},
		{"Q2AREAPORTAL", Q2CONTENTS_AREAPORTAL},
		{"Q2PLAYERCLIP", Q2CONTENTS_PLAYERCLIP},
		{"Q2MONSTERCLIP", Q2CONTENTS_MONSTERCLIP},
		{"Q2CURRENT_0", Q2CONTENTS_CURRENT_0},
		{"Q2CURRENT_90", Q2CONTENTS_CURRENT_90},
		{"Q2CURRENT_180", Q2CONTENTS_CURRENT_180},
		{"Q2CURRENT_270", Q2CONTENTS_CURRENT_270},
		{"Q2CURRENT_UP", Q2CONTENTS_CURRENT_UP},
		{"Q2CURRENT_DOWN", Q2CONTENTS_CURRENT_DOWN},
		{"Q2ORIGIN", Q2CONTENTS_ORIGIN},
		{"Q2MONSTER", Q2CONTENTS_MONSTER},
		{"Q2DEADMONSTER", Q2CONTENTS_DEADMONSTER},
		{"Q2DETAIL", Q2CONTENTS_DETAIL},
		{"Q2TRANSLUCENT", Q2CONTENTS_TRANSLUCENT},
		{"Q2LADDER", Q2CONTENTS_LADDER},
		{"Q3SOLID", Q3CONTENTS_SOLID},
		{"Q3LAVA", Q3CONTENTS_LAVA},
		{"Q3SLIME", Q3CONTENTS_SLIME},
		{"Q3WATER", Q3CONTENTS_WATER},
		{"Q3NOTTEAM1", Q3CONTENTS_NOTTEAM1},
		{"Q3NOTTEAM2", Q3CONTENTS_NOTTEAM2},
		{"Q3NOBOTCLIP", Q3CONTENTS_NOBOTCLIP},
		{"Q3AREAPORTAL", Q3CONTENTS_AREAPORTAL},
		{"Q3PLAYERCLIP", Q3CONTENTS_PLAYERCLIP},
		{"Q3MONSTERCLIP", Q3CONTENTS_MONSTERCLIP},
		{"Q3TELEPORTER", Q3CONTENTS_TELEPORTER},
		{"Q3JUMPPAD", Q3CONTENTS_JUMPPAD},
		{"Q3CLUSTERPORTAL", Q3CONTENTS_CLUSTERPORTAL},
		{"Q3DONOTENTER", Q3CONTENTS_DONOTENTER},
		{"Q3BOTCLIP", Q3CONTENTS_BOTCLIP},
		{"Q3MOVER", Q3CONTENTS_MOVER},
		{"Q3ORIGIN", Q3CONTENTS_ORIGIN},
		{"Q3BODY", Q3CONTENTS_BODY},
		{"Q3CORSE", Q3CONTENTS_CORPSE},
		{"Q3DETAIL", Q3CONTENTS_DETAIL},
		{"Q3STRUCTURAL", Q3CONTENTS_STRUCTURAL},
		{"Q3TRANSLUCENT", Q3CONTENTS_TRANSLUCENT},
		{"Q3TRIGGER", Q3CONTENTS_TRIGGER},
		{"Q3NODROP", Q3CONTENTS_NODROP},
	};
	if (!*contremap)
		for (i = 0; i < 32; i++)
			prv->contentsremap[i] = 1<<i;
	else for (i = 0; i < 32; i++)
	{
		contremap = cmdfuncs->ParseToken(contremap, contname, sizeof(contname), NULL);
		if (!contremap || !*contname)
			prv->contentsremap[i] = 0;
		else
		{
			char *tmp;
			int bit = strtol(contname, &tmp, 10);
			if (!*tmp)
			{
				if (bit >= 0)
					prv->contentsremap[i] = 1<<bit;
			}
			else
			{
				for (j = 0; j < countof(knowncontents); j++)
				{
					if (!Q_strcasecmp(contname, knowncontents[j].name))
					{
						prv->contentsremap[i] = knowncontents[j].contents;
						break;
					}
				}
				if (j == countof(knowncontents))
					Con_Printf(CON_WARNING"%s: Unknown bit name %s\n", hl2_contents_remap->name, contname);
			}
		}
	}
}

static void VBSP_SetParent (mnode_t *node, mnode_t *parent)
{
	node->parent = parent;
	if (node->contents != -1)
		return;
	VBSP_SetParent (node->children[0], node);
	VBSP_SetParent (node->children[1], node);
}

static void VBSP_FindBrushRange (vbspinfo_t	*prv, mnode_t *node, size_t *firstbrush, size_t *lastbrush)
{
	size_t u, b;
	mleaf_t *leaf;
	while (node->contents == -1)
	{	//walk every node to find every leaf...
		VBSP_FindBrushRange(prv, node->children[0], firstbrush, lastbrush);
		node = node->children[1];
	}

	leaf = (mleaf_t*)node;
	for (u = 0; u < leaf->numleafbrushes; u++)
	{
		b = prv->leafbrushes[leaf->firstleafbrush+u]-prv->brushes;
		if (*firstbrush > b)
			*firstbrush = b;
		if (*lastbrush < b+1)
			*lastbrush = b+1;
	}
}

static qboolean VBSP_LoadVertexes (model_t *loadmodel, qbyte *mod_base, vlump_t *l)
{
	dvertex_t	*in;
	mvertex_t	*out;
	size_t			i, count;

	in = (void *)(mod_base + l->fileofs);
	count = l->filelen / sizeof(*in);
	if (l->filelen % sizeof(*in) || count > SANITY_LIMIT(*out))
	{
		Con_Printf (CON_ERROR "VBSP_LoadVertexes: funny lump size in %s\n", loadmodel->name);
		return false;
	}
	out = plugfuncs->GMalloc(&loadmodel->memgroup, count*sizeof(*out));

	loadmodel->vertexes = out;
	loadmodel->numvertexes = count;

	for ( i=0 ; i<count ; i++, in++, out++)
	{
		out->position[0] = LittleFloat (in->point[0]);
		out->position[1] = LittleFloat (in->point[1]);
		out->position[2] = LittleFloat (in->point[2]);
	}

	return true;
}
static qboolean VBSP_LoadEdges (model_t *loadmodel, qbyte *mod_base, vlump_t *l)
{
	medge_t *out;
	size_t 	i, count;

	dsedge_t *in = (void *)(mod_base + l->fileofs);
	count = l->filelen / sizeof(*in);
	if (l->filelen % sizeof(*in) || count > SANITY_LIMIT(*out))
	{
		Con_Printf ("VBSP_LoadEdges: funny lump size in %s\n", loadmodel->name);
		return false;
	}
	out = plugfuncs->GMalloc(&loadmodel->memgroup, (count + 1) * sizeof(*out));

	loadmodel->edges = out;
	loadmodel->numedges = count;

	for ( i=0 ; i<count ; i++, in++, out++)
	{
		out->v[0] = (unsigned short)LittleShort(in->v[0]);
		out->v[1] = (unsigned short)LittleShort(in->v[1]);
	}

	return true;
}
static qboolean VBSP_LoadSurfedges (model_t *loadmodel, qbyte *mod_base, vlump_t *l)
{
	size_t		i, count;
	unsigned int		*in, *out;

	in = (void *)(mod_base + l->fileofs);
	count = l->filelen / sizeof(*in);
	if (l->filelen % sizeof(*in) || count > SANITY_LIMIT(*out))
	{
		Con_Printf (CON_ERROR "VBSP_LoadSurfedges: funny lump size in %s\n",loadmodel->name);
		return false;
	}
	out = plugfuncs->GMalloc(&loadmodel->memgroup, count*sizeof(*out));

	loadmodel->surfedges = out;
	loadmodel->numsurfedges = count;

	for ( i=0 ; i<count ; i++)
		out[i] = LittleLong (in[i]);

	return true;
}
static qboolean VBSP_LoadMarksurfaces (model_t *loadmodel, qbyte *mod_base, vlump_t *l)
{
	size_t		i, j, count;
	msurface_t **out;

	unsigned short		*ins;
	ins = (void *)(mod_base + l->fileofs);
	count = l->filelen / sizeof(*ins);
	if (l->filelen % sizeof(*ins) || count > SANITY_LIMIT(*out))
	{
		Con_Printf (CON_ERROR "VBSP_LoadMarksurfaces: funny lump size in %s\n",loadmodel->name);
		return false;
	}
	out = plugfuncs->GMalloc(&loadmodel->memgroup, count*sizeof(*out));

	loadmodel->marksurfaces = out;
	loadmodel->nummarksurfaces = count;

	for ( i=0 ; i<count ; i++)
	{
		j = (unsigned short)LittleShort(ins[i]);
		if (j >= loadmodel->numsurfaces)
		{
			Con_Printf (CON_ERROR "VBSP_LoadMarksurfaces: bad surface number\n");
			return false;
		}
		out[i] = loadmodel->surfaces + j;
	}

	return true;
}
static qboolean VBSP_LoadEntities (model_t *loadmodel, qbyte *mod_base, vlump_t *l)
{
	return modfuncs->LoadEntities(loadmodel, mod_base+l->fileofs, l->filelen);
}

/*
=================
CMod_LoadSubmodels
=================
*/
static qboolean VBSP_LoadSubmodels (model_t *loadmodel, qbyte *mod_base, vlump_t *l)
{
	vbspinfo_t	*prv = (vbspinfo_t*)loadmodel->meshinfo;
	q2dmodel_t	*in;
	cmodel_t	*out;
	int			i, j, count;
	size_t		firstbrush, lastbrush;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
	{
		Con_Printf (CON_ERROR "VBSP_LoadSubmodels: funny lump size\n");
		return false;
	}
	count = l->filelen / sizeof(*in);

	if (count < 1)
	{
		Con_Printf (CON_ERROR "Map with no models\n");
		return false;
	}
	if (count > SANITY_MAX_Q2MAP_MODELS)
	{
		Con_Printf (CON_ERROR "Map has too many models\n");
		return false;
	}

	out = prv->cmodels = plugfuncs->GMalloc(&loadmodel->memgroup, count * sizeof(*prv->cmodels));
	prv->numcmodels = count;

	for (i=0 ; i<count ; i++, in++, out++)
	{
		for (j=0 ; j<3 ; j++)
		{	// spread the mins / maxs by a pixel
			out->mins[j] = LittleFloat (in->mins[j]) - 1;
			out->maxs[j] = LittleFloat (in->maxs[j]) + 1;
			out->origin[j] = LittleFloat (in->origin[j]);
		}
		out->headnode = loadmodel->nodes + LittleLong (in->headnode);
		out->firstsurface = LittleLong (in->firstface);
		out->numsurfaces = LittleLong (in->numfaces);


		firstbrush = ~0u;
		lastbrush = 0u;
		VBSP_FindBrushRange(prv, out->headnode, &firstbrush, &lastbrush);
		if (lastbrush > firstbrush)
		{
			out->firstbrush = firstbrush;
			out->num_brushes = lastbrush-firstbrush;
		}
	}

	AddPointToBounds(prv->cmodels[0].mins, loadmodel->mins, loadmodel->maxs);
	AddPointToBounds(prv->cmodels[0].maxs, loadmodel->mins, loadmodel->maxs);

	return true;
}

/*
=================
CMod_LoadBrushes

=================
*/
static qboolean VBSP_LoadBrushes (model_t *mod, qbyte *mod_base, vlump_t *l)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	q2dbrush_t	*in;
	q2cbrush_t	*out;
	int			i, count;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
	{
		Con_Printf (CON_ERROR "VBSP_LoadBrushes: funny lump size\n");
		return false;
	}
	count = l->filelen / sizeof(*in);

	if (count > SANITY_LIMIT(*out))
	{
		Con_Printf (CON_ERROR "Map has too many brushes");
		return false;
	}

	prv->brushes = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * (count+1));

	out = prv->brushes;

	prv->numbrushes = count;

	for (i=0 ; i<count ; i++, out++, in++)
	{
		//FIXME: missing bounds checks
		out->brushside = &prv->brushsides[LittleLong(in->firstside)];
		out->numsides = LittleLong(in->numsides);
		out->contents = VBSP_TranslateContentBits(prv, LittleLong(in->contents));
		VBSP_FinalizeBrush(out);
	}

	return true;
}

/*
=================
CMod_LoadPlanes
=================
*/
static qboolean VBSP_LoadPlanes (model_t *mod, qbyte *mod_base, vlump_t *l)
{
	int			i, j;
	mplane_t	*out;
	dplane_t 	*in;
	int			count;
	int			bits;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
	{
		Con_Printf (CON_ERROR "VBSP_LoadPlanes: funny lump size\n");
		return false;
	}
	count = l->filelen / sizeof(*in);

	if (count < 1)
	{
		Con_Printf (CON_ERROR "Map with no planes\n");
		return false;
	}
	// need to save space for box planes
	if (count > SANITY_LIMIT(*out))
	{
		Con_Printf (CON_ERROR "Map has too many planes (%i)\n", count);
		return false;
	}

	mod->planes = out = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * count);
	mod->numplanes = count;

	for ( i=0 ; i<count ; i++, in++, out++)
	{
		bits = 0;
		for (j=0 ; j<3 ; j++)
		{
			out->normal[j] = LittleFloat (in->normal[j]);
			if (out->normal[j] < 0)
				bits |= 1<<j;
		}

		out->dist = LittleFloat (in->dist);
		out->type = LittleLong (in->type);
		out->signbits = bits;
	}

	return true;
}

/*
=================
CMod_LoadLeafBrushes
=================
*/
static qboolean VBSP_LoadLeafBrushes (model_t *mod, qbyte *mod_base, vlump_t *l)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	int			i;
	q2cbrush_t	**out;
	unsigned short 	*in;
	int			count;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
	{
		Con_Printf (CON_ERROR "VBSP_LoadLeafBrushes: funny lump size\n");
		return false;
	}
	count = l->filelen / sizeof(*in);

	if (count < 1)
	{
		Con_Printf (CON_ERROR "Map with no planes\n");
		return false;
	}
	// need to save space for box planes
	if (count > SANITY_LIMIT(**out))
	{
		Con_Printf (CON_ERROR "Map has too many leafbrushes\n");
		return false;
	}

	//prv->numbrushes is because of submodels being weird.
	out = prv->leafbrushes = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * (count+prv->numbrushes));
	prv->numleafbrushes = count;

	for ( i=0 ; i<count ; i++, in++, out++)
		*out = prv->brushes + (unsigned short)(short)LittleShort (*in);

	return true;
}

/*
=================
CMod_LoadAreas
=================
*/
static qboolean VBSP_LoadAreas (model_t *mod, qbyte *mod_base, vlump_t *l)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	int			i;
	carea_t	*out;
	q2darea_t 	*in;
	int			count;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
	{
		Con_Printf (CON_ERROR "VBSP_LoadAreas: funny lump size\n");
		return false;
	}
	count = l->filelen / sizeof(*in);

	if (count > MAX_Q2MAP_AREAS)
	{
		Con_Printf (CON_ERROR "Map has too many areas\n");
		return false;
	}

	out = prv->areas = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * count);
	prv->numareas = count;

	for ( i=0 ; i<count ; i++, in++, out++)
	{
		out->numareaportals = LittleLong (in->numareaportals);
		out->firstareaportal = LittleLong (in->firstareaportal);
	}

	return true;
}

/*
=================
CMod_LoadVisibility
=================
*/
static qboolean VBSP_LoadVisibility (model_t *mod, qbyte *mod_base, vlump_t *l)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	int		i;

	prv->numvisibility = l->filelen;
//	if (l->filelen > MAX_Q2MAP_VISIBILITY)
//	{
//		Con_Printf (CON_ERROR "Map has too large visibility lump\n");
//		return false;
//	}

	prv->vis = plugfuncs->GMalloc(&mod->memgroup, l->filelen);
	memcpy (prv->vis, mod_base + l->fileofs, l->filelen);

	mod->vis = prv->vis;

	prv->vis->numclusters = LittleLong (prv->vis->numclusters);
	for (i=0 ; i<prv->vis->numclusters ; i++)
	{
		prv->vis->bitofs[i][0] = LittleLong (prv->vis->bitofs[i][0]);
		prv->vis->bitofs[i][1] = LittleLong (prv->vis->bitofs[i][1]);
	}
	mod->numclusters = prv->vis->numclusters;
	mod->pvsbytes = ((mod->numclusters + 31)>>3)&~3;

	return true;
}

/*
static qbyte *CM_LeafnumPVS (model_t *model, int leafnum, qbyte *buffer, unsigned int buffersize)
{
	return CM_ClusterPVS(model, CM_LeafCluster(model, leafnum), buffer, buffersize);
}
*/

#ifdef HAVE_CLIENT

/*extern int	r_dlightframecount;
static void VBSP_MarkLights (dlight_t *light, dlightbitmask_t bit, mnode_t *node)
{
	mplane_t	*splitplane;
	float		dist;
	msurface_t	*surf;
	int			i;

	if (node->contents != -1)
	{
		mleaf_t *leaf = (mleaf_t *)node;
		msurface_t **mark;

		i = leaf->nummarksurfaces;
		mark = leaf->firstmarksurface;
		while(i--!=0)
		{
			surf = *mark++;
			if (surf->dlightframe != r_dlightframecount)
			{
				surf->dlightbits = 0;
				surf->dlightframe = r_dlightframecount;
			}
			surf->dlightbits |= bit;
		}
		return;
	}

	splitplane = node->plane;
	dist = DotProduct (light->origin, splitplane->normal) - splitplane->dist;

	if (dist > light->radius)
	{
		VBSP_MarkLights (light, bit, node->children[0]);
		return;
	}
	if (dist < -light->radius)
	{
		VBSP_MarkLights (light, bit, node->children[1]);
		return;
	}

// mark the polygons
	surf = cl.worldmodel->surfaces + node->firstsurface;
	for (i=0 ; i<node->numsurfaces ; i++, surf++)
	{
		if (surf->dlightframe != r_dlightframecount)
		{
			surf->dlightbits = 0u;
			surf->dlightframe = r_dlightframecount;
		}
		surf->dlightbits |= bit;
	}

	VBSP_MarkLights (light, bit, node->children[0]);
	VBSP_MarkLights (light, bit, node->children[1]);
}

static void VBSP_StainNode (mnode_t *node, float *parms)
{
	mplane_t	*splitplane;
	float		dist;
	msurface_t	*surf;
	int			i;

	if (node->contents != -1)
		return;

	splitplane = node->plane;
	dist = DotProduct ((parms+1), splitplane->normal) - splitplane->dist;

	if (dist > (*parms))
	{
		VBSP_StainNode (node->children[0], parms);
		return;
	}
	if (dist < (-*parms))
	{
		VBSP_StainNode (node->children[1], parms);
		return;
	}

// mark the polygons
	surf = cl.worldmodel->surfaces + node->firstsurface;
	for (i=0 ; i<node->numsurfaces ; i++, surf++)
	{
		if (surf->flags&~(SURF_DONTWARP|SURF_PLANEBACK))
			continue;
		Surf_StainSurf(surf, parms);
	}

	VBSP_StainNode (node->children[0], parms);
	VBSP_StainNode (node->children[1], parms);
}
*/

#endif

typedef struct
{
	float		vecs[2][4];		// [s/t][xyz offset]
	float		lmvecs[2][4];	//well that's awkward
	int			flags;			// miptex flags + overrides
	int			textureindex;
} hltexinfo_t;
static qboolean VBSP_LoadSurfaces (model_t *mod, qbyte *mod_base, vlump_t *l)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	hltexinfo_t	*in;
	q2mapsurface_t	*out;
	int			i, count;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
	{
		Con_Printf (CON_ERROR "VBSP_LoadSurfaces: funny lump size\n");
		return false;
	}
	count = l->filelen / sizeof(*in);
	if (count < 1)
	{
		Con_Printf (CON_ERROR "Map with no surfaces\n");
		return false;
	}
//	if (count > MAX_Q2MAP_TEXINFO)
//		Host_Error ("Map has too many surfaces");

	mod->numtexinfo = count;
	out = prv->surfaces = plugfuncs->GMalloc(&mod->memgroup, count * sizeof(*prv->surfaces));

	for ( i=0 ; i<count ; i++, in++, out++)
	{
		Q_strncpyz (out->c.name, "FIXME", sizeof(out->c.name));
		Q_strncpyz (out->rname, "FIXME", sizeof(out->rname));
		out->c.flags = LittleLong (in->flags);
		out->c.value = 0;
	}

	return true;
}

typedef struct
{
	vec3_t reflectivity;		//not very useful to us.
	unsigned int stringindex;
	unsigned int width;
	unsigned int height;
	unsigned int width2;	//no idea why there's two of these.
	unsigned int height2;
} hltexture_t;
#define TIHL2_LIGHT			TI_LIGHT
#define TIHL2_SKYBOX		0x2
#define TIHL2_SKYROOM		0x4
#define TIHL2_WARP			TI_WARP

#define	TIHL2_TRANS			TI_TRANS33
#define TIHL2_NOPORTAL		0x20
#define TIHL2_TRIGGER		0x40
#define TIHL2_NODRAW		TI_NODRAW
//#define TIHL2_HINT		0x100
//#define TIHL2_SKIP		0x200
#define TIHL2_NOLIGHT		0x400
//#define TIHL2_BUMPLIGHT	0x800
//#define TIHL2_NOSHADOWS	0x1000
//#define TIHL2_NODECALS	0x2000
//#define TIHL2_NOCHOP		0x4000
//#define TIHL2_HITBOX		0x8000

static qboolean VBSP_LoadTexInfo (model_t *mod, qbyte *mod_base, vlump_t *lumps, char *mapname)
{	//texinfo->textures->stringoffsets->strings. gah, so many lumps just to find the texture name to use!
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	hltexinfo_t *in;
	mtexinfo_t *out;
	int 	i, j, count;
	char	sname[256];
	int texcount;
	hltexture_t *textures = (void*)(mod_base + lumps[VLUMP_TEXTURES].fileofs);
	unsigned int *stringoffsets = (void*)(mod_base + lumps[VLUMP_STRINGOFFSETS].fileofs);
	char *strings = mod_base + lumps[VLUMP_STRINGDATA].fileofs;
	unsigned int flags;

	in = (void *)(mod_base + lumps[VLUMP_TEXINFO].fileofs);
	if (lumps[VLUMP_TEXINFO].filelen % sizeof(*in))
	{
		Con_Printf ("VBSP_LoadTexInfo: funny lump size in %s\n", mod->name);
		return false;
	}
	count = lumps[VLUMP_TEXINFO].filelen / sizeof(*in);
	out = plugfuncs->GMalloc(&mod->memgroup, count*sizeof(*out));
	prv->texinfo = plugfuncs->GMalloc(&mod->memgroup, count*sizeof(*prv->texinfo));

	mod->textures = plugfuncs->GMalloc(&mod->memgroup, sizeof(texture_t *)*count);
	texcount = 0;

	mod->texinfo = out;
	mod->numtexinfo = count;

	for ( i=0 ; i<count ; i++, in++, out++)
	{
		hltexture_t *texture = ((in->textureindex>=0)?textures + in->textureindex:NULL);
		char *texturename = (texture?strings + stringoffsets[texture->stringindex]:"INVALID");
		flags = LittleLong (in->flags);

		for (j=0 ; j<4 ; j++)
			out->vecs[0][j] = LittleFloat (in->vecs[0][j]);
		for (j=0 ; j<4 ; j++)
			out->vecs[1][j] = LittleFloat (in->vecs[1][j]);
		out->vecscale[0] = 1.0/Length (out->vecs[0]);
		out->vecscale[1] = 1.0/Length (out->vecs[1]);

		for (j=0 ; j<4 ; j++)
			prv->texinfo[i].lmvecs[0][j] = LittleFloat (in->lmvecs[0][j]);
		for (j=0 ; j<4 ; j++)
			prv->texinfo[i].lmvecs[1][j] = LittleFloat (in->lmvecs[1][j]);

		if (flags & (TIHL2_SKYBOX|TIHL2_SKYROOM))
			Q_snprintfz(sname, sizeof(sname), "sky/%s", texturename);
		else
			Q_snprintfz(sname, sizeof(sname), "%s", texturename);
		if (flags & (TIHL2_WARP))
			Q_strncatz(sname, "#WARP", sizeof(sname));
//		if (out->flags & TIHL2_FLOWING)
//			Q_strncatz(sname, "#FLOW", sizeof(sname));
//		if (out->flags & TIHL2_TRANS66)
//			Q_strncatz(sname, "#ALPHA=0.66", sizeof(sname));
		else if (out->flags & TIHL2_TRANS)
			Q_strncatz(sname, "#ALPHA=1", sizeof(sname));
//		else if (out->flags & (TIHL2_WARP))
//			Q_strncatz(sname, "#ALPHA=1", sizeof(sname));

		out->flags = 0;
		if (flags & TIHL2_NOLIGHT)
			out->flags |= TEX_SPECIAL;

		//compact the textures.
		for (j=0; j < texcount; j++)
		{
			if (!Q_strcasecmp(sname, mod->textures[j]->name))
			{
				out->texture = mod->textures[j];
				break;
			}
		}
		if (j == texcount)	//load a new one
		{
			out->texture = plugfuncs->GMalloc(&mod->memgroup, sizeof(texture_t));
			Q_strncpyz(out->texture->name, sname, sizeof(out->texture->name));
			Q_strlwr(out->texture->name);
			if (texture)
			{
				out->texture->vwidth = texture->width;
				out->texture->vheight = texture->height;
			}
			else
			{
				out->texture->vwidth = out->texture->vheight = 128;
			}

			mod->textures[texcount++] = out->texture;
		}
	}

	mod->numtextures = texcount;

	return true;
}

typedef struct
{
	//shared with q2dnode_t
	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

	//new for hl2
	unsigned short	area;
	unsigned short pad;
} hl2dnode_t;
static qboolean VBSP_LoadNodes (model_t *mod, qbyte *mod_base, vlump_t *l)
{
	hl2dnode_t *in;
	int			child;
	mnode_t		*out;
	int			i, j, count;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
	{
		Con_Printf (CON_ERROR "VBSP_LoadNodes: funny lump size\n");
		return false;
	}
	count = l->filelen / sizeof(*in);

	if (count < 1)
	{
		Con_Printf (CON_ERROR "Map has no nodes\n");
		return false;
	}
	if (count > SANITY_LIMIT(*out))
	{
		Con_Printf (CON_ERROR "Map has too many nodes\n");
		return false;
	}

	out = plugfuncs->GMalloc(&mod->memgroup, sizeof(mnode_t)*count);

	mod->nodes = out;
	mod->numnodes = count;

	for (i=0 ; i<count ; i++, out++, in++)
	{
		memset(out, 0, sizeof(*out));

		for (j=0 ; j<3 ; j++)
		{
			out->minmaxs[j] = LittleShort (in->mins[j]);
			out->minmaxs[3+j] = LittleShort (in->maxs[j]);
		}

		out->plane = mod->planes + LittleLong(in->planenum);

		out->firstsurface = (unsigned short)LittleShort (in->firstface);
		out->numsurfaces = (unsigned short)LittleShort (in->numfaces);
		out->contents = -1;	// differentiate from leafs

		for (j=0 ; j<2 ; j++)
		{
			child = LittleLong (in->children[j]);
			out->childnum[j] = child;
			if (child < 0)
				out->children[j] = (mnode_t *)(mod->leafs + -1-child);
			else
				out->children[j] = mod->nodes + child;
		}
	}

	VBSP_SetParent (mod->nodes, NULL);	// sets nodes and leafs

	return true;
}
typedef struct
{
	//copied from q2dleaf_t
	int				contents;			// OR of all brushes (NOTE: hl2 doesn't seem to have these all set properly, at least for detail brushes)

	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;

	//new for hl2
	short leafwaterid;
	struct	//present in v19. gone in v20.
	{
		qbyte rgb[3];
		signed char e;
	} light[6];
	short pad;
} hl2dleaf_t;
static qboolean VBSP_LoadLeafs (model_t *mod, qbyte *mod_base, vlump_t *l, int ver)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	int			i, j;
	mleaf_t		*out;
	hl2dleaf_t	*in;
	int			count;
	size_t		insize = sizeof(*in);
	struct leaflightpoint_s *lightpoint = NULL;
	if (ver < 20)
		insize = 56;	//older maps have some lighting info here.
	else
		insize = 32;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % insize)
	{
		Con_Printf (CON_ERROR "VBSP_LoadLeafs: funny lump size\n");
		return false;
	}
	count = l->filelen / insize;

	if (count < 1)
	{
		Con_Printf (CON_ERROR "Map with no leafs\n");
		return false;
	}
	// need to save space for box planes
	if (count > SANITY_LIMIT(*out))
	{
		Con_Printf (CON_ERROR "Map has too many leafs\n");
		return false;
	}

	out = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * (count+1));
	mod->numclusters = 0;

	mod->leafs = out;
	mod->numleafs = count;

	if (ver < 20)
	{
		prv->leaflight = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * count);
		lightpoint = plugfuncs->GMalloc(&mod->memgroup, sizeof(*lightpoint) * count);
	}

	for ( i=0 ; i<count ; i++, in = (hl2dleaf_t*)((qbyte*)in+insize), out++)
	{
		memset(out, 0, sizeof(*out));

		for (j=0 ; j<3 ; j++)
		{
			out->minmaxs[j] = LittleShort (in->mins[j]);
			out->minmaxs[3+j] = LittleShort (in->maxs[j]);
		}

		out->contents = VBSP_TranslateContentBits(prv,LittleLong (in->contents));
		out->cluster = (unsigned short)LittleShort (in->cluster);
		if (out->cluster == 0xffff)
			out->cluster = -1;

		out->area = (unsigned short)LittleShort (in->area);
		out->area &= 0x1ff;		//upper part is flags.
		out->firstleafbrush = (unsigned short)LittleShort (in->firstleafbrush);
		out->numleafbrushes = (unsigned short)LittleShort (in->numleafbrushes);

		out->firstmarksurface = mod->marksurfaces +
			(unsigned short)LittleShort(in->firstleafface);
		out->nummarksurfaces = (unsigned short)LittleShort(in->numleaffaces);

		if (out->cluster >= mod->numclusters)
			mod->numclusters = out->cluster + 1;

		if (lightpoint)
		{
			for (j = 0; j < 6; j++)
			{
				float e = pow(2, in->light[j].e);
				lightpoint->rgb[j][0] = e * in->light[j].rgb[0];
				lightpoint->rgb[j][1] = e * in->light[j].rgb[1];
				lightpoint->rgb[j][2] = e * in->light[j].rgb[2];
			}
			prv->leaflight[i].count = 1;
			prv->leaflight[i].point = lightpoint++;
		}
	}
	mod->pvsbytes = ((mod->numclusters + 31)>>3)&~3;

	return true;
}

typedef struct
{
	unsigned short portalnum;
	unsigned short otherarea;

	unsigned short firstvert;
	unsigned short numverts;
	unsigned int planenum;
} hl2dareaportal_t;
static qboolean VBSP_LoadAreaPortals (model_t *mod, qbyte *mod_base, vlump_t *l, vlump_t *lump_verts)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	int			i;
	q2dareaportal_t		*out;
	hl2dareaportal_t 	*in;
	int			count, vcount;
	vec3_t		*inverts;
	mesh_t		mesh;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
	{
		Con_Printf (CON_ERROR "VBSP_LoadAreaPortals: funny lump size\n");
		return false;
	}
	count = l->filelen / sizeof(*in);

	inverts = (void *)(mod_base + lump_verts->fileofs);
	if (lump_verts->filelen % sizeof(*inverts))
	{
		Con_Printf (CON_ERROR "VBSP_LoadAreaPortals: funny lump size\n");
		return false;
	}
	vcount = lump_verts->filelen / sizeof(*inverts);

	if (count > MAX_Q2MAP_AREAS)
	{
		Con_Printf (CON_ERROR "Map has too many areas\n");
		return false;
	}

	out = prv->areaportals = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * count);
	prv->portalpoly = plugfuncs->GMalloc(&mod->memgroup, sizeof(*prv->portalpoly)*count);
	prv->portalplane = plugfuncs->GMalloc(&mod->memgroup, sizeof(*prv->portalplane)*count);
	prv->numareaportals = count;

	mesh.xyz_array = plugfuncs->GMalloc(&mod->memgroup, sizeof(*mesh.xyz_array)*vcount);
	for (i=0 ; i<vcount ; i++)
	{
		mesh.xyz_array[i][0] = LittleFloat(inverts[i][0]);
		mesh.xyz_array[i][1] = LittleFloat(inverts[i][1]);
		mesh.xyz_array[i][2] = LittleFloat(inverts[i][2]);
	}
	mesh.indexes = plugfuncs->GMalloc(&mod->memgroup, sizeof(*mesh.indexes)*64*3);
	mesh.st_array = plugfuncs->GMalloc(&mod->memgroup, sizeof(*mesh.st_array)*64);
	for (i=0 ; i<64 ; i++)
	{
		Vector2Set(mesh.st_array[i], 0,0);
		mesh.indexes[i*3+0] = 0;
		mesh.indexes[i*3+1] = i+1;
		mesh.indexes[i*3+2] = i+2;
	}

	for (i=0 ; i<count ; i++, in++, out++)
	{
		out->portalnum = LittleShort (in->portalnum);
		out->otherarea = LittleShort (in->otherarea);

		prv->portalplane[i] = mod->planes + LittleLong (in->planenum);

		prv->portalpoly[i].xyz_array = mesh.xyz_array+LittleLong(in->firstvert);
		prv->portalpoly[i].st_array = mesh.st_array;
		prv->portalpoly[i].numvertexes = LittleLong(in->numverts);

		if (prv->portalpoly[i].numvertexes>2)
		{
			prv->portalpoly[i].istrifan = true;
			prv->portalpoly[i].indexes = mesh.indexes;
			prv->portalpoly[i].numindexes = (prv->portalpoly[i].numvertexes-2)*3;
		}
	}

	return true;
}

typedef struct
{	//the main displacement lump
	vec3_t position;	//not really sure how to use this.
	int firstvert;		//((1<<power)+1) squared verts
	int firsttriflags;	//ignored (two shorts per quad)
	int power;
	int minpower;	//ignored... FIXME: add lod...
	float smoothangle;
	unsigned int contents;
	unsigned short faceidx; //mod->surfaces index
	unsigned int lightmapalphaoffset;	//erk, rgba? that's going to restrict lightmap formats.
	unsigned int lightofs;	//extents? cabbage? oh noes we've gone mad again! or is this some special blend weights in addition to the surface's lighting?
	struct
	{	//erk
		unsigned short peer;
		unsigned char orientation;
		unsigned char span;
		unsigned char peerspan;
	} edgepeers[8];	//two per edge
	struct
	{	//no idea how this works
		unsigned short peer[4];
		unsigned char numpeers;
	} cornerpeers[4];
	unsigned int allowedverts[10];
} hl2ddisplacement_t;
typedef struct
{
	vec3_t norm;
	float dist;
	float alpha;	//vertex alpha.
} hl2displacementvert_t;
static qboolean VBSP_LoadDisplacements (model_t *mod, qbyte *mod_base, vlump_t *lumps)
{
	vbspinfo_t			*prv = (vbspinfo_t*)mod->meshinfo;
	vlump_t 			*l = &lumps[VLUMP_DISP_INFO];
	vlump_t 			*vl = &lumps[VLUMP_DISP_VERTS];
	hl2ddisplacement_t	*in;
	dispinfo_t			*out;
	int					i, count, x, y;
	hl2displacementvert_t *inv;
	struct dispvert_s	*verts;
	vecV_t				*xyz;
	index_t 			*indexes;
	size_t				maxverts;
	msurface_t 			*surf;
	float *sverts[4];
	signed int e, idx;
	float fx,fy;
	vec3_t p, base;
	size_t stride;

	int primary;
	float pdist,dist;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
	{
		Con_Printf ("VBSP_LoadDisplacements: funny lump size in %s\n",mod->name);
		return false;
	}
	count = l->filelen / sizeof(*in);
	if (!count)
		return true;	//nothing to worry about.
	out = plugfuncs->GMalloc(&mod->memgroup, count*sizeof(*out));

	for (maxverts = 0, i = 0; i < count; i++)
		maxverts += ((1<<in[i].power)) * ((1<<in[i].power));
	indexes = plugfuncs->GMalloc(&mod->memgroup, maxverts*sizeof(*indexes)*6);

	for (maxverts = 0, i = 0; i < count; i++)
		maxverts += ((1<<in[i].power)+1) * ((1<<in[i].power)+1);
	verts = plugfuncs->GMalloc(&mod->memgroup, maxverts*sizeof(*verts));
	xyz = plugfuncs->GMalloc(&mod->memgroup, maxverts*sizeof(*xyz));

	prv->displacements = out;
	prv->numdisplacements = count;
	for (i = 0; i < count; i++, out++, in++)
	{
		surf = mod->surfaces + in->faceidx;
		if (surf->numedges != 4)
		{
			Con_Printf ("VBSP_LoadDisplacements: displacement surface doesn't have 4 edges in %s\n",mod->name);
			return false;
		}

		//find the 4 verts... messy.
		for (x = 0; x < 4; x++)
		{
			e = mod->surfedges[surf->firstedge+x];
			idx = e < 0;
			if (idx)
				e = -e;
			if (e < 0 || e >= mod->numedges)
				sverts[x] = mod->vertexes[0].position;
			else
				sverts[x] = mod->vertexes[mod->edges[e].v[idx]].position;
		}

		//this is just stupid and pointless.
		//the in->position point tells us which point is the primary one, instead of just rotating the edges.
		primary = 0;
		pdist = FLT_MAX;
		for (x = 0; x < 4; x++)
		{
			VectorSubtract(sverts[x], in->position, p);
			dist = DotProduct(p,p);
			if (dist < pdist)
			{
				pdist = dist;
				primary = x;
			}
		}

		out->surf = surf;
		prv->surfdisp[in->faceidx] = out;	//the surface needs to be able to get its proper info when building vbos
		ClearBounds(out->aamin, out->aamax);
		out->contents = VBSP_TranslateContentBits(prv,in->contents);
		out->width = (1<<in->power);
		out->height = (1<<in->power);

		out->idx = indexes;
		stride = out->width+1;
		for (y=0 ; y<out->height ; y++)
		for (x=0 ; x<out->width ; x++)
		{
			if ((x+y)&1)
			{	//a diamond pattern - flipping alternately
				*indexes++ = (x+0)+(y+1)*stride;
				*indexes++ = (x+1)+(y+1)*stride;
				*indexes++ = (x+1)+(y+0)*stride;
				*indexes++ = (x+0)+(y+1)*stride;
				*indexes++ = (x+1)+(y+0)*stride;
				*indexes++ = (x+0)+(y+0)*stride;
			}
			else
			{
				*indexes++ = (x+0)+(y+0)*stride;
				*indexes++ = (x+0)+(y+1)*stride;
				*indexes++ = (x+1)+(y+1)*stride;
				*indexes++ = (x+0)+(y+0)*stride;
				*indexes++ = (x+1)+(y+1)*stride;
				*indexes++ = (x+1)+(y+0)*stride;
			}
		}
		out->numindexes = indexes - out->idx;

		inv = (void *)(mod_base + vl->fileofs);
		inv += in->firstvert;
		out->verts = verts;
		out->xyz = xyz;
		for (y = 0; y <= out->height; y++)
			for (x = 0; x <= out->width; x++)
			{
				//I have no idea if this is right. probably not. oh well.
				fx = (float)x/out->width;
				fy = (float)y/out->height;
				VectorClear(base);
				VectorMA(base, (1-fx)*(1-fy), sverts[(primary+0)&3], base);
				VectorMA(base, (1-fx)*(  fy), sverts[(primary+1)&3], base);
				VectorMA(base, (  fx)*(  fy), sverts[(primary+2)&3], base);
				VectorMA(base, (  fx)*(1-fy), sverts[(primary+3)&3], base);
				verts->st[0] = DotProduct(base, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3];
				verts->st[1] = DotProduct(base, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3];

				VectorScale(inv->norm, inv->dist*hl2_displacement_scale->value, p);
				VectorNormalize2(p, verts->norm);
				VectorAdd(base, p, (*xyz));
				verts->alpha = inv->alpha;
				AddPointToBounds((*xyz), out->aamin, out->aamax);

				inv++;
				verts++;
				xyz++;
			}

		surf->mesh->numindexes = out->numindexes;
		surf->mesh->numvertexes = verts-out->verts;
	}
	return true;
}

typedef struct
{
	short		planenum;
	qbyte		side;
	qbyte		onnode;	//o.O

	int			firstedge;		// we must support > 64k edges
	unsigned short		numedges;
	unsigned short		texinfo;

	unsigned short		dispinfo;
	short		fogvolume;

// lighting info
	qbyte		styles[4];
	int			lightofs;		// start of [numstyles*surfsize] samples
	float		surfacearea;
	int			extents_min[2];
	int			extents_size[2];

	int			origface;
	unsigned short numprims;
	unsigned short firstprim;
	unsigned int smoothinggroup;
} hl2dface_t;
static qboolean VBSP_LoadFaces (model_t *mod, qbyte *mod_base, vlump_t *lumps, int version)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	vlump_t *l = &lumps[VLUMP_FACES_LDR];
	vlump_t *l2 = &lumps[VLUMP_FACES_HDR];
	hl2dface_t	*in;
	msurface_t 	*out;
	int			i, count, surfnum;
	int			planenum;
	int			ti, st;
	int			lumpsize = sizeof(*in);

	mesh_t		*meshes;

	if (l2->filelen && !(hl2_favour_ldr->ival && lumps[VLUMP_LIGHTING_LDR].filelen))
		l = l2;

	if (version == 18)
	{	//this version seems to have rgbx*4 prefixed
		in = (void *)(mod_base + l->fileofs + 4*4);
		lumpsize += 4*4;
	}
	else
		in = (void *)(mod_base + l->fileofs);
	if (l->filelen % lumpsize)
	{
		Con_Printf ("VBSP_LoadFaces: funny lump size in %s\n",mod->name);
		return false;
	}
	count = l->filelen / lumpsize;
	out = plugfuncs->GMalloc(&mod->memgroup, count*sizeof(*out));
	prv->surfdisp = plugfuncs->GMalloc(&mod->memgroup, count * sizeof(*prv->surfdisp));

	meshes = plugfuncs->GMalloc(&mod->memgroup, count*sizeof(*meshes));

	mod->surfaces = out;
	mod->numsurfaces = count;

	mod->lightmaps.surfstyles = 1;

	for ( surfnum=0 ; surfnum<count ; surfnum++, in = (void*)((qbyte*)in+lumpsize), out++)
	{
		out->firstedge = LittleLong(in->firstedge);
		out->numedges = (unsigned short)LittleShort(in->numedges);
		out->flags = 0;
		out->mesh = meshes+surfnum;
		out->mesh->numvertexes = out->numedges;
		out->mesh->numindexes = (out->mesh->numvertexes-2)*3;

		planenum = (unsigned short)LittleShort(in->planenum);
		if (in->side)
			out->flags |= SURF_PLANEBACK;
		if (!in->onnode)
			out->flags |= SURF_OFFNODE;

		out->plane = mod->planes + planenum;

		ti = (unsigned short)LittleShort (in->texinfo);
		if (ti < 0 || ti >= mod->numtexinfo)
		{
			Con_Printf (CON_ERROR "VBSP_LoadFaces: bad texinfo number\n");
			return false;
		}
		out->texinfo = mod->texinfo + ti;

		if (out->texinfo->flags & TI_SKY)
		{
			out->flags |= SURF_DRAWSKY;
		}
		if (out->texinfo->flags & TI_WARP)
		{
			out->flags |= SURF_DRAWTURB|SURF_DRAWTILED;
		}

		out->lmshift = 0;
		out->texturemins[0] = in->extents_min[0];
		out->texturemins[1] = in->extents_min[1];
		out->extents[0] = in->extents_size[0];
		out->extents[1] = in->extents_size[1];

	// lighting info

		for (i=0 ; i<Q1Q2BSP_STYLESPERSURF ; i++)
		{
			st = in->styles[i];
			if (st == 255)
				st = INVALID_LIGHTSTYLE;
			else if (mod->lightmaps.maxstyle < st)
				mod->lightmaps.maxstyle = st;
			out->styles[i] = st;
		}
		for (; i<MAXCPULIGHTMAPS ; i++)
			out->styles[i] = INVALID_LIGHTSTYLE;
		for (i = 0; i<MAXRLIGHTMAPS ; i++)
			out->vlstyles[i] = INVALID_VLIGHTSTYLE;
		i = LittleLong(in->lightofs);
		if (i == -1 || !mod->lightdata)
			out->samples = NULL;
		else
			out->samples = mod->lightdata + i;

	// set the drawing flags

		if (out->texinfo->flags & TI_WARP)
			out->flags |= SURF_DRAWTURB;
	}

	return true;
}
#ifdef HAVE_CLIENT
static void VBSP_BuildSurfMesh(model_t *mod, msurface_t *surf, builddata_t *bd)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;

	unsigned int vertidx;
	int i, lindex, edgevert;
	mesh_t *mesh = surf->mesh;
	float *vec;
	float s, t, miss;
	int sty;
	struct vbsptexinfo_s *vtexinfo;

	//displacement surfaces...
	dispinfo_t *d = prv->surfdisp[surf-mod->surfaces];
	if (d)
	{
		struct dispvert_s *dv = d->verts;

		mesh->istrifan = false;

		memcpy(mesh->indexes, d->idx, sizeof(index_t)*d->numindexes);

		//output the renderable verticies
		for (i=0 ; i<mesh->numvertexes ; i++, dv++)
		{
			//xyz
			VectorCopy (d->xyz[i], mesh->xyz_array[i]);

			//st
			mesh->st_array[i][0] = dv->st[0];
			mesh->st_array[i][1] = dv->st[1];
			if (surf->texinfo->texture->vwidth)
				mesh->st_array[i][0] /= surf->texinfo->texture->vwidth;
			if (surf->texinfo->texture->vheight)
				mesh->st_array[i][1] /= surf->texinfo->texture->vheight;

			//lmst
			s = (float)(i%(d->width+1))/d->width;
			t = (float)(i/(d->width+1))/d->height;
			for (sty = 0; sty < 1; sty++)
			{
				mesh->lmst_array[sty][i][0] = (s*surf->extents[0] + surf->light_s[sty] + 0.5) / (mod->lightmaps.width);
				mesh->lmst_array[sty][i][1] = (t*surf->extents[1] + surf->light_t[sty] + 0.5) / (mod->lightmaps.height);
			}

			//normals
			VectorCopy(surf->plane->normal, mesh->normals_array[i]);
			VectorCopy(surf->texinfo->vecs[0], mesh->snormals_array[i]);
			VectorNegate(surf->texinfo->vecs[1], mesh->tnormals_array[i]);

			//rgba
			for (sty = 0; sty < 1; sty++)
			{
				mesh->colors4f_array[sty][i][0] = 1;
				mesh->colors4f_array[sty][i][1] = 1;
				mesh->colors4f_array[sty][i][2] = 1;
				mesh->colors4f_array[sty][i][3] = ((int)dv->alpha&255)/255.0;
			}
		}
		return;
	}

	//regular surfaces...
	mesh->istrifan = true;

	//output the mesh's indicies
	for (i=0 ; i<mesh->numvertexes-2 ; i++)
	{
		mesh->indexes[i*3] = 0;
		mesh->indexes[i*3+1] = i+1;
		mesh->indexes[i*3+2] = i+2;
	}
	//output the renderable verticies
	for (i=0 ; i<mesh->numvertexes ; i++)
	{
		lindex = mod->surfedges[surf->firstedge + i];
		edgevert = lindex <= 0;
		if (edgevert)
			lindex = -lindex;
		if (lindex < 0 || lindex >= mod->numedges)
			vertidx = 0;
		else
			vertidx = mod->edges[lindex].v[edgevert];
		vec = mod->vertexes[vertidx].position;

		s = DotProduct (vec, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3];
		t = DotProduct (vec, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3];

		VectorCopy (vec, mesh->xyz_array[i]);

		mesh->st_array[i][0] = s;
		mesh->st_array[i][1] = t;
		if (surf->texinfo->texture->vwidth)
			mesh->st_array[i][0] /= surf->texinfo->texture->vwidth;
		if (surf->texinfo->texture->vheight)
			mesh->st_array[i][1] /= surf->texinfo->texture->vheight;

		vtexinfo = &prv->texinfo[surf->texinfo-mod->texinfo];
		s = DotProduct (vec, vtexinfo->lmvecs[0]) + vtexinfo->lmvecs[0][3];
		t = DotProduct (vec, vtexinfo->lmvecs[1]) + vtexinfo->lmvecs[1][3];
		for (sty = 0; sty < 1; sty++)
		{
			mesh->lmst_array[sty][i][0] = (s - surf->texturemins[0] + (surf->light_s[sty]<<surf->lmshift) + (1<<surf->lmshift)*0.5) / (mod->lightmaps.width<<surf->lmshift);
			mesh->lmst_array[sty][i][1] = (t - surf->texturemins[1] + (surf->light_t[sty]<<surf->lmshift) + (1<<surf->lmshift)*0.5) / (mod->lightmaps.height<<surf->lmshift);
		}

		//figure out the texture directions, for bumpmapping and stuff
		if (surf->flags & SURF_PLANEBACK)
			VectorNegate(surf->plane->normal, mesh->normals_array[i]);
		else
			VectorCopy(surf->plane->normal, mesh->normals_array[i]);
		VectorCopy(surf->texinfo->vecs[0], mesh->snormals_array[i]);
		VectorNegate(surf->texinfo->vecs[1], mesh->tnormals_array[i]);
		//the s+t vectors are axis-aligned, so fiddle them so they're normal aligned instead
		miss = -DotProduct(mesh->normals_array[i], mesh->snormals_array[i]);
		VectorMA(mesh->snormals_array[i], miss, mesh->normals_array[i], mesh->snormals_array[i]);
		miss = -DotProduct(mesh->normals_array[i], mesh->tnormals_array[i]);
		VectorMA(mesh->tnormals_array[i], miss, mesh->normals_array[i], mesh->tnormals_array[i]);
		VectorNormalize(mesh->snormals_array[i]);
		VectorNormalize(mesh->tnormals_array[i]);

		//q1bsp has no colour information (fixme: sample from the lightmap?)
		for (sty = 0; sty < 1; sty++)
		{
			mesh->colors4f_array[sty][i][0] = 1;
			mesh->colors4f_array[sty][i][1] = 1;
			mesh->colors4f_array[sty][i][2] = 1;
			mesh->colors4f_array[sty][i][3] = 1;
		}
	}
}


static void VBSP_LoadLighting (model_t *mod, qbyte *mod_base, vlump_t *ldr, vlump_t *hdr)
{
	qbyte *src;
	unsigned int *out;
	size_t count;
	if (hdr->filelen && !(hl2_favour_ldr->ival && ldr->filelen))
	{
		mod->lightdatasize = hdr->filelen;
		src = (mod_base + hdr->fileofs);
	}
	else if (ldr->filelen)
	{
		mod->lightdatasize = ldr->filelen;
		src = (mod_base + ldr->fileofs);
	}
	else
		return;

	mod->lightmaps.fmt = LM_E5BGR9;
	mod->lightdata = (qbyte*)(out = plugfuncs->GMalloc(&mod->memgroup, mod->lightdatasize));

	//convert from linear e8bgr8 to srgb e5bgr9
	for (count = mod->lightdatasize/4; count --> 0; src+=4)
	{
		int e = 0;
		float m;
		float scale;
		unsigned int hdr;
		vec3_t rgb;

		//decode input
		m = pow(2, (signed char)src[3])/255.0;
		rgb[0] = m * src[0];
		rgb[1] = m * src[1];
		rgb[2] = m * src[2];

		//rescale its gamma ramp to something we can actually use properly
		rgb[0] = M_LinearToSRGB(rgb[0], 1.0);
		rgb[1] = M_LinearToSRGB(rgb[1], 1.0);
		rgb[2] = M_LinearToSRGB(rgb[2], 1.0);

		//encode output
		m = max(max(rgb[0], rgb[1]), rgb[2]);
		if (m < 0)
			m = 0;

		if (m >= 0.5)
		{	//positive exponent
			while (m >= (1<<(e)) && e < 30-15)	//don't do nans.
				e++;
		}
		else
		{	//negative exponent...
			while (m < 1/(1<<-e) && e > -14)	//don't do denormals.
				e--;
		}

		scale = pow(2, e-9);
		hdr = ((e+15)<<27);
		hdr |= bound(0, (int)(rgb[0]/scale + 0.5), 0x1ff)<<0;
		hdr |= bound(0, (int)(rgb[1]/scale + 0.5), 0x1ff)<<9;
		hdr |= bound(0, (int)(rgb[2]/scale + 0.5), 0x1ff)<<18;
		*out++ = hdr;
	}
}
#endif

typedef struct
{
	unsigned short planenum;
	short texinfo;
	unsigned short dispinfo;
	short bevel;
} hl2dbrushside_t;
static qboolean VBSP_LoadBrushSides (model_t *mod, qbyte *mod_base, vlump_t *l)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	unsigned int			i, j;
	q2cbrushside_t	*out;
	hl2dbrushside_t *in;
	int			count;
	int			num;

	in = (void *)(mod_base + l->fileofs);
	if (l->filelen % sizeof(*in))
	{
		Con_Printf (CON_ERROR "VBSP_LoadBrushSides: funny lump size\n");
		return false;
	}
	count = l->filelen / sizeof(*in);

	// need to save space for box planes
	if (count > SANITY_MAX_MAP_BRUSHSIDES)
	{
		Con_Printf (CON_ERROR "Map has too many brushsides (%i)\n", count);
		return false;
	}

	out = prv->brushsides = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * count);
	prv->numbrushsides = count;

	for ( i=0 ; i<count ; i++, in++, out++)
	{
		num = (unsigned short)LittleShort (in->planenum);
		out->plane = &mod->planes[num];
		j = (unsigned short)LittleShort (in->texinfo);
		if (j >= mod->numtexinfo)
			out->surface = &nullsurface;
		else
			out->surface = &prv->surfaces[j];
	}

	return true;
}

typedef struct {
	unsigned int count;
	struct {
		unsigned int id;
		unsigned short flags;
		unsigned short version;
		unsigned int ofs;
		unsigned int len;
	} sl[1];
} hlgamelumpheader_t;
static qboolean VBSP_LoadStaticProps(model_t *mod, qbyte *offset, size_t size, int version)	//present on server, because they're potentially solid.
{
	vbspinfo_t *prv = mod->meshinfo;
	struct {
		const char name[128];
	} *modelref;
	size_t nummodels, numleafrefs, numprops, i;
	unsigned short *leafref, *eleafref;
	struct staticprop_s *sent;
	entity_t *ent;

	size_t modelindex;

	qboolean skip = false;
	int dxlevel = 95, cpulevel=0, gpulevel=0;
	unsigned int leafcount, l;

	qbyte *prop;
	size_t propsize;
	switch(version)
	{
	case 4:
		propsize = 14*4;
		break;
	case 5:	//+scale
		propsize = 15*4;
		break;
	case 6://+dxlevels
		propsize = 16*4;
		break;
	case 7:	//+rgba
	case 8: //-dxlevels+[cg]pulevels
		propsize = 17*4;
		break;
	case 9:	//+360
	case 10://-360+flags
		propsize = 18*4;
		break;
	case 11://+scale
		propsize = 19*4;
		break;
	default:
		return true;	//version not supported, just ignore it entirely. sorry.
	}


	nummodels = LittleLong(*(int*)offset);
	offset	+= 4;
	size	-= 4;
	modelref = (void*)offset;
	offset	+= nummodels*sizeof(*modelref);
	size	-= nummodels*sizeof(*modelref);

	numleafrefs = LittleLong(*(int*)offset);
	offset	+= 4;
	size	-= 4;
	leafref = (void*)offset;
	offset	+= numleafrefs*sizeof(*leafref);
	size	-= numleafrefs*sizeof(*leafref);

	numprops = LittleLong(*(int*)offset);
	offset	+= 4;
	size	-= 4;
	prop = (void*)offset;
	offset	+= numprops*propsize;
	size	-= numprops*propsize;

	if (size)
		return true;	//funny lump size...

	prv->staticprops = plugfuncs->GMalloc(&mod->memgroup, sizeof(*prv->staticprops)*numprops);
	for (i = 0, sent = prv->staticprops; i < numprops; i++)
	{
		ent = &sent->ent;
		skip = false;
		ent->playerindex = -1;
		ent->topcolour = TOP_DEFAULT;
		ent->bottomcolour = BOTTOM_DEFAULT;
		ent->scale = 1;
		ent->shaderRGBAf[0] = 1;
		ent->shaderRGBAf[1] = 1;
		ent->shaderRGBAf[2] = 1;
		ent->shaderRGBAf[3] = 1;
		ent->framestate.g[FS_REG].frame[0] = 0;
		ent->framestate.g[FS_REG].lerpweight[0] = 1;


		ent->origin[0] = LittleFloat(*(float*)prop);					prop += sizeof(float);
		ent->origin[1] = LittleFloat(*(float*)prop);					prop += sizeof(float);
		ent->origin[2] = LittleFloat(*(float*)prop);					prop += sizeof(float);
		ent->angles[0] = LittleFloat(*(float*)prop);					prop += sizeof(float);
		ent->angles[1] = LittleFloat(*(float*)prop);					prop += sizeof(float);
		ent->angles[2] = LittleFloat(*(float*)prop);					prop += sizeof(float);
		modelindex = (unsigned short)LittleShort(*(short*)prop);		prop += sizeof(unsigned short);
		eleafref = leafref+(unsigned short)LittleShort(*(unsigned short*)prop);			prop += sizeof(unsigned short);
		leafcount = LittleShort(*(unsigned short*)prop);				prop += sizeof(unsigned short);
		sent->solid = *prop;											prop += sizeof(qbyte);
		/*ent->flags = *prop*/;											prop += sizeof(qbyte);
		ent->skinnum = LittleLong(*(unsigned int*)prop);				prop += sizeof(unsigned int);
		sent->fademindist = LittleFloat(*(float*)prop);					prop += sizeof(float);
		sent->fademaxdist = LittleFloat(*(float*)prop);					prop += sizeof(float);
		sent->lightorg[0] = LittleFloat(*(float*)prop);					prop += sizeof(float);
		sent->lightorg[1] = LittleFloat(*(float*)prop);					prop += sizeof(float);
		sent->lightorg[2] = LittleFloat(*(float*)prop);					prop += sizeof(float);
		if (version >= 5)
		{
			/*ent->fadescale = LittleFloat(*(float*)prop);*/			prop += sizeof(float);
		}
		if (version >= 8)
		{
			skip |= (prop[0] > cpulevel || cpulevel > prop[1]);			prop += sizeof(qbyte)*2;
			skip |= (prop[0] > gpulevel || gpulevel > prop[1]);			prop += sizeof(qbyte)*2;
		}
		else if (version >= 6)
		{
			unsigned short minlev, maxlev;
			minlev = LittleShort(*(unsigned short*)prop);				prop += sizeof(unsigned short);
			maxlev = LittleShort(*(unsigned short*)prop);				prop += sizeof(unsigned short);
			skip |= (minlev > dxlevel || dxlevel > maxlev);
		}
		if (version >= 7)
		{
			VectorScale(prop, 1/255.0, ent->shaderRGBAf);				prop += sizeof(qbyte)*4;
		}

		if (version == 9)
		{
			/*disablex360 = LittleLong(*(int*)prop);*/					prop += sizeof(int);
		}
		if (version >= 10)
		{
			ent->flags = LittleLong(*(int*)prop);						prop += sizeof(int);
		}
		if (version >= 11)
		{
			ent->scale = LittleFloat(*(float*)prop);					prop += sizeof(float);
		}

		//okay, we parsed the prop data now...
		skip |= modelindex >= nummodels;
		if (skip)
			continue;	//we're ignoring it for some reason
		ent->model = modfuncs->BeginSubmodelLoad(modelref[modelindex].name);
		modfuncs->AngleVectors(ent->angles, ent->axis[0], ent->axis[1], ent->axis[2]);
		VectorNegate(ent->axis[1],ent->axis[1]);

		//transforms, in case we need to recursively walk its bih
		VectorCopy(ent->axis[0], prv->staticprops[i].transform.axis[0]);
		VectorCopy(ent->axis[1], prv->staticprops[i].transform.axis[1]);
		VectorCopy(ent->axis[2], prv->staticprops[i].transform.axis[2]);
		VectorCopy(ent->origin, prv->staticprops[i].transform.origin);

		//Hack: special value to flag it for linking once we've loaded its model. this needs to go when we make them solid.
		if (leafcount > countof(ent->pvscache.leafnums))
			ent->pvscache.num_leafs = -2;	//overflow. calculate it later once its loaded.
		else
		{
			ent->pvscache.areanum = -1;	//FIXME
			ent->pvscache.areanum2 = -1;
			ent->pvscache.num_leafs = leafcount;	//overflow. calculate it later once its loaded.
			for (l = 0; l < leafcount; l++)
			{
				mleaf_t *lf = mod->leafs + *eleafref++;
				ent->pvscache.leafnums[l]/*actually clusters*/ = lf->cluster;
				//and try to track the areas too. not quite so reliable...
				if (ent->pvscache.areanum == -1)
					ent->pvscache.areanum = lf->area;
				else
					ent->pvscache.areanum2 = lf->area;
			}
		}
		//Hack: lighting is wrong.
//		ent->light_type = ELT_UNKNOWN;
		VectorSet(ent->light_dir, 0, 0.707, 0.707);
		VectorSet(ent->light_avg, 0.75, 0.75, 0.75);
		VectorSet(ent->light_range, 0.5, 0.5, 0.5);

		//not all props will be emitted, according to d3d levels...
		prv->numstaticprops++;
		sent++;
	}
	return true;
}
static qboolean VBSP_LoadGameLump(model_t *mod, qbyte *mod_base, vlump_t *l)
{
	size_t i;
	hlgamelumpheader_t *blob = (void*)(mod_base + l->fileofs);
	if (!l->filelen)
		return true; //missing
	if (l->filelen < sizeof(*blob) + sizeof(*blob->sl)*(blob->count-1))
		return false;	//not even enough space for the header...
	for (i = 0; i < blob->count; i++)
	{
#define LUMPTYPE(a,b,c,d, minver, maxver) (blob->sl[i].id == (((qbyte)a<<24)|((qbyte)b<<16)|((qbyte)c<<8)|((qbyte)d<<0)) && blob->sl[i].version >= minver && blob->sl[i].version <= maxver)
		if (LUMPTYPE('s','p','r','p', 4,10) && !blob->sl[i].flags)	//static props (placed by mapper)
			VBSP_LoadStaticProps(mod, mod_base+blob->sl[i].ofs/*sigh*/, blob->sl[i].len, blob->sl[i].version);
		else if (LUMPTYPE('d','p','r','p', 4,4) && !blob->sl[i].flags)	//dynamic props (generated by textures)
			;
		else if (LUMPTYPE('d','p','l','t', 0,0) && !blob->sl[i].flags)	//detail prop ldr lighting
			;
		else if (LUMPTYPE('d','p','l','h', 0,0) && !blob->sl[i].flags)	//detail prop hdr lighting
			;
		else
			Con_Printf("Unsupported gamelump id/version %c%c%c%c %i\n", (blob->sl[i].id>>24),(blob->sl[i].id>>16),(blob->sl[i].id>>8),(blob->sl[i].id>>0),blob->sl[i].version);
#undef LUMPTYPE
	}
	return true;
}

#ifdef HAVE_CLIENT
static void VBSP_GenerateMaterials(void *ctx, void *data, size_t a, size_t b)
{
	model_t *mod = ctx;
	const char *script;

	if (!a)
	{	//submodels share textures, so only do this if 'a' is 0 (inline index, 0 = world).
		for(a = 0; a < mod->numtextures; a++)
		{
			script = NULL;
			if (!strncmp(mod->textures[a]->name, "sky/", 4))
				script =
					"{\n"
						"sort sky\n"
						"surfaceparm nodlight\n"
						"skyparms - - -\n"
					"}\n";
			mod->textures[a]->shader = modfuncs->RegisterBasicShader(mod, mod->textures[a]->name, SUF_LIGHTMAP, script, PTI_INVALID, 0, 0, NULL, NULL);
		}
	}
	modfuncs->Batches_Build(mod, data);
	if (data)
		plugfuncs->Free(data);
}
#endif

/*
==================
CM_InlineModel
==================
*/
static cmodel_t	*VBSP_InlineModel (model_t *model, char *name)
{
	vbspinfo_t	*prv = (vbspinfo_t*)model->meshinfo;
	int		num;

	if (!name)
		Host_Error("Bad model\n");
	else if (name[0] != '*')
		Host_Error("Bad model\n");

	num = atoi (name+1);

	if (num < 1 || num >= prv->numcmodels)
		Host_Error ("CM_InlineModel: bad number");

	return &prv->cmodels[num];
}

static int VBSP_NumInlineModels (model_t *model)
{
	vbspinfo_t	*prv = (vbspinfo_t*)model->meshinfo;
	return prv->numcmodels;
}

static int VBSP_LeafContents (model_t *model, int leafnum)
{
	if (leafnum < 0 || leafnum >= model->numleafs)
		Host_Error ("CM_LeafContents: bad number");
	return model->leafs[leafnum].contents;
}

static int VBSP_LeafCluster (model_t *model, int leafnum)
{
	if (leafnum < 0 || leafnum >= model->numleafs)
		Host_Error ("CM_LeafCluster: bad number");
	return model->leafs[leafnum].cluster;
}

static int VBSP_LeafArea (model_t *model, int leafnum)
{
	if (leafnum < 0 || leafnum >= model->numleafs)
		Host_Error ("CM_LeafArea: bad number");
	return model->leafs[leafnum].area;
}

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

/*
==================
CM_PointLeafnum_r

==================
*/
static int VBSP_PointLeafnum_r (model_t *mod, const vec3_t p, int num)
{
	float		d;
	mnode_t		*node;
	mplane_t	*plane;

	while (num >= 0)
	{
		node = mod->nodes + num;
		plane = node->plane;

		if (plane->type < 3)
			d = p[plane->type] - plane->dist;
		else
			d = DotProduct (plane->normal, p) - plane->dist;
		if (d < 0)
			num = node->childnum[1];
		else
			num = node->childnum[0];
	}

	return -1 - num;
}

static int VBSP_PointLeafnum (model_t *mod, const vec3_t p)
{
	if (mod->loadstate != MLS_LOADED)
		return 0;		// sound may call this without map loaded
	return VBSP_PointLeafnum_r (mod, p, 0);
}

static int VBSP_PointCluster (model_t *mod, const vec3_t p, int *area)
{
	int leaf;
	if (mod->loadstate != MLS_LOADED)
		return 0;		// sound may call this without map loaded

	leaf = VBSP_PointLeafnum_r (mod, p, 0);
	if (area)
		*area = VBSP_LeafArea(mod, leaf);
	return VBSP_LeafCluster(mod, leaf);
}

static unsigned int VBSP_PointContents (model_t *mod, const vec3_t axis[3], const vec3_t p)
{
	vec3_t np;
	if (mod->loadstate != MLS_LOADED)
		return 0;

	if (axis)
	{
		np[0] = DotProduct(p, axis[0]);
		np[1] = DotProduct(p, axis[1]);
		np[2] = DotProduct(p, axis[2]);
		p = np;
	}

	return VBSP_LeafContents(mod, VBSP_PointLeafnum_r (mod, p, 0));
}

/*
=============
CM_BoxLeafnums

Fills in a list of all the leafs touched
=============
*/
static int		leaf_count, leaf_maxcount;
static int		*leaf_list;
static const float	*leaf_mins, *leaf_maxs;
static int		leaf_topnode;

static void VBSP_BoxLeafnums_r (model_t *mod, int nodenum)
{
	mplane_t	*plane;
	mnode_t		*node;
	int		s;

	while (1)
	{
		if (nodenum < 0)
		{
			if (leaf_count >= leaf_maxcount)
				return;
			leaf_list[leaf_count++] = -1 - nodenum;
			return;
		}

		node = &mod->nodes[nodenum];
		plane = node->plane;
//		s = BoxOnPlaneSide (leaf_mins, leaf_maxs, plane);
		s = BOX_ON_PLANE_SIDE(leaf_mins, leaf_maxs, plane);
		if (s == 1)
			nodenum = node->childnum[0];
		else if (s == 2)
			nodenum = node->childnum[1];
		else
		{	// go down both
			if (leaf_topnode == -1)
				leaf_topnode = nodenum;
			VBSP_BoxLeafnums_r (mod, node->childnum[0]);
			nodenum = node->childnum[1];
		}

	}
}

static int	VBSP_BoxLeafnums_headnode (model_t *mod, const vec3_t mins, const vec3_t maxs, int *list, int listsize, int headnode, int *topnode)
{
	leaf_list = list;
	leaf_count = 0;
	leaf_maxcount = listsize;
	leaf_mins = mins;
	leaf_maxs = maxs;

	leaf_topnode = -1;

	VBSP_BoxLeafnums_r (mod, headnode);

	if (topnode)
		*topnode = leaf_topnode;

	return leaf_count;
}

static int	VBSP_BoxLeafnums (model_t *mod, const vec3_t mins, const vec3_t maxs, int *list, int listsize, int *topnode)
{
	return VBSP_BoxLeafnums_headnode (mod, mins, maxs, list,
		listsize, mod->hulls[0].firstclipnode, topnode);
}

static void VBSP_FindTouchedLeafs(model_t *model, struct pvscache_s *ent, const float *mins, const float *maxs)
{
#define MAX_TOTAL_ENT_LEAFS		128
	int			leafs[MAX_TOTAL_ENT_LEAFS];
	int			clusters[MAX_TOTAL_ENT_LEAFS];
	int num_leafs;
	int			topnode;
	int i, j;
	int			area;
	int nullarea = -1;

	//ent->num_leafs == q2's ent->num_clusters
	ent->num_leafs = 0;
	ent->areanum = nullarea;
	ent->areanum2 = nullarea;

	if (!mins || !maxs)
		return;

	//get all leafs, including solids
	num_leafs = VBSP_BoxLeafnums (model, mins, maxs,
		leafs, MAX_TOTAL_ENT_LEAFS, &topnode);

	// set areas
	for (i=0 ; i<num_leafs ; i++)
	{
		clusters[i] = VBSP_LeafCluster (model, leafs[i]);
		area = VBSP_LeafArea (model, leafs[i]);
		if (area != nullarea)
		{	// doors may legally straggle two areas,
			// but nothing should ever need more than that
			if (ent->areanum != nullarea && ent->areanum != area)
				ent->areanum2 = area;
			else
				ent->areanum = area;
		}
	}

	if (num_leafs >= MAX_TOTAL_ENT_LEAFS)
	{	// assume we missed some leafs, and mark by headnode
		ent->num_leafs = -1;
		ent->headnode = topnode;
	}
	else
	{
		ent->num_leafs = 0;
		for (i=0 ; i<num_leafs ; i++)
		{
			if (clusters[i] == -1)
				continue;		// not a visible leaf
			for (j=0 ; j<i ; j++)
				if (clusters[j] == clusters[i])
					break;
			if (j == i)
			{
				if (ent->num_leafs == MAX_ENT_LEAFS)
				{	// assume we missed some leafs, and mark by headnode
					ent->num_leafs = -1;
					ent->headnode = topnode;
					break;
				}

				ent->leafnums[ent->num_leafs++] = clusters[i];
			}
		}
	}
}

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

BOX TRACING

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

static void VBSP_FinalizeBrush(q2cbrush_t *brush)
{
	vecV_t verts[256];
	vec4_t planes[256];
	int i, j;
	ClearBounds(brush->absmins, brush->absmaxs);
	for (i = 0; i < brush->numsides; i++)
	{
		VectorCopy(brush->brushside[i].plane->normal, planes[i]);
		planes[i][3] = brush->brushside[i].plane->dist;
	}
	for (i = 0; i < brush->numsides; i++)
	{
		//most brushes are axial, which can save some a little loadtime
		if (planes[i][0] == 1)
			brush->absmaxs[0] = planes[i][3];
		else if (planes[i][1] == 1)
			brush->absmaxs[1] = planes[i][3];
		else if (planes[i][2] == 1)
			brush->absmaxs[2] = planes[i][3];
		else if (planes[i][0] == -1)
			brush->absmins[0] = -planes[i][3];
		else if (planes[i][1] == -1)
			brush->absmins[1] = -planes[i][3];
		else if (planes[i][2] == -1)
			brush->absmins[2] = -planes[i][3];
		else
		{
			j = modfuncs->ClipPlaneToBrush(verts, countof(verts), planes, sizeof(planes[0]), brush->numsides, planes[i]);
			while (j-- > 0)
				AddPointToBounds(verts[j], brush->absmins, brush->absmaxs);
		}
	}
}

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

AREAPORTALS

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

static void FloodArea_r (vbspinfo_t	*prv, size_t areaidx, int floodnum)
{
	size_t		i;

	careaflood_t *flood = &prv->areaflood[areaidx];
	if (flood->floodvalid == prv->floodvalid)
	{
		if (flood->floodnum == floodnum)
			return;
		Con_Printf ("FloodArea_r: reflooded\n");
		return;
	}

	flood->floodnum = floodnum;
	flood->floodvalid = prv->floodvalid;

	{
		carea_t *area = &prv->areas[areaidx];
		q2dareaportal_t	*p = &prv->areaportals[area->firstareaportal];
		for (i=0 ; i<area->numareaportals ; i++, p++)
		{
			if (prv->portalopen[p->portalnum])
				FloodArea_r (prv, p->otherarea, floodnum);
		}
	}
}

/*
====================
FloodAreaConnections


====================
*/
static void	FloodAreaConnections (vbspinfo_t	*prv)
{
	size_t		i;
	int		floodnum;

	// all current floods are now invalid
	prv->floodvalid++;
	floodnum = 0;

	// area 0 is not used
	for (i=0 ; i<prv->numareas ; i++)
	{
		if (prv->areaflood[i].floodvalid == prv->floodvalid)
			continue;		// already flooded into
		floodnum++;
		FloodArea_r (prv, i, floodnum);
	}
}

static void	VBSP_SetAreaPortalState (model_t *mod, unsigned int portalnum, unsigned int area1, unsigned int area2, qboolean open)
{
	vbspinfo_t	*prv;
	prv = (vbspinfo_t*)mod->meshinfo;
	if (portalnum > prv->numareaportals)
		return;
	if (prv->portalopen[portalnum] == open)
		return;
	prv->portalopen[portalnum] = open;
	FloodAreaConnections (prv);
}

static qboolean	VBSP_AreasConnected (model_t *mod, unsigned int area1, unsigned int area2)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;

	if (map_noareas->value)
		return true;

	if (area1 == ~0 || area2 == ~0)
		return area1 == area2;
	if (area1 > prv->numareas || area2 > prv->numareas)
		Host_Error ("area > numareas");

	if (prv->areaflood[area1].floodnum == prv->areaflood[area2].floodnum)
		return true;
	return false;
}


/*
=================
CM_WriteAreaBits

Writes a length qbyte followed by a bit vector of all the areas
that area in the same flood as the area parameter

This is used by the client refreshes to cull visibility
=================
*/
static int VBSP_WriteAreaBits (model_t *mod, qbyte *buffer, int area, qboolean merge)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	int		i;
	int		floodnum;
	int		bytes;
	int		nullarea = 0;

	bytes = (prv->numareas+7)>>3;

	if (map_noareas->value || (area == nullarea && !merge))
	{	// for debugging, send everything
		if (!merge)
			memset (buffer, 255, bytes);
	}
	else
	{
		if (!merge)
			memset (buffer, 0, bytes);

		floodnum = prv->areaflood[area].floodnum;
		for (i=0 ; i<prv->numareas ; i++)
		{
			if (prv->areaflood[i].floodnum == floodnum)
				buffer[i>>3] |= 1<<(i&7);
		}
	}

	return bytes;
}

/*
===================
CM_WritePortalState

Returns a size+pointer to the data that needs to be written into a saved game. 
===================
*/
static size_t VBSP_SaveAreaPortalBlob (model_t *mod, void **data)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;

	*data = prv->portalopen;
	return sizeof(prv->portalopen);
}

/*
===================
CM_ReadPortalState

Reads the portal state from a savegame file
and recalculates the area connections
===================
*/
static size_t VBSP_LoadAreaPortalBlob (model_t *mod, void *ptr, size_t ptrsize)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;

	memcpy(prv->portalopen, ptr, min(ptrsize,sizeof(prv->portalopen)));

	FloodAreaConnections (prv);
	return sizeof(prv->portalopen);
}


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

PVS / PHS

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

/*
===================
CM_DecompressVis
===================
*/
static void VBSP_DecompressVis (model_t *mod, qbyte *in, qbyte *out, qboolean merge)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	int		c;
	qbyte	*out_p;
	int		row;

	row = (mod->numclusters+7)>>3;
	out_p = out;

	if (!in || !prv->numvisibility)
	{	// no vis info, so make all visible
		while (row)
		{
			*out_p++ = 0xff;
			row--;
		}
		return;
	}

	if (merge)
	{
		do
		{
			if (*in)
			{
				*out_p++ |= *in++;
				continue;
			}

			out_p += in[1];
			in += 2;
		} while (out_p - out < row);
	}
	else
	{
		do
		{
			if (*in)
			{
				*out_p++ = *in++;
				continue;
			}

			c = in[1];
			in += 2;
			if ((out_p - out) + c > row)
			{
				c = row - (out_p - out);
				Con_DPrintf ("warning: Vis decompression overrun\n");
			}
			while (c)
			{
				*out_p++ = 0;
				c--;
			}
		} while (out_p - out < row);
	}
}

static pvsbuffer_t	pvsrow;
static pvsbuffer_t	phsrow;



static qbyte	*VBSP_ClusterPVS (model_t *mod, int cluster, pvsbuffer_t *buffer, pvsmerge_t merge)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	if (!buffer)
		buffer = &pvsrow;
	if (buffer->buffersize < mod->pvsbytes)
		buffer->buffer = plugfuncs->Realloc(buffer->buffer, buffer->buffersize=mod->pvsbytes);

	if (cluster == -1)
		memset (buffer->buffer, 0, (mod->numclusters+7)>>3);
	else
		VBSP_DecompressVis (mod, ((qbyte*)prv->vis) + prv->vis->bitofs[cluster][DVIS_PVS], buffer->buffer, merge==PVM_MERGE);
	return buffer->buffer;
}

static qbyte	*VBSP_ClusterPHS (model_t *mod, int cluster, pvsbuffer_t *buffer)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;

	if (!buffer)
		buffer = &phsrow;
	if (buffer->buffersize < mod->pvsbytes)
		buffer->buffer = plugfuncs->Realloc(buffer->buffer, buffer->buffersize=mod->pvsbytes);

	if (cluster == -1)
		memset (buffer->buffer, 0, (mod->numclusters+7)>>3);
	else
		VBSP_DecompressVis (mod, ((qbyte*)prv->vis) + prv->vis->bitofs[cluster][DVIS_PHS], buffer->buffer, false);
	return buffer->buffer;
}

static unsigned int  VBSP_FatPVS (model_t *mod, const vec3_t org, pvsbuffer_t *result, qboolean merge)
{
	int	leafs[64];
	int		i, j, count;
	vec3_t	mins, maxs;

	for (i=0 ; i<3 ; i++)
	{
		mins[i] = org[i] - 8;
		maxs[i] = org[i] + 8;
	}

	count = VBSP_BoxLeafnums (mod, mins, maxs, leafs, countof(leafs), NULL);
	if (count < 1)
		Sys_Errorf ("SV_Q2FatPVS: count < 1");

	// convert leafs to clusters
	for (i=0 ; i<count ; i++)
		leafs[i] = VBSP_LeafCluster(mod, leafs[i]);

	//grow the buffer if needed
	if (result->buffersize < mod->pvsbytes)
		result->buffer = plugfuncs->Realloc(result->buffer, result->buffersize=mod->pvsbytes);

	if (count == 1 && leafs[0] == -1)
	{	//if the only leaf is the outside then broadcast it.
		memset(result->buffer, 0xff, mod->pvsbytes);
		i = count;
	}
	else
	{
		i = 0;
		if (!merge)
			mod->funcs.ClusterPVS(mod, leafs[i++], result, PVM_REPLACE);
		// or in all the other leaf bits
		for ( ; i<count ; i++)
		{
			for (j=0 ; j<i ; j++)
				if (leafs[i] == leafs[j])
					break;
			if (j != i)
				continue;		// already have the cluster we want
			mod->funcs.ClusterPVS(mod, leafs[i], result, PVM_MERGE);
		}
	}
	return mod->pvsbytes;
}

/*
=============
CM_HeadnodeVisible

Returns true if any leaf under headnode has a cluster that
is potentially visible
=============
*/
static qboolean VBSP_HeadnodeVisible (model_t *mod, int nodenum, const qbyte *visbits)
{
	int		leafnum;
	int		cluster;
	mnode_t	*node;

	if (nodenum < 0)
	{
		leafnum = -1-nodenum;
		cluster = mod->leafs[leafnum].cluster;
		if (cluster == -1)
			return false;
		if (visbits[cluster>>3] & (1<<(cluster&7)))
			return true;
		return false;
	}

	node = &mod->nodes[nodenum];
	if (VBSP_HeadnodeVisible(mod, node->childnum[0], visbits))
		return true;
	return VBSP_HeadnodeVisible(mod, node->childnum[1], visbits);
}

static qboolean VBSP_EdictInFatPVS(model_t *mod, const pvscache_t *ent, const qbyte *pvs, const int *areas)
{
	int i,l;
	int nullarea = 0;
	if (areas)
	{
		for (i = 1; ; i++)
		{
			if (i > areas[0])
				return false;	//none of the camera's areas could see the entity
			if (areas[i] == ent->areanum)
			{
				if (areas[i] != nullarea)
					break;
				//else entity is fully outside the world, invisible to all...
			}
			else if (VBSP_AreasConnected (mod, areas[i], ent->areanum))
				break;
			// doors can legally straddle two areas, so
			// we may need to check another one
			else if (ent->areanum2 != nullarea && VBSP_AreasConnected (mod, areas[i], ent->areanum2))
				break;
		}
	}

	if (ent->num_leafs == -1)
	{	// too many leafs for individual check, go by headnode
		if (!VBSP_HeadnodeVisible (mod, ent->headnode, pvs))
			return false;
	}
	else
	{	// check individual leafs
		for (i=0 ; i < ent->num_leafs ; i++)
		{
			l = ent->leafnums[i];
			if (pvs[l >> 3] & (1 << (l&7) ))
				break;
		}
		if (i == ent->num_leafs)
			return false;		// not visible
	}
	return true;
}


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

Collision Stuff.

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

static void VBSP_BuildBIHSubmodel(model_t *mod, int submodel)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	cmodel_t	*sub = &prv->cmodels[submodel];

	struct bihleaf_s *bihleaf, *l;
	size_t i;

	bihleaf = l = plugfuncs->Malloc(sizeof(*bihleaf)*sub->num_brushes);
	for (i = 0; i < sub->num_brushes; i++)
	{
		q2cbrush_t *b = &prv->brushes[sub->firstbrush+i];
		l->type = BIH_BRUSH;
		l->data.brush = b;

		l->data.contents = b->contents;
		VectorCopy(b->absmins, l->mins);
		VectorCopy(b->absmaxs, l->maxs);
		l++;
	}

	modfuncs->BIH_Build(mod, bihleaf, l-bihleaf);
	plugfuncs->Free(bihleaf);
}
static void VBSP_BuildBIHMain(void *ctx, void *unusedp, size_t unuseda, size_t unusedb)
{	//NOTE: must be on main thread because we're waiting for submodels for their size.
	model_t		*mod = ctx;
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	cmodel_t	*sub = &prv->cmodels[0];

	struct bihleaf_s *bihleaf, *l;
	size_t bihleafs, i;

	bihleafs = sub->num_brushes;
	for (i = 0; i < prv->numdisplacements; i++)
		bihleafs += prv->displacements[i].numindexes/3;
	for (i = 0; i < prv->numstaticprops; i++)
	{
		if (prv->staticprops[i].solid)
		{
			if (prv->staticprops[i].ent.model && prv->staticprops[i].ent.model->loadstate == MLS_NOTLOADED)
				modfuncs->GetModel(prv->staticprops[i].ent.model->publicname, MLV_WARN);	//we use threads, so these'll load in time.
			bihleafs++;
		}
	}

	bihleaf = l = plugfuncs->Malloc(sizeof(*bihleaf)*bihleafs);

	//now we have enough storage, spit them out providing bounds info.
	for (i = 0; i < sub->num_brushes; i++)
	{
		q2cbrush_t *b = &prv->brushes[sub->firstbrush+i];
		l->type = BIH_BRUSH;
		l->data.brush = b;

		l->data.contents = b->contents;
		VectorCopy(b->absmins, l->mins);
		VectorCopy(b->absmaxs, l->maxs);
		l++;
	}
	for (i = 0; i < prv->numdisplacements; i++)
	{
		dispinfo_t *d = &prv->displacements[i];

		size_t j;
		for (j = 0; j < d->numindexes; j+=3)
		{
			index_t *v = d->idx+j;
			vec_t *v1 = d->xyz[v[0]], *v2 = d->xyz[v[1]], *v3 = d->xyz[v[2]];

			l->type = BIH_TRIANGLE;
			l->data.tri.xyz = d->xyz;
			l->data.tri.indexes = v;

			l->data.contents = d->contents;
			VectorCopy(v1, l->mins);
			VectorCopy(v1, l->maxs);
			AddPointToBounds(v2, l->mins, l->maxs);
			AddPointToBounds(v3, l->mins, l->maxs);
			l++;
		}
	}
	for (i = 0; i < prv->numstaticprops; i++)
	{
		if (!prv->staticprops[i].solid)
			continue;

		l->type = BIH_MODEL;
		l->data.mesh.model = prv->staticprops[i].ent.model;
		l->data.mesh.tr = &prv->staticprops[i].transform;

		//*cry*
		while (l->data.mesh.model->loadstate==MLS_LOADING)
			threadfuncs->WaitForCompletion(l->data.mesh.model, &l->data.mesh.model->loadstate, MLS_LOADING);

		if (!l->data.mesh.model || !l->data.mesh.model->funcs.NativeTrace || !l->data.mesh.model->funcs.NativeContents)
		{
			Con_Printf("%s has no collision info and must not be used as a solid static prop\n", l->data.mesh.model->name);
			continue;
		}

		l->data.contents = ~0u; //yuck!

		//a clever person could probably do a better job.
		l->mins[0] = prv->staticprops[i].ent.origin[0] - l->data.mesh.model->radius;
		l->mins[1] = prv->staticprops[i].ent.origin[1] - l->data.mesh.model->radius;
		l->mins[2] = prv->staticprops[i].ent.origin[2] - l->data.mesh.model->radius;
		l->maxs[0] = prv->staticprops[i].ent.origin[0] + l->data.mesh.model->radius;
		l->maxs[1] = prv->staticprops[i].ent.origin[1] + l->data.mesh.model->radius;
		l->maxs[2] = prv->staticprops[i].ent.origin[2] + l->data.mesh.model->radius;
		l++;
	}

	modfuncs->BIH_Build(mod, bihleaf, l-bihleaf);
	plugfuncs->Free(bihleaf);

	mod->funcs.PointContents		= VBSP_PointContents;

	//and make sure we finished checksumming, too.
	threadfuncs->WaitForCompletion(mod, &prv->summed, false);
}

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

Rendering stuff

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

#ifdef HAVE_CLIENT
static qboolean VBSP_CullBox (vec3_t mins, vec3_t maxs)
{
	//this isn't very precise.
	//checking each plane individually can be problematic
	//if you have a large object behind the view, it can cross multiple planes, and be infront of each one at some point, yet should still be outside the view.
	//this is quite noticable with terrain where the potential height of a section is essentually infinite.
	//note that this is not a concern for spheres, just boxes.
	int		i;

	for (i = 0; i < refdef->frustum_numplanes; i++)
		if (BOX_ON_PLANE_SIDE (mins, maxs, &refdef->frustum[i]) == 2)
			return true;
	return false;
}
static void VBSP_RecursiveWorldNode (model_t *model, mnode_t *node)
{
	int			c, side;
	mplane_t	*plane;
	msurface_t	*surf, **mark;
	mleaf_t		*pleaf;
	double		dot;

	int sidebit;

	if (node->contents == FTECONTENTS_SOLID)
		return;		// solid

	if (node->visframe != vbsp_nodesequence)
		return;
	if (VBSP_CullBox (node->minmaxs, node->minmaxs+3))
		return;

// if a leaf node, draw stuff
	if (node->contents != -1)
	{
		pleaf = (mleaf_t *)node;

		// check for door connected areas
		if (! (refdef->areabits[pleaf->area>>3] & (1<<(pleaf->area&7)) ) )
			return;		// not visible

		c = pleaf->cluster;
		if (c >= 0)
			frustumvis[c>>3] |= 1<<(c&7);

		mark = pleaf->firstmarksurface;
		c = pleaf->nummarksurfaces;

		if (c)
		{
			do
			{
				surf = *mark++;
				if (surf->flags & SURF_OFFNODE)
				{
					if (surf->visframe != vbsp_surfsequence)
					{	//only add once, it might be in multiple leafs.
						surf->visframe = vbsp_surfsequence;
						modfuncs->RenderDynamicLightmaps (surf);
						surf->sbatch->mesh[surf->sbatch->meshes++] = surf->mesh;
					}
				}
				else
					surf->visframe = vbsp_surfsequence;
			} while (--c);
		}
		return;
	}

// node is just a decision point, so go down the apropriate sides

// find which side of the node we are on
	plane = node->plane;

	switch (plane->type)
	{
	case PLANE_X:
		dot = modelorg[0] - plane->dist;
		break;
	case PLANE_Y:
		dot = modelorg[1] - plane->dist;
		break;
	case PLANE_Z:
		dot = modelorg[2] - plane->dist;
		break;
	default:
		dot = DotProduct (modelorg, plane->normal) - plane->dist;
		break;
	}

	if (dot >= 0)
	{
		side = 0;
		sidebit = 0;
	}
	else
	{
		side = 1;
		sidebit = SURF_PLANEBACK;
	}

// recurse down the children, front side first
	VBSP_RecursiveWorldNode (model, node->children[side]);

	// draw stuff
	for ( c = node->numsurfaces, surf = model->surfaces + node->firstsurface; c ; c--, surf++)
	{
		if (surf->visframe != vbsp_surfsequence)
			continue;

		if ( (surf->flags & SURF_PLANEBACK) != sidebit )
			continue;		// wrong side

		surf->visframe = 0;//vbsp_surfsequence;//-1;

		modfuncs->RenderDynamicLightmaps (surf);

		surf->sbatch->mesh[surf->sbatch->meshes++] = surf->mesh;
	}


// recurse down the back side
	VBSP_RecursiveWorldNode (model, node->children[!side]);
}
static qbyte *VBSP_MarkLeaves (model_t *model, int clusters[2])
{
	vbspinfo_t	*prv = (vbspinfo_t*)model->meshinfo;
	mnode_t	*node;
	int		i;

	int cluster;
	mleaf_t	*leaf;
	qbyte *vis;

	int portal = refdef->recurse;

	if (refdef->forcevis)
	{
		vis = refdef->forcedvis;
		prv->vcache.vis = NULL;
	}
	else if (portal || hl2_novis->ival || clusters[0] == -1 || !model->vis)
		return NULL;	//use some blind whole-model thing
	else
	{
		vis = prv->vcache.vis;
		if (prv->vcache.viewcluster[0] == clusters[0] && prv->vcache.viewcluster[1] == clusters[1] && vis)
			return vis;

		if (clusters[1] != clusters[0])	// may have to combine two clusters because of solid water boundaries
		{
			vis = VBSP_ClusterPVS (model, clusters[0], &prv->vcache.visbuf, PVM_REPLACE);
			vis = VBSP_ClusterPVS (model, clusters[1], &prv->vcache.visbuf, PVM_MERGE);
		}
		else
			vis = VBSP_ClusterPVS (model, clusters[0], &prv->vcache.visbuf, PVM_FAST);
		prv->vcache.vis = vis;
		prv->vcache.viewcluster[0] = clusters[0];
		prv->vcache.viewcluster[1] = clusters[1];
	}

	vbsp_nodesequence++;

	for (i=0,leaf=model->leafs ; i<model->numleafs ; i++, leaf++)
	{
		cluster = leaf->cluster;
		if (cluster == -1)
			continue;
		if (vis[cluster>>3] & (1<<(cluster&7)))
		{
			node = (mnode_t *)leaf;
			do
			{
				if (node->visframe == vbsp_nodesequence)
					break;
				node->visframe = vbsp_nodesequence;
				node = node->parent;
			} while (node);
		}
	}
	return vis;
}
static void VBSP_PrepareFrame(model_t *mod, refdef_t *r_refdef, int area, int clusters[2], pvsbuffer_t *vis, qbyte **entvis_out, qbyte **surfvis_out)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	qbyte *surfvis, *entvis;

	refdef = r_refdef;

	if (vis->buffersize < mod->pvsbytes)
		vis->buffer = plugfuncs->Realloc(vis->buffer, vis->buffersize=mod->pvsbytes);
	frustumvis = vis->buffer;
	memset(frustumvis, 0, mod->pvsbytes);

	if (!r_refdef->areabitsknown)
	{	//generate the info each frame, as the gamecode didn't tell us what to use.
		int leafnum = VBSP_PointLeafnum (mod, r_refdef->vieworg);
		int clientarea = VBSP_LeafArea (mod, leafnum);
		VBSP_WriteAreaBits(mod, r_refdef->areabits, clientarea, false);
		r_refdef->areabitsknown = true;
	}


	entvis = surfvis = VBSP_MarkLeaves(mod, clusters);
	VectorCopy (r_refdef->vieworg, modelorg);
	if (!surfvis)
	{
		size_t i;
		msurface_t *surf;
		for (i = 0; i < mod->nummodelsurfaces; i++)
		{
			surf = &mod->surfaces[i];
			modfuncs->RenderDynamicLightmaps (surf);
			surf->sbatch->mesh[surf->sbatch->meshes++] = surf->mesh;
		}
	}
	else
	{
		size_t i;
		dispinfo_t *disp;
		msurface_t *surf;
		int areas[2];
		areas[0] = 1;
		areas[1] = area;
		vbsp_surfsequence++;
		VBSP_RecursiveWorldNode (mod, mod->nodes);
		for (i = 0; i < prv->numdisplacements; i++)
		{
			disp = &prv->displacements[i];
			if (VBSP_EdictInFatPVS(mod, &disp->pvs, surfvis, areas))
			{
				surf = disp->surf;
				modfuncs->RenderDynamicLightmaps (surf);
				surf->sbatch->mesh[surf->sbatch->meshes++] = surf->mesh;
			}
		}
	}

	*surfvis_out = frustumvis;
	*entvis_out = entvis;



	if (prv->numstaticprops)
	{
		struct staticprop_s *sent;
		entity_t *src, *ent;
		float d;
		size_t i;
		vec3_t disp;
		for (i = 0; i < prv->numstaticprops; i++)
		{
			sent = &prv->staticprops[i];
			src = &sent->ent;

			if (sent->fademaxdist)
			{
				VectorSubtract(refdef->vieworg, src->origin, disp);
				d = VectorLength(disp);
				if (d > sent->fademaxdist)
					continue;	//skip it.
				d -= sent->fademindist;
				d /= sent->fademaxdist-sent->fademindist;
				if (d < 0)
					d = 0;
			}
			else
				d = 0;

			if (!src->model || src->model->loadstate != MLS_LOADED)
			{
				if (src->model && src->model->loadstate == MLS_NOTLOADED)
					modfuncs->GetModel(src->model->publicname, MLV_WARN);	//we use threads, so these'll load in time.
				continue;
			}
			/*if (!src->light_known)
			{
				vec3_t tmp;
				VectorCopy(src->origin, tmp);
				VectorCopy(sent->lightorg, src->origin);
				R_CalcModelLighting(src, src->model);	//bake and cache, now everything else is working.
				VectorCopy(tmp, src->origin);
			}*/
			if (src->pvscache.num_leafs==-2)
			{
				vec3_t absmin, absmax;
				float r = src->model->radius;
				VectorSet(absmin, -r,-r,-r);
				VectorSet(absmax, r,r,r);
				VectorAdd(absmin, src->origin, absmin);
				VectorAdd(absmax, src->origin, absmax);
				VBSP_FindTouchedLeafs(mod, &src->pvscache, absmin, absmax);
			}

			ent = modfuncs->NewSceneEntity();
			if (!ent)
				return;
			*ent = *src;
			ent->framestate.g[FS_REG].frametime[0] = refdef->time;
			ent->framestate.g[FS_REG].frametime[1] = refdef->time;
			if (d)
			{
				ent->shaderRGBAf[3] *= 1-d;
				ent->flags |= RF_TRANSLUCENT;
			}
		}
	}
}
static void VBSP_InfoForPoint (struct model_s *mod, vec3_t pos, int *area, int *cluster, unsigned int *contentbits)
{
	int leaf = VBSP_PointLeafnum_r (mod, pos, 0);
	*area = VBSP_LeafArea(mod, leaf);
	*cluster = VBSP_LeafCluster(mod, leaf);
	*contentbits = VBSP_LeafContents(mod, leaf);
}


#ifdef RTLIGHTS
static int vbsp_shadowsequence;
static qbyte *shadowedpvs;
static model_t *shadowmodel;
static void VBSP_WalkShadows (dlight_t *dl, void (*callback)(msurface_t *surf), mnode_t *node)
{
	int			c, side;
	mplane_t	*plane;
	msurface_t	*surf, **mark;
	mleaf_t		*pleaf;
	double		dot;

	float		l, maxdist;
	int			j, s, t;
	vec3_t		impact;
	struct vbsptexinfo_s *vtexinfo;
	vbspinfo_t *prv;

	if (node->shadowframe != vbsp_shadowsequence)
		return;

	//if light areabox is outside node, ignore node + children
	for (c = 0; c < 3; c++)
	{
		if (dl->origin[c] + dl->radius < node->minmaxs[c])
			return;
		if (dl->origin[c] - dl->radius > node->minmaxs[3+c])
			return;
	}

// if a leaf node, draw stuff
	if (node->contents != -1)
	{
		pleaf = (mleaf_t *)node;

		if (pleaf->cluster >= 0)
			shadowedpvs[pleaf->cluster>>3] |= 1<<(pleaf->cluster&7);

		mark = pleaf->firstmarksurface;
		c = pleaf->nummarksurfaces;

		if (c)
		{
			do
			{
				surf = *mark++;
				if (surf->flags & SURF_OFFNODE)
				{
					if (surf->shadowframe != vbsp_shadowsequence)
					{	//if its not on a node then its probably not a nice flat surface, so don't bother trying to cull it in fancy ways that depend on its plane.
						surf->shadowframe = vbsp_shadowsequence;
						callback(surf);
					}
				}
				else
					surf->shadowframe = vbsp_shadowsequence;
			} while (--c);
		}
		return;
	}

// node is just a decision point, so go down the apropriate sides

// find which side of the node we are on
	plane = node->plane;

	switch (plane->type)
	{
	case PLANE_X:
		dot = dl->origin[0] - plane->dist;
		break;
	case PLANE_Y:
		dot = dl->origin[1] - plane->dist;
		break;
	case PLANE_Z:
		dot = dl->origin[2] - plane->dist;
		break;
	default:
		dot = DotProduct (dl->origin, plane->normal) - plane->dist;
		break;
	}

	if (dot >= 0)
		side = 0;
	else
		side = 1;

// recurse down the children, front side first
	VBSP_WalkShadows (dl, callback, node->children[side]);

// draw stuff
  	c = node->numsurfaces;
	if (c)
	{
		prv = shadowmodel->meshinfo;
		surf = shadowmodel->surfaces + node->firstsurface;
		maxdist = dl->radius*dl->radius;
		for ( ; c ; c--, surf++)
		{
			if (surf->shadowframe != vbsp_shadowsequence)
				continue;

			if ((dot < 0) ^ !!(surf->flags & SURF_PLANEBACK))
				continue;		// wrong side

/*			if (surf->flags & (SURF_DRAWALPHA | SURF_DRAWTILED))
			{	// no shadows
				continue;
			}*/

			//is the light on the right side?
			if (surf->flags & SURF_PLANEBACK)
			{//inverted normal.
				if (-DotProduct(surf->plane->normal, dl->origin)+surf->plane->dist >= dl->radius)
					continue;
			}
			else
			{
				if (DotProduct(surf->plane->normal, dl->origin)-surf->plane->dist >= dl->radius)
					continue;
			}

			//Yeah, you can blame LordHavoc for this alternate code here.
			for (j=0 ; j<3 ; j++)
				impact[j] = dl->origin[j] - surf->plane->normal[j]*dot;

			vtexinfo = &prv->texinfo[surf->texinfo-shadowmodel->texinfo];
			// clamp center of light to corner and check brightness
			l = DotProduct (impact, vtexinfo->lmvecs[0]) + vtexinfo->lmvecs[0][3] - surf->texturemins[0];
			s = l;if (s < 0) s = 0;else if (s > surf->extents[0]) s = surf->extents[0];
			s = (l - s)*surf->texinfo->vecscale[0];
			l = DotProduct (impact, vtexinfo->lmvecs[1]) + vtexinfo->lmvecs[1][3] - surf->texturemins[1];
			t = l;if (t < 0) t = 0;else if (t > surf->extents[1]) t = surf->extents[1];
			t = (l - t)*surf->texinfo->vecscale[1];
			// compare to minimum light
			if ((s*s+t*t+dot*dot) < maxdist)
				callback(surf);
		}
	}

// recurse down the back side
	VBSP_WalkShadows (dl, callback, node->children[!side]);
}

static void VBSP_MarkShadows(model_t *model, dlight_t *dl, const qbyte *lvis)
{
	mnode_t *node;
	int i;
	mleaf_t *leaf;
	int cluster;

//	if (!dl->die)
	{
		//static
		//variation on mark leaves
		for (i=0,leaf=model->leafs ; i<model->numleafs ; i++, leaf++)
		{
			cluster = leaf->cluster;
			if (cluster == -1)
				continue;
			if (lvis[cluster>>3] & (1<<(cluster&7)))
			{
				node = (mnode_t *)leaf;
				do
				{
					if (node->shadowframe == vbsp_shadowsequence)
						break;
					node->shadowframe = vbsp_shadowsequence;
					node = node->parent;
				} while (node);
			}
		}
	}
/*	else
	{
		//dynamic lights will be discarded after this frame anyway, so only include leafs that are visible
		//variation on mark leaves
		for (i=0,leaf=model->leafs ; i<model->numleafs ; i++, leaf++)
		{
			cluster = leaf->cluster;
			if (cluster == -1)
				continue;
			if (lvis[cluster>>3] & (1<<(cluster&7)))
			{
				node = (mnode_t *)leaf;
				do
				{
					if (node->shadowframe == vbsp_shadowsequence)
						break;
					node->shadowframe = vbsp_shadowsequence;
					node = node->parent;
				} while (node);
			}
		}
	}*/
}
static void VBSP_GenerateShadowMesh(model_t *model, dlight_t *dl, const qbyte *lightvis, qbyte *litvis, void (*callback)(msurface_t *surf))
{
	vbspinfo_t *prv = model->meshinfo;
	dispinfo_t *disp;
	int i;
	//globals are evil
	shadowmodel = model;
	shadowedpvs = litvis;	//this is an output
	vbsp_shadowsequence++;

	VBSP_MarkShadows(model, dl, lightvis);

	VBSP_WalkShadows(dl, callback, model->nodes);

	for (i = 0; i < prv->numdisplacements; i++)
	{
		disp = &prv->displacements[i];
		if (VBSP_EdictInFatPVS(model, &disp->pvs, litvis, NULL))
		{
			callback(disp->surf);
		}
	}
}
#endif




static void VBSP_LoadLeafLight (model_t *mod, qbyte *mod_base, vlump_t *hdridx, vlump_t *ldridx, vlump_t *hdrvals, vlump_t *ldrvals, int version)
{
	vbspinfo_t	*prv = (vbspinfo_t*)mod->meshinfo;
	vlump_t *lump_idx, *lump_vals;
	struct leaflightpoint_s *point;
	size_t i, j;
	unsigned short *in;
	qbyte *inpoint;

	if (version < 20)
		return; //nope. this info is in the leafs.

	if (hdridx && hdrvals)
		lump_idx = hdridx, lump_vals = hdrvals;
	else if (ldridx && ldrvals)
		lump_idx = ldridx, lump_vals = ldrvals;
	else
		return;	//unsupported.

	if (lump_vals->filelen%(7*4))
		return;

	if (lump_idx->filelen != mod->numleafs*sizeof(short)*2)
		return;	//erk?

	//easy enough to load some of the data...
	point = plugfuncs->GMalloc(&mod->memgroup, sizeof(*point)*(lump_vals->filelen/(7*4)));
	inpoint = mod_base + lump_vals->fileofs;
	for (i = 0; i < lump_vals->filelen/(7*4); i++)
	{
		for (j = 0; j < 6; j++, inpoint+=4)
		{
			float e = pow(2, (signed char)inpoint[3]);
			point[i].rgb[j][0] = e * inpoint[0];
			point[i].rgb[j][1] = e * inpoint[1];
			point[i].rgb[j][2] = e * inpoint[2];
		}
		point[i].x = *inpoint++;
		point[i].y = *inpoint++;
		point[i].z = *inpoint++;
		inpoint++;
	}

	prv->leaflight = plugfuncs->GMalloc(&mod->memgroup, sizeof(*prv->leaflight)*mod->numleafs);
	in = (unsigned short*)(mod_base + lump_idx->fileofs);
	for (i = 0; i < mod->numleafs; i++)
	{
		prv->leaflight[i].count = LittleShort(*in++);
		prv->leaflight[i].point = point + (unsigned short)LittleShort(*in++);
	}
}
static void VBSP_LightPointValues	(struct model_s *model, const vec3_t point, vec3_t res_diffuse, vec3_t res_ambient, vec3_t res_dir)
{
	vbspinfo_t	*prv = (vbspinfo_t*)model->meshinfo;
	int leafnum = VBSP_PointLeafnum(model,point);
	mleaf_t *leaf = model->leafs+leafnum;
	struct mleaflight_s *leaflight = prv->leaflight+leafnum;
	struct leaflightpoint_s *best, *lp;
	size_t i, j, d, bd=~0;
	int xyz[3];
	vec3_t diff[6];
	float sig[6];

	static cvar_t *srgbmag, *scale, *forceface;
	if (!srgbmag)	srgbmag		= cvarfuncs->GetNVFDG("hl2_lt_srgb_mag","1",	0, "TEST", "TEST");
	if (!scale)		scale		= cvarfuncs->GetNVFDG("hl2_lt_scale",	"256",	0, "TEST", "TEST");
	if (!forceface)	forceface	= cvarfuncs->GetNVFDG("hl2_lt_face",	"-1",	0, "TEST", "TEST");

	if (prv->leaflight && leaflight->count)
	{
		for (i = 0; i < 3; i++)
			xyz[i] = 255*(point[i] - leaf->minmaxs[i]) / (leaf->minmaxs[3+i]-leaf->minmaxs[i]);
		for (i = 0, best=lp = leaflight->point; i < leaflight->count; i++, lp++)
		{
			int m[3];
			m[0] = xyz[0] - lp->x;
			m[1] = xyz[1] - lp->y;
			m[2] = xyz[2] - lp->z;
			d = DotProduct(m,m);
			if (bd > d)
			{
				bd = d;
				best = lp;
			}
		}


		VectorClear(res_ambient);
		for (j = 0; j < 6; j++)
			VectorAdd(res_ambient, best->rgb[j], res_ambient);
		VectorScale(res_ambient, 1.0/6, res_ambient);

		//try and figure out an average dir for the brightest direction
		for (j = 0; j < 6; j++)
		{
			VectorSubtract(best->rgb[j], res_ambient, diff[j]);
			sig[j] = VectorLength(diff[j]);
		}
		for (j = 0; j < 3; j++)
			res_dir[j] = sig[j*2+1] - sig[j*2];
		VectorNormalize(res_dir);

		//figure out how much light there should be in that direction.
		VectorCopy(res_ambient, res_diffuse);
		for (j = 0; j < 3; j++)
		{
			if (res_dir[0]>=0)
				VectorMA(res_diffuse, res_dir[0], diff[j*2+1], res_diffuse);
			else
				VectorMA(res_diffuse, -res_dir[0], diff[j*2+0], res_diffuse);
		}

		if (forceface->ival >= 0)
		{
			VectorCopy(best->rgb[forceface->ival], res_diffuse);
			VectorCopy(best->rgb[forceface->ival], res_ambient);
			VectorClear(res_dir);
			res_dir[forceface->ival/3] = (forceface->ival&1)?-1:1;
		}

		if (srgbmag->value)
		{
			for (j = 0; j < 3; j++)
			{
				res_diffuse[j] = M_LinearToSRGB(res_diffuse[j], srgbmag->value)*scale->value;
				res_ambient[j] = M_LinearToSRGB(res_ambient[j], srgbmag->value)*scale->value;
			}

			/*for (j = 0; j < 6; j++)
			{
				res_cube[j][0] = M_LinearToSRGB(best->rgb[j][0], srgbmag->value)*scale->value;
				res_cube[j][1] = M_LinearToSRGB(best->rgb[j][1], srgbmag->value)*scale->value;
				res_cube[j][2] = M_LinearToSRGB(best->rgb[j][2], srgbmag->value)*scale->value;
			}*/
		}
		else
		{
			VectorScale(res_diffuse, scale->value, res_diffuse);
			VectorScale(res_ambient, scale->value, res_ambient);

			/*for (j = 0; j < 6; j++)
				VectorScale(best->rgb[j], scale->value, res_cube[j]);*/
		}

		return;
	}
	VectorSet(res_dir, 0,0.707,0.707);
	VectorSet(res_diffuse, 64,64,64);
	VectorSet(res_ambient, 192,192,192);
}
#else
static void VBSP_LightPointValues	(struct model_s *model, const vec3_t point, vec3_t res_diffuse, vec3_t res_ambient, vec3_t res_dir)
{
	VectorSet(res_diffuse, 64,64,64);
	VectorSet(res_ambient, 192,192,192);
	VectorSet(res_dir, 0,0.707,0.707);
}
static void VBSP_LoadLeafLight (model_t *mod, qbyte *mod_base, vlump_t *hdridx, vlump_t *ldridx, vlump_t *hdrvals, vlump_t *ldrvals, int version)
{
}
#endif







static void VBSP_ComputedChecksum(void *ctx, void *data, size_t sum, size_t b)
{
	model_t *mod = ctx;
	vbspinfo_t *prv = mod->meshinfo;
	mod->checksum = mod->checksum2 = sum;
	prv->summed = true;
}
static void VBSP_ComputeChecksum(void *ctx, void *data, size_t length, size_t b)
{
	unsigned int checksum = LittleLong (filefuncs->BlockChecksum(data, length));
	threadfuncs->AddWork(WG_LOADER, VBSP_ComputedChecksum, ctx, NULL, checksum, 0);
}

static qboolean VBSP_LoadModel(model_t *mod, qbyte *mod_base, size_t filelen, char *loadname)
{
	dvbspheader_t *srcheader = (void*)mod_base;
	dvbspheader_t header;
	vbspinfo_t *prv = mod->meshinfo;
	size_t i;
	qboolean noerrors = true;
#ifdef HAVE_CLIENT
	qboolean haverenderer = qrenderer != QR_NONE;
#endif

	VBSP_TranslateContentBits_Setup(prv);

	threadfuncs->AddWork(WG_LOADER, VBSP_ComputeChecksum, mod, mod_base, filelen, 0);

	mod->lightmaps.width = LMBLOCK_SIZE_MAX;
	mod->lightmaps.height = LMBLOCK_SIZE_MAX;

	mod->fromgame = fg_new;
	mod->engineflags |= MDLF_NEEDOVERBRIGHT;
	header.version = LittleLong(srcheader->version);
	for (i=0 ; i<HL2_MAXLUMPS ; i++)
	{
		header.lumps[i].filelen = LittleLong (srcheader->lumps[i].filelen);
		header.lumps[i].fileofs = LittleLong (srcheader->lumps[i].fileofs);
		//fixme: truncate lumps if they go off the end
	}

	if (header.lumps[VLUMP_ZIPFILE].filelen)
		modfuncs->LoadMapArchive(mod, mod_base+header.lumps[VLUMP_ZIPFILE].fileofs, header.lumps[VLUMP_ZIPFILE].filelen);

	// load into heap
	noerrors = noerrors && VBSP_LoadVertexes		(mod, mod_base, &header.lumps[VLUMP_VERTEXES]);
	noerrors = noerrors && VBSP_LoadEdges			(mod, mod_base, &header.lumps[VLUMP_EDGES]);
	noerrors = noerrors && VBSP_LoadSurfedges		(mod, mod_base, &header.lumps[VLUMP_SURFEDGES]);
#ifdef HAVE_CLIENT
	if (noerrors && haverenderer)
		VBSP_LoadLighting							(mod, mod_base, &header.lumps[VLUMP_LIGHTING_LDR], &header.lumps[VLUMP_LIGHTING_HDR]);
#endif
	noerrors = noerrors && VBSP_LoadSurfaces		(mod, mod_base, &header.lumps[VLUMP_TEXINFO]);
	noerrors = noerrors && VBSP_LoadPlanes			(mod, mod_base, &header.lumps[VLUMP_PLANES]);
	noerrors = noerrors && VBSP_LoadTexInfo			(mod, mod_base, header.lumps, loadname);
	if (noerrors)
		VBSP_LoadEntities							(mod, mod_base, &header.lumps[VLUMP_ENTITIES]);
	noerrors = noerrors && VBSP_LoadFaces			(mod, mod_base, header.lumps, header.version);
	noerrors = noerrors && VBSP_LoadDisplacements	(mod, mod_base, header.lumps);
	noerrors = noerrors && VBSP_LoadMarksurfaces	(mod, mod_base, &header.lumps[VLUMP_LEAFFACES]);
	noerrors = noerrors && VBSP_LoadVisibility		(mod, mod_base, &header.lumps[VLUMP_VISIBILITY]);
	noerrors = noerrors && VBSP_LoadBrushSides		(mod, mod_base, &header.lumps[VLUMP_BRUSHSIDES]);
	noerrors = noerrors && VBSP_LoadBrushes			(mod, mod_base, &header.lumps[VLUMP_BRUSHES]);
	noerrors = noerrors && VBSP_LoadLeafBrushes		(mod, mod_base, &header.lumps[VLUMP_LEAFBRUSHES]);
	noerrors = noerrors && VBSP_LoadLeafs			(mod, mod_base, &header.lumps[VLUMP_LEAFS], header.version);
	noerrors = noerrors && VBSP_LoadNodes			(mod, mod_base, &header.lumps[VLUMP_NODES]);
	noerrors = noerrors && VBSP_LoadSubmodels		(mod, mod_base, &header.lumps[VLUMP_MODELS]);
	noerrors = noerrors && VBSP_LoadAreas			(mod, mod_base, &header.lumps[VLUMP_AREAS]);
	noerrors = noerrors && VBSP_LoadAreaPortals		(mod, mod_base, &header.lumps[VLUMP_AREAPORTALS], &header.lumps[VLUMP_AREAPORTALVERTS]);
#ifdef HAVE_CLIENT
	if (noerrors && haverenderer)
		VBSP_LoadLeafLight							(mod, mod_base, &header.lumps[VLUMP_LEAFLIGHTI_HDR], &header.lumps[VLUMP_LEAFLIGHTI_LDR],
																	&header.lumps[VLUMP_LEAFLIGHTV_HDR], &header.lumps[VLUMP_LEAFLIGHTV_LDR], header.version);
#endif
	noerrors = noerrors && VBSP_LoadGameLump		(mod, mod_base, &header.lumps[VLUMP_GAMELUMP]);

	if (!noerrors)
		return false;
#ifdef HAVE_SERVER
	mod->funcs.FatPVS				= VBSP_FatPVS;
	mod->funcs.EdictInFatPVS		= VBSP_EdictInFatPVS;
	mod->funcs.FindTouchedLeafs		= VBSP_FindTouchedLeafs;
#endif
#ifdef HAVE_CLIENT
	mod->funcs.LightPointValues		= VBSP_LightPointValues;
//	mod->funcs.StainNode			= VBSP_StainNode;
//	mod->funcs.MarkLights			= VBSP_MarkLights;
	mod->funcs.GenerateShadowMesh	= VBSP_GenerateShadowMesh;
#endif
	mod->funcs.ClusterPVS			= VBSP_ClusterPVS;
	mod->funcs.ClusterPHS			= VBSP_ClusterPHS;
	mod->funcs.ClusterForPoint		= VBSP_PointCluster;

	mod->funcs.SetAreaPortalState	= VBSP_SetAreaPortalState;
	mod->funcs.AreasConnected		= VBSP_AreasConnected;
	mod->funcs.LoadAreaPortalBlob	= VBSP_LoadAreaPortalBlob;
	mod->funcs.SaveAreaPortalBlob	= VBSP_SaveAreaPortalBlob;

	mod->funcs.PrepareFrame			= VBSP_PrepareFrame;
	mod->funcs.InfoForPoint			= VBSP_InfoForPoint;

	//displacements suck
	for (i = 0; i < prv->numdisplacements; i++)
		VBSP_FindTouchedLeafs(mod, &prv->displacements[i].pvs, prv->displacements[i].aamin, prv->displacements[i].aamax);
//	if (noerrors)
//		CM_CreatePatchesForLeafs (mod, prv);

	return true;
}

/*
==================
CM_LoadMap

Loads in the map and all submodels
==================
*/
static qboolean VBSP_LoadMap (model_t *mod, void *filein, size_t filelen)
{
	unsigned		*buf;
	int				i;
	dvbspheader_t	header;
	model_t			*wmod = mod;
	char			loadname[32];

#ifdef HAVE_CLIENT
	qbyte *facedata = NULL;
	unsigned int facesize = 0;
#endif
	vbspinfo_t	*prv;

	filefuncs->FileBase (mod->name, loadname, sizeof(loadname));

	// free old stuff, just in case.
	mod->meshinfo = prv = plugfuncs->GMalloc(&mod->memgroup, sizeof(*prv));

	mod->type = mod_brush;

	//
	// load the file
	//
	buf = (unsigned	*)filein;
	if (!buf)
	{
		Con_Printf (CON_ERROR "Couldn't load %s\n", mod->name);
		return false;
	}

	header = *(dvbspheader_t *)(buf);
	header.magic = LittleLong(header.magic);
	header.version = LittleLong(header.version);

	ClearBounds(mod->mins, mod->maxs);

	switch(header.version)
	{
	//case 17:	//
	case 18:	//beta
	case 19:	//hl2,cs:s,hl2dm
	case 20:	//portal, l4d, hl2ep2
	case 21:	//cs:go, portal 2, l4d2
	//case 22:	//dota 2
	//case 23:	//dota 2
	//case 27:	//'contagion'
	//case 29:	//'titanfall'
		if (!VBSP_LoadModel(mod, filein, filelen, loadname))
			return false;
		break;
	default:
		Con_Printf (CON_ERROR "VBSP with unknown version (%s: %i should be 18, 19, 20, or 21)\n"
			, mod->name, header.version);
		return false;
	}

	if (map_autoopenportals->value)
		memset (prv->portalopen, 1, sizeof(prv->portalopen));	//open them all. Used for progs that havn't got a clue.
	else
		memset (prv->portalopen, 0, sizeof(prv->portalopen));	//make them start closed.
	FloodAreaConnections (prv);

	mod->nummodelsurfaces = mod->numsurfaces;
	memset(&mod->batches, 0, sizeof(mod->batches));
	mod->vbos = NULL;

	mod->numsubmodels = VBSP_NumInlineModels(mod);

	//in case anyone wants to know the typical player size...
	VectorSet(mod->hulls[1].clip_mins, -16,-16,-36);
	VectorSet(mod->hulls[1].clip_maxs, 16,16,36);
	mod->hulls[0].firstclipnode = prv->cmodels[0].headnode-mod->nodes;
	mod->rootnode = prv->cmodels[0].headnode;
	mod->nummodelsurfaces = prv->cmodels[0].numsurfaces;

#ifdef HAVE_CLIENT
	if (qrenderer != QR_NONE)
	{
		builddata_t *bd = plugfuncs->Malloc(sizeof(*bd) + facesize*mod->nummodelsurfaces);
		bd->buildfunc = VBSP_BuildSurfMesh;
		bd->paintlightmaps = true;
		memcpy(bd+1, facedata + mod->firstmodelsurface*facesize, facesize*mod->nummodelsurfaces);
		threadfuncs->AddWork(WG_MAIN, VBSP_GenerateMaterials, mod, bd, 0, 0);
	}
#endif

	for (i=1 ; i< mod->numsubmodels ; i++)
	{
		cmodel_t	*bm;

		char	name[MAX_QPATH];

		Q_snprintfz (name, sizeof(name), "*%i:%s", i, wmod->publicname);
		mod = modfuncs->BeginSubmodelLoad(name);
		*mod = *wmod;
		mod->archive = NULL;
		mod->entities_raw = NULL;
		mod->submodelof = wmod;
		Q_strncpyz(mod->publicname, name, sizeof(mod->publicname));
		Q_snprintfz (mod->name, sizeof(mod->name), "*%i:%s", i, wmod->name);
		memset(&mod->memgroup, 0, sizeof(mod->memgroup));

		bm = VBSP_InlineModel (wmod, name);

		mod->hulls[0].firstclipnode = -1;	//no nodes,
		if (bm->headleaf)
		{
			mod->leafs = bm->headleaf;
			mod->nodes = NULL;
			mod->hulls[0].firstclipnode = -1;	//make it refer directly to the first leaf, for things that still use numbers.
			mod->rootnode = (mnode_t*)bm->headleaf;
		}
		else
		{
			mod->leafs = wmod->leafs;
			mod->nodes = wmod->nodes;
			mod->hulls[0].firstclipnode = bm->headnode - mod->nodes;	//determine the correct node index
			mod->rootnode = bm->headnode;
		}
		mod->nummodelsurfaces = bm->numsurfaces;
		mod->firstmodelsurface = bm->firstsurface;

		VBSP_BuildBIHSubmodel(mod, i);

		memset(&mod->batches, 0, sizeof(mod->batches));
		mod->vbos = NULL;

		VectorCopy (bm->maxs, mod->maxs);
		VectorCopy (bm->mins, mod->mins);
#ifdef HAVE_CLIENT
		mod->radius = RadiusFromBounds (mod->mins, mod->maxs);

		if (qrenderer != QR_NONE)
		{
			builddata_t *bd = plugfuncs->Malloc(sizeof(*bd) + facesize*mod->nummodelsurfaces);
			bd->buildfunc = VBSP_BuildSurfMesh;
			bd->paintlightmaps = true;
			memcpy(bd+1, facedata + mod->firstmodelsurface*facesize, facesize*mod->nummodelsurfaces);
			threadfuncs->AddWork(WG_MAIN, VBSP_GenerateMaterials, mod, bd, i, 0);
		}
#endif
		modfuncs->EndSubmodelLoad(mod, MLS_LOADED);
	}

	//urgh, we need to wait for models to load in order to get their sizes. that requires being on the main thread and the caller will think we're loaded on completion so we can't safely pingpong it back before generating the bih tree
	threadfuncs->AddWork(WG_MAIN, VBSP_BuildBIHMain, wmod, NULL, 0, 0);
	return true;
}


qboolean VBSP_Init(void)
{
	filefuncs = plugfuncs->GetEngineInterface(plugfsfuncs_name, sizeof(*filefuncs));
	modfuncs = plugfuncs->GetEngineInterface(plugmodfuncs_name, sizeof(*modfuncs));
	if (modfuncs && modfuncs->version < MODPLUGFUNCS_VERSION)
		modfuncs = NULL;
	threadfuncs = plugfuncs->GetEngineInterface(plugthreadfuncs_name, sizeof(*threadfuncs));

	if (modfuncs && filefuncs && threadfuncs)
	{
		modfuncs->RegisterModelFormatMagic("Source (V)BSP", "VBSP",4, VBSP_LoadMap);

#define MAPOPTIONS "Map Cvar Options"
		hl2_novis = cvarfuncs->GetNVFDG("r_novis", "0", 0, "Multiplier for how far displacements can move.", MAPOPTIONS);
		hl2_displacement_scale = cvarfuncs->GetNVFDG("hl2_displacement_scale", "1", CVAR_RENDERERLATCH|CVAR_CHEAT, "Multiplier for how far displacements can move.", MAPOPTIONS);
		hl2_favour_ldr = cvarfuncs->GetNVFDG("hl2_favour_ldr", "0", CVAR_RENDERERLATCH|CVAR_CHEAT, "Favour LDR data instead of HDR (when both are present).", MAPOPTIONS);
		map_noareas = cvarfuncs->GetNVFDG("map_noareas", "0", 0, "Ignore areaportals.", MAPOPTIONS);
		map_autoopenportals = cvarfuncs->GetNVFDG("map_autoopenportals", "0", CVAR_RENDERERLATCH, "When set to 1, force-opens all area portals. Normally these start closed and are opened by doors when they move, but this requires the gamecode to signal this.", MAPOPTIONS);
		hl2_contents_remap = cvarfuncs->GetNVFDG("hl2_contents_remap",
			"/*solid*/SOLID "
			"/*window*/WINDOW "
			"/*aux*/Q2AUX "
			"/*grate*/CLIP "		//would otherwise be LAVA
			"/*slime*/SLIME "
			"/*water*/WATER "
			"/*mist*/Q2MIST "
			"/*opaque*/7 "
			"/*testfogvolume*/8 "
			"/*??*/9 "
			"/*??*/10 "
			"/*team1*/11 "
			"/*team2*/12 "
			"/*ignorenodrawopaque*/13 "
			"/*movable*/-1 "	//would otherwise be LADDER
			"/*areaportal*/Q2AREAPORTAL "
			"/*playerclip*/PLAYERCLIP "
			"/*monsterclip*/MONSTERCLIP "
			"/*current_0*/Q2CURRENT_0 "
			"/*current_90*/Q2CURRENT_90 "
			"/*current_180*/Q2CURRENT_180 "
			"/*current_270*/Q2CURRENT_270 "
			"/*current_up*/Q2CURRENT_UP "
			"/*current_down*/Q2CURRENT_DOWN "
			"/*origin*/Q2ORIGIN "
			"/*monster*/BODY "
			"/*deadmonster*/CORPSE "
			"/*detail*/DETAIL "
			"/*translucent*/Q2TRANSLUCENT "
			"/*ladder*/LADDER "	//would otherwise be Q2LADDER
			"/*hitbox*/30 "
			"/*??*/SKY"
			,CVAR_RENDERERLATCH, "Specifies a table for hl2->internal contentbits (one entry for each source bit).", MAPOPTIONS);

		return true;
	}
	return false;
}
