8ad9f9ff8054f4d36d296d0e4209123b94227ab6
[xonotic/darkplaces.git] / gl_rsurf.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_surf.c: surface-related refresh code
21
22 #include "quakedef.h"
23 #include "r_shadow.h"
24
25 #define MAX_LIGHTMAP_SIZE 256
26
27 static unsigned int intblocklights[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*3]; // LordHavoc: *3 for colored lighting
28 static float floatblocklights[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*3]; // LordHavoc: *3 for colored lighting
29
30 static qbyte templight[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*4];
31
32 cvar_t r_ambient = {0, "r_ambient", "0"};
33 cvar_t r_drawportals = {0, "r_drawportals", "0"};
34 cvar_t r_testvis = {0, "r_testvis", "0"};
35 cvar_t r_floatbuildlightmap = {0, "r_floatbuildlightmap", "0"};
36 cvar_t r_detailtextures = {CVAR_SAVE, "r_detailtextures", "1"};
37 cvar_t r_surfaceworldnode = {0, "r_surfaceworldnode", "1"};
38 cvar_t r_drawcollisionbrushes_polygonfactor = {0, "r_drawcollisionbrushes_polygonfactor", "-1"};
39 cvar_t r_drawcollisionbrushes_polygonoffset = {0, "r_drawcollisionbrushes_polygonoffset", "0"};
40 cvar_t r_q3bsp_renderskydepth = {0, "r_q3bsp_renderskydepth", "0"};
41 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0"};
42
43 /*
44 // FIXME: these arrays are huge!
45 int r_q1bsp_maxmarkleafs;
46 int r_q1bsp_nummarkleafs;
47 mleaf_t *r_q1bsp_maxleaflist[65536];
48 int r_q1bsp_maxmarksurfaces;
49 int r_q1bsp_nummarksurfaces;
50 msurface_t *r_q1bsp_maxsurfacelist[65536];
51
52 // FIXME: these arrays are huge!
53 int r_q3bsp_maxmarkleafs;
54 int r_q3bsp_nummarkleafs;
55 q3mleaf_t *r_q3bsp_maxleaflist[65536];
56 int r_q3bsp_maxmarksurfaces;
57 int r_q3bsp_nummarksurfaces;
58 q3msurface_t *r_q3bsp_maxsurfacelist[65536];
59 */
60
61 static int dlightdivtable[32768];
62
63 static int R_IntAddDynamicLights (const matrix4x4_t *matrix, msurface_t *surf)
64 {
65         int sdtable[256], lnum, td, maxdist, maxdist2, maxdist3, i, s, t, smax, tmax, smax3, red, green, blue, lit, dist2, impacts, impactt, subtract, k;
66         unsigned int *bl;
67         float dist, impact[3], local[3];
68         dlight_t *light;
69
70         lit = false;
71
72         smax = (surf->extents[0] >> 4) + 1;
73         tmax = (surf->extents[1] >> 4) + 1;
74         smax3 = smax * 3;
75
76         for (lnum = 0, light = r_dlight;lnum < r_numdlights;lnum++, light++)
77         {
78                 if (!(surf->dlightbits[lnum >> 5] & (1 << (lnum & 31))))
79                         continue;                                       // not lit by this light
80
81                 Matrix4x4_Transform(matrix, light->origin, local);
82                 dist = DotProduct (local, surf->plane->normal) - surf->plane->dist;
83
84                 // for comparisons to minimum acceptable light
85                 // compensate for LIGHTOFFSET
86                 maxdist = (int) light->rtlight.lightmap_cullradius2 + LIGHTOFFSET;
87
88                 dist2 = dist * dist;
89                 dist2 += LIGHTOFFSET;
90                 if (dist2 >= maxdist)
91                         continue;
92
93                 if (surf->plane->type < 3)
94                 {
95                         VectorCopy(local, impact);
96                         impact[surf->plane->type] -= dist;
97                 }
98                 else
99                 {
100                         impact[0] = local[0] - surf->plane->normal[0] * dist;
101                         impact[1] = local[1] - surf->plane->normal[1] * dist;
102                         impact[2] = local[2] - surf->plane->normal[2] * dist;
103                 }
104
105                 impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
106                 impactt = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
107
108                 s = bound(0, impacts, smax * 16) - impacts;
109                 t = bound(0, impactt, tmax * 16) - impactt;
110                 i = s * s + t * t + dist2;
111                 if (i > maxdist)
112                         continue;
113
114                 // reduce calculations
115                 for (s = 0, i = impacts; s < smax; s++, i -= 16)
116                         sdtable[s] = i * i + dist2;
117
118                 maxdist3 = maxdist - dist2;
119
120                 // convert to 8.8 blocklights format
121                 red = light->rtlight.lightmap_light[0] * (1.0f / 128.0f);
122                 green = light->rtlight.lightmap_light[1] * (1.0f / 128.0f);
123                 blue = light->rtlight.lightmap_light[2] * (1.0f / 128.0f);
124                 subtract = (int) (light->rtlight.lightmap_subtract * 4194304.0f);
125                 bl = intblocklights;
126
127                 i = impactt;
128                 for (t = 0;t < tmax;t++, i -= 16)
129                 {
130                         td = i * i;
131                         // make sure some part of it is visible on this line
132                         if (td < maxdist3)
133                         {
134                                 maxdist2 = maxdist - td;
135                                 for (s = 0;s < smax;s++)
136                                 {
137                                         if (sdtable[s] < maxdist2)
138                                         {
139                                                 k = dlightdivtable[(sdtable[s] + td) >> 7] - subtract;
140                                                 if (k > 0)
141                                                 {
142                                                         bl[0] += (red   * k);
143                                                         bl[1] += (green * k);
144                                                         bl[2] += (blue  * k);
145                                                         lit = true;
146                                                 }
147                                         }
148                                         bl += 3;
149                                 }
150                         }
151                         else // skip line
152                                 bl += smax3;
153                 }
154         }
155         return lit;
156 }
157
158 static int R_FloatAddDynamicLights (const matrix4x4_t *matrix, msurface_t *surf)
159 {
160         int lnum, s, t, smax, tmax, smax3, lit, impacts, impactt;
161         float sdtable[256], *bl, k, dist, dist2, maxdist, maxdist2, maxdist3, td1, td, red, green, blue, impact[3], local[3], subtract;
162         dlight_t *light;
163
164         lit = false;
165
166         smax = (surf->extents[0] >> 4) + 1;
167         tmax = (surf->extents[1] >> 4) + 1;
168         smax3 = smax * 3;
169
170         for (lnum = 0, light = r_dlight;lnum < r_numdlights;lnum++, light++)
171         {
172                 if (!(surf->dlightbits[lnum >> 5] & (1 << (lnum & 31))))
173                         continue;                                       // not lit by this light
174
175                 Matrix4x4_Transform(matrix, light->origin, local);
176                 dist = DotProduct (local, surf->plane->normal) - surf->plane->dist;
177
178                 // for comparisons to minimum acceptable light
179                 // compensate for LIGHTOFFSET
180                 maxdist = (int) light->rtlight.lightmap_cullradius2 + LIGHTOFFSET;
181
182                 dist2 = dist * dist;
183                 dist2 += LIGHTOFFSET;
184                 if (dist2 >= maxdist)
185                         continue;
186
187                 if (surf->plane->type < 3)
188                 {
189                         VectorCopy(local, impact);
190                         impact[surf->plane->type] -= dist;
191                 }
192                 else
193                 {
194                         impact[0] = local[0] - surf->plane->normal[0] * dist;
195                         impact[1] = local[1] - surf->plane->normal[1] * dist;
196                         impact[2] = local[2] - surf->plane->normal[2] * dist;
197                 }
198
199                 impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
200                 impactt = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
201
202                 td = bound(0, impacts, smax * 16) - impacts;
203                 td1 = bound(0, impactt, tmax * 16) - impactt;
204                 td = td * td + td1 * td1 + dist2;
205                 if (td > maxdist)
206                         continue;
207
208                 // reduce calculations
209                 for (s = 0, td1 = impacts; s < smax; s++, td1 -= 16.0f)
210                         sdtable[s] = td1 * td1 + dist2;
211
212                 maxdist3 = maxdist - dist2;
213
214                 // convert to 8.8 blocklights format
215                 red = light->rtlight.lightmap_light[0];
216                 green = light->rtlight.lightmap_light[1];
217                 blue = light->rtlight.lightmap_light[2];
218                 subtract = light->rtlight.lightmap_subtract * 32768.0f;
219                 bl = floatblocklights;
220
221                 td1 = impactt;
222                 for (t = 0;t < tmax;t++, td1 -= 16.0f)
223                 {
224                         td = td1 * td1;
225                         // make sure some part of it is visible on this line
226                         if (td < maxdist3)
227                         {
228                                 maxdist2 = maxdist - td;
229                                 for (s = 0;s < smax;s++)
230                                 {
231                                         if (sdtable[s] < maxdist2)
232                                         {
233                                                 k = (32768.0f / (sdtable[s] + td)) - subtract;
234                                                 bl[0] += red   * k;
235                                                 bl[1] += green * k;
236                                                 bl[2] += blue  * k;
237                                                 lit = true;
238                                         }
239                                         bl += 3;
240                                 }
241                         }
242                         else // skip line
243                                 bl += smax3;
244                 }
245         }
246         return lit;
247 }
248
249 /*
250 ===============
251 R_BuildLightMap
252
253 Combine and scale multiple lightmaps into the 8.8 format in blocklights
254 ===============
255 */
256 static void R_BuildLightMap (const entity_render_t *ent, msurface_t *surf)
257 {
258         if (!r_floatbuildlightmap.integer)
259         {
260                 int smax, tmax, i, j, size, size3, maps, stride, l;
261                 unsigned int *bl, scale;
262                 qbyte *lightmap, *out, *stain;
263
264                 // update cached lighting info
265                 surf->cached_dlight = 0;
266
267                 smax = (surf->extents[0]>>4)+1;
268                 tmax = (surf->extents[1]>>4)+1;
269                 size = smax*tmax;
270                 size3 = size*3;
271                 lightmap = surf->samples;
272
273         // set to full bright if no light data
274                 bl = intblocklights;
275                 if (!ent->model->brushq1.lightdata)
276                 {
277                         for (i = 0;i < size3;i++)
278                                 bl[i] = 255*256;
279                 }
280                 else
281                 {
282         // clear to no light
283                         memset(bl, 0, size*3*sizeof(unsigned int));
284
285                         if (surf->dlightframe == r_framecount)
286                         {
287                                 surf->cached_dlight = R_IntAddDynamicLights(&ent->inversematrix, surf);
288                                 if (surf->cached_dlight)
289                                         c_light_polys++;
290                         }
291
292         // add all the lightmaps
293                         if (lightmap)
294                         {
295                                 bl = intblocklights;
296                                 for (maps = 0;maps < MAXLIGHTMAPS && surf->styles[maps] != 255;maps++, lightmap += size3)
297                                         for (scale = d_lightstylevalue[surf->styles[maps]], i = 0;i < size3;i++)
298                                                 bl[i] += lightmap[i] * scale;
299                         }
300                 }
301
302                 stain = surf->stainsamples;
303                 bl = intblocklights;
304                 out = templight;
305                 // the >> 16 shift adjusts down 8 bits to account for the stainmap
306                 // scaling, and remaps the 0-65536 (2x overbright) to 0-256, it will
307                 // be doubled during rendering to achieve 2x overbright
308                 // (0 = 0.0, 128 = 1.0, 256 = 2.0)
309                 if (ent->model->brushq1.lightmaprgba)
310                 {
311                         stride = (surf->lightmaptexturestride - smax) * 4;
312                         for (i = 0;i < tmax;i++, out += stride)
313                         {
314                                 for (j = 0;j < smax;j++)
315                                 {
316                                         l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
317                                         l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
318                                         l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
319                                         *out++ = 255;
320                                 }
321                         }
322                 }
323                 else
324                 {
325                         stride = (surf->lightmaptexturestride - smax) * 3;
326                         for (i = 0;i < tmax;i++, out += stride)
327                         {
328                                 for (j = 0;j < smax;j++)
329                                 {
330                                         l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
331                                         l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
332                                         l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
333                                 }
334                         }
335                 }
336
337                 R_UpdateTexture(surf->lightmaptexture, templight);
338         }
339         else
340         {
341                 int smax, tmax, i, j, size, size3, maps, stride, l;
342                 float *bl, scale;
343                 qbyte *lightmap, *out, *stain;
344
345                 // update cached lighting info
346                 surf->cached_dlight = 0;
347
348                 smax = (surf->extents[0]>>4)+1;
349                 tmax = (surf->extents[1]>>4)+1;
350                 size = smax*tmax;
351                 size3 = size*3;
352                 lightmap = surf->samples;
353
354         // set to full bright if no light data
355                 bl = floatblocklights;
356                 if (!ent->model->brushq1.lightdata)
357                 {
358                         for (i = 0;i < size3;i++)
359                                 bl[i] = 255*256;
360                 }
361                 else
362                 {
363                         memset(bl, 0, size*3*sizeof(float));
364         
365                         if (surf->dlightframe == r_framecount)
366                         {
367                                 surf->cached_dlight = R_FloatAddDynamicLights(&ent->inversematrix, surf);
368                                 if (surf->cached_dlight)
369                                         c_light_polys++;
370                         }
371         
372                         // add all the lightmaps
373                         if (lightmap)
374                         {
375                                 bl = floatblocklights;
376                                 for (maps = 0;maps < MAXLIGHTMAPS && surf->styles[maps] != 255;maps++, lightmap += size3)
377                                         for (scale = d_lightstylevalue[surf->styles[maps]], i = 0;i < size3;i++)
378                                                 bl[i] += lightmap[i] * scale;
379                         }
380                 }
381
382                 stain = surf->stainsamples;
383                 bl = floatblocklights;
384                 out = templight;
385                 // this scaling adjusts down 8 bits to account for the stainmap
386                 // scaling, and remaps the 0.0-2.0 (2x overbright) to 0-256, it will
387                 // be doubled during rendering to achieve 2x overbright
388                 // (0 = 0.0, 128 = 1.0, 256 = 2.0)
389                 scale = 1.0f / (1 << 16);
390                 if (ent->model->brushq1.lightmaprgba)
391                 {
392                         stride = (surf->lightmaptexturestride - smax) * 4;
393                         for (i = 0;i < tmax;i++, out += stride)
394                         {
395                                 for (j = 0;j < smax;j++)
396                                 {
397                                         l = *bl++ * *stain++ * scale;*out++ = min(l, 255);
398                                         l = *bl++ * *stain++ * scale;*out++ = min(l, 255);
399                                         l = *bl++ * *stain++ * scale;*out++ = min(l, 255);
400                                         *out++ = 255;
401                                 }
402                         }
403                 }
404                 else
405                 {
406                         stride = (surf->lightmaptexturestride - smax) * 3;
407                         for (i = 0;i < tmax;i++, out += stride)
408                         {
409                                 for (j = 0;j < smax;j++)
410                                 {
411                                         l = *bl++ * *stain++ * scale;*out++ = min(l, 255);
412                                         l = *bl++ * *stain++ * scale;*out++ = min(l, 255);
413                                         l = *bl++ * *stain++ * scale;*out++ = min(l, 255);
414                                 }
415                         }
416                 }
417
418                 R_UpdateTexture(surf->lightmaptexture, templight);
419         }
420 }
421
422 void R_StainNode (mnode_t *node, model_t *model, const vec3_t origin, float radius, const float fcolor[8])
423 {
424         float ndist, a, ratio, maxdist, maxdist2, maxdist3, invradius, sdtable[256], td, dist2;
425         msurface_t *surf, *endsurf;
426         int i, s, t, smax, tmax, smax3, impacts, impactt, stained;
427         qbyte *bl;
428         vec3_t impact;
429
430         maxdist = radius * radius;
431         invradius = 1.0f / radius;
432
433 loc0:
434         if (node->contents < 0)
435                 return;
436         ndist = PlaneDiff(origin, node->plane);
437         if (ndist > radius)
438         {
439                 node = node->children[0];
440                 goto loc0;
441         }
442         if (ndist < -radius)
443         {
444                 node = node->children[1];
445                 goto loc0;
446         }
447
448         dist2 = ndist * ndist;
449         maxdist3 = maxdist - dist2;
450
451         if (node->plane->type < 3)
452         {
453                 VectorCopy(origin, impact);
454                 impact[node->plane->type] -= ndist;
455         }
456         else
457         {
458                 impact[0] = origin[0] - node->plane->normal[0] * ndist;
459                 impact[1] = origin[1] - node->plane->normal[1] * ndist;
460                 impact[2] = origin[2] - node->plane->normal[2] * ndist;
461         }
462
463         for (surf = model->brushq1.surfaces + node->firstsurface, endsurf = surf + node->numsurfaces;surf < endsurf;surf++)
464         {
465                 if (surf->stainsamples)
466                 {
467                         smax = (surf->extents[0] >> 4) + 1;
468                         tmax = (surf->extents[1] >> 4) + 1;
469
470                         impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
471                         impactt = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
472
473                         s = bound(0, impacts, smax * 16) - impacts;
474                         t = bound(0, impactt, tmax * 16) - impactt;
475                         i = s * s + t * t + dist2;
476                         if (i > maxdist)
477                                 continue;
478
479                         // reduce calculations
480                         for (s = 0, i = impacts; s < smax; s++, i -= 16)
481                                 sdtable[s] = i * i + dist2;
482
483                         bl = surf->stainsamples;
484                         smax3 = smax * 3;
485                         stained = false;
486
487                         i = impactt;
488                         for (t = 0;t < tmax;t++, i -= 16)
489                         {
490                                 td = i * i;
491                                 // make sure some part of it is visible on this line
492                                 if (td < maxdist3)
493                                 {
494                                         maxdist2 = maxdist - td;
495                                         for (s = 0;s < smax;s++)
496                                         {
497                                                 if (sdtable[s] < maxdist2)
498                                                 {
499                                                         ratio = lhrandom(0.0f, 1.0f);
500                                                         a = (fcolor[3] + ratio * fcolor[7]) * (1.0f - sqrt(sdtable[s] + td) * invradius);
501                                                         if (a >= (1.0f / 64.0f))
502                                                         {
503                                                                 if (a > 1)
504                                                                         a = 1;
505                                                                 bl[0] = (qbyte) ((float) bl[0] + a * ((fcolor[0] + ratio * fcolor[4]) - (float) bl[0]));
506                                                                 bl[1] = (qbyte) ((float) bl[1] + a * ((fcolor[1] + ratio * fcolor[5]) - (float) bl[1]));
507                                                                 bl[2] = (qbyte) ((float) bl[2] + a * ((fcolor[2] + ratio * fcolor[6]) - (float) bl[2]));
508                                                                 stained = true;
509                                                         }
510                                                 }
511                                                 bl += 3;
512                                         }
513                                 }
514                                 else // skip line
515                                         bl += smax3;
516                         }
517                         // force lightmap upload
518                         if (stained)
519                                 surf->cached_dlight = true;
520                 }
521         }
522
523         if (node->children[0]->contents >= 0)
524         {
525                 if (node->children[1]->contents >= 0)
526                 {
527                         R_StainNode(node->children[0], model, origin, radius, fcolor);
528                         node = node->children[1];
529                         goto loc0;
530                 }
531                 else
532                 {
533                         node = node->children[0];
534                         goto loc0;
535                 }
536         }
537         else if (node->children[1]->contents >= 0)
538         {
539                 node = node->children[1];
540                 goto loc0;
541         }
542 }
543
544 void R_Stain (const vec3_t origin, float radius, int cr1, int cg1, int cb1, int ca1, int cr2, int cg2, int cb2, int ca2)
545 {
546         int n;
547         float fcolor[8];
548         entity_render_t *ent;
549         model_t *model;
550         vec3_t org;
551         if (cl.worldmodel == NULL || !cl.worldmodel->brushq1.nodes)
552                 return;
553         fcolor[0] = cr1;
554         fcolor[1] = cg1;
555         fcolor[2] = cb1;
556         fcolor[3] = ca1 * (1.0f / 64.0f);
557         fcolor[4] = cr2 - cr1;
558         fcolor[5] = cg2 - cg1;
559         fcolor[6] = cb2 - cb1;
560         fcolor[7] = (ca2 - ca1) * (1.0f / 64.0f);
561
562         R_StainNode(cl.worldmodel->brushq1.nodes + cl.worldmodel->brushq1.hulls[0].firstclipnode, cl.worldmodel, origin, radius, fcolor);
563
564         // look for embedded bmodels
565         for (n = 0;n < cl_num_brushmodel_entities;n++)
566         {
567                 ent = cl_brushmodel_entities[n];
568                 model = ent->model;
569                 if (model && model->name[0] == '*')
570                 {
571                         Mod_CheckLoaded(model);
572                         if (model->brushq1.nodes)
573                         {
574                                 Matrix4x4_Transform(&ent->inversematrix, origin, org);
575                                 R_StainNode(model->brushq1.nodes + model->brushq1.hulls[0].firstclipnode, model, org, radius, fcolor);
576                         }
577                 }
578         }
579 }
580
581
582 /*
583 =============================================================
584
585         BRUSH MODELS
586
587 =============================================================
588 */
589
590 static void RSurf_AddLightmapToVertexColors_Color4f(const int *lightmapoffsets, float *c, int numverts, const qbyte *samples, int size3, const qbyte *styles)
591 {
592         int i;
593         float scale;
594         const qbyte *lm;
595         if (styles[0] != 255)
596         {
597                 for (i = 0;i < numverts;i++, c += 4)
598                 {
599                         lm = samples + lightmapoffsets[i];
600                         scale = d_lightstylevalue[styles[0]] * (1.0f / 32768.0f);
601                         VectorMA(c, scale, lm, c);
602                         if (styles[1] != 255)
603                         {
604                                 lm += size3;
605                                 scale = d_lightstylevalue[styles[1]] * (1.0f / 32768.0f);
606                                 VectorMA(c, scale, lm, c);
607                                 if (styles[2] != 255)
608                                 {
609                                         lm += size3;
610                                         scale = d_lightstylevalue[styles[2]] * (1.0f / 32768.0f);
611                                         VectorMA(c, scale, lm, c);
612                                         if (styles[3] != 255)
613                                         {
614                                                 lm += size3;
615                                                 scale = d_lightstylevalue[styles[3]] * (1.0f / 32768.0f);
616                                                 VectorMA(c, scale, lm, c);
617                                         }
618                                 }
619                         }
620                 }
621         }
622 }
623
624 static void RSurf_FogColors_Vertex3f_Color4f(const float *v, float *c, float colorscale, int numverts, const float *modelorg)
625 {
626         int i;
627         float diff[3], f;
628         if (fogenabled)
629         {
630                 for (i = 0;i < numverts;i++, v += 3, c += 4)
631                 {
632                         VectorSubtract(v, modelorg, diff);
633                         f = colorscale * (1 - exp(fogdensity/DotProduct(diff, diff)));
634                         VectorScale(c, f, c);
635                 }
636         }
637         else if (colorscale != 1)
638                 for (i = 0;i < numverts;i++, c += 4)
639                         VectorScale(c, colorscale, c);
640 }
641
642 static void RSurf_FoggedColors_Vertex3f_Color4f(const float *v, float *c, float r, float g, float b, float a, float colorscale, int numverts, const float *modelorg)
643 {
644         int i;
645         float diff[3], f;
646         r *= colorscale;
647         g *= colorscale;
648         b *= colorscale;
649         if (fogenabled)
650         {
651                 for (i = 0;i < numverts;i++, v += 3, c += 4)
652                 {
653                         VectorSubtract(v, modelorg, diff);
654                         f = 1 - exp(fogdensity/DotProduct(diff, diff));
655                         c[0] = r * f;
656                         c[1] = g * f;
657                         c[2] = b * f;
658                         c[3] = a;
659                 }
660         }
661         else
662         {
663                 for (i = 0;i < numverts;i++, c += 4)
664                 {
665                         c[0] = r;
666                         c[1] = g;
667                         c[2] = b;
668                         c[3] = a;
669                 }
670         }
671 }
672
673 static void RSurf_FogPassColors_Vertex3f_Color4f(const float *v, float *c, float r, float g, float b, float a, float colorscale, int numverts, const float *modelorg)
674 {
675         int i;
676         float diff[3], f;
677         r *= colorscale;
678         g *= colorscale;
679         b *= colorscale;
680         for (i = 0;i < numverts;i++, v += 3, c += 4)
681         {
682                 VectorSubtract(v, modelorg, diff);
683                 f = exp(fogdensity/DotProduct(diff, diff));
684                 c[0] = r;
685                 c[1] = g;
686                 c[2] = b;
687                 c[3] = a * f;
688         }
689 }
690
691 static int RSurf_LightSeparate_Vertex3f_Color4f(const matrix4x4_t *matrix, const int *dlightbits, int numverts, const float *vert, float *color, float scale)
692 {
693         float f;
694         const float *v;
695         float *c;
696         int i, l, lit = false;
697         const dlight_t *light;
698         vec3_t lightorigin;
699         for (l = 0;l < r_numdlights;l++)
700         {
701                 if (dlightbits[l >> 5] & (1 << (l & 31)))
702                 {
703                         light = &r_dlight[l];
704                         Matrix4x4_Transform(matrix, light->origin, lightorigin);
705                         for (i = 0, v = vert, c = color;i < numverts;i++, v += 3, c += 4)
706                         {
707                                 f = VectorDistance2(v, lightorigin) + LIGHTOFFSET;
708                                 if (f < light->rtlight.lightmap_cullradius2)
709                                 {
710                                         f = ((1.0f / f) - light->rtlight.lightmap_subtract) * scale;
711                                         VectorMA(c, f, light->rtlight.lightmap_light, c);
712                                         lit = true;
713                                 }
714                         }
715                 }
716         }
717         return lit;
718 }
719
720 static void RSurfShader_Sky(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
721 {
722         const msurface_t *surf;
723         rmeshstate_t m;
724
725         // LordHavoc: HalfLife maps have freaky skypolys...
726         if (ent->model->brush.ishlbsp)
727                 return;
728
729         if (skyrendernow)
730         {
731                 skyrendernow = false;
732                 if (skyrendermasked)
733                         R_Sky();
734         }
735
736         R_Mesh_Matrix(&ent->matrix);
737
738         GL_Color(fogcolor[0], fogcolor[1], fogcolor[2], 1);
739         if (skyrendermasked)
740         {
741                 // depth-only (masking)
742                 GL_ColorMask(0,0,0,0);
743                 // just to make sure that braindead drivers don't draw anything
744                 // despite that colormask...
745                 GL_BlendFunc(GL_ZERO, GL_ONE);
746         }
747         else
748         {
749                 // fog sky
750                 GL_BlendFunc(GL_ONE, GL_ZERO);
751         }
752         GL_DepthMask(true);
753         GL_DepthTest(true);
754
755         memset(&m, 0, sizeof(m));
756         while((surf = *surfchain++) != NULL)
757         {
758                 if (surf->visframe == r_framecount)
759                 {
760                         m.pointer_vertex = surf->mesh.data_vertex3f;
761                         R_Mesh_State(&m);
762                         GL_LockArrays(0, surf->mesh.num_vertices);
763                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
764                         GL_LockArrays(0, 0);
765                 }
766         }
767         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
768 }
769
770 static void RSurfShader_Transparent_Callback(const void *calldata1, int calldata2)
771 {
772         const entity_render_t *ent = calldata1;
773         const msurface_t *surf = ent->model->brushq1.surfaces + calldata2;
774         rmeshstate_t m;
775         float currentalpha;
776         float base, colorscale;
777         vec3_t modelorg;
778         texture_t *texture;
779         float args[4] = {0.05f,0,0,0.04f};
780         int rendertype, turb, fullbright;
781
782         R_Mesh_Matrix(&ent->matrix);
783         Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
784
785         texture = surf->texinfo->texture;
786         if (texture->animated)
787                 texture = texture->anim_frames[ent->frame != 0][(texture->anim_total[ent->frame != 0] >= 2) ? ((int) (cl.time * 5.0f) % texture->anim_total[ent->frame != 0]) : 0];
788         currentalpha = ent->alpha;
789         if (surf->flags & SURF_WATERALPHA)
790                 currentalpha *= r_wateralpha.value;
791
792         GL_DepthTest(true);
793         if (ent->effects & EF_ADDITIVE)
794         {
795                 rendertype = SURFRENDER_ADD;
796                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
797                 GL_DepthMask(false);
798         }
799         else if (currentalpha < 1 || texture->skin.fog != NULL)
800         {
801                 rendertype = SURFRENDER_ALPHA;
802                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
803                 GL_DepthMask(false);
804         }
805         else
806         {
807                 rendertype = SURFRENDER_OPAQUE;
808                 GL_BlendFunc(GL_ONE, GL_ZERO);
809                 GL_DepthMask(true);
810         }
811
812         turb = (surf->flags & SURF_DRAWTURB) && r_waterscroll.value;
813         fullbright = (ent->effects & EF_FULLBRIGHT) || (surf->flags & SURF_DRAWFULLBRIGHT) || !surf->samples;
814         base = fullbright ? 2.0f : r_ambient.value * (1.0f / 64.0f);
815         if (surf->flags & SURF_DRAWTURB)
816                 base *= 0.5f;
817         if ((surf->flags & SURF_DRAWTURB) && gl_textureshader && r_watershader.value && !fogenabled)
818         {
819                 // NVIDIA Geforce3 distortion texture shader on water
820                 GL_Color(1, 1, 1, currentalpha);
821                 memset(&m, 0, sizeof(m));
822                 m.pointer_vertex = surf->mesh.data_vertex3f;
823                 m.tex[0] = R_GetTexture(mod_shared_distorttexture[(int)(cl.time * 16)&63]);
824                 m.tex[1] = R_GetTexture(texture->skin.base);
825                 m.texcombinergb[0] = GL_REPLACE;
826                 m.texcombinergb[1] = GL_REPLACE;
827                 m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
828                 m.pointer_texcoord[1] = surf->mesh.data_texcoordtexture2f;
829                 Matrix4x4_CreateFromQuakeEntity(&m.texmatrix[0], 0, 0, 0, 0, 0, 0, r_watershader.value);
830                 Matrix4x4_CreateTranslate(&m.texmatrix[1], sin(cl.time) * 0.025 * r_waterscroll.value, sin(cl.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
831                 R_Mesh_State(&m);
832
833                 GL_ActiveTexture(0);
834                 qglTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
835                 GL_ActiveTexture(1);
836                 qglTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_OFFSET_TEXTURE_2D_NV);
837                 qglTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB);
838                 qglTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, &args[0]);
839                 qglEnable(GL_TEXTURE_SHADER_NV);
840
841                 GL_LockArrays(0, surf->mesh.num_vertices);
842                 R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
843                 GL_LockArrays(0, 0);
844
845                 qglDisable(GL_TEXTURE_SHADER_NV);
846                 qglTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
847                 GL_ActiveTexture(0);
848         }
849         else
850         {
851                 memset(&m, 0, sizeof(m));
852                 m.pointer_vertex = surf->mesh.data_vertex3f;
853                 m.pointer_color = varray_color4f;
854                 m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
855                 m.tex[0] = R_GetTexture(texture->skin.base);
856                 if (turb)
857                 {
858                         // scrolling in texture matrix
859                         Matrix4x4_CreateTranslate(&m.texmatrix[0], sin(cl.time) * 0.025 * r_waterscroll.value, sin(cl.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
860                 }
861                 colorscale = 1;
862                 if (gl_combine.integer)
863                 {
864                         m.texrgbscale[0] = 4;
865                         colorscale *= 0.25f;
866                 }
867                 R_FillColors(varray_color4f, surf->mesh.num_vertices, base, base, base, currentalpha);
868                 if (!fullbright)
869                 {
870                         if (surf->dlightframe == r_framecount)
871                                 RSurf_LightSeparate_Vertex3f_Color4f(&ent->inversematrix, surf->dlightbits, surf->mesh.num_vertices, surf->mesh.data_vertex3f, varray_color4f, 1);
872                         if (surf->samples)
873                                 RSurf_AddLightmapToVertexColors_Color4f(surf->mesh.data_lightmapoffsets, varray_color4f,surf->mesh.num_vertices, surf->samples, ((surf->extents[0]>>4)+1)*((surf->extents[1]>>4)+1)*3, surf->styles);
874                 }
875                 RSurf_FogColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, colorscale, surf->mesh.num_vertices, modelorg);
876                 R_Mesh_State(&m);
877                 GL_LockArrays(0, surf->mesh.num_vertices);
878                 R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
879                 GL_LockArrays(0, 0);
880                 if (texture->skin.glow)
881                 {
882                         memset(&m, 0, sizeof(m));
883                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
884                         GL_DepthMask(false);
885                         m.pointer_color = varray_color4f;
886                         m.tex[0] = R_GetTexture(texture->skin.glow);
887                         m.pointer_vertex = surf->mesh.data_vertex3f;
888                         if (m.tex[0])
889                         {
890                                 m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
891                                 if (turb)
892                                 {
893                                         // scrolling in texture matrix
894                                         Matrix4x4_CreateTranslate(&m.texmatrix[0], sin(cl.time) * 0.025 * r_waterscroll.value, sin(cl.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
895                                 }
896                         }
897                         R_Mesh_State(&m);
898                         RSurf_FoggedColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, 1, 1, 1, currentalpha, 1, surf->mesh.num_vertices, modelorg);
899                         GL_LockArrays(0, surf->mesh.num_vertices);
900                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
901                         GL_LockArrays(0, 0);
902                 }
903                 if (fogenabled && rendertype != SURFRENDER_ADD)
904                 {
905                         memset(&m, 0, sizeof(m));
906                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
907                         GL_DepthMask(false);
908                         m.pointer_color = varray_color4f;
909                         m.tex[0] = R_GetTexture(texture->skin.fog);
910                         m.pointer_vertex = surf->mesh.data_vertex3f;
911                         if (m.tex[0])
912                         {
913                                 m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
914                                 if (turb)
915                                 {
916                                         // scrolling in texture matrix
917                                         Matrix4x4_CreateTranslate(&m.texmatrix[0], sin(cl.time) * 0.025 * r_waterscroll.value, sin(cl.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
918                                 }
919                         }
920                         R_Mesh_State(&m);
921                         RSurf_FogPassColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], currentalpha, 1, surf->mesh.num_vertices, modelorg);
922                         GL_LockArrays(0, surf->mesh.num_vertices);
923                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
924                         GL_LockArrays(0, 0);
925                 }
926         }
927 }
928
929 static void RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmapDetailGlow(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
930 {
931         const msurface_t *surf;
932         rmeshstate_t m;
933         int lightmaptexturenum;
934         memset(&m, 0, sizeof(m));
935         GL_BlendFunc(GL_ONE, GL_ZERO);
936         GL_DepthMask(true);
937         GL_DepthTest(true);
938         m.tex[0] = R_GetTexture(texture->skin.base);
939         m.tex[1] = R_GetTexture((**surfchain).lightmaptexture);
940         m.texrgbscale[1] = 2;
941         m.tex[2] = R_GetTexture(texture->skin.detail);
942         m.texrgbscale[2] = 2;
943         if (texture->skin.glow)
944         {
945                 m.tex[3] = R_GetTexture(texture->skin.glow);
946                 m.texcombinergb[3] = GL_ADD;
947         }
948         if (r_shadow_realtime_world.integer)
949                 GL_Color(r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, 1);
950         else
951                 GL_Color(1, 1, 1, 1);
952
953         while((surf = *surfchain++) != NULL)
954         {
955                 if (surf->visframe == r_framecount)
956                 {
957                         lightmaptexturenum = R_GetTexture(surf->lightmaptexture);
958                         m.tex[1] = lightmaptexturenum;
959                         m.pointer_vertex = surf->mesh.data_vertex3f;
960                         m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
961                         m.pointer_texcoord[1] = surf->mesh.data_texcoordlightmap2f;
962                         m.pointer_texcoord[2] = surf->mesh.data_texcoorddetail2f;
963                         m.pointer_texcoord[3] = surf->mesh.data_texcoordtexture2f;
964                         R_Mesh_State(&m);
965                         GL_LockArrays(0, surf->mesh.num_vertices);
966                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
967                         GL_LockArrays(0, 0);
968                 }
969         }
970 }
971
972 static void RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmapDetail(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
973 {
974         const msurface_t *surf;
975         rmeshstate_t m;
976         int lightmaptexturenum;
977         memset(&m, 0, sizeof(m));
978         GL_BlendFunc(GL_ONE, GL_ZERO);
979         GL_DepthMask(true);
980         GL_DepthTest(true);
981         m.tex[0] = R_GetTexture(texture->skin.base);
982         m.tex[1] = R_GetTexture((**surfchain).lightmaptexture);
983         m.texrgbscale[1] = 2;
984         m.tex[2] = R_GetTexture(texture->skin.detail);
985         m.texrgbscale[2] = 2;
986         if (r_shadow_realtime_world.integer)
987                 GL_Color(r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, 1);
988         else
989                 GL_Color(1, 1, 1, 1);
990
991         while((surf = *surfchain++) != NULL)
992         {
993                 if (surf->visframe == r_framecount)
994                 {
995                         lightmaptexturenum = R_GetTexture(surf->lightmaptexture);
996                         m.tex[1] = lightmaptexturenum;
997                         m.pointer_vertex = surf->mesh.data_vertex3f;
998                         m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
999                         m.pointer_texcoord[1] = surf->mesh.data_texcoordlightmap2f;
1000                         m.pointer_texcoord[2] = surf->mesh.data_texcoorddetail2f;
1001                         R_Mesh_State(&m);
1002                         GL_LockArrays(0, surf->mesh.num_vertices);
1003                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
1004                         GL_LockArrays(0, 0);
1005                 }
1006         }
1007 }
1008
1009 static void RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmap(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
1010 {
1011         const msurface_t *surf;
1012         rmeshstate_t m;
1013         int lightmaptexturenum;
1014         memset(&m, 0, sizeof(m));
1015         GL_BlendFunc(GL_ONE, GL_ZERO);
1016         GL_DepthMask(true);
1017         GL_DepthTest(true);
1018         m.tex[0] = R_GetTexture(texture->skin.base);
1019         m.tex[1] = R_GetTexture((**surfchain).lightmaptexture);
1020         m.texrgbscale[1] = 2;
1021         if (r_shadow_realtime_world.integer)
1022                 GL_Color(r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, 1);
1023         else
1024                 GL_Color(1, 1, 1, 1);
1025         while((surf = *surfchain++) != NULL)
1026         {
1027                 if (surf->visframe == r_framecount)
1028                 {
1029                         lightmaptexturenum = R_GetTexture(surf->lightmaptexture);
1030                         m.tex[1] = lightmaptexturenum;
1031                         m.pointer_vertex = surf->mesh.data_vertex3f;
1032                         m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
1033                         m.pointer_texcoord[1] = surf->mesh.data_texcoordlightmap2f;
1034                         R_Mesh_State(&m);
1035                         GL_LockArrays(0, surf->mesh.num_vertices);
1036                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
1037                         GL_LockArrays(0, 0);
1038                 }
1039         }
1040 }
1041
1042 static void RSurfShader_OpaqueWall_Pass_BaseTexture(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
1043 {
1044         const msurface_t *surf;
1045         rmeshstate_t m;
1046         memset(&m, 0, sizeof(m));
1047         GL_DepthMask(true);
1048         GL_DepthTest(true);
1049         GL_BlendFunc(GL_ONE, GL_ZERO);
1050         m.tex[0] = R_GetTexture(texture->skin.base);
1051         if (r_shadow_realtime_world.integer)
1052                 GL_Color(r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, 1);
1053         else
1054                 GL_Color(1, 1, 1, 1);
1055         while((surf = *surfchain++) != NULL)
1056         {
1057                 if (surf->visframe == r_framecount)
1058                 {
1059                         m.pointer_vertex = surf->mesh.data_vertex3f;
1060                         m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
1061                         R_Mesh_State(&m);
1062                         GL_LockArrays(0, surf->mesh.num_vertices);
1063                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
1064                         GL_LockArrays(0, 0);
1065                 }
1066         }
1067 }
1068
1069 static void RSurfShader_OpaqueWall_Pass_BaseLightmap(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
1070 {
1071         const msurface_t *surf;
1072         rmeshstate_t m;
1073         int lightmaptexturenum;
1074         memset(&m, 0, sizeof(m));
1075         GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
1076         GL_DepthMask(false);
1077         GL_DepthTest(true);
1078         m.tex[0] = R_GetTexture((**surfchain).lightmaptexture);
1079         GL_Color(1, 1, 1, 1);
1080         while((surf = *surfchain++) != NULL)
1081         {
1082                 if (surf->visframe == r_framecount)
1083                 {
1084                         lightmaptexturenum = R_GetTexture(surf->lightmaptexture);
1085                         m.tex[0] = lightmaptexturenum;
1086                         m.pointer_vertex = surf->mesh.data_vertex3f;
1087                         m.pointer_texcoord[0] = surf->mesh.data_texcoordlightmap2f;
1088                         R_Mesh_State(&m);
1089                         GL_LockArrays(0, surf->mesh.num_vertices);
1090                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
1091                         GL_LockArrays(0, 0);
1092                 }
1093         }
1094 }
1095
1096 static void RSurfShader_OpaqueWall_Pass_BaseAmbient(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
1097 {
1098         const msurface_t *surf;
1099         rmeshstate_t m;
1100         memset(&m, 0, sizeof(m));
1101         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1102         GL_DepthMask(false);
1103         GL_DepthTest(true);
1104         m.tex[0] = R_GetTexture(texture->skin.base);
1105         GL_Color(r_ambient.value * (1.0f / 128.0f), r_ambient.value * (1.0f / 128.0f), r_ambient.value * (1.0f / 128.0f), 1);
1106         while((surf = *surfchain++) != NULL)
1107         {
1108                 if (surf->visframe == r_framecount)
1109                 {
1110                         m.pointer_vertex = surf->mesh.data_vertex3f;
1111                         m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
1112                         R_Mesh_State(&m);
1113                         GL_LockArrays(0, surf->mesh.num_vertices);
1114                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
1115                         GL_LockArrays(0, 0);
1116                 }
1117         }
1118 }
1119
1120 static void RSurfShader_OpaqueWall_Pass_Fog(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
1121 {
1122         const msurface_t *surf;
1123         rmeshstate_t m;
1124         float modelorg[3];
1125         Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
1126         memset(&m, 0, sizeof(m));
1127         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1128         GL_DepthMask(false);
1129         GL_DepthTest(true);
1130         m.pointer_color = varray_color4f;
1131         while((surf = *surfchain++) != NULL)
1132         {
1133                 if (surf->visframe == r_framecount)
1134                 {
1135                         m.pointer_vertex = surf->mesh.data_vertex3f;
1136                         if (m.tex[0])
1137                                 m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
1138                         R_Mesh_State(&m);
1139                         RSurf_FogPassColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], 1, 1, surf->mesh.num_vertices, modelorg);
1140                         GL_LockArrays(0, surf->mesh.num_vertices);
1141                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
1142                         GL_LockArrays(0, 0);
1143                 }
1144         }
1145 }
1146
1147 static void RSurfShader_OpaqueWall_Pass_BaseDetail(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
1148 {
1149         const msurface_t *surf;
1150         rmeshstate_t m;
1151         memset(&m, 0, sizeof(m));
1152         GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
1153         GL_DepthMask(false);
1154         GL_DepthTest(true);
1155         m.tex[0] = R_GetTexture(texture->skin.detail);
1156         GL_Color(1, 1, 1, 1);
1157         while((surf = *surfchain++) != NULL)
1158         {
1159                 if (surf->visframe == r_framecount)
1160                 {
1161                         m.pointer_vertex = surf->mesh.data_vertex3f;
1162                         m.pointer_texcoord[0] = surf->mesh.data_texcoorddetail2f;
1163                         R_Mesh_State(&m);
1164                         GL_LockArrays(0, surf->mesh.num_vertices);
1165                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
1166                         GL_LockArrays(0, 0);
1167                 }
1168         }
1169 }
1170
1171 static void RSurfShader_OpaqueWall_Pass_Glow(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
1172 {
1173         const msurface_t *surf;
1174         rmeshstate_t m;
1175         memset(&m, 0, sizeof(m));
1176         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1177         GL_DepthMask(false);
1178         GL_DepthTest(true);
1179         m.tex[0] = R_GetTexture(texture->skin.glow);
1180         GL_Color(1, 1, 1, 1);
1181         while((surf = *surfchain++) != NULL)
1182         {
1183                 if (surf->visframe == r_framecount)
1184                 {
1185                         m.pointer_vertex = surf->mesh.data_vertex3f;
1186                         m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
1187                         R_Mesh_State(&m);
1188                         GL_LockArrays(0, surf->mesh.num_vertices);
1189                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
1190                         GL_LockArrays(0, 0);
1191                 }
1192         }
1193 }
1194
1195 /*
1196 static void RSurfShader_OpaqueWall_Pass_OpaqueGlow(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
1197 {
1198         const msurface_t *surf;
1199         rmeshstate_t m;
1200         memset(&m, 0, sizeof(m));
1201         GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
1202         GL_DepthMask(true);
1203         m.tex[0] = R_GetTexture(texture->skin.glow);
1204         if (m.tex[0])
1205                 GL_Color(1, 1, 1, 1);
1206         else
1207                 GL_Color(0, 0, 0, 1);
1208         while((surf = *surfchain++) != NULL)
1209         {
1210                 if (surf->visframe == r_framecount)
1211                 {
1212                         m.pointer_vertex = surf->mesh.data_vertex3f;
1213                         m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
1214                         R_Mesh_State(&m);
1215                         GL_LockArrays(0, surf->mesh.num_vertices);
1216                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
1217                         GL_LockArrays(0, 0);
1218                 }
1219         }
1220 }
1221 */
1222
1223 static void RSurfShader_OpaqueWall_Pass_BaseLightmapOnly(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
1224 {
1225         const msurface_t *surf;
1226         rmeshstate_t m;
1227         int lightmaptexturenum;
1228         memset(&m, 0, sizeof(m));
1229         GL_BlendFunc(GL_ONE, GL_ZERO);
1230         GL_DepthMask(true);
1231         GL_DepthTest(true);
1232         m.tex[0] = R_GetTexture((**surfchain).lightmaptexture);
1233         if (r_shadow_realtime_world.integer)
1234                 GL_Color(r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, 1);
1235         else
1236                 GL_Color(1, 1, 1, 1);
1237         while((surf = *surfchain++) != NULL)
1238         {
1239                 if (surf->visframe == r_framecount)
1240                 {
1241                         lightmaptexturenum = R_GetTexture(surf->lightmaptexture);
1242                         m.tex[0] = lightmaptexturenum;
1243                         m.pointer_vertex = surf->mesh.data_vertex3f;
1244                         m.pointer_texcoord[0] = surf->mesh.data_texcoordlightmap2f;
1245                         R_Mesh_State(&m);
1246                         GL_LockArrays(0, surf->mesh.num_vertices);
1247                         R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
1248                         GL_LockArrays(0, 0);
1249                 }
1250         }
1251 }
1252
1253 void R_UpdateTextureInfo(entity_render_t *ent)
1254 {
1255         int i, texframe, alttextures;
1256         texture_t *t;
1257
1258         if (!ent->model)
1259                 return;
1260
1261         alttextures = ent->frame != 0;
1262         texframe = (int)(cl.time * 5.0f);
1263         for (i = 0;i < ent->model->brushq1.numtextures;i++)
1264         {
1265                 t = ent->model->brushq1.textures + i;
1266                 t->currentalpha = ent->alpha;
1267                 if (t->flags & SURF_WATERALPHA)
1268                         t->currentalpha *= r_wateralpha.value;
1269                 if (ent->effects & EF_ADDITIVE)
1270                         t->rendertype = SURFRENDER_ADD;
1271                 else if (t->currentalpha < 1 || t->skin.fog != NULL)
1272                         t->rendertype = SURFRENDER_ALPHA;
1273                 else
1274                         t->rendertype = SURFRENDER_OPAQUE;
1275                 // we don't need to set currentframe if t->animated is false because
1276                 // it was already set up by the texture loader for non-animating
1277                 if (t->animated)
1278                         t->currentframe = t->anim_frames[alttextures][(t->anim_total[alttextures] >= 2) ? (texframe % t->anim_total[alttextures]) : 0];
1279         }
1280 }
1281
1282 void R_UpdateLightmapInfo(entity_render_t *ent)
1283 {
1284         int i;
1285         msurface_t *surface, **surfacechain;
1286         model_t *model = ent->model;
1287         if (!model)
1288                 return;
1289         if (r_dynamic.integer && !r_shadow_realtime_dlight.integer)
1290                 R_MarkLights(ent);
1291         for (i = 0;i < model->brushq1.light_styles;i++)
1292         {
1293                 if (model->brushq1.light_stylevalue[i] != d_lightstylevalue[model->brushq1.light_style[i]])
1294                 {
1295                         model->brushq1.light_stylevalue[i] = d_lightstylevalue[model->brushq1.light_style[i]];
1296                         for (surfacechain = model->brushq1.light_styleupdatechains[i];(surface = *surfacechain);surfacechain++)
1297                                 surface->cached_dlight = true;
1298                 }
1299         }
1300 }
1301
1302 void R_PrepareSurfaces(entity_render_t *ent)
1303 {
1304         int i, numsurfaces, *surfacevisframes;
1305         model_t *model;
1306         msurface_t *surf, *surfaces;
1307         vec3_t modelorg;
1308
1309         if (!ent->model)
1310                 return;
1311
1312         model = ent->model;
1313         Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
1314         numsurfaces = model->nummodelsurfaces;
1315         surfaces = model->brushq1.surfaces + model->firstmodelsurface;
1316         surfacevisframes = model->brushq1.surfacevisframes + model->firstmodelsurface;
1317         for (i = 0, surf = surfaces;i < numsurfaces;i++, surf++)
1318         {
1319                 if (surfacevisframes[i] == r_framecount)
1320                 {
1321 #if !WORLDNODECULLBACKFACES
1322                         // mark any backface surfaces as not visible
1323                         if (PlaneDist(modelorg, surf->plane) < surf->plane->dist)
1324                         {
1325                                 if (!(surf->flags & SURF_PLANEBACK))
1326                                         surfacevisframes[i] = -1;
1327                         }
1328                         else
1329                         {
1330                                 if ((surf->flags & SURF_PLANEBACK))
1331                                         surfacevisframes[i] = -1;
1332                         }
1333                         if (surfacevisframes[i] == r_framecount)
1334 #endif
1335                         {
1336                                 c_faces++;
1337                                 surf->visframe = r_framecount;
1338                                 if (surf->cached_dlight && surf->lightmaptexture != NULL)
1339                                         R_BuildLightMap(ent, surf);
1340                         }
1341                 }
1342         }
1343 }
1344
1345 void R_DrawSurfaces(entity_render_t *ent, int flagsmask)
1346 {
1347         int texturenumber, f;
1348         vec3_t center;
1349         msurface_t *surf, **chain, **surfchain;
1350         texture_t *t, *texture;
1351         model_t *model = ent->model;
1352         if (model == NULL)
1353                 return;
1354         R_Mesh_Matrix(&ent->matrix);
1355         for (texturenumber = 0, t = model->brushq1.textures;texturenumber < model->brushq1.numtextures;texturenumber++, t++)
1356         {
1357                 if ((f = t->flags & flagsmask) && (texture = t->currentframe) && (surfchain = model->brushq1.pvstexturechains[texturenumber]) != NULL)
1358                 {
1359                         if (texture->flags & SURF_LIGHTMAP)
1360                         {
1361                                 if (gl_lightmaps.integer)
1362                                 {
1363                                         RSurfShader_OpaqueWall_Pass_BaseLightmapOnly(ent, texture, surfchain);
1364                                         if (fogenabled)
1365                                                 RSurfShader_OpaqueWall_Pass_Fog(ent, texture, surfchain);
1366                                 }
1367                                 else if (texture->rendertype != SURFRENDER_OPAQUE)
1368                                 {
1369                                         // transparent vertex shaded from lightmap
1370                                         for (chain = surfchain;(surf = *chain) != NULL;chain++)
1371                                         {
1372                                                 if (surf->visframe == r_framecount)
1373                                                 {
1374                                                         Matrix4x4_Transform(&ent->matrix, surf->poly_center, center);
1375                                                         R_MeshQueue_AddTransparent(center, RSurfShader_Transparent_Callback, ent, surf - ent->model->brushq1.surfaces);
1376                                                 }
1377                                         }
1378                                 }
1379                                 else
1380                                 {
1381                                         if (ent->effects & EF_FULLBRIGHT || r_fullbright.integer)
1382                                         {
1383                                                 RSurfShader_OpaqueWall_Pass_BaseTexture(ent, texture, surfchain);
1384                                                 if (r_detailtextures.integer)
1385                                                         RSurfShader_OpaqueWall_Pass_BaseDetail(ent, texture, surfchain);
1386                                                 if (texture->skin.glow)
1387                                                         RSurfShader_OpaqueWall_Pass_Glow(ent, texture, surfchain);
1388                                         }
1389                                         else if (r_textureunits.integer >= 4 && gl_combine.integer && r_detailtextures.integer && r_ambient.value <= 0)
1390                                                 RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmapDetailGlow(ent, texture, surfchain);
1391                                         else
1392                                         {
1393                                                 if (r_textureunits.integer >= 3 && gl_combine.integer && r_detailtextures.integer && r_ambient.value <= 0)
1394                                                         RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmapDetail(ent, texture, surfchain);
1395                                                 else
1396                                                 {
1397                                                         if (r_textureunits.integer >= 2 && gl_combine.integer)
1398                                                                 RSurfShader_OpaqueWall_Pass_BaseCombine_TextureLightmap(ent, texture, surfchain);
1399                                                         else
1400                                                         {
1401                                                                 RSurfShader_OpaqueWall_Pass_BaseTexture(ent, texture, surfchain);
1402                                                                 RSurfShader_OpaqueWall_Pass_BaseLightmap(ent, texture, surfchain);
1403                                                         }
1404                                                         if (r_ambient.value > 0)
1405                                                                 RSurfShader_OpaqueWall_Pass_BaseAmbient(ent, texture, surfchain);
1406                                                         if (r_detailtextures.integer)
1407                                                                 RSurfShader_OpaqueWall_Pass_BaseDetail(ent, texture, surfchain);
1408                                                 }
1409                                                 if (texture->skin.glow)
1410                                                         RSurfShader_OpaqueWall_Pass_Glow(ent, texture, surfchain);
1411                                         }
1412                                         if (fogenabled)
1413                                                 RSurfShader_OpaqueWall_Pass_Fog(ent, texture, surfchain);
1414                                 }
1415                         }
1416                         else if (texture->flags & SURF_DRAWTURB)
1417                         {
1418                                 for (chain = surfchain;(surf = *chain) != NULL;chain++)
1419                                 {
1420                                         if (surf->visframe == r_framecount)
1421                                         {
1422                                                 if (texture->rendertype == SURFRENDER_OPAQUE)
1423                                                         RSurfShader_Transparent_Callback(ent, surf - ent->model->brushq1.surfaces);
1424                                                 else
1425                                                 {
1426                                                         Matrix4x4_Transform(&ent->matrix, surf->poly_center, center);
1427                                                         R_MeshQueue_AddTransparent(center, RSurfShader_Transparent_Callback, ent, surf - ent->model->brushq1.surfaces);
1428                                                 }
1429                                         }
1430                                 }
1431                         }
1432                         else if (texture->flags & SURF_DRAWSKY)
1433                                 RSurfShader_Sky(ent, texture, surfchain);
1434                 }
1435         }
1436 }
1437
1438 static void R_DrawPortal_Callback(const void *calldata1, int calldata2)
1439 {
1440         int i;
1441         float *v;
1442         rmeshstate_t m;
1443         const entity_render_t *ent = calldata1;
1444         const mportal_t *portal = ent->model->brushq1.portals + calldata2;
1445         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1446         GL_DepthMask(false);
1447         GL_DepthTest(true);
1448         R_Mesh_Matrix(&ent->matrix);
1449
1450         memset(&m, 0, sizeof(m));
1451         m.pointer_vertex = varray_vertex3f;
1452         R_Mesh_State(&m);
1453
1454         i = portal - ent->model->brushq1.portals;
1455         GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f),
1456                          ((i & 0x0038) >> 3) * (1.0f / 7.0f),
1457                          ((i & 0x01C0) >> 6) * (1.0f / 7.0f),
1458                          0.125f);
1459         if (PlaneDiff(r_vieworigin, (&portal->plane)) < 0)
1460         {
1461                 for (i = portal->numpoints - 1, v = varray_vertex3f;i >= 0;i--, v += 3)
1462                         VectorCopy(portal->points[i].position, v);
1463         }
1464         else
1465                 for (i = 0, v = varray_vertex3f;i < portal->numpoints;i++, v += 3)
1466                         VectorCopy(portal->points[i].position, v);
1467         GL_LockArrays(0, portal->numpoints);
1468         R_Mesh_Draw(portal->numpoints, portal->numpoints - 2, polygonelements);
1469         GL_LockArrays(0, 0);
1470 }
1471
1472 // LordHavoc: this is just a nice debugging tool, very slow
1473 static void R_DrawPortals(entity_render_t *ent)
1474 {
1475         int i;
1476         mportal_t *portal, *endportal;
1477         float temp[3], center[3], f;
1478         if (ent->model == NULL)
1479                 return;
1480         for (portal = ent->model->brushq1.portals, endportal = portal + ent->model->brushq1.numportals;portal < endportal;portal++)
1481         {
1482                 if (portal->numpoints <= POLYGONELEMENTS_MAXPOINTS)
1483                 {
1484                         VectorClear(temp);
1485                         for (i = 0;i < portal->numpoints;i++)
1486                                 VectorAdd(temp, portal->points[i].position, temp);
1487                         f = ixtable[portal->numpoints];
1488                         VectorScale(temp, f, temp);
1489                         Matrix4x4_Transform(&ent->matrix, temp, center);
1490                         R_MeshQueue_AddTransparent(center, R_DrawPortal_Callback, ent, portal - ent->model->brushq1.portals);
1491                 }
1492         }
1493 }
1494
1495 void R_PrepareBrushModel(entity_render_t *ent)
1496 {
1497         int i, numsurfaces, *surfacevisframes, *surfacepvsframes;
1498         msurface_t *surf;
1499         model_t *model;
1500 #if WORLDNODECULLBACKFACES
1501         vec3_t modelorg;
1502 #endif
1503
1504         // because bmodels can be reused, we have to decide which things to render
1505         // from scratch every time
1506         model = ent->model;
1507         if (model == NULL)
1508                 return;
1509 #if WORLDNODECULLBACKFACES
1510         Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
1511 #endif
1512         numsurfaces = model->nummodelsurfaces;
1513         surf = model->brushq1.surfaces + model->firstmodelsurface;
1514         surfacevisframes = model->brushq1.surfacevisframes + model->firstmodelsurface;
1515         surfacepvsframes = model->brushq1.surfacepvsframes + model->firstmodelsurface;
1516         for (i = 0;i < numsurfaces;i++, surf++)
1517         {
1518 #if WORLDNODECULLBACKFACES
1519                 // mark any backface surfaces as not visible
1520                 if (PlaneDist(modelorg, surf->plane) < surf->plane->dist)
1521                 {
1522                         if ((surf->flags & SURF_PLANEBACK))
1523                                 surfacevisframes[i] = r_framecount;
1524                 }
1525                 else if (!(surf->flags & SURF_PLANEBACK))
1526                         surfacevisframes[i] = r_framecount;
1527 #else
1528                 surfacevisframes[i] = r_framecount;
1529 #endif
1530                 surf->dlightframe = -1;
1531         }
1532         R_UpdateTextureInfo(ent);
1533         R_UpdateLightmapInfo(ent);
1534 }
1535
1536 void R_SurfaceWorldNode (entity_render_t *ent)
1537 {
1538         int i, *surfacevisframes, *surfacepvsframes, surfnum;
1539         msurface_t *surf;
1540         mleaf_t *leaf;
1541         model_t *model;
1542         vec3_t modelorg;
1543
1544         // equivilant to quake's RecursiveWorldNode but faster and more effective
1545         model = ent->model;
1546         if (model == NULL)
1547                 return;
1548         surfacevisframes = model->brushq1.surfacevisframes + model->firstmodelsurface;
1549         surfacepvsframes = model->brushq1.surfacepvsframes + model->firstmodelsurface;
1550         Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
1551
1552         for (leaf = model->brushq1.pvsleafchain;leaf;leaf = leaf->pvschain)
1553         {
1554                 if (!R_CullBox (leaf->mins, leaf->maxs))
1555                 {
1556                         c_leafs++;
1557                         leaf->visframe = r_framecount;
1558                 }
1559         }
1560
1561         for (i = 0;i < model->brushq1.pvssurflistlength;i++)
1562         {
1563                 surfnum = model->brushq1.pvssurflist[i];
1564                 surf = model->brushq1.surfaces + surfnum;
1565 #if WORLDNODECULLBACKFACES
1566                 if (PlaneDist(modelorg, surf->plane) < surf->plane->dist)
1567                 {
1568                         if ((surf->flags & SURF_PLANEBACK) && !R_CullBox (surf->poly_mins, surf->poly_maxs))
1569                                 surfacevisframes[surfnum] = r_framecount;
1570                 }
1571                 else
1572                 {
1573                         if (!(surf->flags & SURF_PLANEBACK) && !R_CullBox (surf->poly_mins, surf->poly_maxs))
1574                                 surfacevisframes[surfnum] = r_framecount;
1575                 }
1576 #else
1577                 if (!R_CullBox (surf->poly_mins, surf->poly_maxs))
1578                         surfacevisframes[surfnum] = r_framecount;
1579 #endif
1580         }
1581 }
1582
1583 static void R_PortalWorldNode(entity_render_t *ent, mleaf_t *viewleaf)
1584 {
1585         int c, leafstackpos, *mark, *surfacevisframes;
1586 #if WORLDNODECULLBACKFACES
1587         int n;
1588         msurface_t *surf;
1589 #endif
1590         mleaf_t *leaf, *leafstack[8192];
1591         mportal_t *p;
1592         vec3_t modelorg;
1593         msurface_t *surfaces;
1594         if (ent->model == NULL)
1595                 return;
1596         // LordHavoc: portal-passage worldnode with PVS;
1597         // follows portals leading outward from viewleaf, does not venture
1598         // offscreen or into leafs that are not visible, faster than Quake's
1599         // RecursiveWorldNode
1600         surfaces = ent->model->brushq1.surfaces;
1601         surfacevisframes = ent->model->brushq1.surfacevisframes;
1602         Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
1603         viewleaf->worldnodeframe = r_framecount;
1604         leafstack[0] = viewleaf;
1605         leafstackpos = 1;
1606         while (leafstackpos)
1607         {
1608                 c_leafs++;
1609                 leaf = leafstack[--leafstackpos];
1610                 leaf->visframe = r_framecount;
1611                 // draw any surfaces bounding this leaf
1612                 if (leaf->nummarksurfaces)
1613                 {
1614                         for (c = leaf->nummarksurfaces, mark = leaf->firstmarksurface;c;c--)
1615                         {
1616 #if WORLDNODECULLBACKFACES
1617                                 n = *mark++;
1618                                 if (surfacevisframes[n] != r_framecount)
1619                                 {
1620                                         surf = surfaces + n;
1621                                         if (PlaneDist(modelorg, surf->plane) < surf->plane->dist)
1622                                         {
1623                                                 if ((surf->flags & SURF_PLANEBACK))
1624                                                         surfacevisframes[n] = r_framecount;
1625                                         }
1626                                         else
1627                                         {
1628                                                 if (!(surf->flags & SURF_PLANEBACK))
1629                                                         surfacevisframes[n] = r_framecount;
1630                                         }
1631                                 }
1632 #else
1633                                 surfacevisframes[*mark++] = r_framecount;
1634 #endif
1635                         }
1636                 }
1637                 // follow portals into other leafs
1638                 for (p = leaf->portals;p;p = p->next)
1639                 {
1640                         // LordHavoc: this DotProduct hurts less than a cache miss
1641                         // (which is more likely to happen if backflowing through leafs)
1642                         if (DotProduct(modelorg, p->plane.normal) < (p->plane.dist + 1))
1643                         {
1644                                 leaf = p->past;
1645                                 if (leaf->worldnodeframe != r_framecount)
1646                                 {
1647                                         leaf->worldnodeframe = r_framecount;
1648                                         // FIXME: R_CullBox is absolute, should be done relative
1649                                         if (CHECKPVSBIT(r_pvsbits, leaf->clusterindex) && !R_CullBox(leaf->mins, leaf->maxs))
1650                                                 leafstack[leafstackpos++] = leaf;
1651                                 }
1652                         }
1653                 }
1654         }
1655 }
1656
1657 void R_PVSUpdate (entity_render_t *ent, mleaf_t *viewleaf)
1658 {
1659         int j, c, *surfacepvsframes, *mark;
1660         mleaf_t *leaf;
1661         model_t *model;
1662
1663         model = ent->model;
1664         if (model && (model->brushq1.pvsviewleaf != viewleaf || model->brushq1.pvsviewleafnovis != r_novis.integer))
1665         {
1666                 model->brushq1.pvsframecount++;
1667                 model->brushq1.pvsviewleaf = viewleaf;
1668                 model->brushq1.pvsviewleafnovis = r_novis.integer;
1669                 model->brushq1.pvsleafchain = NULL;
1670                 model->brushq1.pvssurflistlength = 0;
1671                 if (viewleaf)
1672                 {
1673                         surfacepvsframes = model->brushq1.surfacepvsframes;
1674                         for (j = 0, leaf = model->brushq1.data_leafs;j < model->brushq1.num_leafs;j++, leaf++)
1675                         {
1676                                 if (CHECKPVSBIT(r_pvsbits, leaf->clusterindex))
1677                                 {
1678                                         leaf->pvsframe = model->brushq1.pvsframecount;
1679                                         leaf->pvschain = model->brushq1.pvsleafchain;
1680                                         model->brushq1.pvsleafchain = leaf;
1681                                         // mark surfaces bounding this leaf as visible
1682                                         for (c = leaf->nummarksurfaces, mark = leaf->firstmarksurface;c;c--, mark++)
1683                                                 surfacepvsframes[*mark] = model->brushq1.pvsframecount;
1684                                 }
1685                         }
1686                         model->brushq1.BuildPVSTextureChains(model);
1687                 }
1688         }
1689 }
1690
1691 void R_WorldVisibility(entity_render_t *ent)
1692 {
1693         vec3_t modelorg;
1694         mleaf_t *viewleaf;
1695
1696         Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
1697         viewleaf = (ent->model && ent->model->brushq1.PointInLeaf) ? ent->model->brushq1.PointInLeaf(ent->model, modelorg) : NULL;
1698         R_PVSUpdate(ent, viewleaf);
1699
1700         if (!viewleaf)
1701                 return;
1702
1703         if (r_surfaceworldnode.integer || viewleaf->contents == CONTENTS_SOLID)
1704                 R_SurfaceWorldNode (ent);
1705         else
1706                 R_PortalWorldNode (ent, viewleaf);
1707
1708         if (r_drawportals.integer)
1709                 R_DrawPortals(ent);
1710 }
1711
1712 void R_Q1BSP_DrawSky(entity_render_t *ent)
1713 {
1714         if (ent->model == NULL)
1715                 return;
1716         if (ent != &cl_entities[0].render)
1717                 R_PrepareBrushModel(ent);
1718         R_PrepareSurfaces(ent);
1719         R_DrawSurfaces(ent, SURF_DRAWSKY);
1720 }
1721
1722 void R_Q1BSP_Draw(entity_render_t *ent)
1723 {
1724         if (ent->model == NULL)
1725                 return;
1726         c_bmodels++;
1727         if (ent != &cl_entities[0].render)
1728                 R_PrepareBrushModel(ent);
1729         R_PrepareSurfaces(ent);
1730         R_UpdateTextureInfo(ent);
1731         R_UpdateLightmapInfo(ent);
1732         R_DrawSurfaces(ent, SURF_DRAWTURB | SURF_LIGHTMAP);
1733 }
1734
1735 void R_Q1BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outclusterlist, qbyte *outclusterpvs, int *outnumclusterspointer, int *outsurfacelist, qbyte *outsurfacepvs, int *outnumsurfacespointer)
1736 {
1737         model_t *model = ent->model;
1738         vec3_t lightmins, lightmaxs;
1739         int t, leafindex, marksurfaceindex, surfaceindex, triangleindex, outnumclusters = 0, outnumsurfaces = 0;
1740         const int *e;
1741         const float *v[3];
1742         msurface_t *surface;
1743         mleaf_t *leaf;
1744         const qbyte *pvs;
1745         lightmins[0] = relativelightorigin[0] - lightradius;
1746         lightmins[1] = relativelightorigin[1] - lightradius;
1747         lightmins[2] = relativelightorigin[2] - lightradius;
1748         lightmaxs[0] = relativelightorigin[0] + lightradius;
1749         lightmaxs[1] = relativelightorigin[1] + lightradius;
1750         lightmaxs[2] = relativelightorigin[2] + lightradius;
1751         *outnumclusterspointer = 0;
1752         *outnumsurfacespointer = 0;
1753         memset(outclusterpvs, 0, model->brush.num_pvsclusterbytes);
1754         memset(outsurfacepvs, 0, (model->nummodelsurfaces + 7) >> 3);
1755         if (model == NULL)
1756         {
1757                 VectorCopy(lightmins, outmins);
1758                 VectorCopy(lightmaxs, outmaxs);
1759                 return;
1760         }
1761         VectorCopy(relativelightorigin, outmins);
1762         VectorCopy(relativelightorigin, outmaxs);
1763         if (model->brush.GetPVS)
1764                 pvs = model->brush.GetPVS(model, relativelightorigin);
1765         else
1766                 pvs = NULL;
1767         // FIXME: use BSP recursion as lights are often small
1768         for (leafindex = 0, leaf = model->brushq1.data_leafs;leafindex < model->brushq1.num_leafs;leafindex++, leaf++)
1769         {
1770                 if (BoxesOverlap(lightmins, lightmaxs, leaf->mins, leaf->maxs) && (pvs == NULL || CHECKPVSBIT(pvs, leaf->clusterindex)))
1771                 {
1772                         outmins[0] = min(outmins[0], leaf->mins[0]);
1773                         outmins[1] = min(outmins[1], leaf->mins[1]);
1774                         outmins[2] = min(outmins[2], leaf->mins[2]);
1775                         outmaxs[0] = max(outmaxs[0], leaf->maxs[0]);
1776                         outmaxs[1] = max(outmaxs[1], leaf->maxs[1]);
1777                         outmaxs[2] = max(outmaxs[2], leaf->maxs[2]);
1778                         if (outclusterpvs)
1779                         {
1780                                 if (!CHECKPVSBIT(outclusterpvs, leaf->clusterindex))
1781                                 {
1782                                         SETPVSBIT(outclusterpvs, leaf->clusterindex);
1783                                         outclusterlist[outnumclusters++] = leaf->clusterindex;
1784                                 }
1785                         }
1786                         if (outsurfacepvs)
1787                         {
1788                                 for (marksurfaceindex = 0;marksurfaceindex < leaf->nummarksurfaces;marksurfaceindex++)
1789                                 {
1790                                         surfaceindex = leaf->firstmarksurface[marksurfaceindex];
1791                                         if (!CHECKPVSBIT(outsurfacepvs, surfaceindex))
1792                                         {
1793                                                 surface = model->brushq1.surfaces + surfaceindex;
1794                                                 if (BoxesOverlap(lightmins, lightmaxs, surface->poly_mins, surface->poly_maxs) && (surface->flags & SURF_LIGHTMAP) && !surface->texinfo->texture->skin.fog)
1795                                                 {
1796                                                         for (triangleindex = 0, t = surface->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;triangleindex < surface->mesh.num_triangles;triangleindex++, t++, e += 3)
1797                                                         {
1798                                                                 v[0] = model->brush.shadowmesh->vertex3f + e[0] * 3;
1799                                                                 v[1] = model->brush.shadowmesh->vertex3f + e[1] * 3;
1800                                                                 v[2] = model->brush.shadowmesh->vertex3f + e[2] * 3;
1801                                                                 if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
1802                                                                 {
1803                                                                         SETPVSBIT(outsurfacepvs, surfaceindex);
1804                                                                         outsurfacelist[outnumsurfaces++] = surfaceindex;
1805                                                                         break;
1806                                                                 }
1807                                                         }
1808                                                 }
1809                                         }
1810                                 }
1811                         }
1812                 }
1813         }
1814
1815         // limit combined leaf box to light boundaries
1816         outmins[0] = max(outmins[0], lightmins[0]);
1817         outmins[1] = max(outmins[1], lightmins[1]);
1818         outmins[2] = max(outmins[2], lightmins[2]);
1819         outmaxs[0] = min(outmaxs[0], lightmaxs[0]);
1820         outmaxs[1] = min(outmaxs[1], lightmaxs[1]);
1821         outmaxs[2] = min(outmaxs[2], lightmaxs[2]);
1822
1823         *outnumclusterspointer = outnumclusters;
1824         *outnumsurfacespointer = outnumsurfaces;
1825 }
1826
1827 void R_Q1BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist)
1828 {
1829         model_t *model = ent->model;
1830         vec3_t lightmins, lightmaxs;
1831         msurface_t *surface;
1832         int surfacelistindex, j, t;
1833         const int *e;
1834         const float *v[3];
1835         if (r_drawcollisionbrushes.integer < 2)
1836         {
1837                 lightmins[0] = relativelightorigin[0] - lightradius;
1838                 lightmins[1] = relativelightorigin[1] - lightradius;
1839                 lightmins[2] = relativelightorigin[2] - lightradius;
1840                 lightmaxs[0] = relativelightorigin[0] + lightradius;
1841                 lightmaxs[1] = relativelightorigin[1] + lightradius;
1842                 lightmaxs[2] = relativelightorigin[2] + lightradius;
1843                 R_Mesh_Matrix(&ent->matrix);
1844                 R_Shadow_PrepareShadowMark(model->brush.shadowmesh->numtriangles);
1845                 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
1846                 {
1847                         surface = model->brushq1.surfaces + surfacelist[surfacelistindex];
1848                         for (j = 0, t = surface->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;j < surface->mesh.num_triangles;j++, t++, e += 3)
1849                         {
1850                                 v[0] = model->brush.shadowmesh->vertex3f + e[0] * 3;
1851                                 v[1] = model->brush.shadowmesh->vertex3f + e[1] * 3;
1852                                 v[2] = model->brush.shadowmesh->vertex3f + e[2] * 3;
1853                                 if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
1854                                         shadowmarklist[numshadowmark++] = t;
1855                         }
1856                 }
1857                 R_Shadow_VolumeFromList(model->brush.shadowmesh->numverts, model->brush.shadowmesh->numtriangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, model->brush.shadowmesh->neighbor3i, relativelightorigin, lightradius + model->radius + r_shadow_projectdistance.value, numshadowmark, shadowmarklist);
1858         }
1859 }
1860
1861 void R_Q1BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap, int numsurfaces, const int *surfacelist)
1862 {
1863         model_t *model = ent->model;
1864         vec3_t lightmins, lightmaxs, modelorg;
1865         msurface_t *surface;
1866         texture_t *t;
1867         int surfacelistindex;
1868         if (r_drawcollisionbrushes.integer < 2)
1869         {
1870                 lightmins[0] = relativelightorigin[0] - lightradius;
1871                 lightmins[1] = relativelightorigin[1] - lightradius;
1872                 lightmins[2] = relativelightorigin[2] - lightradius;
1873                 lightmaxs[0] = relativelightorigin[0] + lightradius;
1874                 lightmaxs[1] = relativelightorigin[1] + lightradius;
1875                 lightmaxs[2] = relativelightorigin[2] + lightradius;
1876                 R_Mesh_Matrix(&ent->matrix);
1877                 Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
1878                 R_UpdateTextureInfo(ent);
1879                 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
1880                 {
1881                         surface = model->brushq1.surfaces + surfacelist[surfacelistindex];
1882                         if (r_shadow_compilingrtlight)
1883                         {
1884                                 // if compiling an rtlight, capture the mesh
1885                                 t = surface->texinfo->texture;
1886                                 if (t->flags & SURF_LIGHTMAP && t->skin.fog == NULL)
1887                                         Mod_ShadowMesh_AddMesh(r_shadow_mempool, r_shadow_compilingrtlight->static_meshchain_light, surface->texinfo->texture->skin.base, surface->texinfo->texture->skin.gloss, surface->texinfo->texture->skin.nmap, surface->mesh.data_vertex3f, surface->mesh.data_svector3f, surface->mesh.data_tvector3f, surface->mesh.data_normal3f, surface->mesh.data_texcoordtexture2f, surface->mesh.num_triangles, surface->mesh.data_element3i);
1888                         }
1889                         else if (ent != &cl_entities[0].render || surface->visframe == r_framecount)
1890                         {
1891                                 t = surface->texinfo->texture->currentframe;
1892                                 if (t->flags & SURF_LIGHTMAP && t->rendertype == SURFRENDER_OPAQUE)
1893                                         R_Shadow_RenderLighting(surface->mesh.num_vertices, surface->mesh.num_triangles, surface->mesh.data_element3i, surface->mesh.data_vertex3f, surface->mesh.data_svector3f, surface->mesh.data_tvector3f, surface->mesh.data_normal3f, surface->mesh.data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, t->skin.gloss, lightcubemap, LIGHTING_DIFFUSE | LIGHTING_SPECULAR);
1894                         }
1895                 }
1896         }
1897 }
1898
1899 void R_DrawCollisionBrush(colbrushf_t *brush)
1900 {
1901         int i;
1902         rmeshstate_t m;
1903         memset(&m, 0, sizeof(m));
1904         m.pointer_vertex = brush->points->v;
1905         R_Mesh_State(&m);
1906         i = ((int)brush) / sizeof(colbrushf_t);
1907         GL_Color((i & 31) * (1.0f / 32.0f), ((i >> 5) & 31) * (1.0f / 32.0f), ((i >> 10) & 31) * (1.0f / 32.0f), 0.2f);
1908         GL_LockArrays(0, brush->numpoints);
1909         R_Mesh_Draw(brush->numpoints, brush->numtriangles, brush->elements);
1910         GL_LockArrays(0, 0);
1911 }
1912
1913 void R_Q3BSP_DrawCollisionFace(entity_render_t *ent, q3msurface_t *face)
1914 {
1915         int i;
1916         rmeshstate_t m;
1917         if (!face->num_collisiontriangles)
1918                 return;
1919         memset(&m, 0, sizeof(m));
1920         m.pointer_vertex = face->data_collisionvertex3f;
1921         R_Mesh_State(&m);
1922         i = ((int)face) / sizeof(q3msurface_t);
1923         GL_Color((i & 31) * (1.0f / 32.0f), ((i >> 5) & 31) * (1.0f / 32.0f), ((i >> 10) & 31) * (1.0f / 32.0f), 0.2f);
1924         GL_LockArrays(0, face->num_collisionvertices);
1925         R_Mesh_Draw(face->num_collisionvertices, face->num_collisiontriangles, face->data_collisionelement3i);
1926         GL_LockArrays(0, 0);
1927 }
1928
1929 void R_Q3BSP_DrawSkyFace(entity_render_t *ent, q3msurface_t *face)
1930 {
1931         rmeshstate_t m;
1932         if (!face->num_triangles)
1933                 return;
1934         c_faces++;
1935         if (skyrendernow)
1936         {
1937                 skyrendernow = false;
1938                 if (skyrendermasked)
1939                         R_Sky();
1940         }
1941         if (!r_q3bsp_renderskydepth.integer)
1942                 return;
1943
1944         R_Mesh_Matrix(&ent->matrix);
1945
1946         GL_Color(fogcolor[0], fogcolor[1], fogcolor[2], 1);
1947         if (skyrendermasked)
1948         {
1949                 // depth-only (masking)
1950                 GL_ColorMask(0,0,0,0);
1951                 // just to make sure that braindead drivers don't draw anything
1952                 // despite that colormask...
1953                 GL_BlendFunc(GL_ZERO, GL_ONE);
1954         }
1955         else
1956         {
1957                 // fog sky
1958                 GL_BlendFunc(GL_ONE, GL_ZERO);
1959         }
1960         GL_DepthMask(true);
1961         GL_DepthTest(true);
1962
1963         memset(&m, 0, sizeof(m));
1964         m.pointer_vertex = face->data_vertex3f;
1965         R_Mesh_State(&m);
1966
1967         GL_LockArrays(0, face->num_vertices);
1968         R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
1969         GL_LockArrays(0, 0);
1970         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
1971 }
1972
1973 void R_Q3BSP_DrawFace_OpaqueWall_Pass_OpaqueGlow(entity_render_t *ent, q3msurface_t *face)
1974 {
1975         rmeshstate_t m;
1976         memset(&m, 0, sizeof(m));
1977         GL_BlendFunc(GL_ONE, GL_ZERO);
1978         GL_DepthMask(true);
1979         GL_DepthTest(true);
1980         if (face->texture->skin.glow)
1981         {
1982                 m.tex[0] = R_GetTexture(face->texture->skin.glow);
1983                 m.pointer_texcoord[0] = face->data_texcoordtexture2f;
1984                 GL_Color(1, 1, 1, 1);
1985         }
1986         else
1987                 GL_Color(0, 0, 0, 1);
1988         m.pointer_vertex = face->data_vertex3f;
1989         R_Mesh_State(&m);
1990         GL_LockArrays(0, face->num_vertices);
1991         R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
1992         GL_LockArrays(0, 0);
1993 }
1994
1995 void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureLightmapCombine(entity_render_t *ent, q3msurface_t *face)
1996 {
1997         rmeshstate_t m;
1998         memset(&m, 0, sizeof(m));
1999         GL_BlendFunc(GL_ONE, GL_ZERO);
2000         GL_DepthMask(true);
2001         GL_DepthTest(true);
2002         m.tex[0] = R_GetTexture(face->texture->skin.base);
2003         m.pointer_texcoord[0] = face->data_texcoordtexture2f;
2004         m.tex[1] = R_GetTexture(face->lightmaptexture);
2005         m.pointer_texcoord[1] = face->data_texcoordlightmap2f;
2006         m.texrgbscale[1] = 2;
2007         GL_Color(1, 1, 1, 1);
2008         m.pointer_vertex = face->data_vertex3f;
2009         R_Mesh_State(&m);
2010         GL_LockArrays(0, face->num_vertices);
2011         R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
2012         GL_LockArrays(0, 0);
2013 }
2014
2015 void R_Q3BSP_DrawFace_OpaqueWall_Pass_Texture(entity_render_t *ent, q3msurface_t *face)
2016 {
2017         rmeshstate_t m;
2018         memset(&m, 0, sizeof(m));
2019         GL_BlendFunc(GL_ONE, GL_ZERO);
2020         GL_DepthMask(true);
2021         GL_DepthTest(true);
2022         m.tex[0] = R_GetTexture(face->texture->skin.base);
2023         m.pointer_texcoord[0] = face->data_texcoordtexture2f;
2024         GL_Color(1, 1, 1, 1);
2025         m.pointer_vertex = face->data_vertex3f;
2026         R_Mesh_State(&m);
2027         GL_LockArrays(0, face->num_vertices);
2028         R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
2029         GL_LockArrays(0, 0);
2030 }
2031
2032 void R_Q3BSP_DrawFace_OpaqueWall_Pass_Lightmap(entity_render_t *ent, q3msurface_t *face)
2033 {
2034         rmeshstate_t m;
2035         memset(&m, 0, sizeof(m));
2036         GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
2037         GL_DepthMask(false);
2038         GL_DepthTest(true);
2039         m.tex[0] = R_GetTexture(face->lightmaptexture);
2040         m.pointer_texcoord[0] = face->data_texcoordlightmap2f;
2041         GL_Color(1, 1, 1, 1);
2042         m.pointer_vertex = face->data_vertex3f;
2043         R_Mesh_State(&m);
2044         GL_LockArrays(0, face->num_vertices);
2045         R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
2046         GL_LockArrays(0, 0);
2047 }
2048
2049 void R_Q3BSP_DrawFace_OpaqueWall_Pass_LightmapOnly(entity_render_t *ent, q3msurface_t *face)
2050 {
2051         rmeshstate_t m;
2052         memset(&m, 0, sizeof(m));
2053         GL_BlendFunc(GL_ONE, GL_ZERO);
2054         GL_DepthMask(true);
2055         GL_DepthTest(true);
2056         m.tex[0] = R_GetTexture(face->lightmaptexture);
2057         m.pointer_texcoord[0] = face->data_texcoordlightmap2f;
2058         if (r_shadow_realtime_world.integer)
2059                 GL_Color(r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, r_shadow_realtime_world_lightmaps.value, 1);
2060         else
2061                 GL_Color(1, 1, 1, 1);
2062         m.pointer_vertex = face->data_vertex3f;
2063         R_Mesh_State(&m);
2064         GL_LockArrays(0, face->num_vertices);
2065         R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
2066         GL_LockArrays(0, 0);
2067 }
2068
2069 void R_Q3BSP_DrawFace_OpaqueWall_Pass_Glow(entity_render_t *ent, q3msurface_t *face)
2070 {
2071         rmeshstate_t m;
2072         memset(&m, 0, sizeof(m));
2073         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2074         GL_DepthMask(false);
2075         GL_DepthTest(true);
2076         if (face->texture->skin.glow)
2077         {
2078                 m.tex[0] = R_GetTexture(face->texture->skin.glow);
2079                 m.pointer_texcoord[0] = face->data_texcoordtexture2f;
2080                 GL_Color(1, 1, 1, 1);
2081         }
2082         else
2083                 GL_Color(0, 0, 0, 1);
2084         m.pointer_vertex = face->data_vertex3f;
2085         R_Mesh_State(&m);
2086         GL_LockArrays(0, face->num_vertices);
2087         R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
2088         GL_LockArrays(0, 0);
2089 }
2090
2091 void R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureVertex(entity_render_t *ent, q3msurface_t *face)
2092 {
2093         int i;
2094         float mul;
2095         rmeshstate_t m;
2096         memset(&m, 0, sizeof(m));
2097         GL_BlendFunc(GL_ONE, GL_ZERO);
2098         GL_DepthMask(true);
2099         GL_DepthTest(true);
2100         m.tex[0] = R_GetTexture(face->texture->skin.base);
2101         m.pointer_texcoord[0] = face->data_texcoordtexture2f;
2102         mul = 2.0f;
2103         if (r_shadow_realtime_world.integer && r_shadow_realtime_world_lightmaps.value != 1)
2104                 mul *= r_shadow_realtime_world_lightmaps.value;
2105         if (mul == 2 && gl_combine.integer)
2106         {
2107                 m.texrgbscale[0] = 2;
2108                 m.pointer_color = face->data_color4f;
2109         }
2110         else if (mul == 1)
2111                 m.pointer_color = face->data_color4f;
2112         else
2113         {
2114                 for (i = 0;i < face->num_vertices;i++)
2115                 {
2116                         varray_color4f[i*4+0] = face->data_color4f[i*4+0] * mul;
2117                         varray_color4f[i*4+1] = face->data_color4f[i*4+1] * mul;
2118                         varray_color4f[i*4+2] = face->data_color4f[i*4+2] * mul;
2119                         varray_color4f[i*4+3] = face->data_color4f[i*4+3];
2120                 }
2121                 m.pointer_color = varray_color4f;
2122         }
2123         m.pointer_vertex = face->data_vertex3f;
2124         R_Mesh_State(&m);
2125         GL_LockArrays(0, face->num_vertices);
2126         R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
2127         GL_LockArrays(0, 0);
2128 }
2129
2130 void R_Q3BSP_DrawFace_OpaqueWall_Pass_VertexOnly(entity_render_t *ent, q3msurface_t *face)
2131 {
2132         int i;
2133         float mul;
2134         rmeshstate_t m;
2135         memset(&m, 0, sizeof(m));
2136         GL_BlendFunc(GL_ONE, GL_ZERO);
2137         GL_DepthMask(true);
2138         GL_DepthTest(true);
2139         mul = 2.0f;
2140         if (r_shadow_realtime_world.integer && r_shadow_realtime_world_lightmaps.value != 1)
2141                 mul *= r_shadow_realtime_world_lightmaps.value;
2142         if (mul == 1)
2143                 m.pointer_color = face->data_color4f;
2144         else
2145         {
2146                 for (i = 0;i < face->num_vertices;i++)
2147                 {
2148                         varray_color4f[i*4+0] = face->data_color4f[i*4+0] * 2.0f;
2149                         varray_color4f[i*4+1] = face->data_color4f[i*4+1] * 2.0f;
2150                         varray_color4f[i*4+2] = face->data_color4f[i*4+2] * 2.0f;
2151                         varray_color4f[i*4+3] = face->data_color4f[i*4+3];
2152                 }
2153                 m.pointer_color = varray_color4f;
2154         }
2155         m.pointer_vertex = face->data_vertex3f;
2156         R_Mesh_State(&m);
2157         GL_LockArrays(0, face->num_vertices);
2158         R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
2159         GL_LockArrays(0, 0);
2160 }
2161
2162 void R_Q3BSP_DrawFace_OpaqueWall_Pass_AddTextureAmbient(entity_render_t *ent, q3msurface_t *face)
2163 {
2164         rmeshstate_t m;
2165         memset(&m, 0, sizeof(m));
2166         GL_BlendFunc(GL_ONE, GL_ONE);
2167         GL_DepthMask(true);
2168         GL_DepthTest(true);
2169         m.tex[0] = R_GetTexture(face->texture->skin.base);
2170         m.pointer_texcoord[0] = face->data_texcoordtexture2f;
2171         GL_Color(r_ambient.value * (1.0f / 128.0f), r_ambient.value * (1.0f / 128.0f), r_ambient.value * (1.0f / 128.0f), 1);
2172         m.pointer_vertex = face->data_vertex3f;
2173         R_Mesh_State(&m);
2174         GL_LockArrays(0, face->num_vertices);
2175         R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
2176         GL_LockArrays(0, 0);
2177 }
2178
2179 void R_Q3BSP_DrawFace_TransparentCallback(const void *voident, int facenumber)
2180 {
2181         const entity_render_t *ent = voident;
2182         q3msurface_t *face = ent->model->brushq3.data_faces + facenumber;
2183         rmeshstate_t m;
2184         R_Mesh_Matrix(&ent->matrix);
2185         memset(&m, 0, sizeof(m));
2186         if (ent->effects & EF_ADDITIVE)
2187                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2188         else
2189                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2190         GL_DepthMask(false);
2191         GL_DepthTest(true);
2192         m.tex[0] = R_GetTexture(face->texture->skin.base);
2193         m.pointer_texcoord[0] = face->data_texcoordtexture2f;
2194         // LordHavoc: quake3 was not able to do this; lit transparent surfaces
2195         if (gl_combine.integer)
2196         {
2197                 m.texrgbscale[0] = 2;
2198                 if (r_textureunits.integer >= 2)
2199                 {
2200                         m.tex[1] = R_GetTexture(face->lightmaptexture);
2201                         m.pointer_texcoord[1] = face->data_texcoordlightmap2f;
2202                         GL_Color(1, 1, 1, ent->alpha);
2203                 }
2204                 else
2205                 {
2206                         if (ent->alpha == 1)
2207                                 m.pointer_color = face->data_color4f;
2208                         else
2209                         {
2210                                 int i;
2211                                 for (i = 0;i < face->num_vertices;i++)
2212                                 {
2213                                         varray_color4f[i*4+0] = face->data_color4f[i*4+0];
2214                                         varray_color4f[i*4+1] = face->data_color4f[i*4+1];
2215                                         varray_color4f[i*4+2] = face->data_color4f[i*4+2];
2216                                         varray_color4f[i*4+3] = face->data_color4f[i*4+3] * ent->alpha;
2217                                 }
2218                                 m.pointer_color = varray_color4f;
2219                         }
2220                 }
2221         }
2222         else
2223         {
2224                 int i;
2225                 for (i = 0;i < face->num_vertices;i++)
2226                 {
2227                         varray_color4f[i*4+0] = face->data_color4f[i*4+0] * 2.0f;
2228                         varray_color4f[i*4+1] = face->data_color4f[i*4+1] * 2.0f;
2229                         varray_color4f[i*4+2] = face->data_color4f[i*4+2] * 2.0f;
2230                         varray_color4f[i*4+3] = face->data_color4f[i*4+3] * ent->alpha;
2231                 }
2232                 m.pointer_color = varray_color4f;
2233         }
2234         m.pointer_vertex = face->data_vertex3f;
2235         R_Mesh_State(&m);
2236         qglDisable(GL_CULL_FACE);
2237         GL_LockArrays(0, face->num_vertices);
2238         R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
2239         GL_LockArrays(0, 0);
2240         qglEnable(GL_CULL_FACE);
2241 }
2242
2243 void R_Q3BSP_DrawFace(entity_render_t *ent, q3msurface_t *face)
2244 {
2245         if (!face->num_triangles)
2246                 return;
2247         if (face->texture->surfaceflags && (face->texture->surfaceflags & (Q3SURFACEFLAG_SKY | Q3SURFACEFLAG_NODRAW)))
2248                 return;
2249         c_faces++;
2250         if ((face->texture->surfaceparms & Q3SURFACEPARM_TRANS) || ent->alpha < 1 || (ent->effects & EF_ADDITIVE))
2251         {
2252                 vec3_t facecenter, center;
2253                 facecenter[0] = (face->mins[0] + face->maxs[0]) * 0.5f;
2254                 facecenter[1] = (face->mins[1] + face->maxs[1]) * 0.5f;
2255                 facecenter[2] = (face->mins[2] + face->maxs[2]) * 0.5f;
2256                 Matrix4x4_Transform(&ent->matrix, facecenter, center);
2257                 R_MeshQueue_AddTransparent(center, R_Q3BSP_DrawFace_TransparentCallback, ent, face - ent->model->brushq3.data_faces);
2258                 return;
2259         }
2260         R_Mesh_Matrix(&ent->matrix);
2261         if (r_shadow_realtime_world.integer && r_shadow_realtime_world_lightmaps.value <= 0)
2262                 R_Q3BSP_DrawFace_OpaqueWall_Pass_OpaqueGlow(ent, face);
2263         else if ((ent->effects & EF_FULLBRIGHT) || r_fullbright.integer)
2264         {
2265                 R_Q3BSP_DrawFace_OpaqueWall_Pass_Texture(ent, face);
2266                 if (face->texture->skin.glow)
2267                         R_Q3BSP_DrawFace_OpaqueWall_Pass_Glow(ent, face);
2268         }
2269         else if (face->lightmaptexture)
2270         {
2271                 if (gl_lightmaps.integer)
2272                         R_Q3BSP_DrawFace_OpaqueWall_Pass_LightmapOnly(ent, face);
2273                 else
2274                 {
2275                         if (r_textureunits.integer >= 2 && gl_combine.integer)
2276                                 R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureLightmapCombine(ent, face);
2277                         else
2278                         {
2279                                 R_Q3BSP_DrawFace_OpaqueWall_Pass_Texture(ent, face);
2280                                 R_Q3BSP_DrawFace_OpaqueWall_Pass_Lightmap(ent, face);
2281                         }
2282                         if (face->texture->skin.glow)
2283                                 R_Q3BSP_DrawFace_OpaqueWall_Pass_Glow(ent, face);
2284                 }
2285         }
2286         else
2287         {
2288                 if (gl_lightmaps.integer)
2289                         R_Q3BSP_DrawFace_OpaqueWall_Pass_VertexOnly(ent, face);
2290                 else
2291                 {
2292                         R_Q3BSP_DrawFace_OpaqueWall_Pass_TextureVertex(ent, face);
2293                         if (face->texture->skin.glow)
2294                                 R_Q3BSP_DrawFace_OpaqueWall_Pass_Glow(ent, face);
2295                 }
2296         }
2297         if (r_ambient.value)
2298                 R_Q3BSP_DrawFace_OpaqueWall_Pass_AddTextureAmbient(ent, face);
2299 }
2300
2301 void R_Q3BSP_RecursiveWorldNode(q3mnode_t *node)
2302 {
2303         int i;
2304         q3mleaf_t *leaf;
2305         for (;;)
2306         {
2307                 if (R_CullBox(node->mins, node->maxs))
2308                         return;
2309                 if (!node->plane)
2310                         break;
2311                 c_nodes++;
2312                 R_Q3BSP_RecursiveWorldNode(node->children[0]);
2313                 node = node->children[1];
2314         }
2315         leaf = (q3mleaf_t *)node;
2316         if (CHECKPVSBIT(r_pvsbits, leaf->clusterindex))
2317         {
2318                 c_leafs++;
2319                 for (i = 0;i < leaf->numleaffaces;i++)
2320                         leaf->firstleafface[i]->visframe = r_framecount;
2321         }
2322 }
2323
2324 // FIXME: num_leafs needs to be recalculated at load time to include only
2325 // node-referenced leafs, as some maps are incorrectly compiled with leafs for
2326 // the submodels (which would render the submodels occasionally, as part of
2327 // the world - not good)
2328 void R_Q3BSP_MarkLeafPVS(void)
2329 {
2330         int i, j;
2331         q3mleaf_t *leaf;
2332         for (j = 0, leaf = cl.worldmodel->brushq3.data_leafs;j < cl.worldmodel->brushq3.num_leafs;j++, leaf++)
2333         {
2334                 if (CHECKPVSBIT(r_pvsbits, leaf->clusterindex))
2335                 {
2336                         c_leafs++;
2337                         for (i = 0;i < leaf->numleaffaces;i++)
2338                                 leaf->firstleafface[i]->visframe = r_framecount;
2339                 }
2340         }
2341 }
2342
2343 static int r_q3bsp_framecount = -1;
2344
2345 void R_Q3BSP_DrawSky(entity_render_t *ent)
2346 {
2347         int i;
2348         q3msurface_t *face;
2349         vec3_t modelorg;
2350         model_t *model;
2351         R_Mesh_Matrix(&ent->matrix);
2352         model = ent->model;
2353         if (r_drawcollisionbrushes.integer < 2)
2354         {
2355                 Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
2356                 if (ent == &cl_entities[0].render)
2357                 {
2358                         if (r_q3bsp_framecount != r_framecount)
2359                         {
2360                                 r_q3bsp_framecount = r_framecount;
2361                                 R_Q3BSP_RecursiveWorldNode(model->brushq3.data_nodes);
2362                                 //R_Q3BSP_MarkLeafPVS();
2363                         }
2364                         for (i = 0, face = model->brushq3.data_thismodel->firstface;i < model->brushq3.data_thismodel->numfaces;i++, face++)
2365                                 if (face->visframe == r_framecount && (face->texture->surfaceflags & Q3SURFACEFLAG_SKY) && !R_CullBox(face->mins, face->maxs))
2366                                         R_Q3BSP_DrawSkyFace(ent, face);
2367                 }
2368                 else
2369                         for (i = 0, face = model->brushq3.data_thismodel->firstface;i < model->brushq3.data_thismodel->numfaces;i++, face++)
2370                                 if ((face->texture->surfaceflags & Q3SURFACEFLAG_SKY))
2371                                         R_Q3BSP_DrawSkyFace(ent, face);
2372         }
2373 }
2374
2375 void R_Q3BSP_Draw(entity_render_t *ent)
2376 {
2377         int i;
2378         q3msurface_t *face;
2379         vec3_t modelorg;
2380         model_t *model;
2381         qbyte *pvs;
2382         R_Mesh_Matrix(&ent->matrix);
2383         model = ent->model;
2384         if (r_drawcollisionbrushes.integer < 2)
2385         {
2386                 Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
2387                 if (ent == &cl_entities[0].render)
2388                 {
2389                         if (model->brush.num_pvsclusters && !r_novis.integer && (pvs = model->brush.GetPVS(model, modelorg)))
2390                         if (r_q3bsp_framecount != r_framecount)
2391                         {
2392                                 r_q3bsp_framecount = r_framecount;
2393                                 R_Q3BSP_RecursiveWorldNode(model->brushq3.data_nodes);
2394                                 //R_Q3BSP_MarkLeafPVS();
2395                         }
2396                         for (i = 0, face = model->brushq3.data_thismodel->firstface;i < model->brushq3.data_thismodel->numfaces;i++, face++)
2397                                 if (face->visframe == r_framecount && !R_CullBox(face->mins, face->maxs))
2398                                         R_Q3BSP_DrawFace(ent, face);
2399                 }
2400                 else
2401                         for (i = 0, face = model->brushq3.data_thismodel->firstface;i < model->brushq3.data_thismodel->numfaces;i++, face++)
2402                                 R_Q3BSP_DrawFace(ent, face);
2403         }
2404         if (r_drawcollisionbrushes.integer >= 1)
2405         {
2406                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2407                 GL_DepthMask(false);
2408                 GL_DepthTest(true);
2409                 qglPolygonOffset(r_drawcollisionbrushes_polygonfactor.value, r_drawcollisionbrushes_polygonoffset.value);
2410                 for (i = 0;i < model->brushq3.data_thismodel->numbrushes;i++)
2411                         if (model->brushq3.data_thismodel->firstbrush[i].colbrushf && model->brushq3.data_thismodel->firstbrush[i].colbrushf->numtriangles)
2412                                 R_DrawCollisionBrush(model->brushq3.data_thismodel->firstbrush[i].colbrushf);
2413                 for (i = 0, face = model->brushq3.data_thismodel->firstface;i < model->brushq3.data_thismodel->numfaces;i++, face++)
2414                         if (face->num_collisiontriangles)
2415                                 R_Q3BSP_DrawCollisionFace(ent, face);
2416                 qglPolygonOffset(0, 0);
2417         }
2418 }
2419
2420 void R_Q3BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outclusterlist, qbyte *outclusterpvs, int *outnumclusterspointer, int *outsurfacelist, qbyte *outsurfacepvs, int *outnumsurfacespointer)
2421 {
2422         model_t *model = ent->model;
2423         vec3_t lightmins, lightmaxs;
2424         int t, leafindex, marksurfaceindex, surfaceindex, triangleindex, outnumclusters = 0, outnumsurfaces = 0;
2425         const int *e;
2426         const float *v[3];
2427         q3msurface_t *surface;
2428         q3mleaf_t *leaf;
2429         const qbyte *pvs;
2430         lightmins[0] = relativelightorigin[0] - lightradius;
2431         lightmins[1] = relativelightorigin[1] - lightradius;
2432         lightmins[2] = relativelightorigin[2] - lightradius;
2433         lightmaxs[0] = relativelightorigin[0] + lightradius;
2434         lightmaxs[1] = relativelightorigin[1] + lightradius;
2435         lightmaxs[2] = relativelightorigin[2] + lightradius;
2436         *outnumclusterspointer = 0;
2437         *outnumsurfacespointer = 0;
2438         memset(outclusterpvs, 0, model->brush.num_pvsclusterbytes);
2439         memset(outsurfacepvs, 0, (model->nummodelsurfaces + 7) >> 3);
2440         if (model == NULL)
2441         {
2442                 VectorCopy(lightmins, outmins);
2443                 VectorCopy(lightmaxs, outmaxs);
2444                 return;
2445         }
2446         VectorCopy(relativelightorigin, outmins);
2447         VectorCopy(relativelightorigin, outmaxs);
2448         if (model->brush.GetPVS)
2449                 pvs = model->brush.GetPVS(model, relativelightorigin);
2450         else
2451                 pvs = NULL;
2452         // FIXME: use BSP recursion as lights are often small
2453         for (leafindex = 0, leaf = model->brushq3.data_leafs;leafindex < model->brushq3.num_leafs;leafindex++, leaf++)
2454         {
2455                 if (BoxesOverlap(lightmins, lightmaxs, leaf->mins, leaf->maxs) && (pvs == NULL || CHECKPVSBIT(pvs, leaf->clusterindex)))
2456                 {
2457                         outmins[0] = min(outmins[0], leaf->mins[0]);
2458                         outmins[1] = min(outmins[1], leaf->mins[1]);
2459                         outmins[2] = min(outmins[2], leaf->mins[2]);
2460                         outmaxs[0] = max(outmaxs[0], leaf->maxs[0]);
2461                         outmaxs[1] = max(outmaxs[1], leaf->maxs[1]);
2462                         outmaxs[2] = max(outmaxs[2], leaf->maxs[2]);
2463                         if (outclusterpvs)
2464                         {
2465                                 if (!CHECKPVSBIT(outclusterpvs, leaf->clusterindex))
2466                                 {
2467                                         SETPVSBIT(outclusterpvs, leaf->clusterindex);
2468                                         outclusterlist[outnumclusters++] = leaf->clusterindex;
2469                                 }
2470                         }
2471                         if (outsurfacepvs)
2472                         {
2473                                 for (marksurfaceindex = 0;marksurfaceindex < leaf->numleaffaces;marksurfaceindex++)
2474                                 {
2475                                         surface = leaf->firstleafface[marksurfaceindex];
2476                                         surfaceindex = surface - model->brushq3.data_faces;
2477                                         if (!CHECKPVSBIT(outsurfacepvs, surfaceindex))
2478                                         {
2479                                                 if (BoxesOverlap(lightmins, lightmaxs, surface->mins, surface->maxs) && !(surface->texture->surfaceparms & Q3SURFACEPARM_TRANS) && !(surface->texture->surfaceflags & (Q3SURFACEFLAG_SKY | Q3SURFACEFLAG_NODRAW)))
2480                                                 {
2481                                                         for (triangleindex = 0, t = surface->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;triangleindex < surface->num_triangles;triangleindex++, t++, e += 3)
2482                                                         {
2483                                                                 v[0] = model->brush.shadowmesh->vertex3f + e[0] * 3;
2484                                                                 v[1] = model->brush.shadowmesh->vertex3f + e[1] * 3;
2485                                                                 v[2] = model->brush.shadowmesh->vertex3f + e[2] * 3;
2486                                                                 if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
2487                                                                 {
2488                                                                         SETPVSBIT(outsurfacepvs, surfaceindex);
2489                                                                         outsurfacelist[outnumsurfaces++] = surfaceindex;
2490                                                                         break;
2491                                                                 }
2492                                                         }
2493                                                 }
2494                                         }
2495                                 }
2496                         }
2497                 }
2498         }
2499
2500         // limit combined leaf box to light boundaries
2501         outmins[0] = max(outmins[0], lightmins[0]);
2502         outmins[1] = max(outmins[1], lightmins[1]);
2503         outmins[2] = max(outmins[2], lightmins[2]);
2504         outmaxs[0] = min(outmaxs[0], lightmaxs[0]);
2505         outmaxs[1] = min(outmaxs[1], lightmaxs[1]);
2506         outmaxs[2] = min(outmaxs[2], lightmaxs[2]);
2507
2508         *outnumclusterspointer = outnumclusters;
2509         *outnumsurfacespointer = outnumsurfaces;
2510 }
2511
2512 void R_Q3BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist)
2513 {
2514         model_t *model = ent->model;
2515         vec3_t lightmins, lightmaxs;
2516         q3msurface_t *surface;
2517         int surfacelistindex, j, t;
2518         const int *e;
2519         const float *v[3];
2520         if (r_drawcollisionbrushes.integer < 2)
2521         {
2522                 lightmins[0] = relativelightorigin[0] - lightradius;
2523                 lightmins[1] = relativelightorigin[1] - lightradius;
2524                 lightmins[2] = relativelightorigin[2] - lightradius;
2525                 lightmaxs[0] = relativelightorigin[0] + lightradius;
2526                 lightmaxs[1] = relativelightorigin[1] + lightradius;
2527                 lightmaxs[2] = relativelightorigin[2] + lightradius;
2528                 R_Mesh_Matrix(&ent->matrix);
2529                 R_Shadow_PrepareShadowMark(model->brush.shadowmesh->numtriangles);
2530                 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
2531                 {
2532                         surface = model->brushq3.data_faces + surfacelist[surfacelistindex];
2533                         // FIXME: check some manner of face->rendermode here?
2534                         if (!(surface->texture->surfaceflags & Q3SURFACEFLAG_NODRAW) && surface->num_triangles && !surface->texture->skin.fog)
2535                         {
2536                                 for (j = 0, t = surface->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;j < surface->num_triangles;j++, t++, e += 3)
2537                                 {
2538                                         v[0] = model->brush.shadowmesh->vertex3f + e[0] * 3;
2539                                         v[1] = model->brush.shadowmesh->vertex3f + e[1] * 3;
2540                                         v[2] = model->brush.shadowmesh->vertex3f + e[2] * 3;
2541                                         if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
2542                                                 shadowmarklist[numshadowmark++] = t;
2543                                 }
2544                         }
2545                 }
2546                 R_Shadow_VolumeFromList(model->brush.shadowmesh->numverts, model->brush.shadowmesh->numtriangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, model->brush.shadowmesh->neighbor3i, relativelightorigin, lightradius + model->radius + r_shadow_projectdistance.value, numshadowmark, shadowmarklist);
2547         }
2548 }
2549
2550 void R_Q3BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap, int numsurfaces, const int *surfacelist)
2551 {
2552         model_t *model = ent->model;
2553         vec3_t lightmins, lightmaxs, modelorg;
2554         q3msurface_t *surface;
2555         int surfacelistindex;
2556         if (r_drawcollisionbrushes.integer < 2)
2557         {
2558                 lightmins[0] = relativelightorigin[0] - lightradius;
2559                 lightmins[1] = relativelightorigin[1] - lightradius;
2560                 lightmins[2] = relativelightorigin[2] - lightradius;
2561                 lightmaxs[0] = relativelightorigin[0] + lightradius;
2562                 lightmaxs[1] = relativelightorigin[1] + lightradius;
2563                 lightmaxs[2] = relativelightorigin[2] + lightradius;
2564                 R_Mesh_Matrix(&ent->matrix);
2565                 Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
2566                 for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
2567                 {
2568                         surface = model->brushq3.data_faces + surfacelist[surfacelistindex];
2569                         if (r_shadow_compilingrtlight)
2570                         {
2571                                 // if compiling an rtlight, capture the mesh
2572                                 Mod_ShadowMesh_AddMesh(r_shadow_mempool, r_shadow_compilingrtlight->static_meshchain_light, surface->texture->skin.base, surface->texture->skin.gloss, surface->texture->skin.nmap, surface->data_vertex3f, surface->data_svector3f, surface->data_tvector3f, surface->data_normal3f, surface->data_texcoordtexture2f, surface->num_triangles, surface->data_element3i);
2573                         }
2574                         else if ((ent != &cl_entities[0].render || surface->visframe == r_framecount) && !(surface->texture->surfaceflags & Q3SURFACEFLAG_NODRAW) && surface->num_triangles)
2575                                 R_Shadow_RenderLighting(surface->num_vertices, surface->num_triangles, surface->data_element3i, surface->data_vertex3f, surface->data_svector3f, surface->data_tvector3f, surface->data_normal3f, surface->data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, surface->texture->skin.base, surface->texture->skin.nmap, surface->texture->skin.gloss, lightcubemap, LIGHTING_DIFFUSE | LIGHTING_SPECULAR);
2576                 }
2577         }
2578 }
2579
2580 static void gl_surf_start(void)
2581 {
2582 }
2583
2584 static void gl_surf_shutdown(void)
2585 {
2586 }
2587
2588 static void gl_surf_newmap(void)
2589 {
2590 }
2591
2592 void GL_Surf_Init(void)
2593 {
2594         int i;
2595         dlightdivtable[0] = 4194304;
2596         for (i = 1;i < 32768;i++)
2597                 dlightdivtable[i] = 4194304 / (i << 7);
2598
2599         Cvar_RegisterVariable(&r_ambient);
2600         Cvar_RegisterVariable(&r_drawportals);
2601         Cvar_RegisterVariable(&r_testvis);
2602         Cvar_RegisterVariable(&r_floatbuildlightmap);
2603         Cvar_RegisterVariable(&r_detailtextures);
2604         Cvar_RegisterVariable(&r_surfaceworldnode);
2605         Cvar_RegisterVariable(&r_drawcollisionbrushes_polygonfactor);
2606         Cvar_RegisterVariable(&r_drawcollisionbrushes_polygonoffset);
2607         Cvar_RegisterVariable(&r_q3bsp_renderskydepth);
2608         Cvar_RegisterVariable(&gl_lightmaps);
2609
2610         R_RegisterModule("GL_Surf", gl_surf_start, gl_surf_shutdown, gl_surf_newmap);
2611 }
2612