cnq3/code/renderer/tr_bsp.cpp

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

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Quake III Arena source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

#include "tr_local.h"

/*
Loads and prepares a map file for scene rendering.
A single entry point: void RE_LoadWorldMap( const char* name );
*/

static world_t s_worldData;
static byte* fileBase;

static const int LMVirtPageSize	= 128;
static const int LMBorderSize	= 1;	// bilinear filtering on, mip-mapping and anisotropic filtering off
static const int LMPhysPageSize	= 128 + LMBorderSize * 2;

static vec2_t lightmapBiases[MAX_LIGHTMAPS];
static float lightmapScale[2];
static int lightmapsPerAtlas;


static void R_ColorShiftLightingBytesRGB( const byte* in, byte* out )
{
	const int scale16 = (int)( r_mapBrightness->value * 65536.0f );

	// scale based on brightness
	int r = ( (int)in[0] * scale16 ) >> 16;
	int g = ( (int)in[1] * scale16 ) >> 16;
	int b = ( (int)in[2] * scale16 ) >> 16;

	// normalize by color instead of saturating to white
	if ( ( r | g | b ) > 255 ) {
		int max;
		max = r > g ? r : g;
		max = max > b ? max : b;
		r = r * 255 / max;
		g = g * 255 / max;
		b = b * 255 / max;
	}

	out[0] = r;
	out[1] = g;
	out[2] = b;
}


static void R_ColorShiftLightingBytes( const byte in[4], byte out[4] )
{
	R_ColorShiftLightingBytesRGB( in, out );
	out[3] = in[3];
}


static void R_ComputeAtlasSize( int* sizeX, int* sizeY, int tileSize, int tileCount, int maxTextureSize )
{
	int h = 128;

	while ( h <= maxTextureSize ) {
		int w = 128;

		while ( w <= maxTextureSize ) {
			const int countX = w / tileSize;
			const int countY = h / tileSize;
			const int count = countX * countY;

			if ( count >= tileCount ) {
				*sizeX = w;
				*sizeY = h;
				return;
			}

			w *= 2;
		}

		h *= 2;
	}

	*sizeX = maxTextureSize;
	*sizeY = maxTextureSize;
}


static void R_LerpPixels( byte* dst, const byte* src1, const byte* src2 )
{
	dst[0] = (byte)(((uint16_t)src1[0] + (uint16_t)src2[0]) / 2);
	dst[1] = (byte)(((uint16_t)src1[1] + (uint16_t)src2[1]) / 2);
	dst[2] = (byte)(((uint16_t)src1[2] + (uint16_t)src2[2]) / 2);
	dst[3] = (byte)(((uint16_t)src1[3] + (uint16_t)src2[3]) / 2);
}


static void R_FillBorderTexels( byte* image )
{
	const int stride = LMPhysPageSize * 4;

	const byte* const topSrc = image + 4 + stride;
	byte* const topDst = image + 4;
	memcpy( topDst, topSrc, LMVirtPageSize * 4 );

	const byte* const bottomSrc = image + 4 + (LMPhysPageSize - 2) * stride;
	byte* const bottomDst = image + 4 + (LMPhysPageSize - 1) * stride;
	memcpy( bottomDst, bottomSrc, LMVirtPageSize * 4 );

	const uint32_t* leftSrc = (const uint32_t*)(image + 4 + stride);
	uint32_t* leftDst = (uint32_t*)(image + stride);
	const uint32_t* rightSrc = (const uint32_t*)(image + 2 * stride - 8);
	uint32_t* rightDst = (uint32_t*)(image + 2 * stride - 4);
	for ( int i = 0; i < LMVirtPageSize; ++i ) {
		*leftDst = *leftSrc;
		*rightDst = *rightSrc;
		leftSrc += LMPhysPageSize;
		leftDst += LMPhysPageSize;
		rightSrc += LMPhysPageSize;
		rightDst += LMPhysPageSize;
	}

	R_LerpPixels( image, image + 4, image + stride );
	R_LerpPixels( image + stride - 4, image + stride - 8, image + 2 * stride - 4 );
	R_LerpPixels( image + (LMPhysPageSize - 1) * stride, image + (LMPhysPageSize - 2) * stride, image + (LMPhysPageSize - 1) * stride + 4 );
	R_LerpPixels( image + LMPhysPageSize * stride - 4, image + LMPhysPageSize * stride - 8, image + (LMPhysPageSize - 1) * stride - 4 );
}


static void R_LoadLightmaps( const lump_t* l )
{
	// set this now as the default to avoid divisions by 0
	lightmapsPerAtlas = 1;

	// if we are in r_vertexLight mode, we don't need the lightmaps at all
	if ( r_vertexLight->integer )
		return;

	const int fileBytes = l->filelen;
	if ( !fileBytes )
		return;

	byte* p = fileBase + l->fileofs;

	// we are about to upload textures
	R_SyncRenderThread();

	int numFileLightmaps = fileBytes / (LMVirtPageSize * LMVirtPageSize * 3);
	if ( numFileLightmaps >= MAX_LIGHTMAPS ) {
		ri.Printf( PRINT_WARNING, "WARNING: number of lightmaps > MAX_LIGHTMAPS\n" );
		numFileLightmaps = MAX_LIGHTMAPS;
	}

	int sizeX;
	int sizeY;
	R_ComputeAtlasSize( &sizeX, &sizeY, LMPhysPageSize, numFileLightmaps, glInfo.maxTextureSize );

	static byte image[LMPhysPageSize * LMPhysPageSize * 4];
	const float scaleX = (float)LMVirtPageSize / (float)sizeX;
	const float scaleY = (float)LMVirtPageSize / (float)sizeY;
	const int numTilesPerAtlas = (sizeX / LMPhysPageSize) * (sizeY / LMPhysPageSize);
	const int numAtlases = (numFileLightmaps + numTilesPerAtlas - 1) / numTilesPerAtlas;
	const int countX = sizeX / LMPhysPageSize;

	int i = 0; // lightmapNum
	for ( int a = 0; a < numAtlases; ++a ) {
		tr.lightmaps[a] = R_CreateImage( va("*lightmapatlas%i", a), NULL, sizeX, sizeY, GL_RGBA, IMG_LMATLAS, GL_CLAMP );

		for ( int t = 0; t < numTilesPerAtlas && i < numFileLightmaps; ++t ) {
			for ( int y = 0; y < LMVirtPageSize; ++y ) {
				const byte* s = p + y * LMVirtPageSize * 3;
				byte* d = image + (LMBorderSize + LMPhysPageSize * (LMBorderSize + y)) * 4;

				for ( int x = 0; x < LMVirtPageSize; ++x ) {
					R_ColorShiftLightingBytesRGB(s, d);
					d[3] = 255;
					d += 4;
					s += 3;
				}
			}

			R_FillBorderTexels( image );

			const int offX = (t % countX) * LMPhysPageSize;
			const int offY = (t / countX) * LMPhysPageSize;
			R_UploadLightmapTile( tr.lightmaps[a], image, offX, offY, LMPhysPageSize, LMPhysPageSize );

			lightmapBiases[i][0] = (float)(offX + LMBorderSize) / (float)sizeX;
			lightmapBiases[i][1] = (float)(offY + LMBorderSize) / (float)sizeY;

			p += LMVirtPageSize * LMVirtPageSize * 3;
			++i;
		}
	}

	tr.numLightmaps = numAtlases;
	lightmapsPerAtlas = numTilesPerAtlas;
	lightmapScale[0] = scaleX;
	lightmapScale[1] = scaleY;
}


