added r_rtworld, r_rtworldshadows, r_rtdlight, r_rtdlightshadows, and r_lightmapinten...
[xonotic/darkplaces.git] / r_light.c
index 5e05081..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,52 +20,147 @@ 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;
+
+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)
 {
+       lighttexturepool = NULL;
+       lightcorona = NULL;
 }
 
 void r_light_newmap(void)
 {
+       int i;
+       for (i = 0;i < 256;i++)
+               d_lightstylevalue[i] = 264;             // normal light value
 }
 
 void R_Light_Init(void)
 {
-       Cvar_RegisterVariable(&r_lightmodels);
+       Cvar_RegisterVariable(&r_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;
-       }       
+               l = cl_lightstyle[j].map[l] - 'a';
+               d_lightstylevalue[j] = ((k*frac)+(l*(1-frac)))*22;
+       }
+
+       r_numdlights = 0;
+       c_dlights = 0;
+
+       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++)
+       {
+               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, 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)
+       {
+               for (lnum = 0, light = r_shadow_worldlightchain;light;light = light->next, lnum++)
+               {
+                       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)
+                       {
+                               cscale = light->rtlight.corona * r_coronas.value * 0.25f;
+                               scale = light->rtlight.radius * 0.25f;
+                               R_DrawSprite(GL_ONE, GL_ONE, lightcorona, true, light->rtlight.shadoworigin, r_viewright, r_viewup, scale, -scale, -scale, scale, light->rtlight.color[0] * cscale, light->rtlight.color[1] * cscale, light->rtlight.color[2] * cscale, 1);
+                       }
+               }
+       }
+       for (i = 0, light = r_dlight;i < r_numdlights;i++, light++)
+       {
+               if (light->corona * r_coronas.value > 0 && (dist = (DotProduct(light->origin, r_viewforward) - viewdist)) >= 24.0f && CL_TraceLine(light->origin, r_vieworigin, NULL, NULL, true, NULL, SUPERCONTENTS_SOLID) == 1)
+               {
+                       cscale = light->corona * r_coronas.value * 0.25f;
+                       scale = light->radius * 0.25f;
+                       if (gl_flashblend.integer)
+                       {
+                               cscale *= 4.0f;
+                               scale *= 2.0f;
+                       }
+                       R_DrawSprite(GL_ONE, GL_ONE, lightcorona, true, light->origin, r_viewright, r_viewup, scale, -scale, -scale, scale, light->color[0] * cscale, light->color[1] * cscale, light->color[2] * cscale, 1);
+               }
+       }
 }
 
 /*
@@ -76,343 +171,112 @@ DYNAMIC LIGHTS
 =============================================================================
 */
 
+static int lightpvsbytes;
+static qbyte lightpvs[(MAX_MAP_LEAFS+7)>>3];
+
 /*
 =============
 R_MarkLights
 =============
 */
