added r_rtworld, r_rtworldshadows, r_rtdlight, r_rtdlightshadows, and r_lightmapinten...
[xonotic/darkplaces.git] / r_light.c
index 3bbf6b5..908b5aa 100644 (file)
--- a/r_light.c
+++ b/r_light.c
@@ -8,7 +8,7 @@ of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 See the GNU General Public License for more details.
 
@@ -20,797 +20,588 @@ 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"
 
-cvar_t r_lightmodels = {"r_lightmodels", "1"};
+dlight_t r_dlight[MAX_DLIGHTS];
+int r_numdlights = 0;
 
-void r_light_start()
+cvar_t r_modellights = {CVAR_SAVE, "r_modellights", "4"};
+cvar_t r_vismarklights = {0, "r_vismarklights", "1"};
+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;
+
+void r_light_start(void)
 {
+       float dx, dy;
+       int x, y, a;
+       qbyte pixels[32][32][4];
+       lighttexturepool = R_AllocTexturePool();
+       for (y = 0;y < 32;y++)
+       {
+               dy = (y - 15.5f) * (1.0f / 16.0f);
+               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))) * 32.0f / (1.0f / (1.0f + 0.2));
+                       a = bound(0, a, 255);
+                       pixels[y][x][0] = a;
+                       pixels[y][x][1] = a;
+                       pixels[y][x][2] = a;
+                       pixels[y][x][3] = 255;
+               }
+       }
+       lightcorona = R_LoadTexture2D(lighttexturepool, "lightcorona", 32, 32, &pixels[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
 }
 
-void r_light_shutdown()
+void r_light_shutdown(void)
 {
+       lighttexturepool = NULL;
+       lightcorona = NULL;
 }
 
-void R_Light_Init()
+void r_light_newmap(void)
 {
-       Cvar_RegisterVariable(&r_lightmodels);
-       R_RegisterModule("R_Light", r_light_start, r_light_shutdown);
+       int i;
+       for (i = 0;i < 256;i++)
+               d_lightstylevalue[i] = 264;             // normal light value
 }
 
-int    r_dlightframecount;
+void R_Light_Init(void)
+{
+       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);
-       for (j=0 ; j<MAX_LIGHTSTYLES ; j++)
+       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;
-       }       
-}
-
-/*
-=============================================================================
-
-DYNAMIC LIGHTS
-
-=============================================================================
-*/
+               l = cl_lightstyle[j].map[l] - 'a';
+               d_lightstylevalue[j] = ((k*frac)+(l*(1-frac)))*22;
+       }
 
-/*
-=============
-R_MarkLights
-=============
-*/
-void R_OldMarkLights (vec3_t lightorigin, dlight_t *light, int bit, int bitindex, mnode_t *node)
-{
-       float           dist;
-       msurface_t      *surf;
-       int                     i;
+       r_numdlights = 0;
+       c_dlights = 0;
 
-loc0:
-       if (node->contents < 0)
+       if (!r_dynamic.integer || !cl_dlights)
                return;
 
-       dist = PlaneDiff(lightorigin, node->plane);
-       
-       if (dist > light->radius)
+       // TODO: optimize to not scan whole cl_dlights array if possible
+       for (i = 0;i < MAX_DLIGHTS;i++)
        {
-               if (node->children[0]->contents >= 0) // LordHavoc: save some time by not pushing another stack frame
+               if (cl_dlights[i].radius > 0)
                {
-                       node = node->children[0];
-                       goto loc0;
+                       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
                }
-               return;
        }
-       if (dist < -light->radius)
-       {
-               if (node->children[1]->contents >= 0) // LordHavoc: save some time by not pushing another stack frame
-               {
-                       node = node->children[1];
-                       goto loc0;
-               }
-               return;
-       }
-
-       if (node->dlightframe != r_dlightframecount) // not dynamic until now
-       {
-               node->dlightbits[0] = node->dlightbits[1] = node->dlightbits[2] = node->dlightbits[3] = node->dlightbits[4] = node->dlightbits[5] = node->dlightbits[6] = node->dlightbits[7] = 0;
-               node->dlightframe = r_dlightframecount;
-       }
-       node->dlightbits[bitindex] |= bit;
+}
 