static void R_GetLightmapTransform( int* number, vec2_t scale, vec2_t bias )
{
	const int i = *number;

	if ( i >= 0 ) {
		scale[0] = lightmapScale[0];
		scale[1] = lightmapScale[1];
		bias[0] = lightmapBiases[i][0];
		bias[1] = lightmapBiases[i][1];
		*number /= lightmapsPerAtlas;
	} else {
		scale[0] = 1.0f;
		scale[1] = 1.0f;
		bias[0] = 0.0f;
		bias[1] = 0.0f;
	}
}


static void R_SaveLightmapTransform( shader_t* shader, const vec2_t scale, const vec2_t bias )
{
	shader->lmScale[0] = scale[0];
	shader->lmScale[1] = scale[1];
	shader->lmBias[0] = bias[0];
	shader->lmBias[1] = bias[1];
}


// called by the clipmodel subsystem so we can share the PVS

void RE_SetWorldVisData( const byte* vis )
{
	tr.externalVisData = vis;
}


static void R_LoadVisibility( const lump_t* l )
{
	int len = ( s_worldData.numClusters + 63 ) & ~63;
	s_worldData.novis = RI_New<byte>( len );
	Com_Memset( s_worldData.novis, 0xff, len );

	len = l->filelen;
	if ( !len )
		return;

	byte* p = fileBase + l->fileofs;

	s_worldData.numClusters = LittleLong( ((int *)p)[0] );
	s_worldData.clusterBytes = LittleLong( ((int *)p)[1] );

	// CM_Load should have given us the vis data to share, so
	// we don't need to allocate another copy
	if ( tr.externalVisData ) {
		s_worldData.vis = tr.externalVisData;
	} else {
		byte* dest = RI_New<byte>( len - 8 );
		Com_Memcpy( dest, p + 8, len - 8 );
		s_worldData.vis = dest;
	}
}


///////////////////////////////////////////////////////////////


static shader_t* ShaderForShaderNum( int shaderNum, int lightmapNum )
{
	shaderNum = LittleLong( shaderNum );
	if ( shaderNum < 0 || shaderNum >= s_worldData.numShaders )
		ri.Error( ERR_DROP, "ShaderForShaderNum: bad num %i", shaderNum );

	const dshader_t* dsh = &s_worldData.shaders[ shaderNum ];

	if (r_vertexLight->integer)
		lightmapNum = LIGHTMAP_BY_VERTEX;

	shader_t* shader = R_FindShader( dsh->shader, lightmapNum, qtrue );

	if ( r_singleShader->integer && (shader->sort != SS_ENVIRONMENT) )
		return tr.defaultShader;

	// if the shader had errors, just use default shader
	if ( shader->defaultShader )
		return tr.defaultShader;

	return shader;
}


template <class T> T* AllocSurface( int numVerts, int numIndexes )
{
	T* surf = (T*)RI_New<byte>
		( sizeof(T) + (numVerts * sizeof(*surf->verts)) + (numIndexes * sizeof(*surf->indexes)) );
	surf->verts = (srfVert_t*)(surf + 1);
	surf->indexes = (int*)(surf->verts + numVerts);
	surf->numVerts = numVerts;
	surf->numIndexes = numIndexes;
	return surf;
}


static void ParseFace( const dsurface_t* ds, const drawVert_t* verts, msurface_t* surf, const int* indexes )
{
	surf->fogIndex = LittleLong( ds->fogNum ) + 1;
	int lightmapNum = LittleLong( ds->lightmapNum );
	vec2_t lmScale, lmBias;
	R_GetLightmapTransform( &lightmapNum, lmScale, lmBias );
	shader_t* const shader = ShaderForShaderNum( ds->shaderNum, lightmapNum );
	surf->shader = shader;
	R_SaveLightmapTransform( shader, lmScale, lmBias );

	int numVerts = LittleLong( ds->numVerts );
	if (numVerts > MAX_FACE_POINTS) {
		ri.Printf( PRINT_WARNING, "WARNING: MAX_FACE_POINTS exceeded: %i\n", numVerts );
		numVerts = MAX_FACE_POINTS;
		surf->shader = tr.defaultShader;
	}

	const int numIndexes = LittleLong( ds->numIndexes );

	srfSurfaceFace_t* cv = AllocSurface<srfSurfaceFace_t>( numVerts, numIndexes );
	cv->surfaceType = SF_FACE;

	surf->data = (surfaceType_t*)cv;

	verts += LittleLong( ds->firstVert );
	for ( int i = 0 ; i < numVerts ; i++ ) {
		for ( int j = 0 ; j < 3 ; j++ ) {
			cv->verts[i].xyz[j] = LittleFloat( verts[i].xyz[j] );
		}
		for ( int j = 0 ; j < 2 ; j++ ) {
			cv->verts[i].st[j] = LittleFloat( verts[i].st[j] );
			cv->verts[i].st2[j] = lmBias[j] + lmScale[j] * LittleFloat( verts[i].lightmap[j] );
		}
		R_ColorShiftLightingBytes( verts[i].color, cv->verts[i].rgba );
	}

	indexes += LittleLong( ds->firstIndex );
	for ( int i = 0 ; i < numIndexes ; i++ ) {
		cv->indexes[i] = LittleLong( indexes[i] );
	}

	// take the plane information from the lightmap vector
	for ( int i = 0 ; i < 3 ; i++ ) {
		cv->plane.normal[i] = LittleFloat( ds->lightmapVecs[2][i] );
	}
	cv->plane.dist = DotProduct( cv->verts[0].xyz, cv->plane.normal );
	SetPlaneSignbits( &cv->plane );
	cv->plane.type = PlaneTypeForNormal( cv->plane.normal );

	if ( numVerts >= 3 && numIndexes >= 3 && VectorLengthSquared(cv->plane.normal) < 0.01f ) {
		// this face's normal is messed up, so we copy something new
		vec3_t v1, v2, normal;
		const int i0 = cv->indexes[0];
		const int i1 = cv->indexes[1];
		const int i2 = cv->indexes[2];
		VectorSubtract(cv->verts[i2].xyz, cv->verts[i0].xyz, v1);
		VectorSubtract(cv->verts[i1].xyz, cv->verts[i0].xyz, v2);
		CrossProduct(v1, v2, normal);
		VectorNormalize(normal);

		for ( int i = 0; i < numVerts; ++i ) {
			VectorCopy(normal, cv->verts[i].normal);
		}
	} else {
		// copy the normal we already have
		for ( int i = 0; i < numVerts; ++i ) {
			VectorCopy(cv->plane.normal, cv->verts[i].normal);
		}
	}
}


