X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=r_light.c;h=269d3d1f0fd7cfd10f9d2669df9892f48248bc04;hb=23f1bc3fdf9819b0a1e92b26820d791c7789014b;hp=8de4bdf7dc105c9823e54f7d45c5d26c1430243d;hpb=ec6dd5edf7290360f59fe1d6345af69875fbea81;p=xonotic%2Fdarkplaces.git

diff --git a/r_light.c b/r_light.c
index 8de4bdf7..269d3d1f 100644
--- a/r_light.c
+++ b/r_light.c
@@ -141,18 +141,11 @@ void R_BuildLightList(void)
 void R_DrawCoronas(void)
 {
 	int i;
-	rmeshstate_t m;
-	float scale, viewdist, diff[3], dist;
+	float cscale, scale, viewdist, dist;
 	rdlight_t *rd;
 	if (!r_coronas.integer)
 		return;
-	memset(&m, 0, sizeof(m));
-	m.blendfunc1 = GL_ONE;
-	m.blendfunc2 = GL_ONE;
-	m.depthdisable = true; // magic
-	m.tex[0] = R_GetTexture(lightcorona);
 	R_Mesh_Matrix(&r_identitymatrix);
-	R_Mesh_State(&m);
 	viewdist = DotProduct(r_origin, vpn);
 	for (i = 0;i < r_numdlights;i++)
 	{
@@ -160,19 +153,14 @@ void R_DrawCoronas(void)
 		dist = (DotProduct(rd->origin, vpn) - viewdist);
 		if (dist >= 24.0f && CL_TraceLine(rd->origin, r_origin, NULL, NULL, 0, true, NULL) == 1)
 		{
-			scale = r_colorscale * (1.0f / 131072.0f);
-			if (gl_flashblend.integer)
-				scale *= 4.0f;
-			if (fogenabled)
-			{
-				VectorSubtract(rd->origin, r_origin, diff);
-				scale *= 1 - exp(fogdensity/DotProduct(diff,diff));
-			}
-			GL_Color(rd->light[0] * scale, rd->light[1] * scale, rd->light[2] * scale, 1);
+			cscale = (1.0f / 131072.0f);
 			scale = rd->cullradius * 0.25f;
 			if (gl_flashblend.integer)
+			{
+				cscale *= 4.0f;
 				scale *= 2.0f;
-			R_DrawSpriteMesh(rd->origin, vright, vup, scale, -scale, -scale, scale);
+			}
+			R_DrawSprite(GL_ONE, GL_ONE, lightcorona, true, rd->origin, vright, vup, scale, -scale, -scale, scale, rd->light[0] * cscale, rd->light[1] * cscale, rd->light[2] * cscale, 1);
 		}
 	}
 }
@@ -204,7 +192,7 @@ static void R_OldMarkLights (entity_render_t *ent, vec3_t lightorigin, rdlight_t
 	// for comparisons to minimum acceptable light
 	maxdist = rd->cullradius2;
 
-	surfacepvsframes = ent->model->surfacepvsframes;
+	surfacepvsframes = ent->model->brushq1.surfacepvsframes;
 loc0:
 	if (node->contents < 0)
 		return;
@@ -223,10 +211,10 @@ loc0:
 	}
 
 // mark the polygons