-void R_OldMarkLights (vec3_t lightorigin, dlight_t *light, int bit, int bitindex, mnode_t *node)
+static void R_RecursiveMarkLights(entity_render_t *ent, vec3_t lightorigin, dlight_t *light, int bit, int bitindex, mnode_t *node, qbyte *pvs, int pvsbits)
 {
-       float           ndist, maxdist;
-       msurface_t      *surf;
-       mleaf_t         *leaf;
-       int                     i;
-
-       if (!r_dynamic.value)
-               return;
+       int i;
+       mleaf_t *leaf;
+       float dist;
 
        // for comparisons to minimum acceptable light
-       maxdist = light->radius * light->radius;
-
-       // clamp radius to avoid exceeding 32768 entry division table
-       if (maxdist > 4194304)
-               maxdist = 4194304;
-
-loc0:
-       if (node->contents < 0)
+       while(node->contents >= 0)
        {
-               if (node->contents != CONTENTS_SOLID)
+               dist = PlaneDiff(lightorigin, node->plane);
+               if (dist > light->rtlight.lightmap_cullradius)
+                       node = node->children[0];
+               else
                {
-                       leaf = (mleaf_t *)node;
-                       if (leaf->dlightframe != r_framecount) // not dynamic until now
-                       {
-                               leaf->dlightbits[0] = leaf->dlightbits[1] = leaf->dlightbits[2] = leaf->dlightbits[3] = leaf->dlightbits[4] = leaf->dlightbits[5] = leaf->dlightbits[6] = leaf->dlightbits[7] = 0;
-                               leaf->dlightframe = r_framecount;
-                       }
-                       leaf->dlightbits[bitindex] |= bit;
+                       if (dist >= -light->rtlight.lightmap_cullradius)
+                               R_RecursiveMarkLights(ent, lightorigin, light, bit, bitindex, node->children[0], pvs, pvsbits);
+                       node = node->children[1];
                }
-               return;
        }
 
-       ndist = PlaneDiff(lightorigin, node->plane);
-       
-       if (ndist > light->radius)
+       // check if leaf is visible according to pvs
+       leaf = (mleaf_t *)node;
+       i = leaf->clusterindex;
+       if (leaf->nummarksurfaces && (i >= pvsbits || CHECKPVSBIT(pvs, i)))
        {
-               node = node->children[0];
-               goto loc0;
-       }
-       if (ndist < -light->radius)
-       {
-               node = node->children[1];
-               goto loc0;
-       }
-
-// mark the polygons
-       surf = cl.worldmodel->surfaces + node->firstsurface;
-       for (i=0 ; i<node->numsurfaces ; i++, surf++)
-       {
-               int d;
-               float dist, dist2, impact[3];
-               if (surf->visframe != r_framecount)
-                       continue;
-               dist = ndist;
-               if (surf->flags & SURF_PLANEBACK)
-                       dist = -dist;
+               int *surfacepvsframes, d, impacts, impactt;
+               float sdist, maxdist, dist2, impact[3];
+               msurface_t *surf;
+               // mark the polygons
+               maxdist = light->rtlight.lightmap_cullradius2;
+               surfacepvsframes = ent->model->brushq1.surfacepvsframes;
+               for (i = 0;i < leaf->nummarksurfaces;i++)
+               {
+                       if (surfacepvsframes[leaf->firstmarksurface[i]] != ent->model->brushq1.pvsframecount)
+                               continue;
+                       surf = ent->model->brushq1.surfaces + leaf->firstmarksurface[i];
+                       dist = sdist = PlaneDiff(lightorigin, surf->plane);
+                       if (surf->flags & SURF_PLANEBACK)
+                               dist = -dist;
 
-               if (dist < -0.25f && !(surf->flags & SURF_LIGHTBOTHSIDES))
-                       continue;
+                       if (dist < -0.25f && !(surf->flags & SURF_LIGHTBOTHSIDES))
+                               continue;
 
-               dist2 = dist * dist;
-               if (dist2 >= maxdist)
-                       continue;
+                       dist2 = dist * dist;
+                       if (dist2 >= maxdist)
+                               continue;
 
-               impact[0] = light->origin[0] - surf->plane->normal[0] * dist;
-               impact[1] = light->origin[1] - surf->plane->normal[1] * dist;
-               impact[2] = light->origin[2] - surf->plane->normal[2] * dist;
+                       VectorCopy(lightorigin, impact);
+                       if (surf->plane->type >= 3)
+                               VectorMA(impact, -sdist, surf->plane->normal, impact);
+                       else
+                               impact[surf->plane->type] -= sdist;
 
-               d = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
+                       impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
 
-               if (d < 0)
-               {
+                       d = bound(0, impacts, surf->extents[0] + 16) - impacts;
                        dist2 += d * d;
-                       if (dist2 >= maxdist)
+                       if (dist2 > maxdist)
                                continue;
-               }
-               else
-               {
-                       d -= surf->extents[0] + 16;
-                       if (d > 0)
-                       {
-                               dist2 += d * d;
-                               if (dist2 >= maxdist)
-                                       continue;
-                       }
-               }
 
-               d = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
+                       impactt = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
 
-               if (d < 0)
-               {
+                       d = bound(0, impactt, surf->extents[1] + 16) - impactt;
                        dist2 += d * d;
-                       if (dist2 >= maxdist)
+                       if (dist2 > maxdist)
                                continue;
-               }
-               else
-               {
-                       d -= surf->extents[1] + 16;
-                       if (d > 0)
-                       {
-                               dist2 += d * d;
-                               if (dist2 >= maxdist)
-                                       continue;
-                       }
-               }
-
-               if (surf->dlightframe != r_framecount) // not dynamic until now
-               {
-                       surf->dlightbits[0] = surf->dlightbits[1] = surf->dlightbits[2] = surf->dlightbits[3] = surf->dlightbits[4] = surf->dlightbits[5] = surf->dlightbits[6] = surf->dlightbits[7] = 0;
-                       surf->dlightframe = r_framecount;
-               }
-               surf->dlightbits[bitindex] |= bit;
 
-               /*
-               if (((surf->flags & SURF_PLANEBACK) == 0) == ((PlaneDist(lightorigin, surf->plane)) >= surf->plane->dist))
-               {
                        if (surf->dlightframe != r_framecount) // not dynamic until now
                        {
                                surf->dlightbits[0] = surf->dlightbits[1] = surf->dlightbits[2] = surf->dlightbits[3] = surf->dlightbits[4] = surf->dlightbits[5] = surf->dlightbits[6] = surf->dlightbits[7] = 0;
                                surf->dlightframe = r_framecount;
+                               surf->cached_dlight = true;
                        }
                        surf->dlightbits[bitindex] |= bit;
                }
-               */
-       }
-
-       if (node->children[0]->contents >= 0)
-       {
-               if (node->children[1]->contents >= 0)
-               {
-                       R_OldMarkLights (lightorigin, 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)
+void R_MarkLights(entity_render_t *ent)
 {
-       R_OldMarkLights(lightorigin, light, bit, bitindex, model->nodes + model->hulls[0].firstclipnode);
-}
-
-void R_VisMarkLights (vec3_t lightorigin, dlight_t *light, int bit, int bitindex, model_t *model)
-{
-       static int lightframe = 0;
-       mleaf_t *pvsleaf = Mod_PointInLeaf (lightorigin, model);
-
-       if (!r_dynamic.value)
-               return;
-
-       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
+       int i, bit, bitindex;
+       dlight_t *light;
+       vec3_t lightorigin;
+       if (!gl_flashblend.integer && r_dynamic.integer && ent->model && ent->model->brushq1.num_leafs)
        {
-               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, dist, maxdist;
-
-               lightframe++;
-
-               radius = light->radius * 3;
-
-               // clamp radius to avoid exceeding 32768 entry division table
-               if (radius > 2048)
-                       radius = 2048;
-
-               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;
-
-               // for comparisons to minimum acceptable light
-               maxdist = radius*radius;
-
-               k = 0;
-               while (k < row)
+               for (i = 0, light = r_dlight;i < r_numdlights;i++, light++)
                {
-                       c = *in++;
-                       if (c)
-                       {
-                               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];
-//                                             if (leaf->visframe != r_framecount)
-//                                                     continue;
-//                                             if (leaf->contents == CONTENTS_SOLID)
-//                                                     continue;
-                                               // if out of the light radius, skip
-                                               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 (leaf->dlightframe != r_framecount) // not dynamic until now
-                                               {
-                                                       leaf->dlightbits[0] = leaf->dlightbits[1] = leaf->dlightbits[2] = leaf->dlightbits[3] = leaf->dlightbits[4] = leaf->dlightbits[5] = leaf->dlightbits[6] = leaf->dlightbits[7] = 0;
-                                                       leaf->dlightframe = r_framecount;
-                                               }
-                                               leaf->dlightbits[bitindex] |= bit;
-                                               if ((m = leaf->nummarksurfaces))
-                                               {
-                                                       mark = leaf->firstmarksurface;
-                                                       do
-                                                       {
-                                                               surf = *mark++;
-                                                               // if not visible in current frame, or already marked because it was in another leaf we passed, skip
-                                                               if (surf->lightframe == lightframe)
-                                                                       continue;
-                                                               surf->lightframe = lightframe;
-                                                               if (surf->visframe != r_framecount)
-                                                                       continue;
-                                                               dist = PlaneDiff(lightorigin, surf->plane);
-                                                               if (surf->flags & SURF_PLANEBACK)
-                                                                       dist = -dist;
-                                                               // LordHavoc: make sure it is infront of the surface and not too far away
-                                                               if (dist < radius && (dist > -0.25f || ((surf->flags & SURF_LIGHTBOTHSIDES) && dist > -radius)))
-                                                               {
-                                                                       int d;
-                                                                       float dist2, impact[3];
-
-                                                                       dist2 = dist * dist;
-
-                                                                       impact[0] = light->origin[0] - surf->plane->normal[0] * dist;
-                                                                       impact[1] = light->origin[1] - surf->plane->normal[1] * dist;
-                                                                       impact[2] = light->origin[2] - surf->plane->normal[2] * dist;
-
-                                                                       d = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
-
-                                                                       if (d < 0)
-                                                                       {
-                                                                               dist2 += d * d;
-                                                                               if (dist2 >= maxdist)
-                                                                                       continue;
-                                                                       }
-                                                                       else
-                                                                       {
-                                                                               d -= surf->extents[0] + 16;
-                                                                               if (d > 0)
-                                                                               {
-                                                                                       dist2 += d * d;
-                                                                                       if (dist2 >= maxdist)
-                                                                                               continue;
-                                                                               }
-                                                                       }
-
-                                                                       d = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
-
-                                                                       if (d < 0)
-                                                                       {
-                                                                               dist2 += d * d;
-                                                                               if (dist2 >= maxdist)
-                                                                                       continue;
-                                                                       }
-                                                                       else
-                                                                       {
-                                                                               d -= surf->extents[1] + 16;
-                                                                               if (d > 0)
-                                                                               {
-                                                                                       dist2 += d * d;
-                                                                                       if (dist2 >= maxdist)
-                                                                                               continue;
-                                                                               }
-                                                                       }
-
-                                                                       if (surf->dlightframe != r_framecount) // not dynamic until now
-                                                                       {
-                                                                               surf->dlightbits[0] = surf->dlightbits[1] = surf->dlightbits[2] = surf->dlightbits[3] = surf->dlightbits[4] = surf->dlightbits[5] = surf->dlightbits[6] = surf->dlightbits[7] = 0;
-                                                                               surf->dlightframe = r_framecount;
-                                                                       }
-                                                                       surf->dlightbits[bitindex] |= bit;
-                                                               }
-                                                       }
-                                                       while (--m);
-                                               }
-                                       }
-                               }
-                               k++;
-                               continue;
-                       }
-               
-                       k += *in++;
+                       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));
                }
        }
 }
 