-// mark the polygons
-       surf = cl.worldmodel->surfaces + node->firstsurface;
-       for (i=0 ; i<node->numsurfaces ; i++, surf++)
+void R_DrawCoronas(void)
+{
+       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)
        {
-               if (((surf->flags & SURF_PLANEBACK) == 0) == ((PlaneDist(lightorigin, surf->plane)) >= surf->plane->dist))
+               for (lnum = 0, light = r_shadow_worldlightchain;light;light = light->next, lnum++)
                {
-                       if (surf->dlightframe != r_dlightframecount) // not dynamic until now
+                       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)
                        {
-                               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_dlightframecount;
+                               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);
                        }
-                       surf->dlightbits[bitindex] |= bit;
                }
        }
-
-       if (node->children[0]->contents >= 0)
-       {
-               if (node->children[1]->contents >= 0)
-               {
-                       R_OldMarkLights (lightorigin, light, 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;
-       }
-}
-
-void R_NoVisMarkLights (vec3_t lightorigin, dlight_t *light, int bit, int bitindex, model_t *model)
-{
-       R_OldMarkLights(lightorigin, light, bit, bitindex, model->nodes + model->hulls[0].firstclipnode);
-}
-
-int lightframe = 0;
-void R_VisMarkLights (vec3_t lightorigin, dlight_t *light, int bit, int bitindex, model_t *model)
-{
-       mleaf_t *pvsleaf = Mod_PointInLeaf (lightorigin, model);
-
-       if (!pvsleaf->compressed_vis)
-       {       // no vis info, so make all visible
-               R_OldMarkLights(lightorigin, light, bit, bitindex, model->nodes + model->hulls[0].firstclipnode);
-               return;
-       }
-       else
+       for (i = 0, light = r_dlight;i < r_numdlights;i++, light++)
        {
-               int             i, k, l, m, c;
-               msurface_t *surf, **mark;
-               mleaf_t *leaf;
-               byte    *in = pvsleaf->compressed_vis;
-               int             row = (model->numleafs+7)>>3;
-               float   low[3], high[3], radius;
-
-               radius = light->radius * 4.0f;
-               low[0] = lightorigin[0] - radius;low[1] = lightorigin[1] - radius;low[2] = lightorigin[2] - radius;
-               high[0] = lightorigin[0] + radius;high[1] = lightorigin[1] + radius;high[2] = lightorigin[2] + radius;
-
-               lightframe++;
-               k = 0;
-               while (k < row)
+               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)
                {
-                       c = *in++;
-                       if (c)
+                       cscale = light->corona * r_coronas.value * 0.25f;
+                       scale = light->radius * 0.25f;
+                       if (gl_flashblend.integer)
                        {
-                               l = model->numleafs - (k << 3);
-                               if (l > 8)
-                                       l = 8;
-                               for (i=0 ; i<l ; i++)
-                               {
-                                       if (c & (1<<i))
-                                       {
-                                               leaf = &model->leafs[(k << 3)+i+1];
-                                               leaf->lightframe = lightframe;
-                                               if (leaf->visframe != r_visframecount)
-                                                       continue;
-                                               if (leaf->contents == CONTENTS_SOLID)
-                                                       continue;
-                                               // if out of the light radius, skip
-                                               /*
-                                               if (leaf->minmaxs[0] > high[0] || leaf->minmaxs[3] < low[0]
-                                                || leaf->minmaxs[1] > high[1] || leaf->minmaxs[4] < low[1]
-                                                || leaf->minmaxs[2] > high[2] || leaf->minmaxs[5] < low[2])
-                                                       continue;
-                                               */
-                                               if (leaf->dlightframe != r_dlightframecount) // 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_dlightframecount;
-                                               }
-                                               leaf->dlightbits[bitindex] |= bit;
-                                               if ((m = leaf->nummarksurfaces))
-                                               {
-                                                       mark = leaf->firstmarksurface;
-                                                       do
-                                                       {
-                                                               surf = *mark++;
-                                                               if (surf->visframe != r_framecount || surf->lightframe == lightframe)
-                                                                       continue;
-                                                               surf->lightframe = lightframe;
-                                                               if (((surf->flags & SURF_PLANEBACK) == 0) == ((PlaneDist(lightorigin, surf->plane)) >= surf->plane->dist))
-                                                               {
-                                                                       if (surf->dlightframe != r_dlightframecount) // 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_dlightframecount;
-                                                                       }
-                                                                       surf->dlightbits[bitindex] |= bit;
-                                                               }
-                                                       }
-                                                       while (--m);
-                                               }
-                                       }
-                               }
-                               k++;
-                               continue;
+                               cscale *= 4.0f;
+                               scale *= 2.0f;
                        }
-               
-                       k += *in++;
+                       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);
                }
        }
 }
 