static void ParseMesh( const dsurface_t* ds, const drawVert_t* verts, msurface_t* surf )
{
	static surfaceType_t skipData = SF_SKIP;
	drawVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE];

	surf->fogIndex = LittleLong( ds->fogNum ) + 1;
	int lightmapNum = LittleLong(ds->lightmapNum);
	vec2_t lmScale, lmBias;
	R_GetLightmapTransform( &lightmapNum, lmScale, lmBias );
	shader_t* const shader = ShaderForShaderNum( ds->shaderNum, lightmapNum );
	surf->shader = shader;
	R_SaveLightmapTransform( shader, lmScale, lmBias );

	// we may have a nodraw surface, because they might still need to
	// be around for movement clipping
	if ( s_worldData.shaders[ LittleLong( ds->shaderNum ) ].surfaceFlags & SURF_NODRAW ) {
		surf->data = &skipData;
		return;
	}

	int w = LittleLong( ds->patchWidth );
	int h = LittleLong( ds->patchHeight );
	int numPoints = w * h;

	verts += LittleLong( ds->firstVert );

	for (int i = 0; i < numPoints; ++i) {
		for (int j = 0; j < 3; ++j) {
			points[i].xyz[j] = LittleFloat( verts[i].xyz[j] );
			points[i].normal[j] = LittleFloat( verts[i].normal[j] );
		}
		points[i].st[0] = LittleFloat( verts[i].st[0] );
		points[i].lightmap[0] = lmBias[0] + lmScale[0] * LittleFloat( verts[i].lightmap[0] );
		points[i].st[1] = LittleFloat( verts[i].st[1] );
		points[i].lightmap[1] = lmBias[1] + lmScale[1] * LittleFloat( verts[i].lightmap[1] );
		R_ColorShiftLightingBytes( verts[i].color, points[i].color );
	}

	// pre-tesseleate
	srfGridMesh_t* grid = R_SubdividePatchToGrid( w, h, points );
	surf->data = (surfaceType_t*)grid;

	// copy the level of detail origin, which is the center
	// of the group of all curves that must subdivide the same
	// to avoid cracking
	vec3_t bounds[2], v;
	for (int i = 0; i < 3; ++i) {
		bounds[0][i] = LittleFloat( ds->lightmapVecs[0][i] );
		bounds[1][i] = LittleFloat( ds->lightmapVecs[1][i] );
	}
	VectorAdd( bounds[0], bounds[1], bounds[1] );
	VectorScale( bounds[1], 0.5f, grid->lodOrigin );
	VectorSubtract( bounds[0], grid->lodOrigin, v );
	grid->lodRadius = VectorLength( v );
}


static void ParseTriSurf( const dsurface_t* ds, const drawVert_t* verts, msurface_t* surf, const int* indexes )
{
	int i, j;

	shader_t* const shader = ShaderForShaderNum( ds->shaderNum, LIGHTMAP_BY_VERTEX );
	surf->fogIndex = LittleLong( ds->fogNum ) + 1;
	surf->shader = shader;

	int lightmapNum = LittleLong( ds->lightmapNum );
	vec2_t lmScale, lmBias;
	R_GetLightmapTransform( &lightmapNum, lmScale, lmBias );
	R_SaveLightmapTransform( shader, lmScale, lmBias );

	int numVerts = LittleLong( ds->numVerts );
	int numIndexes = LittleLong( ds->numIndexes );

	srfTriangles_t* tri = AllocSurface<srfTriangles_t>( numVerts, numIndexes );
	tri->surfaceType = SF_TRIANGLES;

	surf->data = (surfaceType_t*)tri;

	ClearBounds( tri->bounds[0], tri->bounds[1] );
	verts += LittleLong( ds->firstVert );
	for ( i = 0 ; i < numVerts ; i++ ) {
		for ( j = 0 ; j < 3 ; j++ ) {
			tri->verts[i].xyz[j] = LittleFloat( verts[i].xyz[j] );
			tri->verts[i].normal[j] = LittleFloat( verts[i].normal[j] );
		}
		AddPointToBounds( tri->verts[i].xyz, tri->bounds[0], tri->bounds[1] );
		for ( j = 0 ; j < 2 ; j++ ) {
			tri->verts[i].st[j] = LittleFloat( verts[i].st[j] );
			tri->verts[i].st2[j] = lmBias[j] + lmScale[j] * LittleFloat( verts[i].lightmap[j] );
		}
		R_ColorShiftLightingBytes( verts[i].color, tri->verts[i].rgba );
	}

	indexes += LittleLong( ds->firstIndex );
	for ( i = 0 ; i < numIndexes ; i++ ) {
		tri->indexes[i] = LittleLong( indexes[i] );
		if ( tri->indexes[i] < 0 || tri->indexes[i] >= numVerts ) {
			ri.Error( ERR_DROP, "Bad index in triangle surface" );
		}
	}
}


static void ParseFlare( const dsurface_t* ds, const drawVert_t* verts, msurface_t* surf, const int* indexes )
{
	surf->fogIndex = LittleLong( ds->fogNum ) + 1;
	surf->shader = ShaderForShaderNum( ds->shaderNum, LIGHTMAP_BY_VERTEX );

	srfFlare_t* flare = RI_New<srfFlare_t>();
	flare->surfaceType = SF_FLARE;

	surf->data = (surfaceType_t*)flare;

	for (int i = 0; i < 3; ++i) {
		flare->origin[i] = LittleFloat( ds->lightmapOrigin[i] );
		flare->color[i] = LittleFloat( ds->lightmapVecs[0][i] );
		flare->normal[i] = LittleFloat( ds->lightmapVecs[2][i] );
	}
}


/*
=================
R_MergedWidthPoints

returns qtrue if there are grid points merged on a width edge
=================
*/
static int R_MergedWidthPoints(srfGridMesh_t *grid, int offset) {
	int i, j;

	for (i = 1; i < grid->width-1; i++) {
		for (j = i + 1; j < grid->width-1; j++) {
			if ( fabs(grid->verts[i + offset].xyz[0] - grid->verts[j + offset].xyz[0]) > .1) continue;
			if ( fabs(grid->verts[i + offset].xyz[1] - grid->verts[j + offset].xyz[1]) > .1) continue;
			if ( fabs(grid->verts[i + offset].xyz[2] - grid->verts[j + offset].xyz[2]) > .1) continue;
			return qtrue;
		}
	}
	return qfalse;
}

/*
=================
R_MergedHeightPoints

returns qtrue if there are grid points merged on a height edge
=================
*/
static int R_MergedHeightPoints(srfGridMesh_t *grid, int offset) {
	int i, j;

	for (i = 1; i < grid->height-1; i++) {
		for (j = i + 1; j < grid->height-1; j++) {
			if ( fabs(grid->verts[grid->width * i + offset].xyz[0] - grid->verts[grid->width * j + offset].xyz[0]) > .1) continue;
			if ( fabs(grid->verts[grid->width * i + offset].xyz[1] - grid->verts[grid->width * j + offset].xyz[1]) > .1) continue;
			if ( fabs(grid->verts[grid->width * i + offset].xyz[2] - grid->verts[grid->width * j + offset].xyz[2]) > .1) continue;
			return qtrue;
		}
	}
	return qfalse;
}

