/*
Copyright (C) 1996-2001 Id Software, Inc.
Copyright (C) 2002-2009 John Fitzgibbons and others
Copyright (C) 2007-2008 Kristian Duske
Copyright (C) 2010-2014 QuakeSpasm developers

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.

*/
// r_brush.c: brush model rendering. renamed from r_surf.c

#include "q_defs.h"

extern cvar_t gl_fullbrights, r_drawflat, gl_overbright, r_oldwater; //johnfitz
extern cvar_t gl_zfix; // QuakeSpasm z-fighting fix

int32_t         gl_lightmap_format;
int32_t         lightmap_bytes;

#define BLOCK_WIDTH     128
#define BLOCK_HEIGHT    128

gltexture_t     *lightmap_textures[MAX_LIGHTMAPS]; //johnfitz -- changed to an array

unsigned        blocklights[BLOCK_WIDTH * BLOCK_HEIGHT * 3]; //johnfitz -- was 18*18, added lit support (*3) and loosened surface extents maximum (BLOCK_WIDTH*BLOCK_HEIGHT)

typedef struct glRect_s
{
	uint8_t l, t, w, h;
} glRect_t;

glpoly_t        *lightmap_polys[MAX_LIGHTMAPS];
bool    lightmap_modified[MAX_LIGHTMAPS];
glRect_t        lightmap_rectchange[MAX_LIGHTMAPS];

int32_t                 allocated[MAX_LIGHTMAPS][BLOCK_WIDTH];
int32_t                 last_lightmap_allocated; //ericw -- optimization: remember the index of the last lightmap AllocBlock stored a surf in

// the lightmap texture data needs to be kept in
// main memory so texsubimage can update properly
byte            lightmaps[4 * MAX_LIGHTMAPS * BLOCK_WIDTH * BLOCK_HEIGHT];


/*
===============
R_TextureAnimation -- johnfitz -- added "frame" param to eliminate use of "currententity" global

Returns the proper texture for a given time and base texture
===============
*/
texture_t *R_TextureAnimation(texture_t *base, int32_t frame)
{
	int32_t         relative;
	int32_t         count;

	if(frame)
		if(base->alternate_anims)
			base = base->alternate_anims;

	if(!base->anim_total)
		return base;

	relative = (int32_t)(cl.time * 10) % base->anim_total;

	count = 0;
	while(base->anim_min > relative || base->anim_max <= relative)
	{
		base = base->anim_next;
		if(!base)
			Sys_Error("R_TextureAnimation: broken cycle");
		if(++count > 100)
			Sys_Error("R_TextureAnimation: infinite cycle");
	}

	return base;
}

/*
================
DrawGLPoly
================
*/
void DrawGLPoly(glpoly_t *p)
{
	float   *v;
	int32_t         i;

	glBegin(GL_POLYGON);
	v = p->verts[0];
	for(i = 0 ; i < p->numverts ; i++, v += VERTEXSIZE)
	{
		glTexCoord2f(v[3], v[4]);
		glVertex3fv(v);
	}
	glEnd();
}

/*
================
DrawGLTriangleFan -- johnfitz -- like DrawGLPoly but for r_showtris
================
*/
void DrawGLTriangleFan(glpoly_t *p)
{
	float   *v;
	int32_t         i;

	glBegin(GL_TRIANGLE_FAN);
	v = p->verts[0];
	for(i = 0 ; i < p->numverts ; i++, v += VERTEXSIZE)
	{
		glVertex3fv(v);
	}
	glEnd();
}

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

        BRUSH MODELS

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