-
-/*
-=============
-R_PushDlights
-=============
-*/
-void R_PushDlights (void)
-{
-       int             i;
-       dlight_t        *l;
-
-       r_dlightframecount = r_framecount + 1;  // because the count hasn't advanced yet for this frame
-
-       if (!r_dynamic.value)
-               return;
-
-       l = cl_dlights;
-
-       for (i=0 ; i<MAX_DLIGHTS ; i++, l++)
-       {
-               if (l->die < cl.time || !l->radius)
-                       continue;
-//             R_MarkLights (l->origin, l, 1<<(i&31), i >> 5, cl.worldmodel->nodes );
-               R_VisMarkLights (l->origin, l, 1<<(i&31), i >> 5, cl.worldmodel);
-       }
-}
-
-
 /*
 =============================================================================
 
-LIGHT SAMPLING
+DYNAMIC LIGHTS
 
 =============================================================================
 */
 
-mplane_t               *lightplane;
-vec3_t                 lightspot;
-
-extern cvar_t r_ambient;
+static int lightpvsbytes;
+static qbyte lightpvs[(MAX_MAP_LEAFS+7)>>3];
 
 /*
-int RecursiveLightPoint (vec3_t color, mnode_t *node, vec3_t start, vec3_t end)
+=============
+R_MarkLights
+=============
+*/
+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           front, back, frac;
-       vec3_t          mid;
-
-loc0:
-       if (node->contents < 0)
-               return false;           // didn't hit anything
-       
-// calculate mid point
-       front = PlaneDiff (start, node->plane);
-       back = PlaneDiff (end, node->plane);
-
-       // LordHavoc: optimized recursion
-       if ((back < 0) == (front < 0))
-//             return RecursiveLightPoint (color, node->children[front < 0], start, end);
+       int i;
+       mleaf_t *leaf;
+       float dist;
+
+       // for comparisons to minimum acceptable light
+       while(node->contents >= 0)
        {
-               node = node->children[front < 0];
-               goto loc0;
+               dist = PlaneDiff(lightorigin, node->plane);
+               if (dist > light->rtlight.lightmap_cullradius)
+                       node = node->children[0];
+               else
+               {
+                       if (dist >= -light->rtlight.lightmap_cullradius)
+                               R_RecursiveMarkLights(ent, lightorigin, light, bit, bitindex, node->children[0], pvs, pvsbits);
+                       node = node->children[1];
+               }
        }