/*
=================
R_FixSharedVertexLodError_r

NOTE: never sync LoD through grid edges with merged points!

FIXME: write generalized version that also avoids cracks between a patch and one that meets half way?
=================
*/
static void R_FixSharedVertexLodError_r( int start, srfGridMesh_t *grid1 ) {
	int j, k, l, m, n, offset1, offset2, touch;
	srfGridMesh_t *grid2;

	for ( j = start; j < s_worldData.numsurfaces; j++ ) {
		//
		grid2 = (srfGridMesh_t *) s_worldData.surfaces[j].data;
		// if this surface is not a grid
		if ( grid2->surfaceType != SF_GRID ) continue;
		// if the LOD errors are already fixed for this patch
		if ( grid2->lodFixed == 2 ) continue;
		// grids in the same LOD group should have the exact same lod radius
		if ( grid1->lodRadius != grid2->lodRadius ) continue;
		// grids in the same LOD group should have the exact same lod origin
		if ( grid1->lodOrigin[0] != grid2->lodOrigin[0] ) continue;
		if ( grid1->lodOrigin[1] != grid2->lodOrigin[1] ) continue;
		if ( grid1->lodOrigin[2] != grid2->lodOrigin[2] ) continue;
		//
		touch = qfalse;
		for (n = 0; n < 2; n++) {
			//
			if (n) offset1 = (grid1->height-1) * grid1->width;
			else offset1 = 0;
			if (R_MergedWidthPoints(grid1, offset1)) continue;
			for (k = 1; k < grid1->width-1; k++) {
				for (m = 0; m < 2; m++) {

					if (m) offset2 = (grid2->height-1) * grid2->width;
					else offset2 = 0;
					if (R_MergedWidthPoints(grid2, offset2)) continue;
					for ( l = 1; l < grid2->width-1; l++) {
					//
						if ( fabs(grid1->verts[k + offset1].xyz[0] - grid2->verts[l + offset2].xyz[0]) > .1) continue;
						if ( fabs(grid1->verts[k + offset1].xyz[1] - grid2->verts[l + offset2].xyz[1]) > .1) continue;
						if ( fabs(grid1->verts[k + offset1].xyz[2] - grid2->verts[l + offset2].xyz[2]) > .1) continue;
						// ok the points are equal and should have the same lod error
						grid2->widthLodError[l] = grid1->widthLodError[k];
						touch = qtrue;
					}
				}
				for (m = 0; m < 2; m++) {

					if (m) offset2 = grid2->width-1;
					else offset2 = 0;
					if (R_MergedHeightPoints(grid2, offset2)) continue;
					for ( l = 1; l < grid2->height-1; l++) {
					//
						if ( fabs(grid1->verts[k + offset1].xyz[0] - grid2->verts[grid2->width * l + offset2].xyz[0]) > .1) continue;
						if ( fabs(grid1->verts[k + offset1].xyz[1] - grid2->verts[grid2->width * l + offset2].xyz[1]) > .1) continue;
						if ( fabs(grid1->verts[k + offset1].xyz[2] - grid2->verts[grid2->width * l + offset2].xyz[2]) > .1) continue;
						// ok the points are equal and should have the same lod error
						grid2->heightLodError[l] = grid1->widthLodError[k];
						touch = qtrue;
					}
				}
			}
		}
		for (n = 0; n < 2; n++) {
			//
			if (n) offset1 = grid1->width-1;
			else offset1 = 0;
			if (R_MergedHeightPoints(grid1, offset1)) continue;
			for (k = 1; k < grid1->height-1; k++) {
				for (m = 0; m < 2; m++) {

					if (m) offset2 = (grid2->height-1) * grid2->width;
					else offset2 = 0;
					if (R_MergedWidthPoints(grid2, offset2)) continue;
					for ( l = 1; l < grid2->width-1; l++) {
					//
						if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[0] - grid2->verts[l + offset2].xyz[0]) > .1) continue;
						if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[1] - grid2->verts[l + offset2].xyz[1]) > .1) continue;
						if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[2] - grid2->verts[l + offset2].xyz[2]) > .1) continue;
						// ok the points are equal and should have the same lod error
						grid2->widthLodError[l] = grid1->heightLodError[k];
						touch = qtrue;
					}
				}
				for (m = 0; m < 2; m++) {

					if (m) offset2 = grid2->width-1;
					else offset2 = 0;
					if (R_MergedHeightPoints(grid2, offset2)) continue;
					for ( l = 1; l < grid2->height-1; l++) {
					//
						if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[0] - grid2->verts[grid2->width * l + offset2].xyz[0]) > .1) continue;
						if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[1] - grid2->verts[grid2->width * l + offset2].xyz[1]) > .1) continue;
						if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[2] - grid2->verts[grid2->width * l + offset2].xyz[2]) > .1) continue;
						// ok the points are equal and should have the same lod error
						grid2->heightLodError[l] = grid1->heightLodError[k];
						touch = qtrue;
					}
				}
			}
		}
		if (touch) {
			grid2->lodFixed = 2;
			R_FixSharedVertexLodError_r ( start, grid2 );
			//NOTE: this would be correct but makes things really slow
			//grid2->lodFixed = 1;
		}
	}
}

/*
=================
R_FixSharedVertexLodError

This function assumes that all patches in one group are nicely stitched together for the highest LoD.
If this is not the case this function will still do its job but won't fix the highest LoD cracks.
=================
*/
static void R_FixSharedVertexLodError( void ) {
	int i;
	srfGridMesh_t *grid1;

	for ( i = 0; i < s_worldData.numsurfaces; i++ ) {
		//
		grid1 = (srfGridMesh_t *) s_worldData.surfaces[i].data;
		// if this surface is not a grid
		if ( grid1->surfaceType != SF_GRID )
			continue;
		//
		if ( grid1->lodFixed )
			continue;
		//
		grid1->lodFixed = 2;
		// recursively fix other patches in the same LOD group
		R_FixSharedVertexLodError_r( i + 1, grid1);
	}
}


