detail texturing added (although with just one generated texture applied to everything)
[xonotic/darkplaces.git] / r_light.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // r_light.c
21
22 #include "quakedef.h"
23 #include "cl_collision.h"
24
25 rdlight_t r_dlight[MAX_DLIGHTS];
26 int r_numdlights = 0;
27
28 cvar_t r_modellights = {CVAR_SAVE, "r_modellights", "4"};
29 cvar_t r_vismarklights = {0, "r_vismarklights", "1"};
30
31 static rtexture_t *lightcorona;
32 static rtexturepool_t *lighttexturepool;
33
34 void r_light_start(void)
35 {
36         float dx, dy;
37         int x, y, a;
38         qbyte pixels[32][32][4];
39         lighttexturepool = R_AllocTexturePool();
40         for (y = 0;y < 32;y++)
41         {
42                 dy = (y - 15.5f) * (1.0f / 16.0f);
43                 for (x = 0;x < 32;x++)
44                 {
45                         dx = (x - 15.5f) * (1.0f / 16.0f);
46                         a = ((1.0f / (dx * dx + dy * dy + 0.2f)) - (1.0f / (1.0f + 0.2))) * 32.0f / (1.0f / (1.0f + 0.2));
47                         a = bound(0, a, 255);
48                         pixels[y][x][0] = a;
49                         pixels[y][x][1] = a;
50                         pixels[y][x][2] = a;
51                         pixels[y][x][3] = 255;
52                 }
53         }
54         lightcorona = R_LoadTexture (lighttexturepool, "lightcorona", 32, 32, &pixels[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE);
55 }
56
57 void r_light_shutdown(void)
58 {
59         lighttexturepool = NULL;
60         lightcorona = NULL;
61 }
62
63 void r_light_newmap(void)
64 {
65 }
66
67 void R_Light_Init(void)
68 {
69         Cvar_RegisterVariable(&r_modellights);
70         Cvar_RegisterVariable(&r_vismarklights);
71         R_RegisterModule("R_Light", r_light_start, r_light_shutdown, r_light_newmap);
72 }
73
74 /*
75 ==================
76 R_AnimateLight
77 ==================
78 */
79 void R_AnimateLight (void)
80 {
81         int i, j, k;
82
83 //
84 // light animations
85 // 'm' is normal light, 'a' is no light, 'z' is double bright
86         i = (int)(cl.time * 10);
87         for (j = 0;j < MAX_LIGHTSTYLES;j++)
88         {
89                 if (!cl_lightstyle[j].length)
90                 {
91                         d_lightstylevalue[j] = 256;
92                         continue;
93                 }
94                 k = i % cl_lightstyle[j].length;
95                 k = cl_lightstyle[j].map[k] - 'a';
96                 k = k*22;
97                 d_lightstylevalue[j] = k;
98         }
99 }
100
101
102 void R_BuildLightList(void)
103 {
104         int i;
105         dlight_t *cd;
106         rdlight_t *rd;
107
108         r_numdlights = 0;
109         c_dlights = 0;
110
111         if (!r_dynamic.integer)
112                 return;
113
114         for (i = 0;i < MAX_DLIGHTS;i++)
115         {
116                 cd = cl_dlights + i;
117                 if (cd->radius <= 0)
118                         continue;
119                 rd = &r_dlight[r_numdlights++];
120                 VectorCopy(cd->origin, rd->origin);
121                 VectorScale(cd->color, cd->radius * 64.0f, rd->light);
122                 rd->cullradius2 = DotProduct(rd->light, rd->light) * (0.25f / (64.0f * 64.0f)) + 4096.0f;
123                 // clamp radius to avoid overflowing division table in lightmap code
124                 if (rd->cullradius2 > (2048.0f * 2048.0f))
125                         rd->cullradius2 = (2048.0f * 2048.0f);
126                 rd->cullradius = sqrt(rd->cullradius2);
127                 rd->subtract = 1.0f / rd->cullradius2;
128                 //rd->ent = cd->ent;
129                 r_numdlights++;
130                 c_dlights++; // count every dlight in use
131         }
132 }
133
134 void R_DrawCoronas(void)
135 {
136         int i;
137         rmeshbufferinfo_t m;
138         float scale, viewdist, diff[3], dist;
139         rdlight_t *rd;
140         memset(&m, 0, sizeof(m));
141         m.transparent = false;
142         m.blendfunc1 = GL_ONE;
143         m.blendfunc2 = GL_ONE;
144         m.depthdisable = true; // magic
145         m.numtriangles = 2;
146         m.numverts = 4;
147         m.tex[0] = R_GetTexture(lightcorona);
148         viewdist = DotProduct(r_origin, vpn);
149         for (i = 0;i < r_numdlights;i++)
150         {
151                 rd = r_dlight + i;
152                 dist = (DotProduct(rd->origin, vpn) - viewdist);
153                 if (dist >= 24.0f)
154                 {
155                         // trace to a point just barely closer to the eye
156                         VectorSubtract(rd->origin, vpn, diff);
157                         if (CL_TraceLine(r_origin, diff, NULL, NULL, 0, true) == 1 && R_Mesh_Draw_GetBuffer(&m, false))
158                         {
159                                 scale = m.colorscale * (1.0f / 131072.0f);
160                                 if (fogenabled)
161                                 {
162                                         VectorSubtract(rd->origin, r_origin, diff);
163                                         scale *= 1 - exp(fogdensity/DotProduct(diff,diff));
164                                 }
165                                 m.index[0] = 0;
166                                 m.index[1] = 1;
167                                 m.index[2] = 2;
168                                 m.index[3] = 0;
169                                 m.index[4] = 2;
170                                 m.index[5] = 3;
171                                 m.color[0] = m.color[4] = m.color[8] = m.color[12] = rd->light[0] * scale;
172                                 m.color[1] = m.color[5] = m.color[9] = m.color[13] = rd->light[1] * scale;
173                                 m.color[2] = m.color[6] = m.color[10] = m.color[14] = rd->light[2] * scale;
174                                 m.color[3] = m.color[7] = m.color[11] = m.color[15] = 1;
175                                 m.texcoords[0][0] = 0;
176                                 m.texcoords[0][1] = 0;
177                                 m.texcoords[0][2] = 0;
178                                 m.texcoords[0][3] = 1;
179                                 m.texcoords[0][4] = 1;
180                                 m.texcoords[0][5] = 1;
181                                 m.texcoords[0][6] = 1;
182                                 m.texcoords[0][7] = 0;
183                                 scale = rd->cullradius * 0.25f;
184                                 m.vertex[0] = rd->origin[0] - vright[0] * scale - vup[0] * scale;
185                                 m.vertex[1] = rd->origin[1] - vright[1] * scale - vup[1] * scale;
186                                 m.vertex[2] = rd->origin[2] - vright[2] * scale - vup[2] * scale;
187                                 m.vertex[4] = rd->origin[0] - vright[0] * scale + vup[0] * scale;
188                                 m.vertex[5] = rd->origin[1] - vright[1] * scale + vup[1] * scale;
189                                 m.vertex[6] = rd->origin[2] - vright[2] * scale + vup[2] * scale;
190                                 m.vertex[8] = rd->origin[0] + vright[0] * scale + vup[0] * scale;
191                                 m.vertex[9] = rd->origin[1] + vright[1] * scale + vup[1] * scale;
192                                 m.vertex[10] = rd->origin[2] + vright[2] * scale + vup[2] * scale;
193                                 m.vertex[12] = rd->origin[0] + vright[0] * scale - vup[0] * scale;
194                                 m.vertex[13] = rd->origin[1] + vright[1] * scale - vup[1] * scale;
195                                 m.vertex[14] = rd->origin[2] + vright[2] * scale - vup[2] * scale;
196                         }
197                 }
198         }
199 }
200
201 /*
202 =============================================================================
203
204 DYNAMIC LIGHTS
205
206 =============================================================================
207 */
208
209 /*
210 =============
211 R_MarkLights
212 =============
213 */
214 static void R_OldMarkLights (vec3_t lightorigin, rdlight_t *rd, int bit, int bitindex, mnode_t *node)
215 {
216         float ndist, maxdist;
217         msurface_t *surf;
218         mleaf_t *leaf;
219         int i;
220
221         if (!r_dynamic.integer)
222                 return;
223
224         // for comparisons to minimum acceptable light
225         maxdist = rd->cullradius2;
226
227 loc0:
228         if (node->contents < 0)
229         {
230                 if (node->contents != CONTENTS_SOLID)
231                 {
232                         leaf = (mleaf_t *)node;
233                         if (leaf->dlightframe != r_framecount) // not dynamic until now
234                         {
235                                 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;
236                                 leaf->dlightframe = r_framecount;
237                         }
238                         leaf->dlightbits[bitindex] |= bit;
239                 }
240                 return;
241         }
242
243         ndist = PlaneDiff(lightorigin, node->plane);
244
245         if (ndist > rd->cullradius)
246         {
247                 node = node->children[0];
248                 goto loc0;
249         }
250         if (ndist < -rd->cullradius)
251         {
252                 node = node->children[1];
253                 goto loc0;
254         }
255
256 // mark the polygons
257         surf = currentrenderentity->model->surfaces + node->firstsurface;
258         for (i=0 ; i<node->numsurfaces ; i++, surf++)
259         {
260                 int d, impacts, impactt;
261                 float dist, dist2, impact[3];
262                 if (surf->visframe != r_framecount)
263                         continue;
264                 dist = ndist;
265                 if (surf->flags & SURF_PLANEBACK)
266                         dist = -dist;
267
268                 if (dist < -0.25f && !(surf->flags & SURF_LIGHTBOTHSIDES))
269                         continue;
270
271                 dist2 = dist * dist;
272                 if (dist2 >= maxdist)
273                         continue;
274
275                 if (node->plane->type < 3)
276                 {
277                         VectorCopy(rd->origin, impact);
278                         impact[node->plane->type] -= dist;
279                 }
280                 else
281                 {
282                         impact[0] = rd->origin[0] - surf->plane->normal[0] * dist;
283                         impact[1] = rd->origin[1] - surf->plane->normal[1] * dist;
284                         impact[2] = rd->origin[2] - surf->plane->normal[2] * dist;
285                 }
286
287                 impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
288
289                 d = bound(0, impacts, surf->extents[0] + 16) - impacts;
290                 dist2 += d * d;
291                 if (dist2 > maxdist)
292                         continue;
293
294                 impactt = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
295
296                 d = bound(0, impactt, surf->extents[1] + 16) - impactt;
297                 dist2 += d * d;
298                 if (dist2 > maxdist)
299                         continue;
300
301                 if (surf->dlightframe != r_framecount) // not dynamic until now
302                 {
303                         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;
304                         surf->dlightframe = r_framecount;
305                 }
306                 surf->dlightbits[bitindex] |= bit;
307         }
308
309         if (node->children[0]->contents >= 0)
310         {
311                 if (node->children[1]->contents >= 0)
312                 {
313                         R_OldMarkLights (lightorigin, rd, bit, bitindex, node->children[0]);
314                         node = node->children[1];
315                         goto loc0;
316                 }
317                 else
318                 {
319                         node = node->children[0];
320                         goto loc0;
321                 }
322         }
323         else if (node->children[1]->contents >= 0)
324         {
325                 node = node->children[1];
326                 goto loc0;
327         }
328 }
329
330
331 static void R_VisMarkLights (rdlight_t *rd, int bit, int bitindex)
332 {
333         static int lightframe = 0;
334         mleaf_t *pvsleaf;
335         vec3_t lightorigin;
336         model_t *model;
337         int i, k, m, c, leafnum;
338         msurface_t *surf, **mark;
339         mleaf_t *leaf;
340         qbyte *in;
341         int row;
342         float low[3], high[3], dist, maxdist;
343
344         if (!r_dynamic.integer)
345                 return;
346
347         model = currentrenderentity->model;
348         softwareuntransform(rd->origin, lightorigin);
349
350         if (!r_vismarklights.integer)
351         {
352                 R_OldMarkLights(lightorigin, rd, bit, bitindex, model->nodes + model->hulls[0].firstclipnode);
353                 return;
354         }
355
356         pvsleaf = Mod_PointInLeaf (lightorigin, model);
357         if (pvsleaf == NULL)
358         {
359                 Con_Printf("R_VisMarkLights: NULL leaf??\n");
360                 R_OldMarkLights(lightorigin, rd, bit, bitindex, model->nodes + model->hulls[0].firstclipnode);
361                 return;
362         }
363
364         in = pvsleaf->compressed_vis;
365         if (!in)
366         {
367                 // no vis info, so make all visible
368                 R_OldMarkLights(lightorigin, rd, bit, bitindex, model->nodes + model->hulls[0].firstclipnode);
369                 return;
370         }
371
372         lightframe++;
373
374         low[0] = lightorigin[0] - rd->cullradius;low[1] = lightorigin[1] - rd->cullradius;low[2] = lightorigin[2] - rd->cullradius;
375         high[0] = lightorigin[0] + rd->cullradius;high[1] = lightorigin[1] + rd->cullradius;high[2] = lightorigin[2] + rd->cullradius;
376
377         // for comparisons to minimum acceptable light
378         maxdist = rd->cullradius2;
379
380         row = (model->numleafs+7)>>3;
381
382         k = 0;
383         while (k < row)
384         {
385                 c = *in++;
386                 if (c)
387                 {
388                         for (i = 0;i < 8;i++)
389                         {
390                                 if (c & (1<<i))
391                                 {
392                                         // warning to the clumsy: numleafs is one less than it should be, it only counts leafs with vis bits (skips leaf 0)
393                                         leafnum = (k << 3)+i+1;
394                                         if (leafnum > model->numleafs)
395                                                 return;
396                                         leaf = &model->leafs[leafnum];
397                                         if (leaf->visframe != r_framecount
398                                          || leaf->contents == CONTENTS_SOLID
399                                          || leaf->mins[0] > high[0] || leaf->maxs[0] < low[0]
400                                          || leaf->mins[1] > high[1] || leaf->maxs[1] < low[1]
401                                          || leaf->mins[2] > high[2] || leaf->maxs[2] < low[2])
402                                                 continue;
403                                         if (leaf->dlightframe != r_framecount)
404                                         {
405                                                 // not dynamic until now
406                                                 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;
407                                                 leaf->dlightframe = r_framecount;
408                                         }
409                                         leaf->dlightbits[bitindex] |= bit;
410                                         if ((m = leaf->nummarksurfaces))
411                                         {
412                                                 mark = leaf->firstmarksurface;
413                                                 do
414                                                 {
415                                                         surf = *mark++;
416                                                         // if not visible in current frame, or already marked because it was in another leaf we passed, skip
417                                                         if (surf->lightframe == lightframe)
418                                                                 continue;
419                                                         surf->lightframe = lightframe;
420                                                         if (surf->visframe != r_framecount)
421                                                                 continue;
422                                                         dist = PlaneDiff(lightorigin, surf->plane);
423                                                         if (surf->flags & SURF_PLANEBACK)
424                                                                 dist = -dist;
425                                                         // LordHavoc: make sure it is infront of the surface and not too far away
426                                                         if (dist < rd->cullradius && (dist > -0.25f || ((surf->flags & SURF_LIGHTBOTHSIDES) && dist > -rd->cullradius)))
427                                                         {
428                                                                 int d;
429                                                                 int impacts, impactt;
430                                                                 float dist2, impact[3];
431
432                                                                 dist2 = dist * dist;
433
434                                                                 if (surf->plane->type < 3)
435                                                                 {
436                                                                         VectorCopy(rd->origin, impact);
437                                                                         impact[surf->plane->type] -= dist;
438                                                                 }
439                                                                 else
440                                                                 {
441                                                                         impact[0] = rd->origin[0] - surf->plane->normal[0] * dist;
442                                                                         impact[1] = rd->origin[1] - surf->plane->normal[1] * dist;
443                                                                         impact[2] = rd->origin[2] - surf->plane->normal[2] * dist;
444                                                                 }
445
446                                                                 impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
447                                                                 d = bound(0, impacts, surf->extents[0] + 16) - impacts;
448                                                                 dist2 += d * d;
449                                                                 if (dist2 > maxdist)
450                                                                         continue;
451
452                                                                 impactt = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
453                                                                 d = bound(0, impactt, surf->extents[1] + 16) - impactt;
454                                                                 dist2 += d * d;
455                                                                 if (dist2 > maxdist)
456                                                                         continue;
457
458                                                                 if (surf->dlightframe != r_framecount) // not dynamic until now
459                                                                 {
460                                                                         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;
461                                                                         surf->dlightframe = r_framecount;
462                                                                 }
463                                                                 surf->dlightbits[bitindex] |= bit;
464                                                         }
465                                                 }
466                                                 while (--m);
467                                         }
468                                 }
469                         }
470                         k++;
471                         continue;
472                 }
473
474                 k += *in++;
475         }
476 }
477
478 void R_MarkLights(void)
479 {
480         int i;
481         for (i = 0;i < r_numdlights;i++)
482                 R_VisMarkLights (r_dlight + i, 1 << (i & 31), i >> 5);
483 }
484
485 /*
486 =============================================================================
487
488 LIGHT SAMPLING
489
490 =============================================================================
491 */
492
493 static int RecursiveLightPoint (vec3_t color, mnode_t *node, float x, float y, float startz, float endz)
494 {
495         int side, distz = endz - startz;
496         float front, back;
497         float mid;
498
499 loc0:
500         if (node->contents < 0)
501                 return false;           // didn't hit anything
502
503         switch (node->plane->type)
504         {
505         case PLANE_X:
506                 node = node->children[x < node->plane->dist];
507                 goto loc0;
508         case PLANE_Y:
509                 node = node->children[y < node->plane->dist];
510                 goto loc0;
511         case PLANE_Z:
512                 side = startz < node->plane->dist;
513                 if ((endz < node->plane->dist) == side)
514                 {
515                         node = node->children[side];
516                         goto loc0;
517                 }
518                 // found an intersection
519                 mid = node->plane->dist;
520                 break;
521         default:
522                 back = front = x * node->plane->normal[0] + y * node->plane->normal[1];
523                 front += startz * node->plane->normal[2];
524                 back += endz * node->plane->normal[2];
525                 side = front < node->plane->dist;
526                 if ((back < node->plane->dist) == side)
527                 {
528                         node = node->children[side];
529                         goto loc0;
530                 }
531                 // found an intersection
532                 mid = startz + distz * (front - node->plane->dist) / (front - back);
533                 break;
534         }
535
536         // go down front side
537         if (node->children[side]->contents >= 0 && RecursiveLightPoint (color, node->children[side], x, y, startz, mid))
538                 return true;    // hit something
539         else
540         {
541                 // check for impact on this node
542                 if (node->numsurfaces)
543                 {
544                         int i, ds, dt;
545                         msurface_t *surf;
546
547                         surf = cl.worldmodel->surfaces + node->firstsurface;
548                         for (i = 0;i < node->numsurfaces;i++, surf++)
549                         {
550                                 if (!(surf->flags & SURF_LIGHTMAP))
551                                         continue;       // no lightmaps
552
553                                 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]);
554                                 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]);
555
556                                 if (ds < surf->texturemins[0] || dt < surf->texturemins[1])
557                                         continue;
558
559                                 ds -= surf->texturemins[0];
560                                 dt -= surf->texturemins[1];
561
562                                 if (ds > surf->extents[0] || dt > surf->extents[1])
563                                         continue;
564
565                                 if (surf->samples)
566                                 {
567                                         qbyte *lightmap;
568                                         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;
569                                         line3 = ((surf->extents[0]>>4)+1)*3;
570                                         size3 = ((surf->extents[0]>>4)+1) * ((surf->extents[1]>>4)+1)*3; // LordHavoc: *3 for colored lighting
571
572                                         lightmap = surf->samples + ((dt>>4) * ((surf->extents[0]>>4)+1) + (ds>>4))*3; // LordHavoc: *3 for color
573
574                                         for (maps = 0;maps < MAXLIGHTMAPS && surf->styles[maps] != 255;maps++)
575                                         {
576                                                 scale = d_lightstylevalue[surf->styles[maps]];
577                                                 r00 += lightmap[      0] * scale;g00 += lightmap[      1] * scale;b00 += lightmap[      2] * scale;
578                                                 r01 += lightmap[      3] * scale;g01 += lightmap[      4] * scale;b01 += lightmap[      5] * scale;
579                                                 r10 += lightmap[line3+0] * scale;g10 += lightmap[line3+1] * scale;b10 += lightmap[line3+2] * scale;
580                                                 r11 += lightmap[line3+3] * scale;g11 += lightmap[line3+4] * scale;b11 += lightmap[line3+5] * scale;
581                                                 lightmap += size3;
582                                         }
583
584 /*
585 LordHavoc: here's the readable version of the interpolation
586 code, not quite as easy for the compiler to optimize...
587
588 dsfrac is the X position in the lightmap pixel, * 16
589 dtfrac is the Y position in the lightmap pixel, * 16
590 r00 is top left corner, r01 is top right corner
591 r10 is bottom left corner, r11 is bottom right corner
592 g and b are the same layout.
593 r0 and r1 are the top and bottom intermediate results
594
595 first we interpolate the top two points, to get the top
596 edge sample
597
598         r0 = (((r01-r00) * dsfrac) >> 4) + r00;
599         g0 = (((g01-g00) * dsfrac) >> 4) + g00;
600         b0 = (((b01-b00) * dsfrac) >> 4) + b00;
601
602 then we interpolate the bottom two points, to get the
603 bottom edge sample
604
605         r1 = (((r11-r10) * dsfrac) >> 4) + r10;
606         g1 = (((g11-g10) * dsfrac) >> 4) + g10;
607         b1 = (((b11-b10) * dsfrac) >> 4) + b10;
608
609 then we interpolate the top and bottom samples to get the
610 middle sample (the one which was requested)
611
612         r = (((r1-r0) * dtfrac) >> 4) + r0;
613         g = (((g1-g0) * dtfrac) >> 4) + g0;
614         b = (((b1-b0) * dtfrac) >> 4) + b0;
615 */
616
617                                         color[0] += (float) ((((((((r11-r10) * dsfrac) >> 4) + r10)-((((r01-r00) * dsfrac) >> 4) + r00)) * dtfrac) >> 4) + ((((r01-r00) * dsfrac) >> 4) + r00)) * (1.0f / 32768.0f);
618                                         color[1] += (float) ((((((((g11-g10) * dsfrac) >> 4) + g10)-((((g01-g00) * dsfrac) >> 4) + g00)) * dtfrac) >> 4) + ((((g01-g00) * dsfrac) >> 4) + g00)) * (1.0f / 32768.0f);
619                                         color[2] += (float) ((((((((b11-b10) * dsfrac) >> 4) + b10)-((((b01-b00) * dsfrac) >> 4) + b00)) * dtfrac) >> 4) + ((((b01-b00) * dsfrac) >> 4) + b00)) * (1.0f / 32768.0f);
620                                 }
621                                 return true; // success
622                         }
623                 }
624
625                 // go down back side
626                 node = node->children[side ^ 1];
627                 startz = mid;
628                 distz = endz - startz;
629                 goto loc0;
630         }
631 }
632
633 void R_CompleteLightPoint (vec3_t color, vec3_t p, int dynamic, mleaf_t *leaf)
634 {
635         int i, *dlightbits;
636         vec3_t v;
637         float f;
638         rdlight_t *rd;
639         mlight_t *sl;
640         if (leaf == NULL)
641                 leaf = Mod_PointInLeaf(p, cl.worldmodel);
642
643         if (leaf->contents == CONTENTS_SOLID)
644         {
645                 color[0] = color[1] = color[2] = 0;
646                 return;
647         }
648
649         if (r_fullbright.integer || !cl.worldmodel->lightdata)
650         {
651                 color[0] = color[1] = color[2] = 2;
652                 return;
653         }
654
655         color[0] = color[1] = color[2] = r_ambient.value * (2.0f / 128.0f);
656         if (cl.worldmodel->numlights)
657         {
658                 for (i = 0;i < cl.worldmodel->numlights;i++)
659                 {
660                         sl = cl.worldmodel->lights + i;
661                         if (d_lightstylevalue[sl->style] > 0)
662                         {
663                                 VectorSubtract (p, sl->origin, v);
664                                 f = ((1.0f / (DotProduct(v, v) * sl->falloff + sl->distbias)) - sl->subtract);
665                                 if (f > 0 && CL_TraceLine(p, sl->origin, NULL, NULL, 0, false) == 1)
666                                 {
667                                         f *= d_lightstylevalue[sl->style] * (1.0f / 65536.0f);
668                                         VectorMA(color, f, sl->light, color);
669                                 }
670                         }
671                 }
672         }
673         else
674                 RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
675
676         if (dynamic && leaf->dlightframe == r_framecount)
677         {
678                 dlightbits = leaf->dlightbits;
679                 for (i = 0;i < r_numdlights;i++)
680                 {
681                         if (!(dlightbits[i >> 5] & (1 << (i & 31))))
682                                 continue;
683                         rd = r_dlight + i;
684                         VectorSubtract (p, rd->origin, v);
685                         f = DotProduct(v, v);
686                         if (f < rd->cullradius2)
687                         {
688                                 f = (1.0f / (f + LIGHTOFFSET)) - rd->subtract;
689                                 VectorMA(color, f, rd->light, color);
690                         }
691                 }
692         }
693 }
694
695 void R_ModelLightPoint (vec3_t color, vec3_t p, int *dlightbits)
696 {
697         mleaf_t *leaf;
698         leaf = Mod_PointInLeaf(p, cl.worldmodel);
699         if (leaf->contents == CONTENTS_SOLID)
700         {
701                 color[0] = color[1] = color[2] = 0;
702                 dlightbits[0] = dlightbits[1] = dlightbits[2] = dlightbits[3] = dlightbits[4] = dlightbits[5] = dlightbits[6] = dlightbits[7] = 0;
703                 return;
704         }
705
706         if (r_fullbright.integer || !cl.worldmodel->lightdata || currentrenderentity->effects & EF_FULLBRIGHT)
707         {
708                 color[0] = color[1] = color[2] = 2;
709                 dlightbits[0] = dlightbits[1] = dlightbits[2] = dlightbits[3] = dlightbits[4] = dlightbits[5] = dlightbits[6] = dlightbits[7] = 0;
710                 return;
711         }
712
713         color[0] = color[1] = color[2] = r_ambient.value * (2.0f / 128.0f);
714         if (!cl.worldmodel->numlights)
715                 RecursiveLightPoint (color, cl.worldmodel->nodes, p[0], p[1], p[2], p[2] - 65536);
716
717         if (leaf->dlightframe == r_framecount)
718         {
719                 dlightbits[0] = leaf->dlightbits[0];
720                 dlightbits[1] = leaf->dlightbits[1];
721                 dlightbits[2] = leaf->dlightbits[2];
722                 dlightbits[3] = leaf->dlightbits[3];
723                 dlightbits[4] = leaf->dlightbits[4];
724                 dlightbits[5] = leaf->dlightbits[5];
725                 dlightbits[6] = leaf->dlightbits[6];
726                 dlightbits[7] = leaf->dlightbits[7];
727         }
728         else
729                 dlightbits[0] = dlightbits[1] = dlightbits[2] = dlightbits[3] = dlightbits[4] = dlightbits[5] = dlightbits[6] = dlightbits[7] = 0;
730 }
731
732 void R_LightModel(int numverts, float colorr, float colorg, float colorb, int worldcoords)
733 {
734         int i, j, nearlights = 0, maxnearlights = r_modellights.integer;
735         float color[3], basecolor[3], v[3], t, *av, *avn, *avc, a, f, dist2, mscale, dot, stylescale, intensity, ambientcolor[3];
736         struct
737         {
738                 vec3_t origin;
739                 //vec_t cullradius2;
740                 vec3_t light;
741                 // how much this light would contribute to ambient if replaced
742                 vec3_t ambientlight;
743                 vec_t subtract;
744                 vec_t falloff;
745                 vec_t offset;
746                 // used for choosing only the brightest lights
747                 vec_t intensity;
748         }
749         nearlight[MAX_DLIGHTS], *nl;
750         int modeldlightbits[8];
751         mlight_t *sl;
752         rdlight_t *rd;
753         a = currentrenderentity->alpha;
754         // scale of the model's coordinate space, to alter light attenuation to match
755         // make the mscale squared so it can scale the squared distance results
756         mscale = currentrenderentity->scale * currentrenderentity->scale;
757         if ((maxnearlights != 0) && !r_fullbright.integer && !(currentrenderentity->effects & EF_FULLBRIGHT))
758         {
759                 R_ModelLightPoint(basecolor, currentrenderentity->origin, modeldlightbits);
760
761                 nl = &nearlight[0];
762                 VectorSubtract(currentrenderentity->origin, currentrenderentity->entlightsorigin, v);
763                 if ((realtime > currentrenderentity->entlightstime && DotProduct(v,v) >= 1.0f))
764                 {
765                         currentrenderentity->numentlights = 0;
766                         currentrenderentity->entlightstime = realtime + 0.2;
767                         VectorCopy(currentrenderentity->origin, currentrenderentity->entlightsorigin);
768                         for (i = 0, sl = cl.worldmodel->lights;i < cl.worldmodel->numlights && currentrenderentity->numentlights < MAXENTLIGHTS;i++, sl++)
769                                 if (CL_TraceLine(currentrenderentity->origin, sl->origin, NULL, NULL, 0, false) == 1)
770                                         currentrenderentity->entlights[currentrenderentity->numentlights++] = i;
771                 }
772                 for (i = 0;i < currentrenderentity->numentlights;i++)
773                 {
774                         sl = cl.worldmodel->lights + currentrenderentity->entlights[i];
775                         stylescale = d_lightstylevalue[sl->style] * (1.0f / 65536.0f);
776                         VectorSubtract (currentrenderentity->origin, sl->origin, v);
777                         f = ((1.0f / (DotProduct(v, v) * sl->falloff + sl->distbias)) - sl->subtract) * stylescale;
778                         VectorScale(sl->light, f, ambientcolor);
779                         intensity = DotProduct(ambientcolor, ambientcolor);
780                         if (f < 0)
781                                 intensity *= -1.0f;
782                         if (nearlights < maxnearlights)
783                                 j = nearlights++;
784                         else
785                         {
786                                 for (j = 0;j < maxnearlights;j++)
787                                 {
788                                         if (nearlight[j].intensity < intensity)
789                                         {
790                                                 if (nearlight[j].intensity > 0)
791                                                         VectorAdd(basecolor, nearlight[j].ambientlight, basecolor);
792                                                 break;
793                                         }
794                                 }
795                         }
796                         if (j >= maxnearlights)
797                         {
798                                 // this light is less significant than all others,
799                                 // add it to ambient
800                                 if (intensity > 0)
801                                         VectorAdd(basecolor, ambientcolor, basecolor);
802                         }
803                         else
804                         {
805                                 nl = nearlight + j;
806                                 nl->intensity = intensity;
807                                 // transform the light into the model's coordinate system
808                                 if (worldcoords)
809                                         VectorCopy(sl->origin, nl->origin);
810                                 else
811                                         softwareuntransform(sl->origin, nl->origin);
812                                 // integrate mscale into falloff, for maximum speed
813                                 nl->falloff = sl->falloff * mscale;
814                                 VectorCopy(ambientcolor, nl->ambientlight);
815                                 nl->light[0] = sl->light[0] * stylescale * colorr * 4.0f;
816                                 nl->light[1] = sl->light[1] * stylescale * colorg * 4.0f;
817                                 nl->light[2] = sl->light[2] * stylescale * colorb * 4.0f;
818                                 nl->subtract = sl->subtract;
819                                 nl->offset = sl->distbias;
820                         }
821                 }
822                 for (i = 0;i < r_numdlights;i++)
823                 {
824                         if (!(modeldlightbits[i >> 5] & (1 << (i & 31))))
825                                 continue;
826                         rd = r_dlight + i;
827                         VectorSubtract (currentrenderentity->origin, rd->origin, v);
828                         f = ((1.0f / (DotProduct(v, v) + LIGHTOFFSET)) - rd->subtract);
829                         VectorScale(rd->light, f, ambientcolor);
830                         intensity = DotProduct(ambientcolor, ambientcolor);
831                         if (f < 0)
832                                 intensity *= -1.0f;
833                         if (nearlights < maxnearlights)
834                                 j = nearlights++;
835                         else
836                         {
837                                 for (j = 0;j < maxnearlights;j++)
838                                 {
839                                         if (nearlight[j].intensity < intensity)
840                                         {
841                                                 if (nearlight[j].intensity > 0)
842                                                         VectorAdd(basecolor, nearlight[j].ambientlight, basecolor);
843                                                 break;
844                                         }
845                                 }
846                         }
847                         if (j >= maxnearlights)
848                         {
849                                 // this light is less significant than all others,
850                                 // add it to ambient
851                                 if (intensity > 0)
852                                         VectorAdd(basecolor, ambientcolor, basecolor);
853                         }
854                         else
855                         {
856                                 nl = nearlight + j;
857                                 nl->intensity = intensity;
858                                 // transform the light into the model's coordinate system
859                                 if (worldcoords)
860                                         VectorCopy(rd->origin, nl->origin);
861                                 else
862                                         softwareuntransform(rd->origin, nl->origin);
863                                 // integrate mscale into falloff, for maximum speed
864                                 nl->falloff = mscale;
865                                 VectorCopy(ambientcolor, nl->ambientlight);
866                                 nl->light[0] = rd->light[0] * colorr * 4.0f;
867                                 nl->light[1] = rd->light[1] * colorg * 4.0f;
868                                 nl->light[2] = rd->light[2] * colorb * 4.0f;
869                                 nl->subtract = rd->subtract;
870                                 nl->offset = LIGHTOFFSET;
871                         }
872                 }
873         }
874         else
875         {
876                 R_CompleteLightPoint (basecolor, currentrenderentity->origin, true, NULL);
877         }
878         basecolor[0] *= colorr;
879         basecolor[1] *= colorg;
880         basecolor[2] *= colorb;
881         avc = aliasvertcolor;
882         if (nearlights)
883         {
884                 av = aliasvert;
885                 avn = aliasvertnorm;
886                 for (i = 0;i < numverts;i++)
887                 {
888                         VectorCopy(basecolor, color);
889                         for (j = 0, nl = &nearlight[0];j < nearlights;j++, nl++)
890                         {
891                                 VectorSubtract(nl->origin, av, v);
892                                 // directional shading
893                                 dot = DotProduct(avn,v);
894                                 if (dot > 0)
895                                 {
896                                         // the vertex normal faces the light
897
898                                         // do the distance attenuation
899                                         dist2 = DotProduct(v,v);
900                                         f = (1.0f / (dist2 * nl->falloff + nl->offset)) - nl->subtract;
901                                         if (f > 0)
902                                         {
903                                                 #if SLOWMATH
904                                                 t = 1.0f / sqrt(dist2);
905                                                 #else
906                                                 *((int *)&t) = 0x5f3759df - ((* (int *) &dist2) >> 1);
907                                                 t = t * (1.5f - (dist2 * 0.5f * t * t));
908                                                 #endif
909
910                                                 // dot * t is dotproduct with a normalized v.
911                                                 // (the result would be -1 to +1, but we already
912                                                 // eliminated the <= 0 case, so it is 0 to 1)
913
914                                                 // the hardness variables are for backlighting/shinyness
915                                                 // these have been hardwired at * 0.5 + 0.5 to match
916                                                 // the quake map lighting utility's equations
917                                                 f *= dot * t;// * 0.5f + 0.5f;// * hardness + hardnessoffset;
918                                                 VectorMA(color, f, nl->light, color);
919                                         }
920                                 }
921                         }
922
923                         VectorCopy(color, avc);
924                         avc[3] = a;
925                         avc += 4;
926                         av += 4;
927                         avn += 3;
928                 }
929         }
930         else
931         {
932                 for (i = 0;i < numverts;i++)
933                 {
934                         VectorCopy(basecolor, avc);
935                         avc[3] = a;
936                         avc += 4;
937                 }
938         }
939 }
940