-       
-       frac = front / (front-back);
-       mid[0] = start[0] + (end[0] - start[0])*frac;
-       mid[1] = start[1] + (end[1] - start[1])*frac;
-       mid[2] = start[2] + (end[2] - start[2])*frac;
-       
-// go down front side
-       if (RecursiveLightPoint (color, node->children[front < 0], start, mid))
-               return true;    // hit something
-       else
+
+       // check if leaf is visible according to pvs
+       leaf = (mleaf_t *)node;
+       i = leaf->clusterindex;
+       if (leaf->nummarksurfaces && (i >= pvsbits || CHECKPVSBIT(pvs, i)))
        {
-               int i, ds, dt;
+               int *surfacepvsframes, d, impacts, impactt;
+               float sdist, maxdist, dist2, impact[3];
                msurface_t *surf;
-       // check for impact on this node
-               VectorCopy (mid, lightspot);
-               lightplane = node->plane;
-
-               surf = cl.worldmodel->surfaces + node->firstsurface;
-               for (i = 0;i < node->numsurfaces;i++, surf++)
+               // mark the polygons
+               maxdist = light->rtlight.lightmap_cullradius2;
+               surfacepvsframes = ent->model->brushq1.surfacepvsframes;
+               for (i = 0;i < leaf->nummarksurfaces;i++)
                {
-                       if (surf->flags & SURF_DRAWTILED)
-                               continue;       // no lightmaps
-
-                       ds = (int) ((float) DotProduct (mid, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3]);
-                       dt = (int) ((float) DotProduct (mid, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3]);
+                       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 (ds < surf->texturemins[0] || dt < surf->texturemins[1])
+                       if (dist < -0.25f && !(surf->flags & SURF_LIGHTBOTHSIDES))
                                continue;
-                       
-                       ds -= surf->texturemins[0];
-                       dt -= surf->texturemins[1];
-                       
-                       if (ds > surf->extents[0] || dt > surf->extents[1])
+
+                       dist2 = dist * dist;
+                       if (dist2 >= maxdist)
                                continue;
 
-                       if (surf->samples)
-                       {
-                               byte *lightmap;
-                               int maps, line3, dsfrac = ds & 15, dtfrac = dt & 15, r00 = 0, g00 = 0, b00 = 0, r01 = 0, g01 = 0, b01 = 0, r10 = 0, g10 = 0, b10 = 0, r11 = 0, g11 = 0, b11 = 0;
-                               float scale;
-                               line3 = ((surf->extents[0]>>4)+1)*3;
+                       VectorCopy(lightorigin, impact);
+                       if (surf->plane->type >= 3)
+                               VectorMA(impact, -sdist, surf->plane->normal, impact);
+                       else
+                               impact[surf->plane->type] -= sdist;
 
-                               lightmap = surf->samples + ((dt>>4) * ((surf->extents[0]>>4)+1) + (ds>>4))*3; // LordHavoc: *3 for color
+                       impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
 
-                               for (maps = 0;maps < MAXLIGHTMAPS && surf->styles[maps] != 255;maps++)
-                               {
-                                       scale = (float) d_lightstylevalue[surf->styles[maps]] * 1.0 / 256.0;
-                                       r00 += (float) lightmap[      0] * scale;g00 += (float) lightmap[      1] * scale;b00 += (float) lightmap[2] * scale;
-                                       r01 += (float) lightmap[      3] * scale;g01 += (float) lightmap[      4] * scale;b01 += (float) lightmap[5] * scale;
-                                       r10 += (float) lightmap[line3+0] * scale;g10 += (float) lightmap[line3+1] * scale;b10 += (float) lightmap[line3+2] * scale;
-                                       r11 += (float) lightmap[line3+3] * scale;g11 += (float) lightmap[line3+4] * scale;b11 += (float) lightmap[line3+5] * scale;
-                                       lightmap += ((surf->extents[0]>>4)+1) * ((surf->extents[1]>>4)+1)*3; // LordHavoc: *3 for colored lighting
-                               }
+                       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];
 
-                               color[0] += (float) ((int) ((((((((r11-r10) * dsfrac) >> 4) + r10)-((((r01-r00) * dsfrac) >> 4) + r00)) * dtfrac) >> 4) + ((((r01-r00) * dsfrac) >> 4) + r00)));
-                               color[1] += (float) ((int) ((((((((g11-g10) * dsfrac) >> 4) + g10)-((((g01-g00) * dsfrac) >> 4) + g00)) * dtfrac) >> 4) + ((((g01-g00) * dsfrac) >> 4) + g00)));
-                               color[2] += (float) ((int) ((((((((b11-b10) * dsfrac) >> 4) + b10)-((((b01-b00) * dsfrac) >> 4) + b00)) * dtfrac) >> 4) + ((((b01-b00) * dsfrac) >> 4) + b00)));
+                       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->cached_dlight = true;
                        }
-                       return true; // success
+                       surf->dlightbits[bitindex] |= bit;
                }
-
-       // go down back side
-               return RecursiveLightPoint (color, node->children[front >= 0], mid, end);
        }
 }
 
-void R_LightPoint (vec3_t color, vec3_t p)
+void R_MarkLights(entity_render_t *ent)
 {
-       vec3_t          end;
-       
-       if (r_fullbright.value || !cl.worldmodel->lightdata)
+       int i, bit, bitindex;
+       dlight_t *light;
+       vec3_t lightorigin;
+       if (!gl_flashblend.integer && r_dynamic.integer && ent->model && ent->model->brushq1.num_leafs)
        {
-               color[0] = color[1] = color[2] = 255;
-               return;
+               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));
+               }
        }