-	surf = ent->model->surfaces + node->firstsurface;
+	surf = ent->model->brushq1.surfaces + node->firstsurface;
 	for (i = 0;i < node->numsurfaces;i++, surf++)
 	{
-		if (surfacepvsframes[surf->number] != ent->model->pvsframecount)
+		if (surfacepvsframes[surf->number] != ent->model->brushq1.pvsframecount)
 			continue;
 		dist = ndist;
 		if (surf->flags & SURF_PLANEBACK)
@@ -310,13 +298,13 @@ static void R_VisMarkLights (entity_render_t *ent, rdlight_t *rd, int bit, int b
 	int row;
 	float low[3], high[3], dist, maxdist;
 
-	if (!r_dynamic.integer)
+	if (!r_dynamic.integer || !ent->model)
 		return;
 
 	Matrix4x4_Transform(&ent->inversematrix, rd->origin, lightorigin);
 
 	model = ent->model;
-	pvsleaf = Mod_PointInLeaf (lightorigin, model);
+	pvsleaf = model->brushq1.PointInLeaf(model, lightorigin);
 	if (pvsleaf == NULL)
 		return;
 
@@ -324,7 +312,7 @@ static void R_VisMarkLights (entity_render_t *ent, rdlight_t *rd, int bit, int b
 	if (!r_vismarklights.integer || !in)
 	{
 		// told not to use pvs, or there's no pvs to use
-		R_OldMarkLights(ent, lightorigin, rd, bit, bitindex, model->nodes + model->hulls[0].firstclipnode);
+		R_OldMarkLights(ent, lightorigin, rd, bit, bitindex, model->brushq1.nodes + model->brushq1.hulls[0].firstclipnode);
 		return;
 	}
 
@@ -336,8 +324,8 @@ static void R_VisMarkLights (entity_render_t *ent, rdlight_t *rd, int bit, int b
 	// for comparisons to minimum acceptable light
 	maxdist = rd->cullradius2;
 
-	row = (model->numleafs+7)>>3;
-	surfacepvsframes = model->surfacepvsframes;
+	row = (model->brushq1.numleafs+7)>>3;
+	surfacepvsframes = model->brushq1.surfacepvsframes;
 
 	k = 0;
 	while (k < row)
@@ -351,9 +339,9 @@ static void R_VisMarkLights (entity_render_t *ent, rdlight_t *rd, int bit, int b
 				{
 					// 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)
+					if (leafnum > model->brushq1.numleafs)
 						return;
-					leaf = &model->leafs[leafnum];
+					leaf = &model->brushq1.leafs[leafnum];
 					if (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])
@@ -363,12 +351,12 @@ static void R_VisMarkLights (entity_render_t *ent, rdlight_t *rd, int bit, int b
 						mark = leaf->firstmarksurface;
 						do
 						{
-							surf = model->surfaces + *mark++;
+							surf = model->brushq1.surfaces + *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 (surfacepvsframes[surf->number] != model->pvsframecount)
+							if (surfacepvsframes[surf->number] != model->brushq1.pvsframecount)
 								continue;
 							dist = PlaneDiff(lightorigin, surf->plane);
 							if (surf->flags & SURF_PLANEBACK)
@@ -498,7 +486,7 @@ loc0:
 			int i, ds, dt;
 			msurface_t *surf;
 
-			surf = cl.worldmodel->surfaces + node->firstsurface;
+			surf = cl.worldmodel->brushq1.surfaces + node->firstsurface;
 			for (i = 0;i < node->numsurfaces;i++, surf++)
 			{
 				if (!(surf->flags & SURF_LIGHTMAP))
@@ -591,20 +579,20 @@ void R_CompleteLightPoint (vec3_t color, const vec3_t p, int dynamic, const mlea
 	float f;
 	rdlight_t *rd;
 	mlight_t *sl;
-	if (leaf == NULL)
-		leaf = Mod_PointInLeaf(p, cl.worldmodel);
-	if (!leaf || leaf->contents == CONTENTS_SOLID || r_fullbright.integer || !cl.worldmodel->lightdata)
+	if (leaf == NULL && cl.worldmodel != NULL)
+		leaf = cl.worldmodel->brushq1.PointInLeaf(cl.worldmodel, p);
+	if (!leaf || leaf->contents == CONTENTS_SOLID || r_fullbright.integer || !cl.worldmodel->brushq1.lightdata)
 	{
 		color[0] = color[1] = color[2] = 1;
 		return;
 	}
 
 	color[0] = color[1] = color[2] = r_ambient.value * (2.0f / 128.0f);
-	if (cl.worldmodel->numlights)
+	if (cl.worldmodel->brushq1.numlights)
 	{
-		for (i = 0;i < cl.worldmodel->numlights;i++)
+		for (i = 0;i < cl.worldmodel->brushq1.numlights;i++)
 		{
-			sl = cl.worldmodel->lights + i;
+			sl = cl.worldmodel->brushq1.lights + i;
 			if (d_lightstylevalue[sl->style] > 0)
 			{
 				VectorSubtract (p, sl->origin, v);
@@ -618,7 +606,7 @@ void R_CompleteLightPoint (vec3_t color, const vec3_t p, int dynamic, const mlea
 		}
 	}
 	else
-		RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
+		RecursiveLightPoint (color, cl.worldmodel->brushq1.nodes, p[0], p[1], p[2], p[2] - 65536);
 
 	if (dynamic)
 	{
@@ -636,235 +624,241 @@ void R_CompleteLightPoint (vec3_t color, const vec3_t p, int dynamic, const mlea
 	}
 }
 
-void R_ModelLightPoint (const entity_render_t *ent, vec3_t color, const vec3_t p)
+typedef struct
 {
-	mleaf_t *leaf;
-	leaf = Mod_PointInLeaf(p, cl.worldmodel);
-	if (!leaf || leaf->contents == CONTENTS_SOLID || !cl.worldmodel->lightdata)
-	{
-		color[0] = color[1] = color[2] = 1;
-		return;
-	}
-
-	color[0] = color[1] = color[2] = r_ambient.value * (2.0f / 128.0f);
-	if (!cl.worldmodel->numlights)
-		RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
+	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(const entity_render_t *ent, int numverts, float *vertices, float *normals, float *colors, float colorr, float colorg, float colorb, int worldcoords)
+int R_LightModel(float *ambient4f, const entity_render_t *ent, float colorr, float colorg, float colorb, float colora, int worldcoords)
 {
-	int i, j, nearlights = 0, maxnearlights = r_modellights.integer;
-	float color[3], basecolor[3], v[3], t, *av, *avn, *avc, a, f, dist2, mscale, dot, stylescale, intensity, ambientcolor[3];
-	struct
-	{
-		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[MAX_DLIGHTS], *nl;
+	int i, j, maxnearlights;
+	float v[3], f, mscale, stylescale, intensity, ambientcolor[3];
+	nearlight_t *nl;
 	mlight_t *sl;
 	rdlight_t *rd;
-	a = ent->alpha;
+	mleaf_t *leaf;
+
+	nearlights = 0;
+	maxnearlights = r_modellights.integer;
+	if (r_fullbright.integer || (ent->effects & EF_FULLBRIGHT))
+	{
+		// highly rare
+		ambient4f[0] = colorr;
+		ambient4f[1] = colorg;
+		ambient4f[2] = colorb;
+		ambient4f[3] = colora;
+		return false;
+	}
+	if (r_shadow_realtime_world.integer)
+	{
+		// user config choice
+		ambient4f[0] = r_ambient.value * (2.0f / 128.0f) * colorr;
+		ambient4f[1] = r_ambient.value * (2.0f / 128.0f) * colorg;
+		ambient4f[2] = r_ambient.value * (2.0f / 128.0f) * colorb;
+		ambient4f[3] = colora;
+		return false;
+	}
+	if (maxnearlights == 0)
+	{
+		// user config choice
+		R_CompleteLightPoint (ambient4f, ent->origin, true, NULL);
+		ambient4f[0] *= colorr;
+		ambient4f[1] *= colorg;
+		ambient4f[2] *= colorb;
+		ambient4f[3] = colora;
+		return false;
+	}
+	leaf = cl.worldmodel ? cl.worldmodel->brushq1.PointInLeaf(cl.worldmodel, ent->origin) : NULL;
+	if (!leaf || leaf->contents == CONTENTS_SOLID || !cl.worldmodel->brushq1.lightdata)
+		ambient4f[0] = ambient4f[1] = ambient4f[2] = 1;
+	else
+	{
+		ambient4f[0] = ambient4f[1] = ambient4f[2] = r_ambient.value * (2.0f / 128.0f);
+		if (!cl.worldmodel->brushq1.numlights)
+			RecursiveLightPoint (ambient4f, cl.worldmodel->brushq1.nodes, ent->origin[0], ent->origin[1], ent->origin[2], ent->origin[2] - 65536);
+	}
 	// 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;
-	if (r_fullbright.integer || (ent->effects & EF_FULLBRIGHT))
-		basecolor[0] = basecolor[1] = basecolor[2] = 1.0f;
-	else if (r_shadow_realtime_world.integer)
-		basecolor[0] = basecolor[1] = basecolor[2] = r_ambient.value * (2.0f / 128.0f);
-	else if (maxnearlights == 0)
-		R_CompleteLightPoint (basecolor, ent->origin, true, NULL);
-	else
+	nl = &nearlight[0];
+	for (i = 0;i < ent->numentlights;i++)
 	{
-		R_ModelLightPoint(ent, basecolor, ent->origin);
-		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
 		{
-			sl = cl.worldmodel->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++)
 			{
-				for (j = 0;j < maxnearlights;j++)
+				if (nearlight[j].intensity < intensity)
 				{
-					if (nearlight[j].intensity < intensity)
-					{
-						if (nearlight[j].intensity > 0)
-							VectorAdd(basecolor, nearlight[j].ambientlight, basecolor);
-						break;
-					}
+					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(basecolor, ambientcolor, basecolor);
-			}
+		}
+		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
-			{
-				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;
-			}
+				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_shadow_realtime_dlight.integer)
+	}
+	if (!r_shadow_realtime_dlight.integer)
+	{
+		for (i = 0;i < r_numdlights;i++)
 		{
-			for (i = 0;i < r_numdlights;i++)
+			rd = r_dlight + i;
+			VectorCopy(rd->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, rd->origin, v);
+			if (DotProduct(v, v) < rd->cullradius2)
 			{
-				rd = r_dlight + i;
-				VectorCopy(rd->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, rd->origin, v);
-				if (DotProduct(v, v) < rd->cullradius2)
+				if (CL_TraceLine(ent->origin, rd->origin, NULL, NULL, 0, false, NULL) != 1)
+					continue;
+				VectorSubtract (ent->origin, rd->origin, v);
+				f = ((1.0f / (DotProduct(v, v) + LIGHTOFFSET)) - rd->subtract);
+				VectorScale(rd->light, f, ambientcolor);
+				intensity = DotProduct(ambientcolor, ambientcolor);
+				if (f < 0)
+					intensity *= -1.0f;
+				if (nearlights < maxnearlights)
+					j = nearlights++;
+				else
 				{
-					if (CL_TraceLine(ent->origin, rd->origin, NULL, NULL, 0, false, NULL) != 1)
-						continue;
-					VectorSubtract (ent->origin, rd->origin, v);
-					f = ((1.0f / (DotProduct(v, v) + LIGHTOFFSET)) - rd->subtract);
-					VectorScale(rd->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++)
 					{
-						for (j = 0;j < maxnearlights;j++)
+						if (nearlight[j].intensity < intensity)
 						{
-							if (nearlight[j].intensity < intensity)
-							{
-								if (nearlight[j].intensity > 0)
-									VectorAdd(basecolor, nearlight[j].ambientlight, basecolor);
-								break;
-							}
+							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(basecolor, ambientcolor, basecolor);
-					}
+				}
+				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(rd->origin, nl->origin);
 					else
 					{
-						nl = nearlight + j;
-						nl->intensity = intensity;
-						// transform the light into the model's coordinate system
-						if (worldcoords)
-							VectorCopy(rd->origin, nl->origin);
-						else
-						{
-							Matrix4x4_Transform(&ent->inversematrix, rd->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
-							, rd->origin[0], rd->origin[1], rd->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] = rd->light[0] * colorr * 4.0f;
-						nl->light[1] = rd->light[1] * colorg * 4.0f;
-						nl->light[2] = rd->light[2] * colorb * 4.0f;
-						nl->subtract = rd->subtract;
-						nl->offset = LIGHTOFFSET;
+						Matrix4x4_Transform(&ent->inversematrix, rd->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
+						, rd->origin[0], rd->origin[1], rd->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] = rd->light[0] * colorr * 4.0f;
+					nl->light[1] = rd->light[1] * colorg * 4.0f;
+					nl->light[2] = rd->light[2] * colorb * 4.0f;
+					nl->subtract = rd->subtract;
+					nl->offset = LIGHTOFFSET;
 				}
 			}
 		}
 	}
-	basecolor[0] *= colorr;
-	basecolor[1] *= colorg;
-	basecolor[2] *= colorb;
-	avc = colors;
-	if (nearlights)
+	ambient4f[0] *= colorr;
+	ambient4f[1] *= colorg;
+	ambient4f[2] *= colorb;
+	ambient4f[3] = colora;
+	return nearlights != 0;
+}
+
+void R_LightModel_CalcVertexColors(const float *ambientcolor4f, int numverts, const float *vertex3f, const float *normal3f, float *color4f)
+{
+	int i, j;
+	float color[4], v[3], dot, dist2, f;
+	nearlight_t *nl;
+	// directional shading code here
+	for (i = 0;i < numverts;i++, vertex3f += 3, normal3f += 3, color4f += 4)
 	{
-		GL_UseColorArray();
-		av = vertices;
-		avn = normals;
-		for (i = 0;i < numverts;i++)
+		VectorCopy4(ambientcolor4f, color);
+		for (j = 0, nl = &nearlight[0];j < nearlights;j++, nl++)
 		{
-			VectorCopy(basecolor, color);
-			for (j = 0, nl = &nearlight[0];j < nearlights;j++, nl++)
+			VectorSubtract(vertex3f, nl->origin, v);
+			// first eliminate negative lighting (back side)
+			dot = DotProduct(normal3f, v);
+			if (dot > 0)
 			{
-				VectorSubtract(av, nl->origin, v);
-				// directional shading
-				dot = DotProduct(avn,v);
-				if (dot > 0)
+				// we'll need this again later to normalize the dotproduct
+				dist2 = DotProduct(v,v);
+				// do the distance attenuation math
+				f = (1.0f / (dist2 * nl->falloff + nl->offset)) - nl->subtract;
+				if (f > 0)
 				{
-					// the vertex normal faces the light
-
-					// do the distance attenuation
-					dist2 = DotProduct(v,v);
-					f = (1.0f / (dist2 * nl->falloff + nl->offset)) - nl->subtract;
-					if (f > 0)
-					{
-						//#if SLOWMATH
-						t = 1.0f / sqrt(dist2);
-						//#else
-						//*((int *)&t) = 0x5f3759df - ((* (int *) &dist2) >> 1);
-						//t = t * (1.5f - (dist2 * 0.5f * t * t));
-						//#endif
-
-						// dot * t is dotproduct with a normalized v.
-						// (the result would be -1 to +1, but we already
-						// eliminated the <= 0 case, so it is 0 to 1)
-
-						// the hardness variables are for backlighting/shinyness
-						// these have been hardwired at * 0.5 + 0.5 to match
-						// the quake map lighting utility's equations
-						f *= dot * t;// * 0.5f + 0.5f;// * hardness + hardnessoffset;
-						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
-		GL_Color(basecolor[0], basecolor[1], basecolor[2], a);
 }
 
 void R_UpdateEntLights(entity_render_t *ent)
@@ -872,7 +866,7 @@ void R_UpdateEntLights(entity_render_t *ent)
 	int i;
 	const mlight_t *sl;
 	vec3_t v;
-	if (r_shadow_realtime_dlight.integer)
+	if (r_shadow_realtime_dlight.integer || gl_flashblend.integer)
 		return;
 	VectorSubtract(ent->origin, ent->entlightsorigin, v);
 	if (ent->entlightsframe != (r_framecount - 1) || (realtime > ent->entlightstime && DotProduct(v,v) >= 1.0f))
@@ -881,7 +875,7 @@ void R_UpdateEntLights(entity_render_t *ent)
 		VectorCopy(ent->origin, ent->entlightsorigin);
 		ent->numentlights = 0;
 		if (cl.worldmodel)
-			for (i = 0, sl = cl.worldmodel->lights;i < cl.worldmodel->numlights && ent->numentlights < MAXENTLIGHTS;i++, sl++)
+			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, 0, false, NULL) == 1)
 					ent->entlights[ent->numentlights++] = i;
 	}