-
-/*
-=============
-R_PushDlights
-=============
-*/
-void R_PushDlights (void)
-{
-       int             i;
-       dlight_t        *l;
-
-       if (!r_dynamic.value)
-               return;
-
-       l = cl_dlights;
-
-       for (i=0 ; i<MAX_DLIGHTS ; i++, l++)
-       {
-               if (!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);
-       }
-
-
-}
-
-
 /*
 =============================================================================
 
@@ -421,569 +285,323 @@ LIGHT SAMPLING
 =============================================================================
 */
 
-mplane_t               *lightplane;
-vec3_t                 lightspot;
-
-/*
-int RecursiveLightPoint (vec3_t color, mnode_t *node, vec3_t start, vec3_t end)
+void R_CompleteLightPoint(vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const vec3_t p, int dynamic, const mleaf_t *leaf)
 {
-       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);
-       {
-               node = node->children[front < 0];
-               goto loc0;
-       }
-       
-       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
-       {
-               int i, ds, dt;
-               msurface_t *surf;
-       // check for impact on this node
-               VectorCopy (mid, lightspot);
-               lightplane = node->plane;
+       VectorClear(diffusecolor);
+       VectorClear(diffusenormal);
 
-               surf = cl.worldmodel->surfaces + node->firstsurface;
-               for (i = 0;i < node->numsurfaces;i++, surf++)
-               {
-                       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 (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)
-                       {
-                               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;
-
-                               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 = (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
-                               }
-
-                               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)));
-                       }
-                       return true; // success
-               }
-
-       // go down back side
-               return RecursiveLightPoint (color, node->children[front >= 0], mid, end);
-       }
-}
-
-void R_LightPoint (vec3_t color, vec3_t p)
-{
-       vec3_t          end;
-       
-       if (r_fullbright.value || !cl.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] = 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)
+       if (!r_fullbright.integer && cl.worldmodel && cl.worldmodel->brush.LightPoint)
        {
-               color[0] = color[1] = color[2] = 255;
-               return;
+               ambientcolor[0] = ambientcolor[1] = ambientcolor[2] = r_ambient.value * (2.0f / 128.0f);
+               cl.worldmodel->brush.LightPoint(cl.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
        }
-       
-       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);
-}
-*/
-
-int RecursiveLightPoint (vec3_t color, mnode_t *node, float x, float y, float startz, float endz)
-{
-       int             side, distz = endz - startz;
-       float   front, back;
-       float   mid;
-
-loc0:
-       if (node->contents < 0)
-               return false;           // didn't hit anything
-
-       switch (node->plane->type)
-       {
-       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;
-       }
-       
-       // 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;
-                                       }
-
-                                       /*
-                                       // LordHavoc: here's the readable version of the interpolation
-                                       // code, not quite as easy for the compiler to optimize...
-
-                                       // dsfrac is the X position in the lightmap pixel, * 16
-                                       // dtfrac is the Y position in the lightmap pixel, * 16
-                                       // r00 is top left corner, r01 is top right corner
-                                       // r10 is bottom left corner, r11 is bottom right corner
-                                       // g and b are the same layout.
-                                       // r0 and r1 are the top and bottom intermediate results
-
-                                       // first we interpolate the top two points, to get the top
-                                       // edge sample
-                                       r0 = (((r01-r00) * dsfrac) >> 4) + r00;
-                                       g0 = (((g01-g00) * dsfrac) >> 4) + g00;
-                                       b0 = (((b01-b00) * dsfrac) >> 4) + b00;
-                                       // then we interpolate the bottom two points, to get the
-                                       // bottom edge sample
-                                       r1 = (((r11-r10) * dsfrac) >> 4) + r10;
-                                       g1 = (((g11-g10) * dsfrac) >> 4) + g10;
-                                       b1 = (((b11-b10) * dsfrac) >> 4) + b10;
-                                       // then we interpolate the top and bottom samples to get the
-                                       // middle sample (the one which was requested)
-                                       r = (((r1-r0) * dtfrac) >> 4) + r0;
-                                       g = (((g1-g0) * dtfrac) >> 4) + g0;
-                                       b = (((b1-b0) * dtfrac) >> 4) + b0;
-                                       */
-
-                                       color[0] += (float) ((((((((r11-r10) * dsfrac) >> 4) + r10)-((((r01-r00) * dsfrac) >> 4) + r00)) * dtfrac) >> 4) + ((((r01-r00) * dsfrac) >> 4) + r00)) * (1.0f / 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_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 (dynamic)
        {
-               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) & dlightbits[j]))
-                                       continue;
-                               k = (j<<5)+i;
-                               if (!cl_dlights[k].radius)
-                                       continue;
-                               VectorSubtract (org, cl_dlights[k].origin, dist);
-                               f = DotProduct(dist, dist) + LIGHTOFFSET;
-                               r = cl_dlights[k].radius*cl_dlights[k].radius;
-                               if (f < r)
-                               {
-                                       brightness = r * 128.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);
                        }
                }
        }
 }
 