/*
=================
R_DrawBrushModel
=================
*/
void R_DrawBrushModel(entity_t *e)
{
	int32_t                 i, k;
	msurface_t      *psurf;
	float           dot;
	mplane_t        *pplane;
	qmodel_t        *clmodel;

	if(R_CullModelForEntity(e))
		return;

	currententity = e;
	clmodel = e->model;

	VectorSubtract(r_refdef.vieworg, e->origin, modelorg);
	if(e->angles[0] || e->angles[1] || e->angles[2])
	{
		vec3_t  temp;
		vec3_t  forward, right, up;

		VectorCopy(modelorg, temp);
		AngleVectors(e->angles, forward, right, up);
		modelorg[0] = DotProduct(temp, forward);
		modelorg[1] = -DotProduct(temp, right);
		modelorg[2] = DotProduct(temp, up);
	}

	psurf = &clmodel->surfaces[clmodel->firstmodelsurface];

// calculate dynamic lighting for bmodel if it's not an
// instanced model
	if(clmodel->firstmodelsurface != 0 && !gl_flashblend.value)
	{
		for(k = 0 ; k < cl_max_dlights ; k++)
		{
			if((cl_dlights[k].die < cl.time) ||
			                (!cl_dlights[k].radius))
				continue;

			R_MarkLights(&cl_dlights[k], k,
			             clmodel->nodes + clmodel->hulls[0].firstclipnode);
		}
	}

	glPushMatrix();
	e->angles[0] = -e->angles[0];   // stupid bug
	if(gl_zfix.value)
	{
		e->origin[0] -= DIST_EPSILON;
		e->origin[1] -= DIST_EPSILON;
		e->origin[2] -= DIST_EPSILON;
	}
	R_RotateForEntity(e->origin, e->angles);
	if(gl_zfix.value)
	{
		e->origin[0] += DIST_EPSILON;
		e->origin[1] += DIST_EPSILON;
		e->origin[2] += DIST_EPSILON;
	}
	e->angles[0] = -e->angles[0];   // stupid bug

	R_ClearTextureChains(clmodel, chain_model);
	for(i = 0 ; i < clmodel->nummodelsurfaces ; i++, psurf++)
	{
		pplane = psurf->plane;
		dot = DotProduct(modelorg, pplane->normal) - pplane->dist;
		if(((psurf->flags & SURF_PLANEBACK) && (dot < -BACKFACE_EPSILON)) ||
		                (!(psurf->flags & SURF_PLANEBACK) && (dot > BACKFACE_EPSILON)))
		{
			R_ChainSurface(psurf, chain_model);
			rs_brushpolys++;
		}
	}

	R_DrawTextureChains(clmodel, e, chain_model);
	R_DrawTextureChains_Water(clmodel, e, chain_model);

	glPopMatrix();
}

/*
=================
R_DrawBrushModel_ShowTris -- johnfitz
=================
*/
void R_DrawBrushModel_ShowTris(entity_t *e)
{
	int32_t                 i;
	msurface_t      *psurf;
	float           dot;
	mplane_t        *pplane;
	qmodel_t        *clmodel;
	glpoly_t        *p;

	if(R_CullModelForEntity(e))
		return;

	currententity = e;
	clmodel = e->model;

	VectorSubtract(r_refdef.vieworg, e->origin, modelorg);
	if(e->angles[0] || e->angles[1] || e->angles[2])
	{
		vec3_t  temp;
		vec3_t  forward, right, up;

		VectorCopy(modelorg, temp);
		AngleVectors(e->angles, forward, right, up);
		modelorg[0] = DotProduct(temp, forward);
		modelorg[1] = -DotProduct(temp, right);
		modelorg[2] = DotProduct(temp, up);
	}

	psurf = &clmodel->surfaces[clmodel->firstmodelsurface];

	glPushMatrix();
	e->angles[0] = -e->angles[0];   // stupid bug
	R_RotateForEntity(e->origin, e->angles);
	e->angles[0] = -e->angles[0];   // stupid bug

	//
	// draw it
	//
	for(i = 0 ; i < clmodel->nummodelsurfaces ; i++, psurf++)
	{
		pplane = psurf->plane;
		dot = DotProduct(modelorg, pplane->normal) - pplane->dist;
		if(((psurf->flags & SURF_PLANEBACK) && (dot < -BACKFACE_EPSILON)) ||
		                (!(psurf->flags & SURF_PLANEBACK) && (dot > BACKFACE_EPSILON)))
		{
			if((psurf->flags & SURF_DRAWTURB) && r_oldwater.value)
				for(p = psurf->polys->next; p; p = p->next)
					DrawGLTriangleFan(p);
			else
				DrawGLTriangleFan(psurf->polys);
		}
	}

	glPopMatrix();
}

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

        LIGHTMAPS

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

