]> de.git.xonotic.org Git - xonotic/darkplaces.git/blobdiff - r_light.c
lightmap update checking is now handled very differently; each brush model has a...
[xonotic/darkplaces.git] / r_light.c
index e233ff7e188c4ffdc98a77cd539fa62f2e8c7f1c..86c2a0d4031f33e69c1a75315f5f62920e3d9736 100644 (file)
--- a/r_light.c
+++ b/r_light.c
@@ -21,6 +21,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include "quakedef.h"
 #include "cl_collision.h"
+#include "r_shadow.h"
 
 rdlight_t r_dlight[MAX_DLIGHTS];
 int r_numdlights = 0;
@@ -284,6 +285,8 @@ loc0:
                {
                        surf->dlightbits[0] = surf->dlightbits[1] = surf->dlightbits[2] = surf->dlightbits[3] = surf->dlightbits[4] = surf->dlightbits[5] = surf->dlightbits[6] = surf->dlightbits[7] = 0;
                        surf->dlightframe = r_framecount;
+                       if (r_dlightmap.integer)
+                               surf->cached_dlight = true;
                }
                surf->dlightbits[bitindex] |= bit;
        }
@@ -423,6 +426,8 @@ static void R_VisMarkLights (entity_render_t *ent, rdlight_t *rd, int bit, int b
                                                                {
                                                                        surf->dlightbits[0] = surf->dlightbits[1] = surf->dlightbits[2] = surf->dlightbits[3] = surf->dlightbits[4] = surf->dlightbits[5] = surf->dlightbits[6] = surf->dlightbits[7] = 0;
                                                                        surf->dlightframe = r_framecount;
+                                                                       if (r_dlightmap.integer)
+                                                                               surf->cached_dlight = true;
                                                                }
                                                                surf->dlightbits[bitindex] |= bit;
                                                        }
@@ -658,7 +663,7 @@ void R_ModelLightPoint (const entity_render_t *ent, vec3_t color, const vec3_t p
        }
 
        color[0] = color[1] = color[2] = r_ambient.value * (2.0f / 128.0f);
-       if (!cl.worldmodel->numlights)
+       if (!cl.worldmodel->numlights && r_shadow_lightingmode < 2)
                RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
 }
 