-void R_CompleteLightPoint (vec3_t color, vec3_t p, int dynamic)
+typedef struct
 {
-       mleaf_t *leaf;
-       leaf = Mod_PointInLeaf(p, cl.worldmodel);
-       if (leaf->contents == CONTENTS_SOLID)
-       {
-               color[0] = color[1] = color[2] = 0;
-               return;
-       }
-
-       if (r_fullbright.value || !cl.worldmodel->lightdata)
-       {
-               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);
-
-       if (dynamic)
-               R_DynamicLightPoint(color, p, leaf->dlightbits);
+       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_ModelLightPoint (vec3_t color, vec3_t p, int *dlightbits)
-{
-       mleaf_t *leaf;
-       leaf = Mod_PointInLeaf(p, cl.worldmodel);
-       if (leaf->contents == CONTENTS_SOLID)
-       {
-               color[0] = color[1] = color[2] = 0;
-               dlightbits[0] = dlightbits[1] = dlightbits[2] = dlightbits[3] = dlightbits[4] = dlightbits[5] = dlightbits[6] = dlightbits[7] = 0;
-               return;
-       }
+static int nearlights;
+static nearlight_t nearlight[MAX_DLIGHTS];
 
-       if (r_fullbright.value || !cl.worldmodel->lightdata)
-       {
-               color[0] = color[1] = color[2] = 255;
-               dlightbits[0] = dlightbits[1] = dlightbits[2] = dlightbits[3] = dlightbits[4] = dlightbits[5] = dlightbits[6] = dlightbits[7] = 0;
-               return;
-       }
-       
-       color[0] = color[1] = color[2] = r_ambient.value * 2.0f;
-       RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
-
-       if (leaf->dlightframe == r_framecount)
+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, 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))
        {
-               dlightbits[0] = leaf->dlightbits[0];
-               dlightbits[1] = leaf->dlightbits[1];
-               dlightbits[2] = leaf->dlightbits[2];
-               dlightbits[3] = leaf->dlightbits[3];
-               dlightbits[4] = leaf->dlightbits[4];
-               dlightbits[5] = leaf->dlightbits[5];
-               dlightbits[6] = leaf->dlightbits[6];
-               dlightbits[7] = leaf->dlightbits[7];
+               // highly rare
+               VectorSet(ambient4f, 1, 1, 1);
+               maxnearlights = 0;
        }