/*
===============
R_StitchPatches
===============
*/
static int R_StitchPatches( int grid1num, int grid2num ) {
	float *v1, *v2;
	srfGridMesh_t *grid1, *grid2;
	int k, l, m, n, offset1, offset2, row, column;

	grid1 = (srfGridMesh_t *) s_worldData.surfaces[grid1num].data;
	grid2 = (srfGridMesh_t *) s_worldData.surfaces[grid2num].data;
	for (n = 0; n < 2; n++) {
		//
		if (n) offset1 = (grid1->height-1) * grid1->width;
		else offset1 = 0;
		if (R_MergedWidthPoints(grid1, offset1))
			continue;
		for (k = 0; k < grid1->width-2; k += 2) {

			for (m = 0; m < 2; m++) {

				if ( grid2->width >= MAX_GRID_SIZE )
					break;
				if (m) offset2 = (grid2->height-1) * grid2->width;
				else offset2 = 0;
				for ( l = 0; l < grid2->width-1; l++) {
				//
					v1 = grid1->verts[k + offset1].xyz;
					v2 = grid2->verts[l + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;

					v1 = grid1->verts[k + 2 + offset1].xyz;
					v2 = grid2->verts[l + 1 + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;
					//
					v1 = grid2->verts[l + offset2].xyz;
					v2 = grid2->verts[l + 1 + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) < .01 &&
							fabs(v1[1] - v2[1]) < .01 &&
							fabs(v1[2] - v2[2]) < .01)
						continue;
					//
					//ri.Printf( PRINT_ALL, "found highest LoD crack between two patches\n" );
					// insert column into grid2 right after after column l
					if (m) row = grid2->height-1;
					else row = 0;
					grid2 = R_GridInsertColumn( grid2, l+1, row,
									grid1->verts[k + 1 + offset1].xyz, grid1->widthLodError[k+1]);
					grid2->lodStitched = qfalse;
					s_worldData.surfaces[grid2num].data = (surfaceType_t*)grid2;
					return qtrue;
				}
			}
			for (m = 0; m < 2; m++) {

				if (grid2->height >= MAX_GRID_SIZE)
					break;
				if (m) offset2 = grid2->width-1;
				else offset2 = 0;
				for ( l = 0; l < grid2->height-1; l++) {
					//
					v1 = grid1->verts[k + offset1].xyz;
					v2 = grid2->verts[grid2->width * l + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;

					v1 = grid1->verts[k + 2 + offset1].xyz;
					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;
					//
					v1 = grid2->verts[grid2->width * l + offset2].xyz;
					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) < .01 &&
							fabs(v1[1] - v2[1]) < .01 &&
							fabs(v1[2] - v2[2]) < .01)
						continue;
					//
					//ri.Printf( PRINT_ALL, "found highest LoD crack between two patches\n" );
					// insert row into grid2 right after after row l
					if (m) column = grid2->width-1;
					else column = 0;
					grid2 = R_GridInsertRow( grid2, l+1, column,
										grid1->verts[k + 1 + offset1].xyz, grid1->widthLodError[k+1]);
					grid2->lodStitched = qfalse;
					s_worldData.surfaces[grid2num].data = (surfaceType_t*)grid2;
					return qtrue;
				}
			}
		}
	}
	for (n = 0; n < 2; n++) {
		//
		if (n) offset1 = grid1->width-1;
		else offset1 = 0;
		if (R_MergedHeightPoints(grid1, offset1))
			continue;
		for (k = 0; k < grid1->height-2; k += 2) {
			for (m = 0; m < 2; m++) {

				if ( grid2->width >= MAX_GRID_SIZE )
					break;
				if (m) offset2 = (grid2->height-1) * grid2->width;
				else offset2 = 0;
				for ( l = 0; l < grid2->width-1; l++) {
				//
					v1 = grid1->verts[grid1->width * k + offset1].xyz;
					v2 = grid2->verts[l + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;

					v1 = grid1->verts[grid1->width * (k + 2) + offset1].xyz;
					v2 = grid2->verts[l + 1 + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;
					//
					v1 = grid2->verts[l + offset2].xyz;
					v2 = grid2->verts[(l + 1) + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) < .01 &&
							fabs(v1[1] - v2[1]) < .01 &&
							fabs(v1[2] - v2[2]) < .01)
						continue;
					//
					//ri.Printf( PRINT_ALL, "found highest LoD crack between two patches\n" );
					// insert column into grid2 right after after column l
					if (m) row = grid2->height-1;
					else row = 0;
					grid2 = R_GridInsertColumn( grid2, l+1, row,
									grid1->verts[grid1->width * (k + 1) + offset1].xyz, grid1->heightLodError[k+1]);
					grid2->lodStitched = qfalse;
					s_worldData.surfaces[grid2num].data = (surfaceType_t*)grid2;
					return qtrue;
				}
			}
			for (m = 0; m < 2; m++) {

				if (grid2->height >= MAX_GRID_SIZE)
					break;
				if (m) offset2 = grid2->width-1;
				else offset2 = 0;
				for ( l = 0; l < grid2->height-1; l++) {
				//
					v1 = grid1->verts[grid1->width * k + offset1].xyz;
					v2 = grid2->verts[grid2->width * l + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;

					v1 = grid1->verts[grid1->width * (k + 2) + offset1].xyz;
					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;
					//
					v1 = grid2->verts[grid2->width * l + offset2].xyz;
					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) < .01 &&
							fabs(v1[1] - v2[1]) < .01 &&
							fabs(v1[2] - v2[2]) < .01)
						continue;
					//
					//ri.Printf( PRINT_ALL, "found highest LoD crack between two patches\n" );
					// insert row into grid2 right after after row l
					if (m) column = grid2->width-1;
					else column = 0;
					grid2 = R_GridInsertRow( grid2, l+1, column,
									grid1->verts[grid1->width * (k + 1) + offset1].xyz, grid1->heightLodError[k+1]);
					grid2->lodStitched = qfalse;
					s_worldData.surfaces[grid2num].data = (surfaceType_t*)grid2;
					return qtrue;
				}
			}
		}
	}
	for (n = 0; n < 2; n++) {
		//
		if (n) offset1 = (grid1->height-1) * grid1->width;
		else offset1 = 0;
		if (R_MergedWidthPoints(grid1, offset1))
			continue;
		for (k = grid1->width-1; k > 1; k -= 2) {

			for (m = 0; m < 2; m++) {

				if ( grid2->width >= MAX_GRID_SIZE )
					break;
				if (m) offset2 = (grid2->height-1) * grid2->width;
				else offset2 = 0;
				for ( l = 0; l < grid2->width-1; l++) {
				//
					v1 = grid1->verts[k + offset1].xyz;
					v2 = grid2->verts[l + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;

					v1 = grid1->verts[k - 2 + offset1].xyz;
					v2 = grid2->verts[l + 1 + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;
					//
					v1 = grid2->verts[l + offset2].xyz;
					v2 = grid2->verts[(l + 1) + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) < .01 &&
							fabs(v1[1] - v2[1]) < .01 &&
							fabs(v1[2] - v2[2]) < .01)
						continue;
					//
					//ri.Printf( PRINT_ALL, "found highest LoD crack between two patches\n" );
					// insert column into grid2 right after after column l
					if (m) row = grid2->height-1;
					else row = 0;
					grid2 = R_GridInsertColumn( grid2, l+1, row,
										grid1->verts[k - 1 + offset1].xyz, grid1->widthLodError[k+1]);
					grid2->lodStitched = qfalse;
					s_worldData.surfaces[grid2num].data = (surfaceType_t*)grid2;
					return qtrue;
				}
			}
			for (m = 0; m < 2; m++) {

				if (grid2->height >= MAX_GRID_SIZE)
					break;
				if (m) offset2 = grid2->width-1;
				else offset2 = 0;
				for ( l = 0; l < grid2->height-1; l++) {
				//
					v1 = grid1->verts[k + offset1].xyz;
					v2 = grid2->verts[grid2->width * l + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;

					v1 = grid1->verts[k - 2 + offset1].xyz;
					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;
					//
					v1 = grid2->verts[grid2->width * l + offset2].xyz;
					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) < .01 &&
							fabs(v1[1] - v2[1]) < .01 &&
							fabs(v1[2] - v2[2]) < .01)
						continue;
					//
					//ri.Printf( PRINT_ALL, "found highest LoD crack between two patches\n" );
					// insert row into grid2 right after after row l
					if (m) column = grid2->width-1;
					else column = 0;
					grid2 = R_GridInsertRow( grid2, l+1, column,
										grid1->verts[k - 1 + offset1].xyz, grid1->widthLodError[k+1]);
					if (!grid2)
						break;
					grid2->lodStitched = qfalse;
					s_worldData.surfaces[grid2num].data = (surfaceType_t*)grid2;
					return qtrue;
				}
			}
		}
	}
	for (n = 0; n < 2; n++) {
		//
		if (n) offset1 = grid1->width-1;
		else offset1 = 0;
		if (R_MergedHeightPoints(grid1, offset1))
			continue;
		for (k = grid1->height-1; k > 1; k -= 2) {
			for (m = 0; m < 2; m++) {

				if ( grid2->width >= MAX_GRID_SIZE )
					break;
				if (m) offset2 = (grid2->height-1) * grid2->width;
				else offset2 = 0;
				for ( l = 0; l < grid2->width-1; l++) {
				//
					v1 = grid1->verts[grid1->width * k + offset1].xyz;
					v2 = grid2->verts[l + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;

					v1 = grid1->verts[grid1->width * (k - 2) + offset1].xyz;
					v2 = grid2->verts[l + 1 + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;
					//
					v1 = grid2->verts[l + offset2].xyz;
					v2 = grid2->verts[(l + 1) + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) < .01 &&
							fabs(v1[1] - v2[1]) < .01 &&
							fabs(v1[2] - v2[2]) < .01)
						continue;
					//
					//ri.Printf( PRINT_ALL, "found highest LoD crack between two patches\n" );
					// insert column into grid2 right after after column l
					if (m) row = grid2->height-1;
					else row = 0;
					grid2 = R_GridInsertColumn( grid2, l+1, row,
										grid1->verts[grid1->width * (k - 1) + offset1].xyz, grid1->heightLodError[k+1]);
					grid2->lodStitched = qfalse;
					s_worldData.surfaces[grid2num].data = (surfaceType_t*)grid2;
					return qtrue;
				}
			}
			for (m = 0; m < 2; m++) {

				if (grid2->height >= MAX_GRID_SIZE)
					break;
				if (m) offset2 = grid2->width-1;
				else offset2 = 0;
				for ( l = 0; l < grid2->height-1; l++) {
				//
					v1 = grid1->verts[grid1->width * k + offset1].xyz;
					v2 = grid2->verts[grid2->width * l + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;

					v1 = grid1->verts[grid1->width * (k - 2) + offset1].xyz;
					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) > .1)
						continue;
					if ( fabs(v1[1] - v2[1]) > .1)
						continue;
					if ( fabs(v1[2] - v2[2]) > .1)
						continue;
					//
					v1 = grid2->verts[grid2->width * l + offset2].xyz;
					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
					if ( fabs(v1[0] - v2[0]) < .01 &&
							fabs(v1[1] - v2[1]) < .01 &&
							fabs(v1[2] - v2[2]) < .01)
						continue;
					//
					//ri.Printf( PRINT_ALL, "found highest LoD crack between two patches\n" );
					// insert row into grid2 right after after row l
					if (m) column = grid2->width-1;
					else column = 0;
					grid2 = R_GridInsertRow( grid2, l+1, column,
										grid1->verts[grid1->width * (k - 1) + offset1].xyz, grid1->heightLodError[k+1]);
					grid2->lodStitched = qfalse;
					s_worldData.surfaces[grid2num].data = (surfaceType_t*)grid2;
					return qtrue;
				}
			}
		}
	}
	return qfalse;
}