@@ -690,72 +695,16 @@ void R_LightModel(const entity_render_t *ent, int numverts, float *vertices, flo
        {
                R_ModelLightPoint(ent, basecolor, ent->origin);
 
-               nl = &nearlight[0];
-               for (i = 0;i < ent->numentlights;i++)
+               if (r_shadow_lightingmode < 2)
                {
-                       sl = cl.worldmodel->lights + ent->entlights[i];
-                       stylescale = d_lightstylevalue[sl->style] * (1.0f / 65536.0f);
-                       VectorSubtract (ent->origin, sl->origin, v);
-                       f = ((1.0f / (DotProduct(v, v) * sl->falloff + sl->distbias)) - sl->subtract) * stylescale;
-                       VectorScale(sl->light, f, ambientcolor);
-                       intensity = DotProduct(ambientcolor, ambientcolor);
-                       if (f < 0)
-                               intensity *= -1.0f;
-                       if (nearlights < maxnearlights)
-                               j = nearlights++;
-                       else
+                       nl = &nearlight[0];
+                       for (i = 0;i < ent->numentlights;i++)
                        {
-                               for (j = 0;j < maxnearlights;j++)
-                               {
-                                       if (nearlight[j].intensity < intensity)
-                                       {
-                                               if (nearlight[j].intensity > 0)
-                                                       VectorAdd(basecolor, nearlight[j].ambientlight, basecolor);
-                                               break;
-                                       }
-                               }
-                       }
-                       if (j >= maxnearlights)
-                       {
-                               // this light is less significant than all others,
-                               // add it to ambient
-                               if (intensity > 0)
-                                       VectorAdd(basecolor, ambientcolor, basecolor);
-                       }
-                       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;
-                       }
-               }
-               for (i = 0;i < r_numdlights;i++)
-               {
-                       rd = r_dlight + i;
-                       VectorCopy(rd->origin, v);
-                       if (v[0] < ent->mins[0]) v[0] = ent->mins[0];if (v[0] > ent->maxs[0]) v[0] = ent->maxs[0];
-                       if (v[1] < ent->mins[1]) v[1] = ent->mins[1];if (v[1] > ent->maxs[1]) v[1] = ent->maxs[1];
-                       if (v[2] < ent->mins[2]) v[2] = ent->mins[2];if (v[2] > ent->maxs[2]) v[2] = ent->maxs[2];
-                       VectorSubtract (v, rd->origin, v);
-                       if (DotProduct(v, v) < rd->cullradius2)
-                       {
-                               if (CL_TraceLine(ent->origin, rd->origin, NULL, NULL, 0, false, NULL) != 1)
-                                       continue;
-                               VectorSubtract (ent->origin, rd->origin, v);
-                               f = ((1.0f / (DotProduct(v, v) + LIGHTOFFSET)) - rd->subtract);
-                               VectorScale(rd->light, f, ambientcolor);
+                               sl = cl.worldmodel->lights + ent->entlights[i];
+                               stylescale = d_lightstylevalue[sl->style] * (1.0f / 65536.0f);
+                               VectorSubtract (ent->origin, sl->origin, v);
+                               f = ((1.0f / (DotProduct(v, v) * sl->falloff + sl->distbias)) - sl->subtract) * stylescale;
+                               VectorScale(sl->light, f, ambientcolor);
                                intensity = DotProduct(ambientcolor, ambientcolor);
                                if (f < 0)
                                        intensity *= -1.0f;
@@ -786,43 +735,104 @@ void R_LightModel(const entity_render_t *ent, int numverts, float *vertices, flo
                                        nl->intensity = intensity;
                                        // transform the light into the model's coordinate system
                                        if (worldcoords)
-                                               VectorCopy(rd->origin, nl->origin);
+                                               VectorCopy(sl->origin, nl->origin);
                                        else
-                                       {
-                                               Matrix4x4_Transform(&ent->inversematrix, rd->origin, nl->origin);
-                                               /*
-                                               Con_Printf("%i %s : %f %f %f : %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n"
-                                               , rd - r_dlight, ent->model->name
-                                               , rd->origin[0], rd->origin[1], rd->origin[2]
-                                               , nl->origin[0], nl->origin[1], nl->origin[2]
-                                               , ent->inversematrix.m[0][0], ent->inversematrix.m[0][1], ent->inversematrix.m[0][2], ent->inversematrix.m[0][3]
-                                               , ent->inversematrix.m[1][0], ent->inversematrix.m[1][1], ent->inversematrix.m[1][2], ent->inversematrix.m[1][3]
-                                               , ent->inversematrix.m[2][0], ent->inversematrix.m[2][1], ent->inversematrix.m[2][2], ent->inversematrix.m[2][3]
-                                               , ent->inversematrix.m[3][0], ent->inversematrix.m[3][1], ent->inversematrix.m[3][2], ent->inversematrix.m[3][3]);
-                                               */
-                                       }
+                                               Matrix4x4_Transform(&ent->inversematrix, sl->origin, nl->origin);
                                        // integrate mscale into falloff, for maximum speed
-                                       nl->falloff = mscale;
+                                       nl->falloff = sl->falloff * mscale;
                                        VectorCopy(ambientcolor, nl->ambientlight);
-                                       nl->light[0] = rd->light[0] * colorr * 4.0f;
-                                       nl->light[1] = rd->light[1] * colorg * 4.0f;
-                                       nl->light[2] = rd->light[2] * colorb * 4.0f;
-                                       nl->subtract = rd->subtract;
-                                       nl->offset = LIGHTOFFSET;
+                                       nl->light[0] = sl->light[0] * stylescale * colorr * 4.0f;
+                                       nl->light[1] = sl->light[1] * stylescale * colorg * 4.0f;
+                                       nl->light[2] = sl->light[2] * stylescale * colorb * 4.0f;
+                                       nl->subtract = sl->subtract;
+                                       nl->offset = sl->distbias;
+                               }
+                       }
+                       if (r_shadow_lightingmode < 1)
+                       {
+                               for (i = 0;i < r_numdlights;i++)
+                               {
+                                       rd = r_dlight + i;
+                                       VectorCopy(rd->origin, v);
+                                       if (v[0] < ent->mins[0]) v[0] = ent->mins[0];if (v[0] > ent->maxs[0]) v[0] = ent->maxs[0];
+                                       if (v[1] < ent->mins[1]) v[1] = ent->mins[1];if (v[1] > ent->maxs[1]) v[1] = ent->maxs[1];
+                                       if (v[2] < ent->mins[2]) v[2] = ent->mins[2];if (v[2] > ent->maxs[2]) v[2] = ent->maxs[2];
+                                       VectorSubtract (v, rd->origin, v);
+                                       if (DotProduct(v, v) < rd->cullradius2)
+                                       {
+                                               if (CL_TraceLine(ent->origin, rd->origin, NULL, NULL, 0, false, NULL) != 1)
+                                                       continue;
+                                               VectorSubtract (ent->origin, rd->origin, v);
+                                               f = ((1.0f / (DotProduct(v, v) + LIGHTOFFSET)) - rd->subtract);
+                                               VectorScale(rd->light, f, ambientcolor);
+                                               intensity = DotProduct(ambientcolor, ambientcolor);
+                                               if (f < 0)
+                                                       intensity *= -1.0f;
+                                               if (nearlights < maxnearlights)
+                                                       j = nearlights++;
+                                               else
+                                               {
+                                                       for (j = 0;j < maxnearlights;j++)
+                                                       {
+                                                               if (nearlight[j].intensity < intensity)
+                                                               {
+                                                                       if (nearlight[j].intensity > 0)
+                                                                               VectorAdd(basecolor, nearlight[j].ambientlight, basecolor);
+                                                                       break;
+                                                               }
+                                                       }
+                                               }
+                                               if (j >= maxnearlights)
+                                               {
+                                                       // this light is less significant than all others,
+                                                       // add it to ambient
+                                                       if (intensity > 0)
+                                                               VectorAdd(basecolor, ambientcolor, basecolor);
+                                               }
+                                               else
+                                               {
+                                                       nl = nearlight + j;
+                                                       nl->intensity = intensity;
+                                                       // transform the light into the model's coordinate system
+                                                       if (worldcoords)
+                                                               VectorCopy(rd->origin, nl->origin);
+                                                       else
+                                                       {
+                                                               Matrix4x4_Transform(&ent->inversematrix, rd->origin, nl->origin);
+                                                               /*
+                                                               Con_Printf("%i %s : %f %f %f : %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n"
+                                                               , rd - r_dlight, ent->model->name
+                                                               , rd->origin[0], rd->origin[1], rd->origin[2]
+                                                               , nl->origin[0], nl->origin[1], nl->origin[2]
+                                                               , ent->inversematrix.m[0][0], ent->inversematrix.m[0][1], ent->inversematrix.m[0][2], ent->inversematrix.m[0][3]
+                                                               , ent->inversematrix.m[1][0], ent->inversematrix.m[1][1], ent->inversematrix.m[1][2], ent->inversematrix.m[1][3]
+                                                               , ent->inversematrix.m[2][0], ent->inversematrix.m[2][1], ent->inversematrix.m[2][2], ent->inversematrix.m[2][3]
+                                                               , ent->inversematrix.m[3][0], ent->inversematrix.m[3][1], ent->inversematrix.m[3][2], ent->inversematrix.m[3][3]);
+                                                               */
+                                                       }
+                                                       // integrate mscale into falloff, for maximum speed
+                                                       nl->falloff = mscale;
+                                                       VectorCopy(ambientcolor, nl->ambientlight);
+                                                       nl->light[0] = rd->light[0] * colorr * 4.0f;
+                                                       nl->light[1] = rd->light[1] * colorg * 4.0f;
+                                                       nl->light[2] = rd->light[2] * colorb * 4.0f;
+                                                       nl->subtract = rd->subtract;
+                                                       nl->offset = LIGHTOFFSET;
+                                               }
+                                       }
                                }
                        }
                }
        }
        else
