X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=r_light.c;h=908b5aa62e7346888dcc7ea2facd7d4770fca010;hp=b67dc484a5f207e124a15aa0ffe14a93d1503cf3;hb=ea4fc545e8444f579d88d8f096b054dcd7bc482f;hpb=35fbafed36932577ccb9e269f3c41077cbe62025

diff --git a/r_light.c b/r_light.c
index b67dc484..908b5aa6 100644
--- a/r_light.c
+++ b/r_light.c
@@ -20,13 +20,16 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 // r_light.c
 
 #include "quakedef.h"
+#include "cl_collision.h"
+#include "r_shadow.h"
 
-rdlight_t r_dlight[MAX_DLIGHTS];
+dlight_t r_dlight[MAX_DLIGHTS];
 int r_numdlights = 0;
 
-cvar_t r_lightmodels = {CVAR_SAVE, "r_lightmodels", "1"};
+cvar_t r_modellights = {CVAR_SAVE, "r_modellights", "4"};
 cvar_t r_vismarklights = {0, "r_vismarklights", "1"};
-cvar_t r_lightmodelhardness = {CVAR_SAVE, "r_lightmodelhardness", "0.9"};
+cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "1"};
+cvar_t gl_flashblend = {CVAR_SAVE, "gl_flashblend", "1"};
 
 static rtexture_t *lightcorona;
 static rtexturepool_t *lighttexturepool;
