added r_rtworld, r_rtworldshadows, r_rtdlight, r_rtdlightshadows, and r_lightmapinten...
[xonotic/darkplaces.git] / r_light.c
index 29e8887..908b5aa 100644 (file)
--- a/r_light.c
+++ b/r_light.c
@@ -21,8 +21,9 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #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_modellights = {CVAR_SAVE, "r_modellights", "4"};
@@ -53,7 +54,7 @@ void r_light_start(void)
                        pixels[y][x][3] = 255;
                }
        }
-       lightcorona = R_LoadTexture (lighttexturepool, "lightcorona", 32, 32, &pixels[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE);
+       lightcorona = R_LoadTexture2D(lighttexturepool, "lightcorona", 32, 32, &pixels[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
 }
 
 void r_light_shutdown(void)
@@ -80,17 +81,18 @@ void R_Light_Init(void)
 
 /*
 ==================
-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 || !cl_lightstyle[j].length)
@@ -99,18 +101,11 @@ void R_AnimateLight (void)
                        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;
@@ -118,90 +113,52 @@ void R_BuildLightList(void)
        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 * 64.0f, rd->light);
-               rd->cullradius2 = DotProduct(rd->light, rd->light) * (0.25f / (64.0f * 64.0f)) + 4096.0f;
-               // clamp radius to avoid overflowing division table in lightmap code
-               if (rd->cullradius2 > (2048.0f * 2048.0f))
-                       rd->cullradius2 = (2048.0f * 2048.0f);
-               rd->cullradius = sqrt(rd->cullradius2);
-               rd->subtract = 1.0f / rd->cullradius2;
-               //rd->ent = cd->ent;
-               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
+               }
        }
 }
 
 void R_DrawCoronas(void)
 {
-       int i;
-       rmeshstate_t m;
-       float scale, viewdist, diff[3], dist;
-       rdlight_t *rd;
-       if (!r_coronas.integer)
+       int i, lnum;
+       float cscale, scale, viewdist, dist;
+       dlight_t *light;
+       if (r_coronas.value < 0.01)
                return;
-       memset(&m, 0, sizeof(m));
-       m.blendfunc1 = GL_ONE;
-       m.blendfunc2 = GL_ONE;
-       m.wantoverbright = false;
-       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++)
+       viewdist = DotProduct(r_vieworigin, r_viewforward);
+       if (r_rtworld)
        {
-               rd = r_dlight + i;
-               dist = (DotProduct(rd->origin, vpn) - viewdist);
-               if (dist >= 24.0f && CL_TraceLine(rd->origin, r_origin, NULL, NULL, 0, true) == 1)
+               for (lnum = 0, light = r_shadow_worldlightchain;light;light = light->next, lnum++)
                {
-                       scale = mesh_colorscale * (1.0f / 131072.0f);
-                       if (gl_flashblend.integer)
-                               scale *= 4.0f;
-                       if (fogenabled)
+                       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)
                        {
-                               VectorSubtract(rd->origin, r_origin, diff);
-                               scale *= 1 - exp(fogdensity/DotProduct(diff,diff));
+                               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);
                        }
-                       varray_element[0] = 0;
-                       varray_element[1] = 1;
-                       varray_element[2] = 2;
-                       varray_element[3] = 0;
-                       varray_element[4] = 2;
-                       varray_element[5] = 3;
-                       varray_color[ 0] = varray_color[ 4] = varray_color[ 8] = varray_color[12] = rd->light[0] * scale;
-                       varray_color[ 1] = varray_color[ 5] = varray_color[ 9] = varray_color[13] = rd->light[1] * scale;
-                       varray_color[ 2] = varray_color[ 6] = varray_color[10] = varray_color[14] = rd->light[2] * scale;
-                       varray_color[ 3] = varray_color[ 7] = varray_color[11] = varray_color[15] = 1;
-                       varray_texcoord[0][0] = 0;
-                       varray_texcoord[0][1] = 0;
-                       varray_texcoord[0][2] = 0;
-                       varray_texcoord[0][3] = 1;
-                       varray_texcoord[0][4] = 1;
-                       varray_texcoord[0][5] = 1;
-                       varray_texcoord[0][6] = 1;
-                       varray_texcoord[0][7] = 0;
-                       scale = rd->cullradius * 0.25f;
+               }
+       }
+       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;
-                       varray_vertex[0] = rd->origin[0] - vright[0] * scale - vup[0] * scale;
-                       varray_vertex[1] = rd->origin[1] - vright[1] * scale - vup[1] * scale;
-                       varray_vertex[2] = rd->origin[2] - vright[2] * scale - vup[2] * scale;
-                       varray_vertex[4] = rd->origin[0] - vright[0] * scale + vup[0] * scale;
-                       varray_vertex[5] = rd->origin[1] - vright[1] * scale + vup[1] * scale;
-                       varray_vertex[6] = rd->origin[2] - vright[2] * scale + vup[2] * scale;
-                       varray_vertex[8] = rd->origin[0] + vright[0] * scale + vup[0] * scale;
-                       varray_vertex[9] = rd->origin[1] + vright[1] * scale + vup[1] * scale;
-                       varray_vertex[10] = rd->origin[2] + vright[2] * scale + vup[2] * scale;
-                       varray_vertex[12] = rd->origin[0] + vright[0] * scale - vup[0] * scale;
-                       varray_vertex[13] = rd->origin[1] + vright[1] * scale - vup[1] * scale;
-                       varray_vertex[14] = rd->origin[2] + vright[2] * scale - vup[2] * scale;
-                       R_Mesh_Draw(4, 2);
+                       }
+                       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);
                }
        }
 }
@@ -214,252 +171,110 @@ DYNAMIC LIGHTS
 =============================================================================
 */
 
+static int lightpvsbytes;
+static qbyte lightpvs[(MAX_MAP_LEAFS+7)>>3];
+
 /*
 =============
 R_MarkLights
 =============
 */
-extern int r_pvsframecount;
-static void R_OldMarkLights (entity_render_t *ent, 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;
-       int i, *surfacepvsframes;
-       int d, impacts, impactt;
-       float dist, dist2, impact[3];
-
-       if (!r_dynamic.integer)
-               return;
+       int i;
+       mleaf_t *leaf;
+       float dist;
 
        // for comparisons to minimum acceptable light
-       maxdist = rd->cullradius2;
-
-       surfacepvsframes = ent->model->surfacepvsframes;
-loc0:
-       if (node->contents < 0)
-               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 = ent->model->surfaces + node->firstsurface;
-       for (i = 0;i < node->numsurfaces;i++, surf++)
+       while(node->contents >= 0)
        {
-               if (surfacepvsframes[surf->number] != r_pvsframecount)
-                       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;
-
-               if (node->plane->type < 3)
-               {
-                       VectorCopy(lightorigin, impact);
-                       impact[node->plane->type] -= dist;
-               }
+               dist = PlaneDiff(lightorigin, node->plane);
+               if (dist > light->rtlight.lightmap_cullradius)
+                       node = node->children[0];
                else
                {
-                       impact[0] = lightorigin[0] - surf->plane->normal[0] * dist;
-                       impact[1] = lightorigin[1] - surf->plane->normal[1] * dist;
-                       impact[2] = lightorigin[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;
-
-               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;
-
-               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;
+                       if (dist >= -light->rtlight.lightmap_cullradius)
+                               R_RecursiveMarkLights(ent, lightorigin, light, bit, bitindex, node->children[0], pvs, pvsbits);
+                       node = node->children[1];
                }
-               surf->dlightbits[bitindex] |= bit;
        }
 
-       if (node->children[0]->contents >= 0)
+       // check if leaf is visible according to pvs
+       leaf = (mleaf_t *)node;
+       i = leaf->clusterindex;
+       if (leaf->nummarksurfaces && (i >= pvsbits || CHECKPVSBIT(pvs, i)))
        {
-               if (node->children[1]->contents >= 0)
-               {
-                       R_OldMarkLights (ent, lightorigin, rd, bit, bitindex, node->children[0]);
-                       node = node->children[1];
-                       goto loc0;
-               }
-               else
+               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++)
                {
-                       node = node->children[0];
-                       goto loc0;
-               }
-       }
-       else if (node->children[1]->contents >= 0)
-       {
-               node = node->children[1];
-               goto loc0;
-       }
-}
+                       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;
 
+                       if (dist < -0.25f && !(surf->flags & SURF_LIGHTBOTHSIDES))
+                               continue;
 
-static void R_VisMarkLights (entity_render_t *ent, rdlight_t *rd, int bit, int bitindex)
-{
-       static int lightframe = 0;
-       mleaf_t *pvsleaf;
-       vec3_t lightorigin;
-       model_t *model;
-       int i, k, m, c, leafnum, *surfacepvsframes, *mark;
-       msurface_t *surf;
-       mleaf_t *leaf;
-       qbyte *in;
-       int row;
-       float low[3], high[3], dist, maxdist;
-
-       if (!r_dynamic.integer)
-               return;
-
-       Matrix4x4_Transform(&ent->inversematrix, rd->origin, lightorigin);
+                       dist2 = dist * dist;
+                       if (dist2 >= maxdist)
+                               continue;
 
-       model = ent->model;
-       pvsleaf = Mod_PointInLeaf (lightorigin, model);
-       if (pvsleaf == NULL)
-               return;
-
-       in = pvsleaf->compressed_vis;
-       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);
-               return;
-       }
+                       VectorCopy(lightorigin, impact);
+                       if (surf->plane->type >= 3)
+                               VectorMA(impact, -sdist, surf->plane->normal, impact);
+                       else
+                               impact[surf->plane->type] -= sdist;
 
-       lightframe++;
+                       impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
 
-       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;
+                       d = bound(0, impacts, surf->extents[0] + 16) - impacts;
+                       dist2 += d * d;
+                       if (dist2 > maxdist)
+                               continue;
 
-       // for comparisons to minimum acceptable light
-       maxdist = rd->cullradius2;
+                       impactt = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
 
-       row = (model->numleafs+7)>>3;
-       surfacepvsframes = model->surfacepvsframes;
+                       d = bound(0, impactt, surf->extents[1] + 16) - impactt;
+                       dist2 += d * d;
+                       if (dist2 > maxdist)
+                               continue;
 
-       k = 0;
-       while (k < row)
-       {
-               c = *in++;
-               if (c)
-               {
-                       for (i = 0;i < 8;i++)
+                       if (surf->dlightframe != r_framecount) // not dynamic until now
                        {
-                               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->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 ((m = leaf->nummarksurfaces))
-                                       {
-                                               mark = leaf->firstmarksurface;
-                                               do
-                                               {
-                                                       surf = model->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] != r_pvsframecount)
-                                                               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;
-
-                                                               if (surf->plane->type < 3)
-                                                               {
-                                                                       VectorCopy(lightorigin, impact);
-                                                                       impact[surf->plane->type] -= dist;
-                                                               }
-                                                               else
-                                                               {
-                                                                       impact[0] = lightorigin[0] - surf->plane->normal[0] * dist;
-                                                                       impact[1] = lightorigin[1] - surf->plane->normal[1] * dist;
-                                                                       impact[2] = lightorigin[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;
-
-                                                               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;
-
-                                                               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);
-                                       }
-                               }
+                               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;
                        }
-                       k++;
-                       continue;
+                       surf->dlightbits[bitindex] |= bit;
                }
-
-               k += *in++;
        }
 }
 
 void R_MarkLights(entity_render_t *ent)
 {
-       int i;
-       if (!gl_flashblend.integer)
-               for (i = 0;i < r_numdlights;i++)
-                       R_VisMarkLights (ent, r_dlight + i, 1 << (i & 31), i >> 5);
+       int i, bit, bitindex;
+       dlight_t *light;
+       vec3_t lightorigin;
+       if (!gl_flashblend.integer && r_dynamic.integer && ent->model && ent->model->brushq1.num_leafs)
+       {
+               for (i = 0, light = r_dlight;i < r_numdlights;i++, light++)
+               {
+                       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));
+               }
+       }
 }
 
 /*
@@ -470,307 +285,186 @@ LIGHT SAMPLING
 =============================================================================
 */
 