/*
================
R_RenderDynamicLightmaps
called during rendering
================
*/
void R_RenderDynamicLightmaps(msurface_t *fa)
{
	byte            *base;
	int32_t                 maps;
	glRect_t    *theRect;
	int32_t smax, tmax;

	if(fa->flags & SURF_DRAWTILED)  //johnfitz -- not a lightmapped surface
		return;

	// add to lightmap chain
	fa->polys->chain = lightmap_polys[fa->lightmaptexturenum];
	lightmap_polys[fa->lightmaptexturenum] = fa->polys;

	// check for lightmap modification
	for(maps = 0; maps < MAXLIGHTMAPS && fa->styles[maps] != 255; maps++)
		if(d_lightstylevalue[fa->styles[maps]] != fa->cached_light[maps])
			goto dynamic;

	if(fa->dlightframe == r_framecount      // dynamic this frame
	                || fa->cached_dlight)                   // dynamic previously
	{
dynamic:
		if(r_dynamic.value)
		{
			lightmap_modified[fa->lightmaptexturenum] = true;
			theRect = &lightmap_rectchange[fa->lightmaptexturenum];
			if(fa->light_t < theRect->t)
			{
				if(theRect->h)
					theRect->h += theRect->t - fa->light_t;
				theRect->t = fa->light_t;
			}
			if(fa->light_s < theRect->l)
			{
				if(theRect->w)
					theRect->w += theRect->l - fa->light_s;
				theRect->l = fa->light_s;
			}
			smax = (fa->extents[0] >> 4) + 1;
			tmax = (fa->extents[1] >> 4) + 1;
			if((theRect->w + theRect->l) < (fa->light_s + smax))
				theRect->w = (fa->light_s - theRect->l) + smax;
			if((theRect->h + theRect->t) < (fa->light_t + tmax))
				theRect->h = (fa->light_t - theRect->t) + tmax;
			base = lightmaps + fa->lightmaptexturenum * lightmap_bytes * BLOCK_WIDTH * BLOCK_HEIGHT;
			base += fa->light_t * BLOCK_WIDTH * lightmap_bytes + fa->light_s * lightmap_bytes;
			R_BuildLightMap(fa, base, BLOCK_WIDTH * lightmap_bytes);
		}
	}
}

/*
========================
AllocBlock -- returns a texture number and the position inside it
========================
*/
int32_t AllocBlock(int32_t w, int32_t h, int32_t *x, int32_t *y)
{
	int32_t         i, j;
	int32_t         best, best2;
	int32_t         texnum;

	// ericw -- rather than searching starting at lightmap 0 every time,
	// start at the last lightmap we allocated a surface in.
	// This makes AllocBlock much faster on large levels (can shave off 3+ seconds
	// of load time on a level with 180 lightmaps), at a cost of not quite packing
	// lightmaps as tightly vs. not doing this (uses ~5% more lightmaps)
	for(texnum = last_lightmap_allocated ; texnum < MAX_LIGHTMAPS ; texnum++, last_lightmap_allocated++)
	{
		best = BLOCK_HEIGHT;

		for(i = 0 ; i < BLOCK_WIDTH - w ; i++)
		{
			best2 = 0;

			for(j = 0 ; j < w ; j++)
			{
				if(allocated[texnum][i + j] >= best)
					break;
				if(allocated[texnum][i + j] > best2)
					best2 = allocated[texnum][i + j];
			}
			if(j == w)
			{
				// this is a valid spot
				*x = i;
				*y = best = best2;
			}
		}

		if(best + h > BLOCK_HEIGHT)
			continue;

		for(i = 0 ; i < w ; i++)
			allocated[texnum][*x + i] = best + h;

		return texnum;
	}

	Sys_Error("AllocBlock: full");
	return 0; //johnfitz -- shut up compiler
}


mvertex_t       *r_pcurrentvertbase;
qmodel_t        *currentmodel;

int32_t nColinElim;

/*
========================
GL_CreateSurfaceLightmap
========================
*/
void GL_CreateSurfaceLightmap(msurface_t *surf)
{
	int32_t         smax, tmax;
	byte    *base;

	smax = (surf->extents[0] >> 4) + 1;
	tmax = (surf->extents[1] >> 4) + 1;

	surf->lightmaptexturenum = AllocBlock(smax, tmax, &surf->light_s, &surf->light_t);
	base = lightmaps + surf->lightmaptexturenum * lightmap_bytes * BLOCK_WIDTH * BLOCK_HEIGHT;
	base += (surf->light_t * BLOCK_WIDTH + surf->light_s) * lightmap_bytes;
	R_BuildLightMap(surf, base, BLOCK_WIDTH * lightmap_bytes);
}