-       {
                R_CompleteLightPoint (basecolor, ent->origin, true, NULL);
-       }
        basecolor[0] *= colorr;
        basecolor[1] *= colorg;
        basecolor[2] *= colorb;
        avc = colors;
        if (nearlights)
        {
+               GL_UseColorArray();
                av = vertices;
                avn = normals;
                for (i = 0;i < numverts;i++)
@@ -870,14 +880,7 @@ void R_LightModel(const entity_render_t *ent, int numverts, float *vertices, flo
                }
        }
        else
-       {
-               for (i = 0;i < numverts;i++)
-               {
-                       VectorCopy(basecolor, avc);
-                       avc[3] = a;
-                       avc += 4;
-               }
-       }
+               GL_Color(basecolor[0], basecolor[1], basecolor[2], a);
 }
 
 void R_UpdateEntLights(entity_render_t *ent)
@@ -885,6 +888,8 @@ void R_UpdateEntLights(entity_render_t *ent)
        int i;
        const mlight_t *sl;
        vec3_t v;
+       if (r_shadow_lightingmode >= 2)
+               return;
        VectorSubtract(ent->origin, ent->entlightsorigin, v);
        if (ent->entlightsframe != (r_framecount - 1) || (realtime > ent->entlightstime && DotProduct(v,v) >= 1.0f))
        {