/*
===============
R_TryStitchPatch

This function will try to stitch patches in the same LoD group together for the highest LoD.

Only single missing vertice cracks will be fixed.

Vertices will be joined at the patch side a crack is first found, at the other side
of the patch (on the same row or column) the vertices will not be joined and cracks
might still appear at that side.
===============
*/
static int R_TryStitchingPatch( int grid1num ) {
	int j, numstitches;
	srfGridMesh_t *grid1, *grid2;

	numstitches = 0;
	grid1 = (srfGridMesh_t *) s_worldData.surfaces[grid1num].data;
	for ( j = 0; j < s_worldData.numsurfaces; j++ ) {
		//
		grid2 = (srfGridMesh_t *) s_worldData.surfaces[j].data;
		// if this surface is not a grid
		if ( grid2->surfaceType != SF_GRID ) continue;
		// grids in the same LOD group should have the exact same lod radius
		if ( grid1->lodRadius != grid2->lodRadius ) continue;
		// grids in the same LOD group should have the exact same lod origin
		if ( grid1->lodOrigin[0] != grid2->lodOrigin[0] ) continue;
		if ( grid1->lodOrigin[1] != grid2->lodOrigin[1] ) continue;
		if ( grid1->lodOrigin[2] != grid2->lodOrigin[2] ) continue;
		//
		while (R_StitchPatches(grid1num, j))
		{
			numstitches++;
		}
	}
	return numstitches;
}

/*
===============
R_StitchAllPatches
===============
*/
static void R_StitchAllPatches( void ) {
	int i, stitched, numstitches;
	srfGridMesh_t *grid1;

	numstitches = 0;
	do
	{
		stitched = qfalse;
		for ( i = 0; i < s_worldData.numsurfaces; i++ ) {
			//
			grid1 = (srfGridMesh_t *) s_worldData.surfaces[i].data;
			// if this surface is not a grid
			if ( grid1->surfaceType != SF_GRID )
				continue;
			//
			if ( grid1->lodStitched )
				continue;
			//
			grid1->lodStitched = qtrue;
			stitched = qtrue;
			//
			numstitches += R_TryStitchingPatch( i );
		}
	}
	while (stitched);
	ri.Printf( PRINT_ALL, "stitched %d LoD cracks\n", numstitches );
}


static void R_MovePatchSurfacesToHunk()
{
	for (int i = 0; i < s_worldData.numsurfaces; ++i) {
		srfGridMesh_t* grid = (srfGridMesh_t *) s_worldData.surfaces[i].data;
		if ( grid->surfaceType != SF_GRID )
			continue;

		int size = (grid->width * grid->height - 1) * sizeof( drawVert_t ) + sizeof( *grid );
		srfGridMesh_t* hunkgrid = (srfGridMesh_t*)RI_New<byte>( size );
		Com_Memcpy(hunkgrid, grid, size);

		hunkgrid->widthLodError = RI_New<float>( grid->width );
		Com_Memcpy( hunkgrid->widthLodError, grid->widthLodError, grid->width * 4 );

		hunkgrid->heightLodError = RI_New<float>( grid->height );
		Com_Memcpy( hunkgrid->heightLodError, grid->heightLodError, grid->height * 4 );

		R_FreeSurfaceGridMesh( grid );

		s_worldData.surfaces[i].data = (surfaceType_t*)hunkgrid;
	}
}


// !!! the CM code duplicates virtually all of these functions
// they really should be shared, especially since unpacking etc is so clunky

template <typename T> const T* ReadLump( const lump_t* lump, int* c )
{
	const T* p = (const T*)(fileBase + lump->fileofs);
	if (lump->filelen % sizeof(T))
		ri.Error( ERR_DROP, "LoadMap: funny lump size in %s", s_worldData.name );
	if (c)
		*c = lump->filelen / sizeof(T);
	return p;
}


static void R_LoadSurfaces( const lump_t* surfs, const lump_t* verts, const lump_t* indexLump )
{
	const dsurface_t* in = ReadLump<dsurface_t>( surfs, &s_worldData.numsurfaces );
	const drawVert_t* dv = ReadLump<drawVert_t>( verts, NULL );
	const int* indexes = ReadLump<int>( indexLump, NULL );

	msurface_t* out = RI_New<msurface_t>( s_worldData.numsurfaces );

	int numFaces = 0, numMeshes = 0, numTriSurfs = 0, numFlares = 0;

	s_worldData.surfaces = out;
	for (int i = 0 ; i < s_worldData.numsurfaces; ++i, ++in, ++out)
	{
		switch ( LittleLong( in->surfaceType ) ) {
		case MST_PATCH:
			ParseMesh( in, dv, out );
			numMeshes++;
			break;
		case MST_TRIANGLE_SOUP:
			ParseTriSurf( in, dv, out, indexes );
			numTriSurfs++;
			break;
		case MST_PLANAR:
			ParseFace( in, dv, out, indexes );
			numFaces++;
			break;
		case MST_FLARE:
			ParseFlare( in, dv, out, indexes );
			numFlares++;
			break;
		default:
			ri.Error( ERR_DROP, "Bad surfaceType" );
		}
	}

#ifdef PATCH_STITCHING
	R_StitchAllPatches();
#endif

	R_FixSharedVertexLodError();

#ifdef PATCH_STITCHING
	R_MovePatchSurfacesToHunk();
#endif

	ri.Printf( PRINT_ALL, "...loaded %d faces, %i meshes, %i trisurfs, %i flares\n", 
		numFaces, numMeshes, numTriSurfs, numFlares );
}