-
-       end[0] = p[0];
-       end[1] = p[1];
-       end[2] = p[2] - 2048;
-
-       color[0] = color[1] = color[2] = r_ambient.value * 2.0f;
-       RecursiveLightPoint (color, cl.worldmodel->nodes, p, end);
 }
 
-void SV_LightPoint (vec3_t color, vec3_t p)
-{
-       vec3_t          end;
-       
-       if (!sv.worldmodel->lightdata)
-       {
-               color[0] = color[1] = color[2] = 255;
-               return;
-       }
-       
-       end[0] = p[0];
-       end[1] = p[1];
-       end[2] = p[2] - 2048;
+/*
+=============================================================================
 
-       color[0] = color[1] = color[2] = 0;
-       RecursiveLightPoint (color, sv.worldmodel->nodes, p, end);
-}
+LIGHT SAMPLING
+
+=============================================================================
 */
 
-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;
+       VectorClear(diffusecolor);
+       VectorClear(diffusenormal);
 
-loc0:
-       if (node->contents < 0)
-               return false;           // didn't hit anything
-
-       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;
-                       lightspot[0] = x;
-                       lightspot[1] = y;
-                       lightspot[2] = mid;
-                       lightplane = node->plane;
-
-                       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_DRAWTILED)
-                                       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;
-                                       }
-
-                                       color[0] += (float) ((((((((r11-r10) * dsfrac) >> 4) + r10)-((((r01-r00) * dsfrac) >> 4) + r00)) * dtfrac) >> 4) + ((((r01-r00) * dsfrac) >> 4) + r00)) * (1.0f / 256.0f);
-                                       color[1] += (float) ((((((((g11-g10) * dsfrac) >> 4) + g10)-((((g01-g00) * dsfrac) >> 4) + g00)) * dtfrac) >> 4) + ((((g01-g00) * dsfrac) >> 4) + g00)) * (1.0f / 256.0f);
-                                       color[2] += (float) ((((((((b11-b10) * dsfrac) >> 4) + b10)-((((b01-b00) * dsfrac) >> 4) + b00)) * dtfrac) >> 4) + ((((b01-b00) * dsfrac) >> 4) + b00)) * (1.0f / 256.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_LightPoint (vec3_t color, vec3_t p)
-{
-       if (r_fullbright.value || !cl.worldmodel->lightdata)
+       if (dynamic)
        {
-               color[0] = color[1] = color[2] = 255;
-               return;
-       }
-       
-       color[0] = color[1] = color[2] = r_ambient.value * 2.0f;
-       RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
-}
-
-// LordHavoc: added light checking to the server
-void SV_LightPoint (vec3_t color, vec3_t p)
-{
-       if (!sv.worldmodel->lightdata)
-       {
-               color[0] = color[1] = color[2] = 255;
-               return;
-       }
-       
-       color[0] = color[1] = color[2] = 0;
-       RecursiveLightPoint (color, sv.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
-}
-
-// LordHavoc: R_DynamicLightPoint - acumulates the dynamic lighting
-void R_DynamicLightPoint(vec3_t color, vec3_t org, int *dlightbits)
-{
-       int             i, j, k;
-       vec3_t  dist;
-       float   brightness, r, f;
-
-       if (!r_dynamic.value || (!dlightbits[0] && !dlightbits[1] && !dlightbits[2] && !dlightbits[3] && !dlightbits[4] && !dlightbits[5] && !dlightbits[6] && !dlightbits[7]))
-               return;
-
-       for (j = 0;j < (MAX_DLIGHTS >> 5);j++)
-       {
-               if (dlightbits[j])
+               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++)
                {
-                       for (i=0 ; i<32 ; i++)
+                       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)
                        {
-                               if ((!((1 << (i&31)) & dlightbits[i>>5])) || cl_dlights[i].die < cl.time || !cl_dlights[i].radius)
-                                       continue;
-                               k = (j<<5)+i;
-                               VectorSubtract (org, cl_dlights[k].origin, dist);
-                               f = DotProduct(dist, dist) + LIGHTOFFSET;
-                               r = cl_dlights[k].radius*cl_dlights[k].radius*LIGHTSCALE;
-                               if (f < r)
-                               {
-                                       brightness = r * 16.0f / f;
-                                       color[0] += brightness * cl_dlights[k].color[0];
-                                       color[1] += brightness * cl_dlights[k].color[1];
-                                       color[2] += brightness * cl_dlights[k].color[2];
-                               }
+                               f = (1.0f / (f + LIGHTOFFSET)) - light->rtlight.lightmap_subtract;
+                               VectorMA(ambientcolor, f, light->rtlight.lightmap_light, ambientcolor);
                        }
                }
        }
 }
 