+       else if (r_lightmapintensity <= 0 && !(ent->flags & RENDER_TRANSPARENT))
+               maxnearlights = 0;
        else
-               dlightbits[0] = dlightbits[1] = dlightbits[2] = dlightbits[3] = dlightbits[4] = dlightbits[5] = dlightbits[6] = dlightbits[7] = 0;
-}
-
-/* // not currently used
-void R_DynamicLightPointNoMask(vec3_t color, vec3_t org)
-{
-       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].radius)
-                       continue;
-               VectorSubtract (org, cl_dlights[i].origin, dist);
-               f = DotProduct(dist, dist) + LIGHTOFFSET;
-               r = cl_dlights[i].radius*cl_dlights[i].radius;
-               if (f < r)
+               if (cl.worldmodel && cl.worldmodel->brush.LightPoint)
                {
-                       brightness = r * 256.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];
+                       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);
        }
-}
-*/
 
-void R_LightModel(entity_t *ent, int numverts, vec3_t center, vec3_t basecolor)
-{
-       // 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
-       {
-               vec3_t color;
-               vec3_t origin;
-       } nearlight[MAX_DLIGHTS];
-       int modeldlightbits[8];
-       avc = aliasvertcolor;
-       avn = aliasvertnorm;
-       a = (byte) bound((int) 0, (int) (modelalpha * 255.0f), (int) 255);
-       if (lighthalf)
-       {
-               mod[0] = ent->render.colormod[0] * 0.5f;
-               mod[1] = ent->render.colormod[1] * 0.5f;
-               mod[2] = ent->render.colormod[2] * 0.5f;
-       }
-       else
+       // 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++)
        {
-               mod[0] = ent->render.colormod[0];
-               mod[1] = ent->render.colormod[1];
-               mod[2] = ent->render.colormod[2];
-       }
-       if (ent->render.effects & EF_FULLBRIGHT)
-       {
-               ((byte *)&color)[0] = (byte) (255.0f * mod[0]);
-               ((byte *)&color)[1] = (byte) (255.0f * mod[1]);
-               ((byte *)&color)[2] = (byte) (255.0f * mod[2]);
-               ((byte *)&color)[3] = a;
-               for (i = 0;i < numverts;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
                {
-                       *((int *)avc) = color;
-                       avc += 4;
+                       for (j = 0;j < maxnearlights;j++)
+                       {
+                               if (nearlight[j].intensity < intensity)
+                               {
+                                       if (nearlight[j].intensity > 0)
+                                               VectorAdd(ambient4f, nearlight[j].ambientlight, ambient4f);
+                                       break;
+                               }
+                       }
                }
-               return;
-       }
-       R_ModelLightPoint(basecolor, center, modeldlightbits);
-
-       basecolor[0] *= mod[0];
-       basecolor[1] *= mod[1];
-       basecolor[2] *= mod[2];
-       for (i = 0;i < MAX_DLIGHTS;i++)
-       {
-               if (!modeldlightbits[i >> 5])
+               if (j >= maxnearlights)
                {
-                       i |= 31;
-                       continue;
+                       // this light is less significant than all others,
+                       // add it to ambient
+                       if (intensity > 0)
+                               VectorAdd(ambient4f, ambientcolor, ambient4f);
                }
-               if (!(modeldlightbits[i >> 5] & (1 << (i & 31))))
-                       continue;
-               VectorSubtract (center, cl_dlights[i].origin, dist);
-               t2 = DotProduct(dist,dist) + LIGHTOFFSET;
-               t1 = cl_dlights[i].radius*cl_dlights[i].radius;
-               if (t2 < t1)
+               else
                {
+                       nl = nearlight + j;
+                       nl->intensity = intensity;
                        // transform the light into the model's coordinate system
-                       if (gl_transform.value)
-                               softwareuntransform(cl_dlights[i].origin, nearlight[nearlights].origin);
-                       else
-                       {
-                               VectorCopy(cl_dlights[i].origin, nearlight[nearlights].origin);
-                       }
-                       nearlight[nearlights].color[0] = cl_dlights[i].color[0] * t1 * mod[0];
-                       nearlight[nearlights].color[1] = cl_dlights[i].color[1] * t1 * mod[1];
-                       nearlight[nearlights].color[2] = cl_dlights[i].color[2] * t1 * mod[2];
-                       if (r_lightmodels.value && (ent == NULL || ent != cl_dlights[i].ent))
-                               nearlights++;
+                       if (worldcoords)
+                               VectorCopy(sl->origin, nl->origin);
                        else
-                       {
-                               t1 = 1.0f / t2;
-                               basecolor[0] += nearlight[nearlights].color[0] * t1;
-                               basecolor[1] += nearlight[nearlights].color[1] * t1;
-                               basecolor[2] += nearlight[nearlights].color[2] * t1;
-                       }
+                               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) + LIGHTOFFSET);
-                                       temp = (int) ((float) (basecolor[0] + nearlight[0].color[0] * t));
-                                       avc[0] = bound(0, temp, 255);
-                                       temp = (int) ((float) (basecolor[1] + nearlight[0].color[1] * t));
-                                       avc[1] = bound(0, temp, 255);
-                                       temp = (int) ((float) (basecolor[2] + nearlight[0].color[2] * t));
-                                       avc[2] = bound(0, temp, 255);
-                                       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
-               {
-                       for (i = 0;i < numverts;i++)
-                       {
-                               int lit;
-                               t1 = basecolor[0];
-                               t2 = basecolor[1];
-                               t3 = basecolor[2];
-                               lit = 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) + LIGHTOFFSET);
-                                               t1 += nearlight[j].color[0] * t;
-                                               t2 += nearlight[j].color[1] * t;
-                                               t3 += nearlight[j].color[2] * t;
-                                               lit = true;
+                                               if (nearlight[j].intensity < intensity)
+                                               {
+                                                       if (nearlight[j].intensity > 0)
+                                                               VectorAdd(ambient4f, nearlight[j].ambientlight, ambient4f);
+                                                       break;
+                                               }
                                        }
                                }
-                               if (lit)
+                               if (j >= maxnearlights)
                                {
-                                       int i1, i2, i3;
-                                       i1 = (int) t1;
-                                       avc[0] = bound(0, i1, 255);
-                                       i2 = (int) t2;
-                                       avc[1] = bound(0, i2, 255);
-                                       i3 = (int) t3;
-                                       avc[2] = bound(0, i3, 255);
-                                       avc[3] = a;
+                                       // 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(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 // dodge the costly float -> int conversions
-                                       *((int *)avc) = color;
-                               avc += 4;
-                               av += 3;
-                               avn += 3;
                        }
                }
        }
-       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)
                {
-                       *((int *)avc) = color;
-                       avc += 4;
+                       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++)
+               {
+                       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;
+}
+