/*
================
BuildSurfaceDisplayList -- called at level load time
================
*/
void BuildSurfaceDisplayList(msurface_t *fa)
{
	int32_t                 i, lindex, lnumverts;
	medge_t         *pedges, *r_pedge;
	float           *vec;
	float           s, t;
	glpoly_t        *poly;

// reconstruct the polygon
	pedges = currentmodel->edges;
	lnumverts = fa->numedges;

	//
	// draw texture
	//
	poly = Hunk_AllocName(sizeof(glpoly_t) + (lnumverts - 4) * VERTEXSIZE * sizeof(float), __func__);
	poly->next = fa->polys;
	fa->polys = poly;
	poly->numverts = lnumverts;

	for(i = 0 ; i < lnumverts ; i++)
	{
		lindex = currentmodel->surfedges[fa->firstedge + i];

		if(lindex > 0)
		{
			r_pedge = &pedges[lindex];
			vec = r_pcurrentvertbase[r_pedge->v[0]].position;
		}
		else
		{
			r_pedge = &pedges[-lindex];
			vec = r_pcurrentvertbase[r_pedge->v[1]].position;
		}
		s = DotProduct(vec, fa->texinfo->vecs[0]) + fa->texinfo->vecs[0][3];
		s /= fa->texinfo->texture->width;

		t = DotProduct(vec, fa->texinfo->vecs[1]) + fa->texinfo->vecs[1][3];
		t /= fa->texinfo->texture->height;

		VectorCopy(vec, poly->verts[i]);
		poly->verts[i][3] = s;
		poly->verts[i][4] = t;

		//
		// lightmap texture coordinates
		//
		s = DotProduct(vec, fa->texinfo->vecs[0]) + fa->texinfo->vecs[0][3];
		s -= fa->texturemins[0];
		s += fa->light_s * 16;
		s += 8;
		s /= BLOCK_WIDTH * 16; //fa->texinfo->texture->width;

		t = DotProduct(vec, fa->texinfo->vecs[1]) + fa->texinfo->vecs[1][3];
		t -= fa->texturemins[1];
		t += fa->light_t * 16;
		t += 8;
		t /= BLOCK_HEIGHT * 16; //fa->texinfo->texture->height;

		poly->verts[i][5] = s;
		poly->verts[i][6] = t;
	}

	//johnfitz -- removed gl_keeptjunctions code

	poly->numverts = lnumverts;
}

/*
==================
GL_BuildLightmaps -- called at level load time

Builds the lightmap texture
with all the surfaces from all brush models
==================
*/
void GL_BuildLightmaps(void)
{
	char    name[16];
	byte    *data;
	int32_t         i, j;
	qmodel_t        *m;

	memset(allocated, 0, sizeof(allocated));
	last_lightmap_allocated = 0;

	r_framecount = 1; // no dlightcache

	//johnfitz -- null out array (the gltexture objects themselves were already freed by Mod_ClearAll)
	for(i = 0; i < MAX_LIGHTMAPS; i++)
		lightmap_textures[i] = NULL;
	//johnfitz

	gl_lightmap_format = GL_RGBA;//FIXME: hardcoded for now!

	switch(gl_lightmap_format)
	{
	case GL_RGBA:
		lightmap_bytes = 4;
		break;
	case GL_BGRA:
		lightmap_bytes = 4;
		break;
	default:
		Sys_Error("GL_BuildLightmaps: bad lightmap format");
	}

	for(j = 1 ; j < MAX_MODELS ; j++)
	{
		m = cl.model_precache[j];
		if(!m)
			break;
		if(m->name[0] == '*')
			continue;
		r_pcurrentvertbase = m->vertexes;
		currentmodel = m;
		for(i = 0 ; i < m->numsurfaces ; i++)
		{
			//johnfitz -- rewritten to use SURF_DRAWTILED instead of the sky/water flags
			if(m->surfaces[i].flags & SURF_DRAWTILED)
				continue;
			GL_CreateSurfaceLightmap(m->surfaces + i);
			BuildSurfaceDisplayList(m->surfaces + i);
			//johnfitz
		}
	}

	//
	// upload all lightmaps that were filled
	//
	for(i = 0; i < MAX_LIGHTMAPS; i++)
	{
		if(!allocated[i][0])
			break;          // no more used
		lightmap_modified[i] = false;
		lightmap_rectchange[i].l = BLOCK_WIDTH;
		lightmap_rectchange[i].t = BLOCK_HEIGHT;
		lightmap_rectchange[i].w = 0;
		lightmap_rectchange[i].h = 0;

		//johnfitz -- use texture manager
		sprintf(name, "lightmap%03" PRIi32, i);
		data = lightmaps + i * BLOCK_WIDTH * BLOCK_HEIGHT * lightmap_bytes;
		lightmap_textures[i] = TexMgr_LoadImage(cl.worldmodel, name, BLOCK_WIDTH, BLOCK_HEIGHT, SRC_LIGHTMAP, data, "", (src_offset_t)data, TEXPREF_LINEAR | TEXPREF_NOPICMIP);
		//johnfitz
	}

	//johnfitz -- warn about exceeding old limits
	if(i >= 64)
		Con_DWarning("%" PRIi32 " lightmaps exceeds standard limit of 64 (max = %" PRIi32 ").\n", i, MAX_LIGHTMAPS);
	//johnfitz
}

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

        VBO support

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