-// same as above but no bitmask to check
-void R_DynamicLightPointNoMask(vec3_t color, vec3_t org)
+typedef struct
 {
-       int             i;
-       vec3_t  dist;
-       float   brightness, r, f;
-
-       if (!r_dynamic.value)
-               return;
-
-       for (i=0 ; i<MAX_DLIGHTS ; i++)
-       {
-               if (cl_dlights[i].die < cl.time || !cl_dlights[i].radius)
-                       continue;
-               VectorSubtract (org, cl_dlights[i].origin, dist);
-               f = DotProduct(dist, dist) + LIGHTOFFSET;
-               r = cl_dlights[i].radius*cl_dlights[i].radius*LIGHTSCALE;
-               if (f < r)
-               {
-                       brightness = r * 16.0f / f;
-                       if (cl_dlights[i].dark)
-                               brightness = -brightness;
-                       color[0] += brightness * cl_dlights[i].color[0];
-                       color[1] += brightness * cl_dlights[i].color[1];
-                       color[2] += brightness * cl_dlights[i].color[2];
-               }
-       }
+       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_CompleteLightPoint (vec3_t color, vec3_t p)
-{
-       R_LightPoint(color, p);
-       R_DynamicLightPointNoMask(color, p);
-}
+static int nearlights;
+static nearlight_t nearlight[MAX_DLIGHTS];
 
-extern float *aliasvert;
-extern float *aliasvertnorm;
-extern byte *aliasvertcolor;
-extern float modelalpha;
-extern qboolean lighthalf;
-extern int modeldlightbits[8];
-void R_LightModel(int numverts, vec3_t center, vec3_t basecolor)
+int R_LightModel(float *ambient4f, float *diffusecolor, float *diffusenormal, const entity_render_t *ent, float colorr, float colorg, float colorb, float colora, int worldcoords)
 {
-       // LordHavoc: warning: reliance on int being 4 bytes here (of course the d_8to24table relies on that too...)
-       int i, j, nearlights = 0, color;
-       vec3_t dist, mod;
-       float t, t1, t2, t3, *avn;
-       byte r,g,b,a, *avc;
-       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 color;
-               vec3_t origin;
-       } nearlight[MAX_DLIGHTS];
-       avc = aliasvertcolor;
-       avn = aliasvertnorm;
-       a = (byte) bound((int) 0, (int) (modelalpha * 255.0f), (int) 255);
-       if (currententity->effects & EF_FULLBRIGHT)
+               // highly rare
+               VectorSet(ambient4f, 1, 1, 1);
+               maxnearlights = 0;
+       }
+       else if (r_lightmapintensity <= 0 && !(ent->flags & RENDER_TRANSPARENT))
+               maxnearlights = 0;
+       else
        {
-               if (lighthalf)
+               if (cl.worldmodel && cl.worldmodel->brush.LightPoint)
                {
-                       ((byte *)&color)[0] = (byte) ((float) (128.0f * currententity->colormod[0]));
-                       ((byte *)&color)[1] = (byte) ((float) (128.0f * currententity->colormod[1]));
-                       ((byte *)&color)[2] = (byte) ((float) (128.0f * currententity->colormod[2]));
+                       cl.worldmodel->brush.LightPoint(cl.worldmodel, ent->origin, ambient4f, diffusecolor, tempdiffusenormal);
+                       Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, diffusenormal);
+                       VectorNormalize(diffusenormal);
                }
                else