static void R_LoadSubmodels( const lump_t* l )
{
	int count;
	const dmodel_t* in = ReadLump<dmodel_t>( l, &count );

	s_worldData.bmodels = RI_New<bmodel_t>( count );

	bmodel_t* out = s_worldData.bmodels;
	for (int i = 0; i < count; ++i, ++in, ++out) {
		model_t* model = R_AllocModel();
		assert( model ); // we should always have enough space for these

		model->type = MOD_BRUSH;
		model->bmodel = out;
		Com_sprintf( model->name, sizeof( model->name ), "*%d", i );

		for (int j = 0; j < 3; ++j) {
			out->bounds[0][j] = LittleFloat( in->mins[j] );
			out->bounds[1][j] = LittleFloat( in->maxs[j] );
		}

		out->firstSurface = s_worldData.surfaces + LittleLong( in->firstSurface );
		out->numSurfaces = LittleLong( in->numSurfaces );
	}
}


///////////////////////////////////////////////////////////////


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


static void R_LoadNodesAndLeafs( const lump_t* nodeLump, const lump_t* leafLump )
{
	int numNodes, numLeafs;
	const dnode_t* in = ReadLump<dnode_t>( nodeLump, &numNodes );
	const dleaf_t* inLeaf = ReadLump<dleaf_t>( leafLump, &numLeafs );

	s_worldData.numnodes = numNodes + numLeafs;
	s_worldData.nodes = RI_New<mnode_t>( s_worldData.numnodes );

	mnode_t* out = s_worldData.nodes;
	for (int i = 0; i < numNodes; ++i, ++in, ++out)
	{
		for (int j = 0; j < 3; ++j) {
			out->mins[j] = LittleLong( in->mins[j] );
			out->maxs[j] = LittleLong( in->maxs[j] );
		}

		out->contents = CONTENTS_NODE;	// differentiate from leafs

		int p = LittleLong( in->planeNum );
		out->plane = s_worldData.planes + p;

		p = LittleLong( in->children[0] );
		out->children[0] = s_worldData.nodes + ((p >= 0) ? p : numNodes + (-1 - p));
		p = LittleLong( in->children[1] );
		out->children[1] = s_worldData.nodes + ((p >= 0) ? p : numNodes + (-1 - p));
	}

	for (int i = 0; i < numLeafs; ++i, ++inLeaf, ++out)
	{
		for (int j = 0; j < 3; ++j) {
			out->mins[j] = LittleLong( inLeaf->mins[j] );
			out->maxs[j] = LittleLong( inLeaf->maxs[j] );
		}

		out->cluster = LittleLong( inLeaf->cluster );
		out->area = LittleLong( inLeaf->area );

		if ( out->cluster >= s_worldData.numClusters )
			s_worldData.numClusters = out->cluster + 1;

		out->firstmarksurface = s_worldData.marksurfaces + LittleLong( inLeaf->firstLeafSurface );
		out->nummarksurfaces = LittleLong( inLeaf->numLeafSurfaces );
	}

	// chain descendants
	R_SetParent( s_worldData.nodes, NULL );
}


///////////////////////////////////////////////////////////////


static void R_LoadShaders( const lump_t* l )
{
	const dshader_t* in = ReadLump<dshader_t>( l, &s_worldData.numShaders );

	s_worldData.shaders = RI_New<dshader_t>( s_worldData.numShaders );

	dshader_t* out = s_worldData.shaders;
	Com_Memcpy( out, in, s_worldData.numShaders * sizeof(*out) );

	for (int i = 0; i < s_worldData.numShaders; ++i) {
		out[i].surfaceFlags = LittleLong( out[i].surfaceFlags );
		out[i].contentFlags = LittleLong( out[i].contentFlags );
	}
}


static void R_LoadMarksurfaces( const lump_t* l )
{
	const int* in = ReadLump<int>( l, &s_worldData.nummarksurfaces );

	s_worldData.marksurfaces = RI_New<msurface_t*>( s_worldData.nummarksurfaces );

	for (int i = 0; i < s_worldData.nummarksurfaces; ++i)
		s_worldData.marksurfaces[i] = s_worldData.surfaces + LittleLong( in[i] );
}


static void R_LoadPlanes( const lump_t* l )
{
	const dplane_t* in = ReadLump<dplane_t>( l, &s_worldData.numplanes );

	s_worldData.planes = RI_New<cplane_t>( s_worldData.numplanes );

	cplane_t* out = s_worldData.planes;
	for (int i = 0; i < s_worldData.numplanes; ++i, ++in, ++out)
	{
		out->signbits = 0;
		for (int j = 0; j < 3; ++j) {
			out->normal[j] = LittleFloat( in->normal[j] );
			if (out->normal[j] < 0) {
				out->signbits |= (1 << j);
			}
		}
		out->dist = LittleFloat( in->dist );
		out->type = PlaneTypeForNormal( out->normal );
	}
}


static unsigned ColorBytes4( float r, float g, float b, float a )
{
	unsigned i;

	( (byte *)&i )[0] = r * 255;
	( (byte *)&i )[1] = g * 255;
	( (byte *)&i )[2] = b * 255;
	( (byte *)&i )[3] = a * 255;

	return i;
}


static void R_LoadFogs( const lump_t* l, const lump_t* brushesLump, const lump_t* sidesLump )
{
	const dfog_t* fogs = ReadLump<dfog_t>( l, &s_worldData.numfogs );

	// fog[0] is an empty but referenced element, so we have to alloc that even if the map has none
	// ideally, someone would fix all the callers to not just blindly deref s_worldData.fogs, but >:(
	++s_worldData.numfogs;
	s_worldData.fogs = RI_New<fog_t>( s_worldData.numfogs );
	if (s_worldData.numfogs == 1)
		return;

	fog_t* out = s_worldData.fogs + 1;

	int numBrushes, numSides;
	const dbrush_t* brushes = ReadLump<dbrush_t>( brushesLump, &numBrushes );
	const dbrushside_t* sides = ReadLump<dbrushside_t>( sidesLump, &numSides );

	for (int i = 1; i < s_worldData.numfogs; ++i, ++fogs, ++out)
	{
		out->originalBrushNumber = LittleLong( fogs->brushNum );

		if ( out->originalBrushNumber >= numBrushes )
			ri.Error( ERR_DROP, "fog brushNumber out of range" );

		const dbrush_t* brush = brushes + out->originalBrushNumber;

		int firstSide = LittleLong( brush->firstSide );
		if ( firstSide > numSides - 6 )
			ri.Error( ERR_DROP, "fog brush sideNumber out of range" );
		int sideNum = firstSide, planeNum;

		// brushes are always sorted with the axial sides first
		planeNum = LittleLong( sides[ sideNum ].planeNum );
		out->bounds[0][0] = -s_worldData.planes[ planeNum ].dist;
		++sideNum;

		planeNum = LittleLong( sides[ sideNum ].planeNum );
		out->bounds[1][0] = s_worldData.planes[ planeNum ].dist;
		++sideNum;

		planeNum = LittleLong( sides[ sideNum ].planeNum );
		out->bounds[0][1] = -s_worldData.planes[ planeNum ].dist;
		++sideNum;

		planeNum = LittleLong( sides[ sideNum ].planeNum );
		out->bounds[1][1] = s_worldData.planes[ planeNum ].dist;
		++sideNum;

		planeNum = LittleLong( sides[ sideNum ].planeNum );
		out->bounds[0][2] = -s_worldData.planes[ planeNum ].dist;
		++sideNum;

		planeNum = LittleLong( sides[ sideNum ].planeNum );
		out->bounds[1][2] = s_worldData.planes[ planeNum ].dist;
		++sideNum;

		// get information from the shader for fog parameters
		shader_t* shader = R_FindShader( fogs->shader, LIGHTMAP_NONE, qtrue );

		out->parms = shader->fogParms;

		out->colorInt = ColorBytes4(
			shader->fogParms.color[0] * tr.identityLight,
			shader->fogParms.color[1] * tr.identityLight,
			shader->fogParms.color[2] * tr.identityLight,
			1.0 );

		out->tcScale = 1.0f / (8 * max( 1.0f, shader->fogParms.depthForOpaque ));

		// set the gradient vector
		sideNum = LittleLong( fogs->visibleSide );

		if ( sideNum == -1 ) {
			out->hasSurface = qfalse;
		} else {
			out->hasSurface = qtrue;
			planeNum = LittleLong( sides[ firstSide + sideNum ].planeNum );
			VectorSubtract( vec3_origin, s_worldData.planes[ planeNum ].normal, out->surface );
			out->surface[3] = -s_worldData.planes[ planeNum ].dist;
		}
	}
}