GLuint gl_bmodel_vbo = 0;

void GL_DeleteBModelVertexBuffer(void)
{
	if(!(gl_vbo_able && gl_mtexable && gl_max_texture_units >= 3))
		return;

	GL_DeleteBuffersFunc(1, &gl_bmodel_vbo);
	gl_bmodel_vbo = 0;

	GL_ClearBufferBindings();
}

/*
==================
GL_BuildBModelVertexBuffer

Deletes gl_bmodel_vbo if it already exists, then rebuilds it with all
surfaces from world + all brush models
==================
*/
void GL_BuildBModelVertexBuffer(void)
{
	uint32_t        numverts, varray_bytes, varray_index;
	int32_t         i, j;
	qmodel_t        *m;
	float           *varray;

	if(!(gl_vbo_able && gl_mtexable && gl_max_texture_units >= 3))
		return;

// ask GL for a name for our VBO
	GL_DeleteBuffersFunc(1, &gl_bmodel_vbo);
	GL_GenBuffersFunc(1, &gl_bmodel_vbo);

// count all verts in all models
	numverts = 0;
	for(j = 1 ; j < MAX_MODELS ; j++)
	{
		m = cl.model_precache[j];
		if(!m || m->name[0] == '*' || m->type != mod_brush)
			continue;

		for(i = 0 ; i < m->numsurfaces ; i++)
		{
			numverts += m->surfaces[i].numedges;
		}
	}

// build vertex array
	varray_bytes = VERTEXSIZE * sizeof(float) * numverts;
	varray = (float *) malloc(varray_bytes);
	varray_index = 0;

	for(j = 1 ; j < MAX_MODELS ; j++)
	{
		m = cl.model_precache[j];
		if(!m || m->name[0] == '*' || m->type != mod_brush)
			continue;

		for(i = 0 ; i < m->numsurfaces ; i++)
		{
			msurface_t *s = &m->surfaces[i];
			s->vbo_firstvert = varray_index;
			memcpy(&varray[VERTEXSIZE * varray_index], s->polys->verts, VERTEXSIZE * sizeof(float) * s->numedges);
			varray_index += s->numedges;
		}
	}

// upload to GPU
	GL_BindBufferFunc(GL_ARRAY_BUFFER, gl_bmodel_vbo);
	GL_BufferDataFunc(GL_ARRAY_BUFFER, varray_bytes, varray, GL_STATIC_DRAW);
	free(varray);

// invalidate the cached bindings
	GL_ClearBufferBindings();
}