-               {
-                       ((byte *)&color)[0] = (byte) ((float) (255.0f * currententity->colormod[0]));
-                       ((byte *)&color)[1] = (byte) ((float) (255.0f * currententity->colormod[1]));
-                       ((byte *)&color)[2] = (byte) ((float) (255.0f * currententity->colormod[2]));
-               }
-               ((byte *)&color)[3] = a;
-               for (i = 0;i < numverts;i++)
-               {
-                       *((int *)avc) = color;
-                       avc += 4;
-               }
-               return;
-       }
-       if (lighthalf)
-       {
-               mod[0] = currententity->colormod[0] * 0.5f;
-               mod[1] = currententity->colormod[1] * 0.5f;
-               mod[2] = currententity->colormod[2] * 0.5f;
+                       VectorSet(ambient4f, 1, 1, 1);
        }
-       else
-       {
-               mod[0] = currententity->colormod[0];
-               mod[1] = currententity->colormod[1];
-               mod[2] = currententity->colormod[2];
-       }
-       basecolor[0] *= mod[0];
-       basecolor[1] *= mod[1];
-       basecolor[2] *= mod[2];
-       if (r_lightmodels.value)
+
+       // 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++)
        {
-               for (i = 0;i < MAX_DLIGHTS;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
                {
-                       if (!modeldlightbits[i >> 5])
-                       {
-                               i |= 31;
-                               continue;
-                       }
-                       if (!(modeldlightbits[i >> 5] & (1 << (i & 31))))
-                               continue;
-                       VectorSubtract (center, cl_dlights[i].origin, dist);
-                       t1 = cl_dlights[i].radius*cl_dlights[i].radius*LIGHTSCALE;
-                       t2 = DotProduct(dist,dist) + LIGHTOFFSET;
-                       if (t2 < t1)
+                       for (j = 0;j < maxnearlights;j++)
                        {
-                               VectorCopy(cl_dlights[i].origin, nearlight[nearlights].origin);
-                               nearlight[nearlights].color[0] = cl_dlights[i].color[0] * cl_dlights[i].radius * cl_dlights[i].radius * mod[0];
-                               nearlight[nearlights].color[1] = cl_dlights[i].color[1] * cl_dlights[i].radius * cl_dlights[i].radius * mod[1];
-                               nearlight[nearlights].color[2] = cl_dlights[i].color[2] * cl_dlights[i].radius * cl_dlights[i].radius * mod[2];
-                               t1 = (128.0f / LIGHTSCALE) / t2;
-                               basecolor[0] += nearlight[nearlights].color[0] * t1;
-                               basecolor[1] += nearlight[nearlights].color[1] * t1;
-                               basecolor[2] += nearlight[nearlights].color[2] * t1;
-                               nearlights++;
+                               if (nearlight[j].intensity < intensity)
+                               {
+                                       if (nearlight[j].intensity > 0)
+                                               VectorAdd(ambient4f, nearlight[j].ambientlight, ambient4f);
+                                       break;
+                               }
                        }
                }
-       }
-       else
-       {
-               for (i = 0;i < MAX_DLIGHTS;i++)
+               if (j >= maxnearlights)
                {
-                       if (!modeldlightbits[i >> 5])
-                       {
-                               i |= 31;
-                               continue;
-                       }
-                       if (!(modeldlightbits[i >> 5] & (1 << (i & 31))))
-                               continue;
-                       VectorSubtract (center, cl_dlights[i].origin, dist);
-                       t1 = cl_dlights[i].radius*cl_dlights[i].radius*LIGHTSCALE;
-                       t2 = DotProduct(dist,dist) + LIGHTOFFSET;
-                       if (t2 < t1)
-                       {
-                               dist[0] = cl_dlights[i].color[0] * cl_dlights[i].radius * cl_dlights[i].radius * mod[0];
-                               dist[1] = cl_dlights[i].color[1] * cl_dlights[i].radius * cl_dlights[i].radius * mod[1];
-                               dist[2] = cl_dlights[i].color[2] * cl_dlights[i].radius * cl_dlights[i].radius * mod[2];
-                               t1 = (192.0f / LIGHTSCALE) / t2;
-                               basecolor[0] += dist[0] * t1;
-                               basecolor[1] += dist[1] * t1;
-                               basecolor[2] += dist[2] * t1;
-                       }
+                       // 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;
                }
        }
-       t1 = bound(0, basecolor[0], 255);r = (byte) t1;
-       t1 = bound(0, basecolor[1], 255);g = (byte) t1;
-       t1 = bound(0, basecolor[2], 255);b = (byte) t1;
-       ((byte *)&color)[0] = r;
-       ((byte *)&color)[1] = g;
-       ((byte *)&color)[2] = b;
-       ((byte *)&color)[3] = a;
-       if (nearlights)
+       if (!r_rtdlight || (ent->flags & RENDER_TRANSPARENT))
        {
-               int temp;
-               vec3_t v;
-               float *av;
-               av = aliasvert;
-               if (nearlights == 1)
+               // FIXME: this dlighting doesn't look like rtlights
+               for (i = 0;i < r_numdlights;i++)
                {
-                       for (i = 0;i < numverts;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)
                        {
-                               VectorSubtract(nearlight[0].origin, av, v);
-                               t = DotProduct(avn,v);
-                               if (t > 0)
-                               {
-                                       t /= DotProduct(v,v);
-                                       temp = (int) ((float) (basecolor[0] + nearlight[0].color[0] * t));if (temp < 0) temp = 0;else if (temp > 255) temp = 255;avc[0] = temp;
-                                       temp = (int) ((float) (basecolor[1] + nearlight[0].color[1] * t));if (temp < 0) temp = 0;else if (temp > 255) temp = 255;avc[1] = temp;
-                                       temp = (int) ((float) (basecolor[2] + nearlight[0].color[2] * t));if (temp < 0) temp = 0;else if (temp > 255) temp = 255;avc[2] = temp;
-                                       avc[3] = a;
-                               }
+                               if (CL_TraceLine(ent->origin, light->origin, NULL, NULL, false, NULL, SUPERCONTENTS_SOLID) != 1)
+                                       continue;
+                               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
-                                       *((int *)avc) = color;
-                               avc += 4;
-                               av+=3;
-                               avn+=3;
-                       }
-               }
-               else
-               {
-                       int i1, i2, i3, k;
-                       for (i = 0;i < numverts;i++)
-                       {
-                               t1 = basecolor[0];
-                               t2 = basecolor[1];
-                               t3 = basecolor[2];
-                               k = false;
-                               for (j = 0;j < nearlights;j++)
                                {
-                                       VectorSubtract(nearlight[j].origin, av, v);
-                                       t = DotProduct(avn,v);
-                                       if (t > 0)
+                                       for (j = 0;j < maxnearlights;j++)
                                        {
-                                               t /= DotProduct(v,v);
-                                               t1 += nearlight[j].color[0] * t;
-                                               t2 += nearlight[j].color[1] * t;
-                                               t3 += nearlight[j].color[2] * t;
-                                               k = true;
+                                               if (nearlight[j].intensity < intensity)
+                                               {
+                                                       if (nearlight[j].intensity > 0)
+                                                               VectorAdd(ambient4f, nearlight[j].ambientlight, ambient4f);
+                                                       break;
+                                               }
                                        }
                                }
-                               if (k) // dodge the costly float -> int conversions
+                               if (j >= maxnearlights)
                                {
-                                       i1 = t1;if (i1 < 0) i1 = 0;else if (i1 > 255) i1 = 255;avc[0] = i1;
-                                       i2 = t2;if (i2 < 0) i2 = 0;else if (i2 > 255) i2 = 255;avc[1] = i2;
-                                       i3 = t3;if (i3 < 0) i3 = 0;else if (i3 > 255) i3 = 255;avc[2] = i3;
-                                       avc[3] = a;
+                                       // this light is less significant than all others,
+                                       // add it to ambient
+                                       if (intensity > 0)
+                                               VectorAdd(ambient4f, ambientcolor, ambient4f);
                                }
                                else
-                                       *((int *)avc) = color;
-                               avc += 4;
+                               {
+                                       nl = nearlight + j;
+                                       nl->intensity = intensity;
+                                       // transform the light into the model's coordinate system
+                                       if (worldcoords)
+                                               VectorCopy(light->origin, nl->origin);
+                                       else
+                                       {
+                                               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
+       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)
        {
-               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++)
                {
-                       *((int *)avc) = color;
-                       avc += 4;
+                       VectorSubtract(nl->origin, vertex3f, v);
+                       // first eliminate negative lighting (back side)
+                       dot = DotProduct(normal3f, 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)
+                               {
+                                       // 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);
+                               }
+                       }
                }
+               VectorCopy4(color, color4f);
        }
 }
+
+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))
+       {
+               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;
+}
+