static void R_LoadLightGrid( const lump_t* l )
{
	int i;
	world_t* w = &s_worldData;

	w->lightGridInverseSize[0] = 1.0f / w->lightGridSize[0];
	w->lightGridInverseSize[1] = 1.0f / w->lightGridSize[1];
	w->lightGridInverseSize[2] = 1.0f / w->lightGridSize[2];

	float* wMins = w->bmodels[0].bounds[0];
	float* wMaxs = w->bmodels[0].bounds[1];

	vec3_t maxs;
	for (i = 0; i < 3; ++i) {
		w->lightGridOrigin[i] = w->lightGridSize[i] * ceil( wMins[i] / w->lightGridSize[i] );
		maxs[i] = w->lightGridSize[i] * floor( wMaxs[i] / w->lightGridSize[i] );
		w->lightGridBounds[i] = (maxs[i] - w->lightGridOrigin[i])/w->lightGridSize[i] + 1;
	}

	int numGridPoints = w->lightGridBounds[0] * w->lightGridBounds[1] * w->lightGridBounds[2];

	if ( l->filelen != numGridPoints * 8 ) {
		ri.Printf( PRINT_WARNING, "WARNING: light grid mismatch\n" );
		w->lightGridData = NULL;
		return;
	}

	w->lightGridData = RI_New<byte>( l->filelen );
	Com_Memcpy( w->lightGridData, fileBase + l->fileofs, l->filelen );

	// deal with overbright bits
	for (i = 0; i < numGridPoints; ++i) {
		R_ColorShiftLightingBytes( &w->lightGridData[i*8], &w->lightGridData[i*8] );
		R_ColorShiftLightingBytes( &w->lightGridData[i*8+3], &w->lightGridData[i*8+3] );
	}
}


static void R_LoadEntities( const lump_t* l )
{
	world_t* w = &s_worldData;
	w->lightGridSize[0] = 64;
	w->lightGridSize[1] = 64;
	w->lightGridSize[2] = 128;

	const char* p = (const char*)(fileBase + l->fileofs);

	// store for reference by the cgame
	w->entityString = RI_New<char>( l->filelen + 1 );
	strcpy( w->entityString, p );
	w->entityParsePoint = w->entityString;

	const char* token = COM_ParseExt( &p, qtrue );
	if (!*token || *token != '{')
		return;

	// only parse the world spawn
	while ( 1 ) {
		// parse key
		token = COM_ParseExt( &p, qtrue );

		if ( !*token || *token == '}' ) {
			break;
		}

		char keyname[MAX_TOKEN_CHARS];
		Q_strncpyz(keyname, token, sizeof(keyname));

		// parse value
		token = COM_ParseExt( &p, qtrue );

		if ( !*token || *token == '}' ) {
			break;
		}

		char value[MAX_TOKEN_CHARS];
		Q_strncpyz(value, token, sizeof(value));

		// check for a different grid size
		if (!Q_stricmp(keyname, "gridsize")) {
			sscanf(value, "%f %f %f", &w->lightGridSize[0], &w->lightGridSize[1], &w->lightGridSize[2] );
			continue;
		}
	}
}


qbool R_GetEntityToken( char* buffer, int size )
{
	const char* s = COM_Parse( &s_worldData.entityParsePoint );
	Q_strncpyz( buffer, s, size );

	if ( !s_worldData.entityParsePoint || !s[0] ) {
		s_worldData.entityParsePoint = s_worldData.entityString;
		return qfalse;
	}

	return qtrue;
}


// called directly from cgame

void RE_LoadWorldMap( const char* name )
{
	int i;

	if ( tr.worldMapLoaded )
		ri.Error( ERR_DROP, "ERROR: attempted to redundantly load world map\n" );

	tr.worldMapLoaded = qtrue;

	byte* buffer;
	ri.FS_ReadFile( name, (void**)&buffer );
	if ( !buffer )
		ri.Error( ERR_DROP, "RE_LoadWorldMap: %s not found", name );

	// clear tr.world so if the level fails to load, the next
	// try will not look at the partially loaded version
	tr.world = NULL;

	Com_Memset( &s_worldData, 0, sizeof( s_worldData ) );
	Q_strncpyz( s_worldData.name, name, sizeof( s_worldData.name ) );

	Q_strncpyz( s_worldData.baseName, COM_SkipPath( s_worldData.name ), sizeof( s_worldData.name ) );
	COM_StripExtension(s_worldData.baseName, s_worldData.baseName, sizeof(s_worldData.baseName));

	dheader_t* header = (dheader_t*)buffer;
	fileBase = (byte*)header;

	i = LittleLong(header->version);
	if ( i != BSP_VERSION )
		ri.Error( ERR_DROP, "RE_LoadWorldMap: %s has wrong version number (%i should be %i)", name, i, BSP_VERSION );

	// swap all the lumps
	for (i=0 ; i<sizeof(dheader_t)/4 ; i++) {
		((int *)header)[i] = LittleLong ( ((int *)header)[i]);
	}

	byte* startMarker = (byte*)ri.Hunk_Alloc( 0, h_low );

	R_LoadShaders( &header->lumps[LUMP_SHADERS] );
	R_LoadLightmaps( &header->lumps[LUMP_LIGHTMAPS] );
	R_LoadPlanes (&header->lumps[LUMP_PLANES]);
	R_LoadFogs( &header->lumps[LUMP_FOGS], &header->lumps[LUMP_BRUSHES], &header->lumps[LUMP_BRUSHSIDES] );
	R_LoadSurfaces( &header->lumps[LUMP_SURFACES], &header->lumps[LUMP_DRAWVERTS], &header->lumps[LUMP_DRAWINDEXES] );
	R_LoadMarksurfaces (&header->lumps[LUMP_LEAFSURFACES]);
	R_LoadNodesAndLeafs (&header->lumps[LUMP_NODES], &header->lumps[LUMP_LEAFS]);
	R_LoadSubmodels (&header->lumps[LUMP_MODELS]);
	R_LoadVisibility( &header->lumps[LUMP_VISIBILITY] );
	R_LoadEntities( &header->lumps[LUMP_ENTITIES] );
	R_LoadLightGrid( &header->lumps[LUMP_LIGHTGRID] );

	s_worldData.dataSize = (byte*)ri.Hunk_Alloc( 0, h_low ) - startMarker;

	// only set tr.world now that we know the entire level has loaded properly
	tr.world = &s_worldData;

	ri.FS_FreeFile( buffer );
}


const char* R_GetMapName()
{
	return s_worldData.baseName[0] != '\0' ? s_worldData.baseName : "";
}