/*
===============
R_AddDynamicLights
===============
*/
void R_AddDynamicLights(msurface_t *surf)
{
	int32_t                 lnum;
	int32_t                 sd, td;
	float           dist, rad, minlight;
	vec3_t          impact, local;
	int32_t                 s, t;
	int32_t                 i;
	int32_t                 smax, tmax;
	mtexinfo_t      *tex;
	//johnfitz -- lit support via lordhavoc
	float           cred, cgreen, cblue, brightness;
	unsigned        *bl;
	//johnfitz

	smax = (surf->extents[0] >> 4) + 1;
	tmax = (surf->extents[1] >> 4) + 1;
	tex = surf->texinfo;

	for(lnum = 0 ; lnum < cl_max_dlights ; lnum++)
	{
		if(!(surf->dlightbits[lnum >> 5] & (1U << (lnum & 31))))
			continue;               // not lit by this light

		rad = cl_dlights[lnum].radius;
		dist = DotProduct(cl_dlights[lnum].origin, surf->plane->normal) -
		       surf->plane->dist;
		rad -= fabs(dist);
		minlight = cl_dlights[lnum].minlight;
		if(rad < minlight)
			continue;
		minlight = rad - minlight;

		for(i = 0 ; i < 3 ; i++)
		{
			impact[i] = cl_dlights[lnum].origin[i] -
			            surf->plane->normal[i] * dist;
		}

		local[0] = DotProduct(impact, tex->vecs[0]) + tex->vecs[0][3];
		local[1] = DotProduct(impact, tex->vecs[1]) + tex->vecs[1][3];

		local[0] -= surf->texturemins[0];
		local[1] -= surf->texturemins[1];

		//johnfitz -- lit support via lordhavoc
		bl = blocklights;
		cred = cl_dlights[lnum].color[0] * 256.0f;
		cgreen = cl_dlights[lnum].color[1] * 256.0f;
		cblue = cl_dlights[lnum].color[2] * 256.0f;
		//johnfitz
		for(t = 0 ; t < tmax ; t++)
		{
			td = local[1] - t * 16;
			if(td < 0)
				td = -td;
			for(s = 0 ; s < smax ; s++)
			{
				sd = local[0] - s * 16;
				if(sd < 0)
					sd = -sd;
				if(sd > td)
					dist = sd + (td >> 1);
				else
					dist = td + (sd >> 1);
				if(dist < minlight)
					//johnfitz -- lit support via lordhavoc
				{
					brightness = rad - dist;
					bl[0] += (int32_t)(brightness * cred);
					bl[1] += (int32_t)(brightness * cgreen);
					bl[2] += (int32_t)(brightness * cblue);
				}
				bl += 3;
				//johnfitz
			}
		}
	}
}


/*
===============
R_BuildLightMap -- johnfitz -- revised for lit support via lordhavoc

Combine and scale multiple lightmaps into the 8.8 format in blocklights
===============
*/
void R_BuildLightMap(msurface_t *surf, byte *dest, int32_t stride)
{
	int32_t                 smax, tmax;
	int32_t                 r, g, b;
	int32_t                 i, j, size;
	byte            *lightmap;
	unsigned        scale;
	int32_t                 maps;
	unsigned        *bl;

	surf->cached_dlight = (surf->dlightframe == r_framecount);

	smax = (surf->extents[0] >> 4) + 1;
	tmax = (surf->extents[1] >> 4) + 1;
	size = smax * tmax;
	lightmap = surf->samples;

	if(cl.worldmodel->lightdata)
	{
		// clear to no light
		memset(&blocklights[0], 0, size * 3 * sizeof(uint32_t));   //johnfitz -- lit support via lordhavoc

		// add all the lightmaps
		if(lightmap)
		{
			for(maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ;
			                maps++)
			{
				scale = d_lightstylevalue[surf->styles[maps]];
				surf->cached_light[maps] = scale;       // 8.8 fraction
				//johnfitz -- lit support via lordhavoc
				bl = blocklights;
				for(i = 0 ; i < size ; i++)
				{
					*bl++ += *lightmap++ * scale;
					*bl++ += *lightmap++ * scale;
					*bl++ += *lightmap++ * scale;
				}
				//johnfitz
			}
		}

		// add all the dynamic lights
		if(surf->dlightframe == r_framecount)
			R_AddDynamicLights(surf);
	}
	else
	{
		// set to full bright if no light data
		memset(&blocklights[0], 255, size * 3 * sizeof(uint32_t));   //johnfitz -- lit support via lordhavoc
	}

// bound, invert, and shift
// store:
	switch(gl_lightmap_format)
	{
	case GL_RGBA:
		stride -= smax * 4;
		bl = blocklights;
		for(i = 0 ; i < tmax ; i++, dest += stride)
		{
			for(j = 0 ; j < smax ; j++)
			{
				if(gl_overbright.value)
				{
					r = *bl++ >> 8;
					g = *bl++ >> 8;
					b = *bl++ >> 8;
				}
				else
				{
					r = *bl++ >> 7;
					g = *bl++ >> 7;
					b = *bl++ >> 7;
				}
				*dest++ = (r > 255) ? 255 : r;
				*dest++ = (g > 255) ? 255 : g;
				*dest++ = (b > 255) ? 255 : b;
				*dest++ = 255;
			}
		}
		break;
	case GL_BGRA:
		stride -= smax * 4;
		bl = blocklights;
		for(i = 0 ; i < tmax ; i++, dest += stride)
		{
			for(j = 0 ; j < smax ; j++)
			{
				if(gl_overbright.value)
				{
					r = *bl++ >> 8;
					g = *bl++ >> 8;
					b = *bl++ >> 8;
				}
				else
				{
					r = *bl++ >> 7;
					g = *bl++ >> 7;
					b = *bl++ >> 7;
				}
				*dest++ = (b > 255) ? 255 : b;
				*dest++ = (g > 255) ? 255 : g;
				*dest++ = (r > 255) ? 255 : r;
				*dest++ = 255;
			}
		}
		break;
	default:
		Sys_Error("R_BuildLightMap: bad lightmap format");
	}
}