-static int RecursiveLightPoint (vec3_t color, const 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 = 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 + 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
-       {
-               // check for impact on this node
-               if (node->numsurfaces)
-               {
-                       int i, ds, dt;
-                       msurface_t *surf;
-
-                       surf = cl.worldmodel->surfaces + node->firstsurface;
-                       for (i = 0;i < node->numsurfaces;i++, surf++)
-                       {
-                               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)
-                               {
-                                       qbyte *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;
+               VectorSet(ambientcolor, 1, 1, 1);
 
-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);
-                               }
-                               return true; // success
-                       }
-               }
-
-               // go down back side
-               node = node->children[side ^ 1];
-               startz = mid;
-               distz = endz - startz;
-               goto loc0;
-       }
-}
-
-void R_CompleteLightPoint (vec3_t color, const vec3_t p, int dynamic, const mleaf_t *leaf)
-{
-       int i;
-       vec3_t v;
-       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)
-       {
-               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)
+       // FIXME: this .lights related stuff needs to be ported into the Mod_Q1BSP code
+       if (cl.worldmodel->brushq1.numlights)
        {
-               for (i = 0;i < cl.worldmodel->numlights;i++)
+               int i;
+               vec3_t v;
+               float f;
+               mlight_t *sl;
+               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);
                                f = ((1.0f / (DotProduct(v, v) * sl->falloff + sl->distbias)) - sl->subtract);