@@ -35,7 +38,7 @@ void r_light_start(void)
 {
 	float dx, dy;
 	int x, y, a;
-	byte pixels[32][32][4];
+	qbyte pixels[32][32][4];
 	lighttexturepool = R_AllocTexturePool();
 	for (y = 0;y < 32;y++)
 	{
@@ -43,15 +46,15 @@ void r_light_start(void)
 		for (x = 0;x < 32;x++)
 		{
 			dx = (x - 15.5f) * (1.0f / 16.0f);
-			a = ((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 64.0f / (1.0f / (1.0f + 0.2));
+			a = ((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2));
 			a = bound(0, a, 255);
-			pixels[y][x][0] = 255;
-			pixels[y][x][1] = 255;
-			pixels[y][x][2] = 255;
-			pixels[y][x][3] = a;
+			pixels[y][x][0] = a;
+			pixels[y][x][1] = a;
+			pixels[y][x][2] = a;
+			pixels[y][x][3] = 255;
 		}
 	}
-	lightcorona = R_LoadTexture (lighttexturepool, "lightcorona", 32, 32, &pixels[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_ALPHA);
+	lightcorona = R_LoadTexture2D(lighttexturepool, "lightcorona", 32, 32, &pixels[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
 }
 
 void r_light_shutdown(void)
@@ -62,142 +65,100 @@ void r_light_shutdown(void)
 
 void r_light_newmap(void)
 {
+	int i;
+	for (i = 0;i < 256;i++)
+		d_lightstylevalue[i] = 264;		// normal light value
 }
 
 void R_Light_Init(void)
 {
-	Cvar_RegisterVariable(&r_lightmodels);
-	Cvar_RegisterVariable(&r_lightmodelhardness);
+	Cvar_RegisterVariable(&r_modellights);
 	Cvar_RegisterVariable(&r_vismarklights);
+	Cvar_RegisterVariable(&r_coronas);
+	Cvar_RegisterVariable(&gl_flashblend);
 	R_RegisterModule("R_Light", r_light_start, r_light_shutdown, r_light_newmap);
 }
 
 /*
 ==================
-R_AnimateLight
+R_UpdateLights
 ==================
 */
-void R_AnimateLight (void)
+void R_UpdateLights(void)
 {
-	int i, j, k;
+	float frac;
+	int i, j, k, l;
 
-//
 // light animations
 // 'm' is normal light, 'a' is no light, 'z' is double bright
 	i = (int)(cl.time * 10);
+	frac = (cl.time * 10) - i;
 	for (j = 0;j < MAX_LIGHTSTYLES;j++)
 	{
-		if (!cl_lightstyle[j].length)
+		if (!cl_lightstyle || !cl_lightstyle[j].length)
 		{
 			d_lightstylevalue[j] = 256;
 			continue;
 		}
 		k = i % cl_lightstyle[j].length;
+		l = (i-1) % cl_lightstyle[j].length;
 		k = cl_lightstyle[j].map[k] - 'a';
-		k = k*22;
-		d_lightstylevalue[j] = k;
+		l = cl_lightstyle[j].map[l] - 'a';
+		d_lightstylevalue[j] = ((k*frac)+(l*(1-frac)))*22;
 	}
-}
-
-
-void R_BuildLightList(void)
-{
-	int			i;
-	dlight_t	*cd;
-	rdlight_t	*rd;
 
 	r_numdlights = 0;
 	c_dlights = 0;
 
-	if (!r_dynamic.integer)
+	if (!r_dynamic.integer || !cl_dlights)
 		return;
 
+	// TODO: optimize to not scan whole cl_dlights array if possible
 	for (i = 0;i < MAX_DLIGHTS;i++)
 	{
-		cd = cl_dlights + i;
-		if (cd->radius <= 0)
-			continue;
-		rd = &r_dlight[r_numdlights++];
-		VectorCopy(cd->origin, rd->origin);
-		VectorScale(cd->color, cd->radius * 128.0f, rd->light);
-		rd->cullradius = (1.0f / 128.0f) * sqrt(DotProduct(rd->light, rd->light));
-		// clamp radius to avoid overflowing division table in lightmap code
-		if (rd->cullradius > 2048.0f)
-			rd->cullradius = 2048.0f;
-		rd->cullradius2 = rd->cullradius * rd->cullradius;
-		rd->lightsubtract = 1.0f / rd->cullradius2;
-		rd->ent = cd->ent;
-		r_numdlights++;
-		c_dlights++; // count every dlight in use
+		if (cl_dlights[i].radius > 0)
+		{
+			R_RTLight_UpdateFromDLight(&cl_dlights[i].rtlight, &cl_dlights[i], false);
+			// FIXME: use pointer instead of copy
+			r_dlight[r_numdlights++] = cl_dlights[i];
+			c_dlights++; // count every dlight in use
+		}
 	}
 }
 
-static int coronapolyindex[6] = {0, 1, 2, 0, 2, 3};
-
 void R_DrawCoronas(void)
 {
-	int i;
-	rmeshinfo_t m;
-	float tvxyz[4][4], tvst[4][2], scale, viewdist, diff[3], dist;
-	rdlight_t *rd;
-	memset(&m, 0, sizeof(m));
-	m.transparent = false;
-	m.blendfunc1 = GL_SRC_ALPHA;
-	m.blendfunc2 = GL_ONE;
-	m.depthdisable = true; // magic
-	m.numtriangles = 2;
-	m.numverts = 4;
-	m.index = coronapolyindex;
-	m.vertex = &tvxyz[0][0];
-	m.vertexstep = sizeof(float[4]);
-	m.tex[0] = R_GetTexture(lightcorona);
-	m.texcoords[0] = &tvst[0][0];
-	m.texcoordstep[0] = sizeof(float[2]);
-	tvst[0][0] = 0;
-	tvst[0][1] = 0;
-	tvst[1][0] = 0;
-	tvst[1][1] = 1;
-	tvst[2][0] = 1;
-	tvst[2][1] = 1;
-	tvst[3][0] = 1;
-	tvst[3][1] = 0;
-	viewdist = DotProduct(r_origin, vpn);
-	for (i = 0;i < r_numdlights;i++)
+	int i, lnum;
+	float cscale, scale, viewdist, dist;
+	dlight_t *light;
+	if (r_coronas.value < 0.01)
+		return;
+	R_Mesh_Matrix(&r_identitymatrix);
+	viewdist = DotProduct(r_vieworigin, r_viewforward);
+	if (r_rtworld)
 	{
-		rd = r_dlight + i;
-		dist = (DotProduct(rd->origin, vpn) - viewdist);
-		if (dist >= 24.0f)
+		for (lnum = 0, light = r_shadow_worldlightchain;light;light = light->next, lnum++)
 		{
-			// trace to a point just barely closer to the eye
-			VectorSubtract(rd->origin, vpn, diff);
-			if (TraceLine(r_origin, diff, NULL, NULL, 0, true) == 1)
+			if (light->rtlight.corona * r_coronas.value > 0 && (r_shadow_debuglight.integer < 0 || r_shadow_debuglight.integer == lnum) && (dist = (DotProduct(light->rtlight.shadoworigin, r_viewforward) - viewdist)) >= 24.0f && CL_TraceLine(light->rtlight.shadoworigin, r_vieworigin, NULL, NULL, true, NULL, SUPERCONTENTS_SOLID) == 1)
 			{
-				scale = 1.0f / 262144.0f;
-				//scale = 64.0f / (DotProduct(diff,diff) + 1024.0f);
-				m.cr = rd->light[0] * scale;
-				m.cg = rd->light[1] * scale;
-				m.cb = rd->light[2] * scale;
-				m.ca = 1;
-				if (fogenabled)
-				{
-					VectorSubtract(rd->origin, r_origin, diff);
-					m.ca *= 1 - exp(fogdensity/DotProduct(diff,diff));
-				}
-				scale = rd->cullradius * 0.25f;
-				tvxyz[0][0] = rd->origin[0] - vright[0] * scale - vup[0] * scale;
-				tvxyz[0][1] = rd->origin[1] - vright[1] * scale - vup[1] * scale;
-				tvxyz[0][2] = rd->origin[2] - vright[2] * scale - vup[2] * scale;
-				tvxyz[1][0] = rd->origin[0] - vright[0] * scale + vup[0] * scale;
-				tvxyz[1][1] = rd->origin[1] - vright[1] * scale + vup[1] * scale;
-				tvxyz[1][2] = rd->origin[2] - vright[2] * scale + vup[2] * scale;
-				tvxyz[2][0] = rd->origin[0] + vright[0] * scale + vup[0] * scale;
-				tvxyz[2][1] = rd->origin[1] + vright[1] * scale + vup[1] * scale;
-				tvxyz[2][2] = rd->origin[2] + vright[2] * scale + vup[2] * scale;
-				tvxyz[3][0] = rd->origin[0] + vright[0] * scale - vup[0] * scale;
-				tvxyz[3][1] = rd->origin[1] + vright[1] * scale - vup[1] * scale;
-				tvxyz[3][2] = rd->origin[2] + vright[2] * scale - vup[2] * scale;
-				R_Mesh_Draw(&m);
+				cscale = light->rtlight.corona * r_coronas.value * 0.25f;
+				scale = light->rtlight.radius * 0.25f;
+				R_DrawSprite(GL_ONE, GL_ONE, lightcorona, true, light->rtlight.shadoworigin, r_viewright, r_viewup, scale, -scale, -scale, scale, light->rtlight.color[0] * cscale, light->rtlight.color[1] * cscale, light->rtlight.color[2] * cscale, 1);
+			}
+		}
+	}
+	for (i = 0, light = r_dlight;i < r_numdlights;i++, light++)
+	{
+		if (light->corona * r_coronas.value > 0 && (dist = (DotProduct(light->origin, r_viewforward) - viewdist)) >= 24.0f && CL_TraceLine(light->origin, r_vieworigin, NULL, NULL, true, NULL, SUPERCONTENTS_SOLID) == 1)
+		{
+			cscale = light->corona * r_coronas.value * 0.25f;
+			scale = light->radius * 0.25f;
+			if (gl_flashblend.integer)
+			{
+				cscale *= 4.0f;
+				scale *= 2.0f;
 			}
+			R_DrawSprite(GL_ONE, GL_ONE, lightcorona, true, light->origin, r_viewright, r_viewup, scale, -scale, -scale, scale, light->color[0] * cscale, light->color[1] * cscale, light->color[2] * cscale, 1);
 		}
 	}
 }
@@ -210,369 +171,112 @@ DYNAMIC LIGHTS
 =============================================================================
 */
 
+static int lightpvsbytes;
+static qbyte lightpvs[(MAX_MAP_LEAFS+7)>>3];
+
 /*
 =============
 R_MarkLights
 =============
 */
-static void R_OldMarkLights (vec3_t lightorigin, rdlight_t *rd, int bit, int bitindex, mnode_t *node)
+static void R_RecursiveMarkLights(entity_render_t *ent, vec3_t lightorigin, dlight_t *light, int bit, int bitindex, mnode_t *node, qbyte *pvs, int pvsbits)
 {
-	float		ndist, maxdist;
-	msurface_t	*surf;
-	mleaf_t		*leaf;
-	int			i;
-
-	if (!r_dynamic.integer)
-		return;
+	int i;
+	mleaf_t *leaf;
+	float dist;
 
 	// for comparisons to minimum acceptable light
-	maxdist = rd->cullradius2;
-
-loc0:
-	if (node->contents < 0)
+	while(node->contents >= 0)
 	{
-		if (node->contents != CONTENTS_SOLID)
+		dist = PlaneDiff(lightorigin, node->plane);
+		if (dist > light->rtlight.lightmap_cullradius)
+			node = node->children[0];
+		else
 		{
-			leaf = (mleaf_t *)node;
-			if (leaf->dlightframe != r_framecount) // not dynamic until now
-			{
-				leaf->dlightbits[0] = leaf->dlightbits[1] = leaf->dlightbits[2] = leaf->dlightbits[3] = leaf->dlightbits[4] = leaf->dlightbits[5] = leaf->dlightbits[6] = leaf->dlightbits[7] = 0;
-				leaf->dlightframe = r_framecount;
-			}
-			leaf->dlightbits[bitindex] |= bit;
+			if (dist >= -light->rtlight.lightmap_cullradius)
+				R_RecursiveMarkLights(ent, lightorigin, light, bit, bitindex, node->children[0], pvs, pvsbits);
+			node = node->children[1];
 		}
-		return;
-	}
-
-	ndist = PlaneDiff(lightorigin, node->plane);
-
-	if (ndist > rd->cullradius)
-	{
-		node = node->children[0];
-		goto loc0;
-	}
-	if (ndist < -rd->cullradius)
-	{
-		node = node->children[1];
-		goto loc0;
 	}
 
-// mark the polygons
-	surf = currentrenderentity->model->surfaces + node->firstsurface;
-	for (i=0 ; i<node->numsurfaces ; i++, surf++)
+	// check if leaf is visible according to pvs
+	leaf = (mleaf_t *)node;
+	i = leaf->clusterindex;
+	if (leaf->nummarksurfaces && (i >= pvsbits || CHECKPVSBIT(pvs, i)))
 	{
-		int d, impacts, impactt;
-		float dist, dist2, impact[3];
-		if (surf->visframe != r_framecount)
-			continue;
-		dist = ndist;
-		if (surf->flags & SURF_PLANEBACK)
-			dist = -dist;
-
-		if (dist < -0.25f && !(surf->flags & SURF_LIGHTBOTHSIDES))
-			continue;
-
-		dist2 = dist * dist;
-		if (dist2 >= maxdist)
-			continue;
-
-		impact[0] = rd->origin[0] - surf->plane->normal[0] * dist;
-		impact[1] = rd->origin[1] - surf->plane->normal[1] * dist;
-		impact[2] = rd->origin[2] - surf->plane->normal[2] * dist;
-
-		impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
-
-		d = bound(0, impacts, surf->extents[0] + 16) - impacts;
-		dist2 += d * d;
-		if (dist2 > maxdist)
-			continue;
+		int *surfacepvsframes, d, impacts, impactt;
+		float sdist, maxdist, dist2, impact[3];
+		msurface_t *surf;
+		// mark the polygons
+		maxdist = light->rtlight.lightmap_cullradius2;
+		surfacepvsframes = ent->model->brushq1.surfacepvsframes;
+		for (i = 0;i < leaf->nummarksurfaces;i++)
+		{
+			if (surfacepvsframes[leaf->firstmarksurface[i]] != ent->model->brushq1.pvsframecount)
+				continue;
+			surf = ent->model->brushq1.surfaces + leaf->firstmarksurface[i];
+			dist = sdist = PlaneDiff(lightorigin, surf->plane);
+			if (surf->flags & SURF_PLANEBACK)
+				dist = -dist;
 
-		impactt = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
+			if (dist < -0.25f && !(surf->flags & SURF_LIGHTBOTHSIDES))
+				continue;
 
-		d = bound(0, impactt, surf->extents[1] + 16) - impactt;
-		dist2 += d * d;
-		if (dist2 > maxdist)
-			continue;
+			dist2 = dist * dist;
+			if (dist2 >= maxdist)
+				continue;
 
+			VectorCopy(lightorigin, impact);
+			if (surf->plane->type >= 3)
+				VectorMA(impact, -sdist, surf->plane->normal, impact);
+			else
+				impact[surf->plane->type] -= sdist;
 
-		/*
-		d = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
+			impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
 
-		if (d < 0)
-		{
+			d = bound(0, impacts, surf->extents[0] + 16) - impacts;
 			dist2 += d * d;
-			if (dist2 >= maxdist)
+			if (dist2 > maxdist)
 				continue;
-		}
-		else
-		{
-			d -= surf->extents[0] + 16;
-			if (d > 0)
-			{
-				dist2 += d * d;
-				if (dist2 >= maxdist)
-					continue;
-			}
-		}
 
-		d = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
+			impactt = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
 
-		if (d < 0)
-		{
+			d = bound(0, impactt, surf->extents[1] + 16) - impactt;
 			dist2 += d * d;
-			if (dist2 >= maxdist)
+			if (dist2 > maxdist)
 				continue;
-		}
-		else
-		{
-			d -= surf->extents[1] + 16;
-			if (d > 0)
-			{
-				dist2 += d * d;
-				if (dist2 >= maxdist)
-					continue;
-			}
-		}
-		*/
 
-		if (surf->dlightframe != r_framecount) // not dynamic until now
-		{
-			surf->dlightbits[0] = surf->dlightbits[1] = surf->dlightbits[2] = surf->dlightbits[3] = surf->dlightbits[4] = surf->dlightbits[5] = surf->dlightbits[6] = surf->dlightbits[7] = 0;
-			surf->dlightframe = r_framecount;
-		}
-		surf->dlightbits[bitindex] |= bit;
-
-		/*
-		if (((surf->flags & SURF_PLANEBACK) == 0) == ((PlaneDist(lightorigin, surf->plane)) >= surf->plane->dist))
-		{
 			if (surf->dlightframe != r_framecount) // not dynamic until now
 			{
 				surf->dlightbits[0] = surf->dlightbits[1] = surf->dlightbits[2] = surf->dlightbits[3] = surf->dlightbits[4] = surf->dlightbits[5] = surf->dlightbits[6] = surf->dlightbits[7] = 0;
 				surf->dlightframe = r_framecount;
+				surf->cached_dlight = true;
 			}
 			surf->dlightbits[bitindex] |= bit;
 		}
-		*/
-	}
-
-	if (node->children[0]->contents >= 0)
-	{
-		if (node->children[1]->contents >= 0)
-		{
-			R_OldMarkLights (lightorigin, rd, bit, bitindex, node->children[0]);
-			node = node->children[1];
-			goto loc0;
-		}
-		else
-		{
-			node = node->children[0];
-			goto loc0;
-		}
 	}
-	else if (node->children[1]->contents >= 0)
-	{
-		node = node->children[1];
-		goto loc0;
-	}
-}
-
-/*
-static void R_NoVisMarkLights (rdlight_t *rd, int bit, int bitindex)
-{
-	vec3_t lightorigin;
-	softwareuntransform(rd->origin, lightorigin);
-
-	R_OldMarkLights(lightorigin, rd, bit, bitindex, currentrenderentity->model->nodes + currentrenderentity->model->hulls[0].firstclipnode);
 }
-*/
 
-static void R_VisMarkLights (rdlight_t *rd, int bit, int bitindex)
+void R_MarkLights(entity_render_t *ent)
 {
-	static int lightframe = 0;
-	mleaf_t *pvsleaf;
+	int i, bit, bitindex;
+	dlight_t *light;
 	vec3_t lightorigin;
-	model_t *model;
-	int		i, k, m, c, leafnum;
-	msurface_t *surf, **mark;
-	mleaf_t *leaf;
-	byte	*in;
-	int		row;
-	float	low[3], high[3], dist, maxdist;
-
-	if (!r_dynamic.integer)
-		return;
-
-	model = currentrenderentity->model;
-	softwareuntransform(rd->origin, lightorigin);
-
-	if (!r_vismarklights.integer)
+	if (!gl_flashblend.integer && r_dynamic.integer && ent->model && ent->model->brushq1.num_leafs)
 	{
-		R_OldMarkLights(lightorigin, rd, bit, bitindex, model->nodes + model->hulls[0].firstclipnode);
-		return;
-	}
-
-	pvsleaf = Mod_PointInLeaf (lightorigin, model);
-	if (pvsleaf == NULL)
-	{
-		Con_Printf("R_VisMarkLights: NULL leaf??\n");
-		R_OldMarkLights(lightorigin, rd, bit, bitindex, model->nodes + model->hulls[0].firstclipnode);
-		return;
-	}
-
-	in = pvsleaf->compressed_vis;
-	if (!in)
-	{
-		// no vis info, so make all visible
-		R_OldMarkLights(lightorigin, rd, bit, bitindex, model->nodes + model->hulls[0].firstclipnode);
-		return;
-	}
-
-	lightframe++;
-
-	low[0] = lightorigin[0] - rd->cullradius;low[1] = lightorigin[1] - rd->cullradius;low[2] = lightorigin[2] - rd->cullradius;
-	high[0] = lightorigin[0] + rd->cullradius;high[1] = lightorigin[1] + rd->cullradius;high[2] = lightorigin[2] + rd->cullradius;
-
-	// for comparisons to minimum acceptable light
-	maxdist = rd->cullradius2;
-
-	row = (model->numleafs+7)>>3;
-
-	k = 0;
-	while (k < row)
-	{
-		c = *in++;
-		if (c)
+		for (i = 0, light = r_dlight;i < r_numdlights;i++, light++)
 		{
-			for (i = 0;i < 8;i++)
-			{
-				if (c & (1<<i))
-				{
-					// warning to the clumsy: numleafs is one less than it should be, it only counts leafs with vis bits (skips leaf 0)
-					leafnum = (k << 3)+i+1;
-					if (leafnum > model->numleafs)
-						return;
-					leaf = &model->leafs[leafnum];
-					if (leaf->visframe != r_framecount
-					 || leaf->contents == CONTENTS_SOLID
-					 || leaf->mins[0] > high[0] || leaf->maxs[0] < low[0]
-					 || leaf->mins[1] > high[1] || leaf->maxs[1] < low[1]
-					 || leaf->mins[2] > high[2] || leaf->maxs[2] < low[2])
-						continue;
-					if (leaf->dlightframe != r_framecount)
-					{
-						// not dynamic until now
-						leaf->dlightbits[0] = leaf->dlightbits[1] = leaf->dlightbits[2] = leaf->dlightbits[3] = leaf->dlightbits[4] = leaf->dlightbits[5] = leaf->dlightbits[6] = leaf->dlightbits[7] = 0;
-						leaf->dlightframe = r_framecount;
-					}
-					leaf->dlightbits[bitindex] |= bit;
-					if ((m = leaf->nummarksurfaces))
-					{
-						mark = leaf->firstmarksurface;
-						do
-						{
-							surf = *mark++;
-							// if not visible in current frame, or already marked because it was in another leaf we passed, skip
-							if (surf->lightframe == lightframe)
-								continue;
-							surf->lightframe = lightframe;
-							if (surf->visframe != r_framecount)
-								continue;
-							dist = PlaneDiff(lightorigin, surf->plane);
-							if (surf->flags & SURF_PLANEBACK)
-								dist = -dist;
-							// LordHavoc: make sure it is infront of the surface and not too far away
-							if (dist < rd->cullradius && (dist > -0.25f || ((surf->flags & SURF_LIGHTBOTHSIDES) && dist > -rd->cullradius)))
-							{
-								int d;
-								int impacts, impactt;
-								float dist2, impact[3];
-
-								dist2 = dist * dist;
-
-								impact[0] = rd->origin[0] - surf->plane->normal[0] * dist;
-								impact[1] = rd->origin[1] - surf->plane->normal[1] * dist;
-								impact[2] = rd->origin[2] - surf->plane->normal[2] * dist;
-
-#if 0
-								d = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
-								if (d < 0)
-								{
-									dist2 += d * d;
-									if (dist2 > maxdist)
-										continue;
-								}
-								else
-								{
-									d -= surf->extents[0];
-									if (d < 0)
-									{
-										dist2 += d * d;
-										if (dist2 > maxdist)
-											continue;
-									}
-								}
-
-								d = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
-								if (d < 0)
-								{
-									dist2 += d * d;
-									if (dist2 > maxdist)
-										continue;
-								}
-								else
-								{
-									d -= surf->extents[1];
-									if (d < 0)
-									{
-										dist2 += d * d;
-										if (dist2 > maxdist)
-											continue;
-									}
-								}
-
-#else
-
-								impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
-								d = bound(0, impacts, surf->extents[0] + 16) - impacts;
-								dist2 += d * d;
-								if (dist2 > maxdist)
-									continue;
-
-								impactt = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
-								d = bound(0, impactt, surf->extents[1] + 16) - impactt;
-								dist2 += d * d;
-								if (dist2 > maxdist)
-									continue;
-
-#endif
-
-								if (surf->dlightframe != r_framecount) // not dynamic until now
-								{
-									surf->dlightbits[0] = surf->dlightbits[1] = surf->dlightbits[2] = surf->dlightbits[3] = surf->dlightbits[4] = surf->dlightbits[5] = surf->dlightbits[6] = surf->dlightbits[7] = 0;
-									surf->dlightframe = r_framecount;
-								}
-								surf->dlightbits[bitindex] |= bit;
-							}
-						}
-						while (--m);
-					}
-				}
-			}
-			k++;
-			continue;
+			bit = 1 << (i & 31);
+			bitindex = i >> 5;
+			Matrix4x4_Transform(&ent->inversematrix, light->origin, lightorigin);
+			lightpvsbytes = 0;
+			if (r_vismarklights.integer && ent->model->brush.FatPVS)
+				lightpvsbytes = ent->model->brush.FatPVS(ent->model, lightorigin, 0, lightpvs, sizeof(lightpvs));
+			R_RecursiveMarkLights(ent, lightorigin, light, bit, bitindex, ent->model->brushq1.nodes + ent->model->brushq1.hulls[0].firstclipnode, lightpvs, min(lightpvsbytes * 8, ent->model->brush.num_pvsclusters));
 		}
-
-		k += *in++;
 	}
 }
 
-void R_MarkLights(void)
-{
-	int i;
-	for (i = 0;i < r_numdlights;i++)
-		R_VisMarkLights (r_dlight + i, 1 << (i & 31), i >> 5);
-}
-
 /*
 =============================================================================
 
@@ -581,354 +285,323 @@ LIGHT SAMPLING
 =============================================================================
 */
 
-static int RecursiveLightPoint (vec3_t color, mnode_t *node, float x, float y, float startz, float endz)
+void R_CompleteLightPoint(vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const vec3_t p, int dynamic, const mleaf_t *leaf)
 {
-	int		side, distz = endz - startz;
-	float	front, back;
-	float	mid;
-
-loc0:
-	if (node->contents < 0)
-		return false;		// didn't hit anything
+	VectorClear(diffusecolor);
+	VectorClear(diffusenormal);
 
-	switch (node->plane->type)
+	if (!r_fullbright.integer && cl.worldmodel && cl.worldmodel->brush.LightPoint)
 	{
-	case PLANE_X:
-		node = node->children[x < node->plane->dist];
-		goto loc0;
-	case PLANE_Y:
-		node = node->children[y < node->plane->dist];
-		goto loc0;
-	case PLANE_Z:
-		side = startz < node->plane->dist;
-		if ((endz < node->plane->dist) == side)
-		{
-			node = node->children[side];
-			goto loc0;
-		}
-		// found an intersection
-//		mid = startz + (endz - startz) * (startz - node->plane->dist) / (startz - endz);
-//		mid = startz + distz * (startz - node->plane->dist) / (-distz);
-//		mid = startz + (-(startz - node->plane->dist));
-//		mid = startz - (startz - node->plane->dist);
-//		mid = startz + node->plane->dist - startz;
-		mid = node->plane->dist;
-		break;
-	default:
-		back = front = x * node->plane->normal[0] + y * node->plane->normal[1];
-		front += startz * node->plane->normal[2];
-		back += endz * node->plane->normal[2];
-		side = front < node->plane->dist;
-		if ((back < node->plane->dist) == side)
-		{
-			node = node->children[side];
-			goto loc0;
-		}
-		// found an intersection
-//		mid = startz + (endz - startz) * ((front - node->plane->dist) / ((front - node->plane->dist) - (back - node->plane->dist)));
-//		mid = startz + (endz - startz) * ((front - node->plane->dist) / (front - back));
-		mid = startz + distz * (front - node->plane->dist) / (front - back);
-		break;
+		ambientcolor[0] = ambientcolor[1] = ambientcolor[2] = r_ambient.value * (2.0f / 128.0f);
+		cl.worldmodel->brush.LightPoint(cl.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
 	}
-
-	// go down front side
-	if (node->children[side]->contents >= 0 && RecursiveLightPoint (color, node->children[side], x, y, startz, mid))
-		return true;	// hit something
 	else
+		VectorSet(ambientcolor, 1, 1, 1);
+
+	// FIXME: this .lights related stuff needs to be ported into the Mod_Q1BSP code
+	if (cl.worldmodel->brushq1.numlights)
 	{
-		// check for impact on this node
-		if (node->numsurfaces)
+		int i;
+		vec3_t v;
+		float f;
+		mlight_t *sl;
+		for (i = 0;i < cl.worldmodel->brushq1.numlights;i++)
 		{
-			int i, ds, dt;
-			msurface_t *surf;
-
-			surf = cl.worldmodel->surfaces + node->firstsurface;
-			for (i = 0;i < node->numsurfaces;i++, surf++)
+			sl = cl.worldmodel->brushq1.lights + i;
+			if (d_lightstylevalue[sl->style] > 0)
 			{
-				if (!(surf->flags & SURF_LIGHTMAP))
-					continue;	// no lightmaps
-
-				ds = (int) (x * surf->texinfo->vecs[0][0] + y * surf->texinfo->vecs[0][1] + mid * surf->texinfo->vecs[0][2] + surf->texinfo->vecs[0][3]);
-				dt = (int) (x * surf->texinfo->vecs[1][0] + y * surf->texinfo->vecs[1][1] + mid * surf->texinfo->vecs[1][2] + surf->texinfo->vecs[1][3]);
-
-				if (ds < surf->texturemins[0] || dt < surf->texturemins[1])
-					continue;
-
-				ds -= surf->texturemins[0];
-				dt -= surf->texturemins[1];
-
-				if (ds > surf->extents[0] || dt > surf->extents[1])
-					continue;
-
-				if (surf->samples)
+				VectorSubtract (p, sl->origin, v);
+				f = ((1.0f / (DotProduct(v, v) * sl->falloff + sl->distbias)) - sl->subtract);
+				if (f > 0 && CL_TraceLine(p, sl->origin, NULL, NULL, false, NULL, SUPERCONTENTS_SOLID) == 1)
 				{
-					byte *lightmap;
-					int maps, line3, size3, dsfrac = ds & 15, dtfrac = dt & 15, scale = 0, r00 = 0, g00 = 0, b00 = 0, r01 = 0, g01 = 0, b01 = 0, r10 = 0, g10 = 0, b10 = 0, r11 = 0, g11 = 0, b11 = 0;
-					line3 = ((surf->extents[0]>>4)+1)*3;
-					size3 = ((surf->extents[0]>>4)+1) * ((surf->extents[1]>>4)+1)*3; // LordHavoc: *3 for colored lighting
-
-					lightmap = surf->samples + ((dt>>4) * ((surf->extents[0]>>4)+1) + (ds>>4))*3; // LordHavoc: *3 for color
-
-					for (maps = 0;maps < MAXLIGHTMAPS && surf->styles[maps] != 255;maps++)
-					{
-						scale = d_lightstylevalue[surf->styles[maps]];
-						r00 += lightmap[      0] * scale;g00 += lightmap[      1] * scale;b00 += lightmap[      2] * scale;
-						r01 += lightmap[      3] * scale;g01 += lightmap[      4] * scale;b01 += lightmap[      5] * scale;
-						r10 += lightmap[line3+0] * scale;g10 += lightmap[line3+1] * scale;b10 += lightmap[line3+2] * scale;
-						r11 += lightmap[line3+3] * scale;g11 += lightmap[line3+4] * scale;b11 += lightmap[line3+5] * scale;
-						lightmap += size3;
-					}
-
-					/*
-					// LordHavoc: here's the readable version of the interpolation
-					// code, not quite as easy for the compiler to optimize...
-
-					// dsfrac is the X position in the lightmap pixel, * 16
-					// dtfrac is the Y position in the lightmap pixel, * 16
-					// r00 is top left corner, r01 is top right corner
-					// r10 is bottom left corner, r11 is bottom right corner
-					// g and b are the same layout.
-					// r0 and r1 are the top and bottom intermediate results
-
-					// first we interpolate the top two points, to get the top
-					// edge sample
-					r0 = (((r01-r00) * dsfrac) >> 4) + r00;
-					g0 = (((g01-g00) * dsfrac) >> 4) + g00;
-					b0 = (((b01-b00) * dsfrac) >> 4) + b00;
-					// then we interpolate the bottom two points, to get the
-					// bottom edge sample
-					r1 = (((r11-r10) * dsfrac) >> 4) + r10;
-					g1 = (((g11-g10) * dsfrac) >> 4) + g10;
-					b1 = (((b11-b10) * dsfrac) >> 4) + b10;
-					// then we interpolate the top and bottom samples to get the
-					// middle sample (the one which was requested)
-					r = (((r1-r0) * dtfrac) >> 4) + r0;
-					g = (((g1-g0) * dtfrac) >> 4) + g0;
-					b = (((b1-b0) * dtfrac) >> 4) + b0;
-					*/
-
-					color[0] += (float) ((((((((r11-r10) * dsfrac) >> 4) + r10)-((((r01-r00) * dsfrac) >> 4) + r00)) * dtfrac) >> 4) + ((((r01-r00) * dsfrac) >> 4) + r00)) * (1.0f / 32768.0f);
-					color[1] += (float) ((((((((g11-g10) * dsfrac) >> 4) + g10)-((((g01-g00) * dsfrac) >> 4) + g00)) * dtfrac) >> 4) + ((((g01-g00) * dsfrac) >> 4) + g00)) * (1.0f / 32768.0f);
-					color[2] += (float) ((((((((b11-b10) * dsfrac) >> 4) + b10)-((((b01-b00) * dsfrac) >> 4) + b00)) * dtfrac) >> 4) + ((((b01-b00) * dsfrac) >> 4) + b00)) * (1.0f / 32768.0f);
+					f *= d_lightstylevalue[sl->style] * (1.0f / 65536.0f);
+					VectorMA(ambientcolor, f, sl->light, ambientcolor);
 				}
-				return true; // success
 			}
 		}
-
-		// go down back side
-		node = node->children[side ^ 1];
-		startz = mid;
-		distz = endz - startz;
-		goto loc0;
-//		return RecursiveLightPoint (color, node->children[side ^ 1], x, y, mid, endz);
-	}
-}
-
-void R_CompleteLightPoint (vec3_t color, vec3_t p, int dynamic, mleaf_t *leaf)
-{
-	int	 i, *dlightbits;
-	vec3_t dist;
-	float f;
-	rdlight_t *rd;
-	if (leaf == NULL)
-		leaf = Mod_PointInLeaf(p, cl.worldmodel);
-
-	if (leaf->contents == CONTENTS_SOLID)
-	{
-		color[0] = color[1] = color[2] = 0;
-		return;
-	}
-
-	if (r_fullbright.integer || !cl.worldmodel->lightdata)
-	{
-		color[0] = color[1] = color[2] = 2;
-		return;
 	}
 
-	color[0] = color[1] = color[2] = r_ambient.value * (2.0f / 128.0f);
-	RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
-
-	if (dynamic && leaf->dlightframe == r_framecount)
+	if (dynamic)
 	{
-		dlightbits = leaf->dlightbits;
+		int i;
+		float f, v[3];
+		dlight_t *light;
+		// FIXME: this really should handle dlights as diffusecolor/diffusenormal somehow
 		for (i = 0;i < r_numdlights;i++)
 		{
-			if (!(dlightbits[i >> 5] & (1 << (i & 31))))
-				continue;
-			rd = r_dlight + i;
-			VectorSubtract (p, rd->origin, dist);
-			f = DotProduct(dist, dist) + LIGHTOFFSET;
-			if (f < rd->cullradius2)
+			light = r_dlight + i;
+			VectorSubtract(p, light->origin, v);
+			f = DotProduct(v, v);
+			if (f < light->rtlight.lightmap_cullradius2 && CL_TraceLine(p, light->origin, NULL, NULL, false, NULL, SUPERCONTENTS_SOLID) == 1)
 			{
-				f = (1.0f / f) - rd->lightsubtract;
-				if (f > 0)
-					VectorMA(color, f, rd->light, color);
+				f = (1.0f / (f + LIGHTOFFSET)) - light->rtlight.lightmap_subtract;
+				VectorMA(ambientcolor, f, light->rtlight.lightmap_light, ambientcolor);
 			}
 		}
 	}
 }
 
-void R_ModelLightPoint (vec3_t color, vec3_t p, int *dlightbits)
+typedef struct
 {
-	mleaf_t *leaf;
-	leaf = Mod_PointInLeaf(p, cl.worldmodel);
-	if (leaf->contents == CONTENTS_SOLID)
-	{
-		color[0] = color[1] = color[2] = 0;
-		dlightbits[0] = dlightbits[1] = dlightbits[2] = dlightbits[3] = dlightbits[4] = dlightbits[5] = dlightbits[6] = dlightbits[7] = 0;
-		return;
-	}
-
-	if (r_fullbright.integer || !cl.worldmodel->lightdata)
-	{
-		color[0] = color[1] = color[2] = 2;
-		dlightbits[0] = dlightbits[1] = dlightbits[2] = dlightbits[3] = dlightbits[4] = dlightbits[5] = dlightbits[6] = dlightbits[7] = 0;
-		return;
-	}
-
-	color[0] = color[1] = color[2] = r_ambient.value * (2.0f / 128.0f);
-	RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
-
-	if (leaf->dlightframe == r_framecount)
-	{
-		dlightbits[0] = leaf->dlightbits[0];
-		dlightbits[1] = leaf->dlightbits[1];
-		dlightbits[2] = leaf->dlightbits[2];
-		dlightbits[3] = leaf->dlightbits[3];
-		dlightbits[4] = leaf->dlightbits[4];
-		dlightbits[5] = leaf->dlightbits[5];
-		dlightbits[6] = leaf->dlightbits[6];
-		dlightbits[7] = leaf->dlightbits[7];
-	}
-	else
-		dlightbits[0] = dlightbits[1] = dlightbits[2] = dlightbits[3] = dlightbits[4] = dlightbits[5] = dlightbits[6] = dlightbits[7] = 0;
+	vec3_t origin;
+	//vec_t cullradius2;
+	vec3_t light;
+	// how much this light would contribute to ambient if replaced
+	vec3_t ambientlight;
+	vec_t subtract;
+	vec_t falloff;
+	vec_t offset;
+	// used for choosing only the brightest lights
+	vec_t intensity;
 }
+nearlight_t;
+
+static int nearlights;
+static nearlight_t nearlight[MAX_DLIGHTS];
 
-void R_LightModel(int numverts)
+int R_LightModel(float *ambient4f, float *diffusecolor, float *diffusenormal, const entity_render_t *ent, float colorr, float colorg, float colorb, float colora, int worldcoords)
 {
-	int i, j, nearlights = 0;
-	float color[3], basecolor[3], v[3], t, *av, *avn, *avc, a, number, f, hardness, hardnessoffset, dist2;
-	struct
+	int i, j, maxnearlights;
+	float v[3], f, mscale, stylescale, intensity, ambientcolor[3], tempdiffusenormal[3];
+	nearlight_t *nl;
+	mlight_t *sl;
+	dlight_t *light;
+
+	nearlights = 0;
+	maxnearlights = r_modellights.integer;
+	ambient4f[0] = ambient4f[1] = ambient4f[2] = r_ambient.value * (2.0f / 128.0f);
+	VectorClear(diffusecolor);
+	VectorClear(diffusenormal);
+	if (!(ent->flags & RENDER_LIGHT))
 	{
-		vec3_t origin;
-		vec_t cullradius2;
-		vec3_t light;
-		vec_t lightsubtract;
+		// highly rare
+		VectorSet(ambient4f, 1, 1, 1);
+		maxnearlights = 0;
 	}
-	nearlight[MAX_DLIGHTS], *nl;
-	int modeldlightbits[8];
-	//staticlight_t *sl;
-	a = currentrenderentity->alpha;
-	if (currentrenderentity->effects & EF_FULLBRIGHT)
-		basecolor[0] = basecolor[1] = basecolor[2] = 1;
+	else if (r_lightmapintensity <= 0 && !(ent->flags & RENDER_TRANSPARENT))
+		maxnearlights = 0;
 	else
 	{
-		if (r_lightmodels.integer)
+		if (cl.worldmodel && cl.worldmodel->brush.LightPoint)
 		{
-			R_ModelLightPoint(basecolor, currentrenderentity->origin, modeldlightbits);
+			cl.worldmodel->brush.LightPoint(cl.worldmodel, ent->origin, ambient4f, diffusecolor, tempdiffusenormal);
+			Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, diffusenormal);
+			VectorNormalize(diffusenormal);
+		}
+		else
+			VectorSet(ambient4f, 1, 1, 1);
+	}
 
-			nl = &nearlight[0];
-			/*
-			// this code is unused for now
-			for (i = 0, sl = staticlight;i < staticlights && nearlights < MAX_DLIGHTS;i++, sl++)
+	// scale of the model's coordinate space, to alter light attenuation to match
+	// make the mscale squared so it can scale the squared distance results
+	mscale = ent->scale * ent->scale;
+	// FIXME: no support for .lights on non-Q1BSP?
+	nl = &nearlight[0];
+	for (i = 0;i < ent->numentlights;i++)
+	{
+		sl = cl.worldmodel->brushq1.lights + ent->entlights[i];
+		stylescale = d_lightstylevalue[sl->style] * (1.0f / 65536.0f);
+		VectorSubtract (ent->origin, sl->origin, v);
+		f = ((1.0f / (DotProduct(v, v) * sl->falloff + sl->distbias)) - sl->subtract) * stylescale;
+		VectorScale(sl->light, f, ambientcolor);
+		intensity = DotProduct(ambientcolor, ambientcolor);
+		if (f < 0)
+			intensity *= -1.0f;
+		if (nearlights < maxnearlights)
+			j = nearlights++;
+		else
+		{
+			for (j = 0;j < maxnearlights;j++)
 			{
-				if (TraceLine(currentrenderentity->origin, sl->origin, NULL, NULL, 0) == 1)
+				if (nearlight[j].intensity < intensity)
 				{
-					nl->fadetype = sl->fadetype;
-					nl->distancescale = sl->distancescale;
-					nl->radius = sl->radius;
-					VectorCopy(sl->origin, nl->origin);
-					VectorCopy(sl->color, nl->light);
-					nl->cullradius2 = 99999999;
-					nl->lightsubtract = 0;
-					nl++;
-					nearlights++;
+					if (nearlight[j].intensity > 0)
+						VectorAdd(ambient4f, nearlight[j].ambientlight, ambient4f);
+					break;
 				}
 			}
-			*/
-			for (i = 0;i < r_numdlights && nearlights < MAX_DLIGHTS;i++)
+		}
+		if (j >= maxnearlights)
+		{
+			// this light is less significant than all others,
+			// add it to ambient
+			if (intensity > 0)
+				VectorAdd(ambient4f, ambientcolor, ambient4f);
+		}
+		else
+		{
+			nl = nearlight + j;
+			nl->intensity = intensity;
+			// transform the light into the model's coordinate system
+			if (worldcoords)
+				VectorCopy(sl->origin, nl->origin);
+			else
+				Matrix4x4_Transform(&ent->inversematrix, sl->origin, nl->origin);
+			// integrate mscale into falloff, for maximum speed
+			nl->falloff = sl->falloff * mscale;
+			VectorCopy(ambientcolor, nl->ambientlight);
+			nl->light[0] = sl->light[0] * stylescale * colorr * 4.0f;
+			nl->light[1] = sl->light[1] * stylescale * colorg * 4.0f;
+			nl->light[2] = sl->light[2] * stylescale * colorb * 4.0f;
+			nl->subtract = sl->subtract;
+			nl->offset = sl->distbias;
+		}
+	}
+	if (!r_rtdlight || (ent->flags & RENDER_TRANSPARENT))
+	{
+		// FIXME: this dlighting doesn't look like rtlights
+		for (i = 0;i < r_numdlights;i++)
+		{
+			light = r_dlight + i;
+			VectorCopy(light->origin, v);
+			if (v[0] < ent->mins[0]) v[0] = ent->mins[0];if (v[0] > ent->maxs[0]) v[0] = ent->maxs[0];
+			if (v[1] < ent->mins[1]) v[1] = ent->mins[1];if (v[1] > ent->maxs[1]) v[1] = ent->maxs[1];
+			if (v[2] < ent->mins[2]) v[2] = ent->mins[2];if (v[2] > ent->maxs[2]) v[2] = ent->maxs[2];
+			VectorSubtract (v, light->origin, v);
+			if (DotProduct(v, v) < light->rtlight.lightmap_cullradius2)
 			{
-				if (!(modeldlightbits[i >> 5] & (1 << (i & 31))))
+				if (CL_TraceLine(ent->origin, light->origin, NULL, NULL, false, NULL, SUPERCONTENTS_SOLID) != 1)
 					continue;
-				if (currentrenderentity == r_dlight[i].ent)
+				VectorSubtract (ent->origin, light->origin, v);
+				f = ((1.0f / (DotProduct(v, v) + LIGHTOFFSET)) - light->rtlight.lightmap_subtract);
+				VectorScale(light->rtlight.lightmap_light, f, ambientcolor);
+				intensity = DotProduct(ambientcolor, ambientcolor);
+				if (f < 0)
+					intensity *= -1.0f;
+				if (nearlights < maxnearlights)
+					j = nearlights++;
+				else
 				{
-					f = (1.0f / LIGHTOFFSET) - nl->lightsubtract;
-					if (f > 0)
-						VectorMA(basecolor, f, r_dlight[i].light, basecolor);
+					for (j = 0;j < maxnearlights;j++)
+					{
+						if (nearlight[j].intensity < intensity)
+						{
+							if (nearlight[j].intensity > 0)
+								VectorAdd(ambient4f, nearlight[j].ambientlight, ambient4f);
+							break;
+						}
+					}
+				}
+				if (j >= maxnearlights)
+				{
+					// this light is less significant than all others,
+					// add it to ambient
+					if (intensity > 0)
+						VectorAdd(ambient4f, ambientcolor, ambient4f);
 				}
 				else
 				{
-					// convert 0-255 radius coloring to 0-1, while also amplifying the brightness by 16
-					//if (TraceLine(currentrenderentity->origin, r_dlight[i].origin, NULL, NULL, 0) == 1)
+					nl = nearlight + j;
+					nl->intensity = intensity;
+					// transform the light into the model's coordinate system
+					if (worldcoords)
+						VectorCopy(light->origin, nl->origin);
+					else
 					{
-						// transform the light into the model's coordinate system
-						//if (gl_transform.integer)
-						//	softwareuntransform(r_dlight[i].origin, nl->origin);
-						//else
-							VectorCopy(r_dlight[i].origin, nl->origin);
-						nl->cullradius2 = r_dlight[i].cullradius2;
-						VectorCopy(r_dlight[i].light, nl->light);
-						nl->lightsubtract = r_dlight[i].lightsubtract;
-						nl++;
-						nearlights++;
+						Matrix4x4_Transform(&ent->inversematrix, light->origin, nl->origin);
+						/*
+						Con_Printf("%i %s : %f %f %f : %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n"
+						, rd - r_dlight, ent->model->name
+						, light->origin[0], light->origin[1], light->origin[2]
+						, nl->origin[0], nl->origin[1], nl->origin[2]
+						, ent->inversematrix.m[0][0], ent->inversematrix.m[0][1], ent->inversematrix.m[0][2], ent->inversematrix.m[0][3]
+						, ent->inversematrix.m[1][0], ent->inversematrix.m[1][1], ent->inversematrix.m[1][2], ent->inversematrix.m[1][3]
+						, ent->inversematrix.m[2][0], ent->inversematrix.m[2][1], ent->inversematrix.m[2][2], ent->inversematrix.m[2][3]
+						, ent->inversematrix.m[3][0], ent->inversematrix.m[3][1], ent->inversematrix.m[3][2], ent->inversematrix.m[3][3]);
+						*/
 					}
+					// integrate mscale into falloff, for maximum speed
+					nl->falloff = mscale;
+					VectorCopy(ambientcolor, nl->ambientlight);
+					nl->light[0] = light->rtlight.lightmap_light[0] * colorr * 4.0f;
+					nl->light[1] = light->rtlight.lightmap_light[1] * colorg * 4.0f;
+					nl->light[2] = light->rtlight.lightmap_light[2] * colorb * 4.0f;
+					nl->subtract = light->rtlight.lightmap_subtract;
+					nl->offset = LIGHTOFFSET;
 				}
 			}
 		}
-		else
-			R_CompleteLightPoint (basecolor, currentrenderentity->origin, true, NULL);
 	}
-	avc = aliasvertcolor;
-	if (nearlights)
+	ambient4f[0] *= colorr;
+	ambient4f[1] *= colorg;
+	ambient4f[2] *= colorb;
+	ambient4f[3] = colora;
+	diffusecolor[0] *= colorr;
+	diffusecolor[1] *= colorg;
+	diffusecolor[2] *= colorb;
+	return nearlights != 0 || DotProduct(diffusecolor, diffusecolor) > 0;
+}
+
+void R_LightModel_CalcVertexColors(const float *ambientcolor4f, const float *diffusecolor, const float *diffusenormal, int numverts, const float *vertex3f, const float *normal3f, float *color4f)
+{
+	int i, j, usediffuse;
+	float color[4], v[3], dot, dist2, f, dnormal[3];
+	nearlight_t *nl;
+	usediffuse = DotProduct(diffusecolor, diffusecolor) > 0;
+	// negate the diffuse normal to avoid the need to negate the
+	// dotproduct on each vertex
+	VectorNegate(diffusenormal, dnormal);
+	if (usediffuse)
+		VectorNormalize(dnormal);
+	// directional shading code here
+	for (i = 0;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4)
 	{
-		av = aliasvert;
-		avn = aliasvertnorm;
-		hardness = r_lightmodelhardness.value;
-		hardnessoffset = (1.0f - hardness);
-		for (i = 0;i < numverts;i++)
+		VectorCopy4(ambientcolor4f, color);
+
+		// silly directional diffuse shading
+		if (usediffuse)
+		{
+			dot = DotProduct(normal3f, dnormal);
+			if (dot > 0)
+				VectorMA(color, dot, diffusecolor, color);
+		}
+
+		// pretty good lighting
+		for (j = 0, nl = &nearlight[0];j < nearlights;j++, nl++)
 		{
-			VectorCopy(basecolor, color);
-			for (j = 0, nl = &nearlight[0];j < nearlights;j++, nl++)
+			VectorSubtract(nl->origin, vertex3f, v);
+			// first eliminate negative lighting (back side)
+			dot = DotProduct(normal3f, v);
+			if (dot > 0)
 			{
-				// distance attenuation
-				VectorSubtract(nl->origin, av, v);
+				// we'll need this again later to normalize the dotproduct
 				dist2 = DotProduct(v,v);
-				if (dist2 < nl->cullradius2)
+				// do the distance attenuation math
+				f = (1.0f / (dist2 * nl->falloff + nl->offset)) - nl->subtract;
+				if (f > 0)
 				{
-					f = (1.0f / (dist2 + LIGHTOFFSET)) - nl->lightsubtract;
-					if (f > 0)
-					{
-						// directional shading
-						#if SLOWMATH
-						t = 1.0f / sqrt(dist2);
-						#else
-						number = DotProduct(v, v);
-						*((long *)&t) = 0x5f3759df - ((* (long *) &number) >> 1);
-						t = t * (1.5f - (number * 0.5f * t * t));
-						#endif
-						// DotProduct(avn,v) * t is dotproduct with a normalized v,
-						// the hardness variables are for backlighting/shinyness
-						f *= DotProduct(avn,v) * t * hardness + hardnessoffset;
-						if (f > 0)
-							VectorMA(color, f, nl->light, color);
-					}
+					// we must divide dot by sqrt(dist2) to compensate for
+					// the fact we did not normalize v before doing the
+					// dotproduct, the result is in the range 0 to 1 (we
+					// eliminated negative numbers already)
+					f *= dot / sqrt(dist2);
+					// blend in the lighting
+					VectorMA(color, f, nl->light, color);
 				}
 			}
-
-			VectorCopy(color, avc);
-			avc[3] = a;
-			avc += 4;
-			av += 3;
-			avn += 3;
 		}
+		VectorCopy4(color, color4f);
 	}
-	else
+}
+
+void R_UpdateEntLights(entity_render_t *ent)
+{
+	int i;
+	const mlight_t *sl;
+	vec3_t v;
+	if (r_lightmapintensity <= 0 && !(ent->flags & RENDER_TRANSPARENT))
+		return;
+	VectorSubtract(ent->origin, ent->entlightsorigin, v);
+	if (ent->entlightsframe != (r_framecount - 1) || (realtime > ent->entlightstime && DotProduct(v,v) >= 1.0f))
 	{
-		for (i = 0;i < numverts;i++)
-		{
-			VectorCopy(basecolor, avc);
-			avc[3] = a;
-			avc += 4;
-		}
+		ent->entlightstime = realtime + 0.1;
+		VectorCopy(ent->origin, ent->entlightsorigin);
+		ent->numentlights = 0;
+		if (cl.worldmodel)
+			for (i = 0, sl = cl.worldmodel->brushq1.lights;i < cl.worldmodel->brushq1.numlights && ent->numentlights < MAXENTLIGHTS;i++, sl++)
+				if (CL_TraceLine(ent->origin, sl->origin, NULL, NULL, false, NULL, SUPERCONTENTS_SOLID) == 1)
+					ent->entlights[ent->numentlights++] = i;
 	}
+	ent->entlightsframe = r_framecount;
 }
+