/*
===============
R_UploadLightmap -- johnfitz -- uploads the modified lightmap to opengl if necessary

assumes lightmap texture is already bound
===============
*/
static void R_UploadLightmap(int32_t lmap)
{
	glRect_t        *theRect;

	if(!lightmap_modified[lmap])
		return;

	lightmap_modified[lmap] = false;

	theRect = &lightmap_rectchange[lmap];
	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, theRect->t, BLOCK_WIDTH, theRect->h, gl_lightmap_format,
	                GL_UNSIGNED_BYTE, lightmaps + (lmap * BLOCK_HEIGHT + theRect->t) *BLOCK_WIDTH * lightmap_bytes);
	theRect->l = BLOCK_WIDTH;
	theRect->t = BLOCK_HEIGHT;
	theRect->h = 0;
	theRect->w = 0;

	rs_dynamiclightmaps++;
}

void R_UploadLightmaps(void)
{
	int32_t lmap;

	for(lmap = 0; lmap < MAX_LIGHTMAPS; lmap++)
	{
		if(!lightmap_modified[lmap])
			continue;

		GL_Bind(lightmap_textures[lmap]);
		R_UploadLightmap(lmap);
	}
}

/*
================
R_RebuildAllLightmaps -- johnfitz -- called when gl_overbright gets toggled
================
*/
void R_RebuildAllLightmaps(void)
{
	int32_t                 i, j;
	qmodel_t        *mod;
	msurface_t      *fa;
	byte            *base;

	if(!cl.worldmodel)  // is this the correct test?
		return;

	//for each surface in each model, rebuild lightmap with new scale
	for(i = 1; i < MAX_MODELS; i++)
	{
		if(!(mod = cl.model_precache[i]))
			continue;
		fa = &mod->surfaces[mod->firstmodelsurface];
		for(j = 0; j < mod->nummodelsurfaces; j++, fa++)
		{
			if(fa->flags & SURF_DRAWTILED)
				continue;
			base = lightmaps + fa->lightmaptexturenum * lightmap_bytes * BLOCK_WIDTH * BLOCK_HEIGHT;
			base += fa->light_t * BLOCK_WIDTH * lightmap_bytes + fa->light_s * lightmap_bytes;
			R_BuildLightMap(fa, base, BLOCK_WIDTH * lightmap_bytes);
		}
	}

	//for each lightmap, upload it
	for(i = 0; i < MAX_LIGHTMAPS; i++)
	{
		if(!allocated[i][0])
			break;
		GL_Bind(lightmap_textures[i]);
		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, BLOCK_WIDTH, BLOCK_HEIGHT, gl_lightmap_format,
		                GL_UNSIGNED_BYTE, lightmaps + i * BLOCK_WIDTH * BLOCK_HEIGHT * lightmap_bytes);
	}
}