-                               if (f > 0 && CL_TraceLine(p, sl->origin, NULL, NULL, 0, false) == 1)
+                               if (f > 0 && CL_TraceLine(p, sl->origin, NULL, NULL, false, NULL, SUPERCONTENTS_SOLID) == 1)
                                {
                                        f *= d_lightstylevalue[sl->style] * (1.0f / 65536.0f);
-                                       VectorMA(color, f, sl->light, color);
+                                       VectorMA(ambientcolor, f, sl->light, ambientcolor);
                                }
                        }
                }
        }
-       else
-               RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
 
        if (dynamic)
        {
+               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++)
                {
-                       rd = r_dlight + i;
-                       VectorSubtract (p, rd->origin, v);
+                       light = r_dlight + i;
+                       VectorSubtract(p, light->origin, v);
                        f = DotProduct(v, v);
-                       if (f < rd->cullradius2 && CL_TraceLine(p, rd->origin, NULL, NULL, 0, false) == 1)
+                       if (f < light->rtlight.lightmap_cullradius2 && CL_TraceLine(p, light->origin, NULL, NULL, false, NULL, SUPERCONTENTS_SOLID) == 1)
                        {
-                               f = (1.0f / (f + LIGHTOFFSET)) - rd->subtract;
-                               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 (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 || r_fullbright.integer || !cl.worldmodel->lightdata || ent->effects & EF_FULLBRIGHT)
-       {
-               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;
 
-void R_LightModel(const entity_render_t *ent, int numverts, float colorr, float colorg, float colorb, int worldcoords)
+static int nearlights;
+static nearlight_t nearlight[MAX_DLIGHTS];
+
+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, 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
+       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;
-               // 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;
+               // highly rare
+               VectorSet(ambient4f, 1, 1, 1);
+               maxnearlights = 0;
        }
-       nearlight[MAX_DLIGHTS], *nl;
-       mlight_t *sl;
-       rdlight_t *rd;
-       a = ent->alpha;
+       else if (r_lightmapintensity <= 0 && !(ent->flags & RENDER_TRANSPARENT))
+               maxnearlights = 0;
+       else
+       {
+               if (cl.worldmodel && cl.worldmodel->brush.LightPoint)
+               {
+                       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);
+       }
+
        // 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 ((maxnearlights != 0) && !r_fullbright.integer && !(ent->effects & EF_FULLBRIGHT))
+       // FIXME: no support for .lights on non-Q1BSP?
+       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_rtdlight || (ent->flags & RENDER_TRANSPARENT))
+       {
+               // FIXME: this dlighting doesn't look like rtlights
                for (i = 0;i < r_numdlights;i++)
                {
-                       rd = r_dlight + i;
-                       VectorCopy(rd->origin, v);
+                       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, rd->origin, v);
-                       if (DotProduct(v, v) < rd->cullradius2)
+                       VectorSubtract (v, light->origin, v);
+                       if (DotProduct(v, v) < light->rtlight.lightmap_cullradius2)
                        {
-                               if (CL_TraceLine(ent->origin, rd->origin, NULL, NULL, 0, false) != 1)
+                               if (CL_TraceLine(ent->origin, light->origin, NULL, NULL, false, NULL, SUPERCONTENTS_SOLID) != 1)
                                        continue;
-                               VectorSubtract (ent->origin, rd->origin, v);
-                               f = ((1.0f / (DotProduct(v, v) + LIGHTOFFSET)) - rd->subtract);
-                               VectorScale(rd->light, f, ambientcolor);
+                               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;
@@ -783,7 +477,7 @@ void R_LightModel(const entity_render_t *ent, int numverts, float colorr, float
                                                if (nearlight[j].intensity < intensity)
                                                {
                                                        if (nearlight[j].intensity > 0)
-                                                               VectorAdd(basecolor, nearlight[j].ambientlight, basecolor);
+                                                               VectorAdd(ambient4f, nearlight[j].ambientlight, ambient4f);
                                                        break;
                                                }
                                        }
@@ -793,7 +487,7 @@ void R_LightModel(const entity_render_t *ent, int numverts, float colorr, float
                                        // this light is less significant than all others,
                                        // add it to ambient
                                        if (intensity > 0)
-                                               VectorAdd(basecolor, ambientcolor, basecolor);
+                                               VectorAdd(ambient4f, ambientcolor, ambient4f);
                                }
                                else
                                {
@@ -801,14 +495,14 @@ void R_LightModel(const entity_render_t *ent, int numverts, float colorr, float
                                        nl->intensity = intensity;
                                        // transform the light into the model's coordinate system
                                        if (worldcoords)
-                                               VectorCopy(rd->origin, nl->origin);
+                                               VectorCopy(light->origin, nl->origin);
                                        else
                                        {
-                                               Matrix4x4_Transform(&ent->inversematrix, rd->origin, nl->origin);
+                                               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
-                                               , rd->origin[0], rd->origin[1], rd->origin[2]
+                                               , 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]
@@ -819,79 +513,74 @@ void R_LightModel(const entity_render_t *ent, int numverts, float colorr, float
                                        // 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->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, ent->origin, true, NULL);
-       }
-       basecolor[0] *= colorr;
-       basecolor[1] *= colorg;
-       basecolor[2] *= colorb;
-       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;
-               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)
                        {
-                               VectorSubtract(nl->origin, av, 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 += 4;
-                       avn += 3;
-               }
-       }
-       else
-       {
-               for (i = 0;i < numverts;i++)
-               {
-                       VectorCopy(basecolor, avc);
-                       avc[3] = a;
-                       avc += 4;
                }
+               VectorCopy4(color, color4f);
        }
 }
 
@@ -900,6 +589,8 @@ 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))
        {
@@ -907,9 +598,10 @@ 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++)
-                               if (CL_TraceLine(ent->origin, sl->origin, NULL, NULL, 0, false) == 1)
+                       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;
 }
+