got rid of buildnumber.c and buildnum program, now uses builddate.c (touched each...
[divverent/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
24 #define MAX_LIGHTMAP_SIZE 256
25
26 static signed int blocklights[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*3]; // LordHavoc: *3 for colored lighting
27
28 static byte templight[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*4];
29
30 cvar_t r_ambient = {0, "r_ambient", "0"};
31 cvar_t r_vertexsurfaces = {0, "r_vertexsurfaces", "0"};
32 cvar_t r_dlightmap = {CVAR_SAVE, "r_dlightmap", "1"};
33 cvar_t r_drawportals = {0, "r_drawportals", "0"};
34 cvar_t r_testvis = {0, "r_testvis", "0"};
35
36 static void gl_surf_start(void)
37 {
38 }
39
40 static void gl_surf_shutdown(void)
41 {
42 }
43
44 static void gl_surf_newmap(void)
45 {
46 }
47
48 static int dlightdivtable[32768];
49
50 void GL_Surf_Init(void)
51 {
52         int i;
53         if (!dlightdivtable[1])
54         {
55                 dlightdivtable[0] = 4194304;
56                 for (i = 1;i < 32768;i++)
57                         dlightdivtable[i] = 4194304 / (i << 7);
58         }
59
60         Cvar_RegisterVariable(&r_ambient);
61         Cvar_RegisterVariable(&r_vertexsurfaces);
62         Cvar_RegisterVariable(&r_dlightmap);
63         Cvar_RegisterVariable(&r_drawportals);
64         Cvar_RegisterVariable(&r_testvis);
65
66         R_RegisterModule("GL_Surf", gl_surf_start, gl_surf_shutdown, gl_surf_newmap);
67 }
68
69 static int R_AddDynamicLights (msurface_t *surf)
70 {
71         int         sdtable[256], lnum, td, maxdist, maxdist2, maxdist3, i, s, t, smax, tmax, smax3, red, green, blue, lit, dist2, impacts, impactt, subtract;
72         unsigned int *bl;
73         float       dist;
74         vec3_t      impact, local;
75
76         // LordHavoc: use 64bit integer...  shame it's not very standardized...
77 #if _MSC_VER || __BORLANDC__
78         __int64     k;
79 #else
80         long long   k;
81 #endif
82
83         lit = false;
84
85         smax = (surf->extents[0] >> 4) + 1;
86         tmax = (surf->extents[1] >> 4) + 1;
87
88         for (lnum = 0; lnum < r_numdlights; lnum++)
89         {
90                 if (!(surf->dlightbits[lnum >> 5] & (1 << (lnum & 31))))
91                         continue;                                       // not lit by this light
92
93                 softwareuntransform(r_dlight[lnum].origin, local);
94 //              VectorSubtract (r_dlight[lnum].origin, currentrenderentity->origin, local);
95                 dist = DotProduct (local, surf->plane->normal) - surf->plane->dist;
96
97                 // for comparisons to minimum acceptable light
98                 // compensate for LIGHTOFFSET
99                 maxdist = (int) r_dlight[lnum].cullradius2 + LIGHTOFFSET;
100
101                 // already clamped, skip this
102                 // clamp radius to avoid exceeding 32768 entry division table
103                 //if (maxdist > 4194304)
104                 //      maxdist = 4194304;
105
106                 dist2 = dist * dist;
107                 dist2 += LIGHTOFFSET;
108                 if (dist2 >= maxdist)
109                         continue;
110
111                 impact[0] = local[0] - surf->plane->normal[0] * dist;
112                 impact[1] = local[1] - surf->plane->normal[1] * dist;
113                 impact[2] = local[2] - surf->plane->normal[2] * dist;
114
115                 impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
116                 impactt = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
117
118                 s = bound(0, impacts, smax * 16) - impacts;
119                 t = bound(0, impactt, tmax * 16) - impactt;
120                 i = s * s + t * t + dist2;
121                 if (i > maxdist)
122                         continue;
123
124                 // reduce calculations
125                 for (s = 0, i = impacts; s < smax; s++, i -= 16)
126                         sdtable[s] = i * i + dist2;
127
128                 maxdist3 = maxdist - dist2;
129
130                 // convert to 8.8 blocklights format
131                 red = r_dlight[lnum].light[0];
132                 green = r_dlight[lnum].light[1];
133                 blue = r_dlight[lnum].light[2];
134                 subtract = (int) (r_dlight[lnum].lightsubtract * 4194304.0f);
135                 bl = blocklights;
136                 smax3 = smax * 3;
137
138                 i = impactt;
139                 for (t = 0;t < tmax;t++, i -= 16)
140                 {
141                         td = i * i;
142                         // make sure some part of it is visible on this line
143                         if (td < maxdist3)
144                         {
145                                 maxdist2 = maxdist - td;
146                                 for (s = 0;s < smax;s++)
147                                 {
148                                         if (sdtable[s] < maxdist2)
149                                         {
150                                                 k = dlightdivtable[(sdtable[s] + td) >> 7] - subtract;
151                                                 if (k > 0)
152                                                 {
153                                                         bl[0] += (red   * k) >> 8;
154                                                         bl[1] += (green * k) >> 8;
155                                                         bl[2] += (blue  * k) >> 8;
156                                                         lit = true;
157                                                 }
158                                         }
159                                         bl += 3;
160                                 }
161                         }
162                         else // skip line
163                                 bl += smax3;
164                 }
165         }
166         return lit;
167 }
168
169 void R_StainNode (mnode_t *node, model_t *model, vec3_t origin, float radius, int icolor[8])
170 {
171         float ndist;
172         msurface_t *surf, *endsurf;
173         int sdtable[256], td, maxdist, maxdist2, maxdist3, i, s, t, smax, tmax, smax3, dist2, impacts, impactt, subtract, a, stained, cr, cg, cb, ca, ratio;
174         byte *bl;
175         vec3_t impact;
176         // LordHavoc: use 64bit integer...  shame it's not very standardized...
177 #if _MSC_VER || __BORLANDC__
178         __int64     k;
179 #else
180         long long   k;
181 #endif
182
183
184         // for comparisons to minimum acceptable light
185         // compensate for 4096 offset
186         maxdist = radius * radius + 4096;
187
188         // clamp radius to avoid exceeding 32768 entry division table
189         if (maxdist > 4194304)
190                 maxdist = 4194304;
191
192         subtract = (int) ((1.0f / maxdist) * 4194304.0f);
193
194 loc0:
195         if (node->contents < 0)
196                 return;
197         ndist = PlaneDiff(origin, node->plane);
198         if (ndist > radius)
199         {
200                 node = node->children[0];
201                 goto loc0;
202         }
203         if (ndist < -radius)
204         {
205                 node = node->children[1];
206                 goto loc0;
207         }
208
209         dist2 = ndist * ndist;
210         dist2 += 4096.0f;
211         if (dist2 < maxdist)
212         {
213                 maxdist3 = maxdist - dist2;
214
215                 impact[0] = origin[0] - node->plane->normal[0] * ndist;
216                 impact[1] = origin[1] - node->plane->normal[1] * ndist;
217                 impact[2] = origin[2] - node->plane->normal[2] * ndist;
218
219                 for (surf = model->surfaces + node->firstsurface, endsurf = surf + node->numsurfaces;surf < endsurf;surf++)
220                 {
221                         if (surf->stainsamples)
222                         {
223                                 smax = (surf->extents[0] >> 4) + 1;
224                                 tmax = (surf->extents[1] >> 4) + 1;
225
226                                 impacts = DotProduct (impact, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3] - surf->texturemins[0];
227                                 impactt = DotProduct (impact, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3] - surf->texturemins[1];
228
229                                 s = bound(0, impacts, smax * 16) - impacts;
230                                 t = bound(0, impactt, tmax * 16) - impactt;
231                                 i = s * s + t * t + dist2;
232                                 if (i > maxdist)
233                                         continue;
234
235                                 // reduce calculations
236                                 for (s = 0, i = impacts; s < smax; s++, i -= 16)
237                                         sdtable[s] = i * i + dist2;
238
239                                 // convert to 8.8 blocklights format
240                                 bl = surf->stainsamples;
241                                 smax3 = smax * 3;
242                                 stained = false;
243
244                                 i = impactt;
245                                 for (t = 0;t < tmax;t++, i -= 16)
246                                 {
247                                         td = i * i;
248                                         // make sure some part of it is visible on this line
249                                         if (td < maxdist3)
250                                         {
251                                                 maxdist2 = maxdist - td;
252                                                 for (s = 0;s < smax;s++)
253                                                 {
254                                                         if (sdtable[s] < maxdist2)
255                                                         {
256                                                                 k = dlightdivtable[(sdtable[s] + td) >> 7] - subtract;
257                                                                 if (k > 0)
258                                                                 {
259                                                                         ratio = rand() & 255;
260                                                                         ca = (((icolor[7] - icolor[3]) * ratio) >> 8) + icolor[3];
261                                                                         a = (ca * k) >> 8;
262                                                                         if (a > 0)
263                                                                         {
264                                                                                 a = bound(0, a, 256);
265                                                                                 cr = (((icolor[4] - icolor[0]) * ratio) >> 8) + icolor[0];
266                                                                                 cg = (((icolor[5] - icolor[1]) * ratio) >> 8) + icolor[1];
267                                                                                 cb = (((icolor[6] - icolor[2]) * ratio) >> 8) + icolor[2];
268                                                                                 bl[0] = (byte) ((((cr - (int) bl[0]) * a) >> 8) + (int) bl[0]);
269                                                                                 bl[1] = (byte) ((((cg - (int) bl[1]) * a) >> 8) + (int) bl[1]);
270                                                                                 bl[2] = (byte) ((((cb - (int) bl[2]) * a) >> 8) + (int) bl[2]);
271                                                                                 stained = true;
272                                                                         }
273                                                                 }
274                                                         }
275                                                         bl += 3;
276                                                 }
277                                         }
278                                         else // skip line
279                                                 bl += smax3;
280                                 }
281                                 // force lightmap upload
282                                 if (stained)
283                                         surf->cached_dlight = true;
284                         }
285                 }
286         }
287
288         if (node->children[0]->contents >= 0)
289         {
290                 if (node->children[1]->contents >= 0)
291                 {
292                         R_StainNode(node->children[0], model, origin, radius, icolor);
293                         node = node->children[1];
294                         goto loc0;
295                 }
296                 else
297                 {
298                         node = node->children[0];
299                         goto loc0;
300                 }
301         }
302         else if (node->children[1]->contents >= 0)
303         {
304                 node = node->children[1];
305                 goto loc0;
306         }
307 }
308
309 void R_Stain (vec3_t origin, float radius, int cr1, int cg1, int cb1, int ca1, int cr2, int cg2, int cb2, int ca2)
310 {
311         int n, icolor[8];
312         entity_render_t *ent;
313         model_t *model;
314         vec3_t org;
315         icolor[0] = cr1;
316         icolor[1] = cg1;
317         icolor[2] = cb1;
318         icolor[3] = ca1;
319         icolor[4] = cr2;
320         icolor[5] = cg2;
321         icolor[6] = cb2;
322         icolor[7] = ca2;
323
324         model = cl.worldmodel;
325         softwaretransformidentity();
326         R_StainNode(model->nodes + model->hulls[0].firstclipnode, model, origin, radius, icolor);
327
328         // look for embedded bmodels
329         for (n = 1;n < MAX_EDICTS;n++)
330         {
331                 ent = &cl_entities[n].render;
332                 model = ent->model;
333                 if (model && model->name[0] == '*')
334                 {
335                         Mod_CheckLoaded(model);
336                         if (model->type == mod_brush)
337                         {
338                                 softwaretransformforentity(ent);
339                                 softwareuntransform(origin, org);
340                                 R_StainNode(model->nodes + model->hulls[0].firstclipnode, model, org, radius, icolor);
341                         }
342                 }
343         }
344 }
345
346 /*
347 ===============
348 R_BuildLightMap
349
350 Combine and scale multiple lightmaps into the 8.8 format in blocklights
351 ===============
352 */
353 static void R_BuildLightMap (msurface_t *surf, int dlightchanged)
354 {
355         int             smax, tmax, i, j, size, size3, shift, scale, maps, *bl, stride, l;
356         byte    *lightmap, *out, *stain;
357
358         // update cached lighting info
359         surf->cached_dlight = 0;
360         surf->cached_lightscalebit = lightscalebit;
361         surf->cached_ambient = r_ambient.value;
362         surf->cached_light[0] = d_lightstylevalue[surf->styles[0]];
363         surf->cached_light[1] = d_lightstylevalue[surf->styles[1]];
364         surf->cached_light[2] = d_lightstylevalue[surf->styles[2]];
365         surf->cached_light[3] = d_lightstylevalue[surf->styles[3]];
366
367         smax = (surf->extents[0]>>4)+1;
368         tmax = (surf->extents[1]>>4)+1;
369         size = smax*tmax;
370         size3 = size*3;
371         lightmap = surf->samples;
372
373 // set to full bright if no light data
374         if ((currentrenderentity->effects & EF_FULLBRIGHT) || !cl.worldmodel->lightdata)
375         {
376                 bl = blocklights;
377                 for (i = 0;i < size;i++)
378                 {
379                         *bl++ = 255*256;
380                         *bl++ = 255*256;
381                         *bl++ = 255*256;
382                 }
383         }
384         else
385         {
386 // clear to no light
387                 j = r_ambient.value * 512.0f; // would be 256.0f logically, but using 512.0f to match winquake style
388                 if (j)
389                 {
390                         bl = blocklights;
391                         for (i = 0;i < size3;i++)
392                                 *bl++ = j;
393                 }
394                 else
395                         memset(&blocklights[0], 0, size*3*sizeof(int));
396
397                 if (surf->dlightframe == r_framecount && r_dlightmap.integer)
398                 {
399                         surf->cached_dlight = R_AddDynamicLights(surf);
400                         if (surf->cached_dlight)
401                                 c_light_polys++;
402                         else if (dlightchanged)
403                                 return; // don't upload if only updating dlights and none mattered
404                 }
405
406 // add all the lightmaps
407                 if (lightmap)
408                         for (maps = 0;maps < MAXLIGHTMAPS && surf->styles[maps] != 255;maps++)
409                                 for (scale = d_lightstylevalue[surf->styles[maps]], bl = blocklights, i = 0;i < size3;i++)
410                                         *bl++ += *lightmap++ * scale;
411         }
412
413         stain = surf->stainsamples;
414         if (stain)
415                 for (bl = blocklights, i = 0;i < size3;i++)
416                         if (stain[i] < 255)
417                                 bl[i] = (bl[i] * stain[i]) >> 8;
418
419         bl = blocklights;
420         out = templight;
421         // deal with lightmap brightness scale
422         shift = 7 + lightscalebit;
423         if (currentrenderentity->model->lightmaprgba)
424         {
425                 stride = (surf->lightmaptexturestride - smax) * 4;
426                 for (i = 0;i < tmax;i++, out += stride)
427                 {
428                         for (j = 0;j < smax;j++)
429                         {
430                                 l = *bl++ >> shift;*out++ = min(l, 255);
431                                 l = *bl++ >> shift;*out++ = min(l, 255);
432                                 l = *bl++ >> shift;*out++ = min(l, 255);
433                                 *out++ = 255;
434                         }
435                 }
436         }
437         else
438         {
439                 stride = (surf->lightmaptexturestride - smax) * 3;
440                 for (i = 0;i < tmax;i++, out += stride)
441                 {
442                         for (j = 0;j < smax;j++)
443                         {
444                                 l = *bl++ >> shift;*out++ = min(l, 255);
445                                 l = *bl++ >> shift;*out++ = min(l, 255);
446                                 l = *bl++ >> shift;*out++ = min(l, 255);
447                         }
448                 }
449         }
450
451         R_UpdateTexture(surf->lightmaptexture, templight);
452 }
453
454 /*
455 ===============
456 R_TextureAnimation
457
458 Returns the proper texture for a given time and base texture
459 ===============
460 */
461 /*
462 // note: this was manually inlined in R_PrepareSurfaces
463 static texture_t *R_TextureAnimation (texture_t *base)
464 {
465         if (currentrenderentity->frame && base->alternate_anims != NULL)
466                 base = base->alternate_anims;
467
468         if (base->anim_total < 2)
469                 return base;
470
471         return base->anim_frames[(int)(cl.time * 5.0f) % base->anim_total];
472 }
473 */
474
475
476 /*
477 =============================================================
478
479         BRUSH MODELS
480
481 =============================================================
482 */
483
484
485 static float turbsin[256] =
486 {
487         #include "gl_warp_sin.h"
488 };
489 #define TURBSCALE (256.0 / (2 * M_PI))
490
491 #define MAX_SURFVERTS 1024
492 typedef struct
493 {
494         float v[4];
495         float st[2];
496         float uv[2];
497         float c[4];
498 }
499 surfvert_t;
500 static surfvert_t svert[MAX_SURFVERTS]; // used by the following functions
501
502 static int RSurfShader_Sky(int stage, msurface_t *s)
503 {
504         int                             i;
505         float                   number, length, dir[3], speedscale;
506         surfvertex_t    *v;
507         surfvert_t              *sv;
508         rmeshinfo_t             m;
509
510         // LordHavoc: HalfLife maps have freaky skypolys...
511         if (currentrenderentity->model->ishlbsp)
512                 return true;
513
514         if (stage == 0)
515         {
516                 if (skyrendermasked)
517                 {
518                         if (skyrendernow)
519                         {
520                                 skyrendernow = false;
521                                 R_Sky();
522                         }
523                         // draw depth-only polys
524                         memset(&m, 0, sizeof(m));
525                         m.transparent = false;
526                         m.blendfunc1 = GL_ZERO;
527                         m.blendfunc2 = GL_ONE;
528                         m.depthwrite = true;
529                         m.numtriangles = s->mesh.numtriangles;
530                         m.numverts = s->mesh.numverts;
531                         m.index = s->mesh.index;
532                         //m.cr = 0;
533                         //m.cg = 0;
534                         //m.cb = 0;
535                         //m.ca = 0;
536                         if (softwaretransform_complexity)
537                         {
538                                 m.vertex = &svert[0].v[0];
539                                 m.vertexstep = sizeof(surfvert_t);
540                                 for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
541                                         softwaretransform(v->v, sv->v);
542                         }
543                         else
544                         {
545                                 m.vertex = &s->mesh.vertex[0].v[0];
546                                 m.vertexstep = sizeof(surfvertex_t);
547                         }
548                         R_Mesh_Draw(&m);
549                 }
550                 else if (skyrenderglquake)
551                 {
552                         memset(&m, 0, sizeof(m));
553                         m.transparent = false;
554                         m.blendfunc1 = GL_ONE;
555                         m.blendfunc2 = GL_ZERO;
556                         m.numtriangles = s->mesh.numtriangles;
557                         m.numverts = s->mesh.numverts;
558                         m.index = s->mesh.index;
559                         m.vertex = &svert[0].v[0];
560                         m.vertexstep = sizeof(surfvert_t);
561                         m.cr = 1;
562                         m.cg = 1;
563                         m.cb = 1;
564                         m.ca = 1;
565                         if (r_mergesky.integer)
566                                 m.tex[0] = R_GetTexture(mergeskytexture);
567                         else
568                                 m.tex[0] = R_GetTexture(solidskytexture);
569                         m.texcoords[0] = &svert[0].st[0];
570                         m.texcoordstep[0] = sizeof(surfvert_t);
571                         speedscale = cl.time * (8.0/128.0);
572                         speedscale -= (int)speedscale;
573                         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
574                         {
575                                 softwaretransform(v->v, sv->v);
576                                 VectorSubtract (sv->v, r_origin, dir);
577                                 // flatten the sphere
578                                 dir[2] *= 3;
579
580                                 number = DotProduct(dir, dir);
581                                 #if SLOWMATH
582                                 length = 3.0f / sqrt(number);
583                                 #else
584                                 *((long *)&length) = 0x5f3759df - ((* (long *) &number) >> 1);
585                                 length = 3.0f * (length * (1.5f - (number * 0.5f * length * length)));
586                                 #endif
587
588                                 sv->st[0] = speedscale + dir[0] * length;
589                                 sv->st[1] = speedscale + dir[1] * length;
590                         }
591                         R_Mesh_Draw(&m);
592                 }
593                 else
594                 {
595                         // flat color
596                         memset(&m, 0, sizeof(m));
597                         m.transparent = false;
598                         m.blendfunc1 = GL_ONE;
599                         m.blendfunc2 = GL_ZERO;
600                         m.numtriangles = s->mesh.numtriangles;
601                         m.numverts = s->mesh.numverts;
602                         m.index = s->mesh.index;
603                         m.cr = fogcolor[0];
604                         m.cg = fogcolor[1];
605                         m.cb = fogcolor[2];
606                         m.ca = 1;
607                         if (softwaretransform_complexity)
608                         {
609                                 m.vertex = &svert[0].v[0];
610                                 m.vertexstep = sizeof(surfvert_t);
611                                 for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
612                                         softwaretransform(v->v, sv->v);
613                         }
614                         else
615                         {
616                                 m.vertex = &s->mesh.vertex[0].v[0];
617                                 m.vertexstep = sizeof(surfvertex_t);
618                         }
619                         R_Mesh_Draw(&m);
620                 }
621                 return false;
622         }
623         else if (stage == 1)
624         {
625                 if (skyrenderglquake && !r_mergesky.integer)
626                 {
627                         memset(&m, 0, sizeof(m));
628                         m.transparent = false;
629                         m.blendfunc1 = GL_SRC_ALPHA;
630                         m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
631                         m.numtriangles = s->mesh.numtriangles;
632                         m.numverts = s->mesh.numverts;
633                         m.index = s->mesh.index;
634                         m.vertex = &svert[0].v[0];
635                         m.vertexstep = sizeof(surfvert_t);
636                         m.cr = 1;
637                         m.cg = 1;
638                         m.cb = 1;
639                         m.ca = 1;
640                         m.tex[0] = R_GetTexture(alphaskytexture);
641                         m.texcoords[0] = &svert[0].st[0];
642                         m.texcoordstep[0] = sizeof(surfvert_t);
643                         speedscale = cl.time * (16.0/128.0);
644                         speedscale -= (int)speedscale;
645                         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
646                         {
647                                 softwaretransform(v->v, sv->v);
648                                 VectorSubtract (sv->v, r_origin, dir);
649                                 // flatten the sphere
650                                 dir[2] *= 3;
651
652                                 number = DotProduct(dir, dir);
653                                 #if SLOWMATH
654                                 length = 3.0f / sqrt(number);
655                                 #else
656                                 *((long *)&length) = 0x5f3759df - ((* (long *) &number) >> 1);
657                                 length = 3.0f * (length * (1.5f - (number * 0.5f * length * length)));
658                                 #endif
659
660                                 sv->st[0] = speedscale + dir[0] * length;
661                                 sv->st[1] = speedscale + dir[1] * length;
662                         }
663                         R_Mesh_Draw(&m);
664                         return false;
665                 }
666                 return true;
667         }
668         else
669                 return true;
670 }
671
672 static int RSurf_Light(int *dlightbits, int numverts)
673 {
674         float           f;
675         int                     i, l, lit = false;
676         rdlight_t       *rd;
677         vec3_t          lightorigin;
678         surfvert_t      *sv;
679         for (l = 0;l < r_numdlights;l++)
680         {
681                 if (dlightbits[l >> 5] & (1 << (l & 31)))
682                 {
683                         rd = &r_dlight[l];
684                         // FIXME: support softwareuntransform here and make bmodels use hardware transform?
685                         VectorCopy(rd->origin, lightorigin);
686                         for (i = 0, sv = svert;i < numverts;i++, sv++)
687                         {
688                                 f = VectorDistance2(sv->v, lightorigin) + LIGHTOFFSET;
689                                 if (f < rd->cullradius2)
690                                 {
691                                         f = (1.0f / f) - rd->lightsubtract;
692                                         sv->c[0] += rd->light[0] * f;
693                                         sv->c[1] += rd->light[1] * f;
694                                         sv->c[2] += rd->light[2] * f;
695                                         lit = true;
696                                 }
697                         }
698                 }
699         }
700         return lit;
701 }
702
703 static void RSurfShader_Water_Pass_Base(msurface_t *s)
704 {
705         int                             i;
706         float                   diff[3], alpha, ifog;
707         surfvertex_t    *v;
708         surfvert_t              *sv;
709         rmeshinfo_t             m;
710         alpha = currentrenderentity->alpha * (s->flags & SURF_DRAWNOALPHA ? 1 : r_wateralpha.value);
711
712         memset(&m, 0, sizeof(m));
713         if (alpha != 1 || s->currenttexture->fogtexture != NULL)
714         {
715                 m.transparent = true;
716                 m.blendfunc1 = GL_SRC_ALPHA;
717                 m.blendfunc2 = GL_ONE; //_MINUS_SRC_ALPHA;
718         }
719         else
720         {
721                 m.transparent = false;
722                 m.blendfunc1 = GL_ONE;
723                 m.blendfunc2 = GL_ZERO;
724         }
725         m.numtriangles = s->mesh.numtriangles;
726         m.numverts = s->mesh.numverts;
727         m.index = s->mesh.index;
728         m.vertex = &svert[0].v[0];
729         m.vertexstep = sizeof(surfvert_t);
730         m.color = &svert[0].c[0];
731         m.colorstep = sizeof(surfvert_t);
732         m.tex[0] = R_GetTexture(s->currenttexture->texture);
733         m.texcoords[0] = &svert[0].st[0];
734         m.texcoordstep[0] = sizeof(surfvert_t);
735         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
736         {
737                 softwaretransform(v->v, sv->v);
738                 if (r_waterripple.value)
739                         sv->v[2] += r_waterripple.value * (1.0f / 64.0f) * turbsin[(int)((v->v[0]*(1.0f/32.0f)+cl.time) * TURBSCALE) & 255] * turbsin[(int)((v->v[1]*(1.0f/32.0f)+cl.time) * TURBSCALE) & 255];
740                 if (s->flags & SURF_DRAWFULLBRIGHT)
741                 {
742                         sv->c[0] = 1;
743                         sv->c[1] = 1;
744                         sv->c[2] = 1;
745                         sv->c[3] = alpha;
746                 }
747                 else
748                 {
749                         sv->c[0] = 0.5f;
750                         sv->c[1] = 0.5f;
751                         sv->c[2] = 0.5f;
752                         sv->c[3] = alpha;
753                 }
754                 sv->st[0] = (v->st[0] + turbsin[(int)((v->st[1]*0.125f+cl.time) * TURBSCALE) & 255]) * (1.0f / 64.0f);
755                 sv->st[1] = (v->st[1] + turbsin[(int)((v->st[0]*0.125f+cl.time) * TURBSCALE) & 255]) * (1.0f / 64.0f);
756         }
757         if (s->dlightframe == r_framecount && !(s->flags & SURF_DRAWFULLBRIGHT))
758                 RSurf_Light(s->dlightbits, m.numverts);
759         if (fogenabled/* && m.blendfunc2 == GL_ONE_MINUS_SRC_ALPHA*/)
760         {
761                 for (i = 0, sv = svert;i < m.numverts;i++, sv++)
762                 {
763                         VectorSubtract(sv->v, r_origin, diff);
764                         ifog = 1 - exp(fogdensity/DotProduct(diff, diff));
765                         sv->c[0] *= ifog;
766                         sv->c[1] *= ifog;
767                         sv->c[2] *= ifog;
768                 }
769         }
770         R_Mesh_Draw(&m);
771 }
772
773 static void RSurfShader_Water_Pass_Glow(msurface_t *s)
774 {
775         int                             i;
776         float                   diff[3], alpha, ifog;
777         surfvertex_t    *v;
778         surfvert_t              *sv;
779         rmeshinfo_t             m;
780         alpha = currentrenderentity->alpha * (s->flags & SURF_DRAWNOALPHA ? 1 : r_wateralpha.value);
781
782         memset(&m, 0, sizeof(m));
783         m.transparent = alpha != 1 || s->currenttexture->fogtexture != NULL;
784         m.blendfunc1 = GL_SRC_ALPHA;
785         m.blendfunc2 = GL_ONE;
786         m.numtriangles = s->mesh.numtriangles;
787         m.numverts = s->mesh.numverts;
788         m.index = s->mesh.index;
789         m.vertex = &svert[0].v[0];
790         m.vertexstep = sizeof(surfvert_t);
791         m.cr = 1;
792         m.cg = 1;
793         m.cb = 1;
794         m.ca = alpha;
795         m.tex[0] = R_GetTexture(s->currenttexture->glowtexture);
796         m.texcoords[0] = &svert[0].st[0];
797         m.texcoordstep[0] = sizeof(surfvert_t);
798         if (fogenabled)
799         {
800                 m.color = &svert[0].c[0];
801                 m.colorstep = sizeof(surfvert_t);
802                 for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
803                 {
804                         softwaretransform(v->v, sv->v);
805                         if (r_waterripple.value)
806                                 sv->v[2] += r_waterripple.value * (1.0f / 64.0f) * turbsin[(int)((v->v[0]*(1.0f/32.0f)+cl.time) * TURBSCALE) & 255] * turbsin[(int)((v->v[1]*(1.0f/32.0f)+cl.time) * TURBSCALE) & 255];
807                         sv->st[0] = (v->st[0] + turbsin[(int)((v->st[1]*0.125f+cl.time) * TURBSCALE) & 255]) * (1.0f / 64.0f);
808                         sv->st[1] = (v->st[1] + turbsin[(int)((v->st[0]*0.125f+cl.time) * TURBSCALE) & 255]) * (1.0f / 64.0f);
809                         VectorSubtract(sv->v, r_origin, diff);
810                         ifog = 1 - exp(fogdensity/DotProduct(diff, diff));
811                         sv->c[0] = m.cr * ifog;
812                         sv->c[1] = m.cg * ifog;
813                         sv->c[2] = m.cb * ifog;
814                         sv->c[3] = m.ca;
815                 }
816         }
817         else
818         {
819                 for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
820                 {
821                         softwaretransform(v->v, sv->v);
822                         if (r_waterripple.value)
823                                 sv->v[2] += r_waterripple.value * (1.0f / 64.0f) * turbsin[(int)((v->v[0]*(1.0f/32.0f)+cl.time) * TURBSCALE) & 255] * turbsin[(int)((v->v[1]*(1.0f/32.0f)+cl.time) * TURBSCALE) & 255];
824                         sv->st[0] = (v->st[0] + turbsin[(int)((v->st[1]*0.125f+cl.time) * TURBSCALE) & 255]) * (1.0f / 64.0f);
825                         sv->st[1] = (v->st[1] + turbsin[(int)((v->st[0]*0.125f+cl.time) * TURBSCALE) & 255]) * (1.0f / 64.0f);
826                 }
827         }
828         R_Mesh_Draw(&m);
829 }
830
831 static void RSurfShader_Water_Pass_Fog(msurface_t *s)
832 {
833         int                             i;
834         float                   alpha;
835         surfvertex_t    *v;
836         surfvert_t              *sv;
837         rmeshinfo_t             m;
838         vec3_t                  diff;
839         alpha = currentrenderentity->alpha * (s->flags & SURF_DRAWNOALPHA ? 1 : r_wateralpha.value);
840
841         memset(&m, 0, sizeof(m));
842         m.transparent = alpha != 1 || s->currenttexture->fogtexture != NULL;
843         m.blendfunc1 = GL_SRC_ALPHA;
844         m.blendfunc2 = GL_ONE;
845         m.numtriangles = s->mesh.numtriangles;
846         m.numverts = s->mesh.numverts;
847         m.index = s->mesh.index;
848         m.vertex = &svert[0].v[0];
849         m.vertexstep = sizeof(surfvert_t);
850         m.color = &svert[0].c[0];
851         m.colorstep = sizeof(surfvert_t);
852         m.tex[0] = R_GetTexture(s->currenttexture->fogtexture);
853         m.texcoords[0] = &svert[0].st[0];
854         m.texcoordstep[0] = sizeof(surfvert_t);
855
856         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
857         {
858                 softwaretransform(v->v, sv->v);
859                 if (r_waterripple.value)
860                         sv->v[2] += r_waterripple.value * (1.0f / 64.0f) * turbsin[(int)((v->v[0]*(1.0f/32.0f)+cl.time) * TURBSCALE) & 255] * turbsin[(int)((v->v[1]*(1.0f/32.0f)+cl.time) * TURBSCALE) & 255];
861                 if (m.tex[0])
862                 {
863                         sv->st[0] = (v->st[0] + turbsin[(int)((v->st[1]*0.125f+cl.time) * TURBSCALE) & 255]) * (1.0f / 64.0f);
864                         sv->st[1] = (v->st[1] + turbsin[(int)((v->st[0]*0.125f+cl.time) * TURBSCALE) & 255]) * (1.0f / 64.0f);
865                 }
866                 VectorSubtract(sv->v, r_origin, diff);
867                 sv->c[0] = fogcolor[0];
868                 sv->c[1] = fogcolor[1];
869                 sv->c[2] = fogcolor[2];
870                 sv->c[3] = alpha * exp(fogdensity/DotProduct(diff, diff));
871         }
872         R_Mesh_Draw(&m);
873 }
874
875 static int RSurfShader_Water(int stage, msurface_t *s)
876 {
877         switch(stage)
878         {
879         case 0:
880                 RSurfShader_Water_Pass_Base(s);
881                 return false;
882         case 1:
883                 if (s->currenttexture->glowtexture)
884                         RSurfShader_Water_Pass_Glow(s);
885                 return false;
886         case 2:
887                 if (fogenabled && (s->flags & SURF_DRAWNOALPHA))
888                 {
889                         RSurfShader_Water_Pass_Fog(s);
890                         return false;
891                 }
892                 else
893                         return true;
894         default:
895                 return true;
896         }
897 }
898
899 static void RSurfShader_Wall_Pass_BaseMTex(msurface_t *s)
900 {
901         int                             i;
902         float                   diff[3], ifog;
903         surfvertex_t    *v;
904         surfvert_t              *sv;
905         rmeshinfo_t             m;
906
907         memset(&m, 0, sizeof(m));
908         if (currentrenderentity->effects & EF_ADDITIVE)
909         {
910                 m.transparent = true;
911                 m.blendfunc1 = GL_SRC_ALPHA;
912                 m.blendfunc2 = GL_ONE;
913         }
914         else if (s->currenttexture->fogtexture != NULL || currentrenderentity->alpha != 1)
915         {
916                 m.transparent = true;
917                 m.blendfunc1 = GL_SRC_ALPHA;
918                 m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
919         }
920         else
921         {
922                 m.transparent = false;
923                 m.blendfunc1 = GL_ONE;
924                 m.blendfunc2 = GL_ZERO;
925         }
926         m.numtriangles = s->mesh.numtriangles;
927         m.numverts = s->mesh.numverts;
928         m.index = s->mesh.index;
929         m.cr = 1;
930         if (lighthalf)
931                 m.cr *= 2;
932         if (gl_combine.integer)
933                 m.cr *= 4;
934         m.cg = m.cr;
935         m.cb = m.cr;
936         m.ca = currentrenderentity->alpha;
937         m.tex[0] = R_GetTexture(s->currenttexture->texture);
938         m.tex[1] = R_GetTexture(s->lightmaptexture);
939         m.texcoords[0] = &s->mesh.vertex->st[0];
940         m.texcoords[1] = &s->mesh.vertex->uv[0];
941         m.texcoordstep[0] = sizeof(surfvertex_t);
942         m.texcoordstep[1] = sizeof(surfvertex_t);
943         if (fogenabled)
944         {
945                 m.color = &svert[0].c[0];
946                 m.colorstep = sizeof(surfvert_t);
947                 if (softwaretransform_complexity)
948                 {
949                         m.vertex = &svert[0].v[0];
950                         m.vertexstep = sizeof(surfvert_t);
951                         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
952                         {
953                                 softwaretransform(v->v, sv->v);
954                                 VectorSubtract(sv->v, r_origin, diff);
955                                 ifog = 1 - exp(fogdensity/DotProduct(diff, diff));
956                                 sv->c[0] = m.cr * ifog;
957                                 sv->c[1] = m.cg * ifog;
958                                 sv->c[2] = m.cb * ifog;
959                                 sv->c[3] = m.ca;
960                         }
961                 }
962                 else
963                 {
964                         m.vertex = &s->mesh.vertex->v[0];
965                         m.vertexstep = sizeof(surfvertex_t);
966                         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
967                         {
968                                 VectorSubtract(v->v, r_origin, diff);
969                                 ifog = 1 - exp(fogdensity/DotProduct(diff, diff));
970                                 sv->c[0] = m.cr * ifog;
971                                 sv->c[1] = m.cg * ifog;
972                                 sv->c[2] = m.cb * ifog;
973                                 sv->c[3] = m.ca;
974                         }
975                 }
976         }
977         else
978         {
979                 if (softwaretransform_complexity)
980                 {
981                         m.vertex = &svert[0].v[0];
982                         m.vertexstep = sizeof(surfvert_t);
983                         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
984                                 softwaretransform(v->v, sv->v);
985                 }
986                 else
987                 {
988                         m.vertex = &s->mesh.vertex->v[0];
989                         m.vertexstep = sizeof(surfvertex_t);
990                 }
991         }
992         R_Mesh_Draw(&m);
993 }
994
995 static void RSurfShader_Wall_Pass_BaseTexture(msurface_t *s)
996 {
997         int                             i;
998         surfvertex_t    *v;
999         surfvert_t              *sv;
1000         rmeshinfo_t             m;
1001
1002         memset(&m, 0, sizeof(m));
1003         m.transparent = false;
1004         m.blendfunc1 = GL_ONE;
1005         m.blendfunc2 = GL_ZERO;
1006         m.numtriangles = s->mesh.numtriangles;
1007         m.numverts = s->mesh.numverts;
1008         m.index = s->mesh.index;
1009         if (lighthalf)
1010         {
1011                 m.cr = 2;
1012                 m.cg = 2;
1013                 m.cb = 2;
1014         }
1015         else
1016         {
1017                 m.cr = 1;
1018                 m.cg = 1;
1019                 m.cb = 1;
1020         }
1021         m.ca = 1;
1022         m.tex[0] = R_GetTexture(s->currenttexture->texture);
1023         m.texcoords[0] = &s->mesh.vertex->st[0];
1024         m.texcoordstep[0] = sizeof(surfvertex_t);
1025         if (softwaretransform_complexity)
1026         {
1027                 m.vertex = &svert[0].v[0];
1028                 m.vertexstep = sizeof(surfvert_t);
1029                 for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1030                         softwaretransform(v->v, sv->v);
1031         }
1032         else
1033         {
1034                 m.vertex = &s->mesh.vertex->v[0];
1035                 m.vertexstep = sizeof(surfvertex_t);
1036         }
1037         R_Mesh_Draw(&m);
1038 }
1039
1040 static void RSurfShader_Wall_Pass_BaseLightmap(msurface_t *s)
1041 {
1042         int                             i;
1043         float                   diff[3], ifog;
1044         surfvertex_t    *v;
1045         surfvert_t              *sv;
1046         rmeshinfo_t             m;
1047
1048         memset(&m, 0, sizeof(m));
1049         m.transparent = false;
1050         m.blendfunc1 = GL_ZERO;
1051         m.blendfunc2 = GL_SRC_COLOR;
1052         m.numtriangles = s->mesh.numtriangles;
1053         m.numverts = s->mesh.numverts;
1054         m.index = s->mesh.index;
1055         m.cr = 1;
1056         if (lighthalf)
1057                 m.cr *= 2.0f;
1058         m.cg = m.cr;
1059         m.cb = m.cr;
1060         m.ca = 1;
1061         m.tex[0] = R_GetTexture(s->lightmaptexture);
1062         m.texcoords[0] = &s->mesh.vertex->uv[0];
1063         m.texcoordstep[0] = sizeof(surfvertex_t);
1064         if (fogenabled)
1065         {
1066                 m.color = &svert[0].c[0];
1067                 m.colorstep = sizeof(surfvert_t);
1068                 if (softwaretransform_complexity)
1069                 {
1070                         m.vertex = &svert[0].v[0];
1071                         m.vertexstep = sizeof(surfvert_t);
1072                         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1073                         {
1074                                 softwaretransform(v->v, sv->v);
1075                                 VectorSubtract(sv->v, r_origin, diff);
1076                                 ifog = 1 - exp(fogdensity/DotProduct(diff, diff));
1077                                 sv->c[0] = m.cr * ifog;
1078                                 sv->c[1] = m.cg * ifog;
1079                                 sv->c[2] = m.cb * ifog;
1080                                 sv->c[3] = m.ca;
1081                         }
1082                 }
1083                 else
1084                 {
1085                         m.vertex = &s->mesh.vertex->v[0];
1086                         m.vertexstep = sizeof(surfvertex_t);
1087                         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1088                         {
1089                                 VectorSubtract(v->v, r_origin, diff);
1090                                 ifog = 1 - exp(fogdensity/DotProduct(diff, diff));
1091                                 sv->c[0] = m.cr * ifog;
1092                                 sv->c[1] = m.cg * ifog;
1093                                 sv->c[2] = m.cb * ifog;
1094                                 sv->c[3] = m.ca;
1095                         }
1096                 }
1097         }
1098         else
1099         {
1100                 if (softwaretransform_complexity)
1101                 {
1102                         m.vertex = &svert[0].v[0];
1103                         m.vertexstep = sizeof(surfvert_t);
1104                         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1105                                 softwaretransform(v->v, sv->v);
1106                 }
1107                 else
1108                 {
1109                         m.vertex = &s->mesh.vertex->v[0];
1110                         m.vertexstep = sizeof(surfvertex_t);
1111                 }
1112         }
1113         R_Mesh_Draw(&m);
1114 }
1115
1116 static void RSurfShader_Wall_Pass_BaseVertex(msurface_t *s)
1117 {
1118         int                             i, size3;
1119         float                   c[3], base[3], scale, diff[3], ifog;
1120         surfvertex_t    *v;
1121         surfvert_t              *sv;
1122         rmeshinfo_t             m;
1123         byte                    *lm;
1124
1125         size3 = ((s->extents[0]>>4)+1)*((s->extents[1]>>4)+1)*3;
1126
1127         base[0] = base[1] = base[2] = r_ambient.value * (1.0f / 128.0f);
1128
1129         memset(&m, 0, sizeof(m));
1130         if (currentrenderentity->effects & EF_ADDITIVE)
1131         {
1132                 m.transparent = true;
1133                 m.blendfunc1 = GL_SRC_ALPHA;
1134                 m.blendfunc2 = GL_ONE;
1135         }
1136         else if (s->currenttexture->fogtexture != NULL || currentrenderentity->alpha != 1)
1137         {
1138                 m.transparent = true;
1139                 m.blendfunc1 = GL_SRC_ALPHA;
1140                 m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
1141         }
1142         else
1143         {
1144                 m.transparent = false;
1145                 m.blendfunc1 = GL_ONE;
1146                 m.blendfunc2 = GL_ZERO;
1147         }
1148         m.numtriangles = s->mesh.numtriangles;
1149         m.numverts = s->mesh.numverts;
1150         m.index = s->mesh.index;
1151         m.vertex = &svert[0].v[0];
1152         m.vertexstep = sizeof(surfvert_t);
1153         m.color = &svert[0].c[0];
1154         m.colorstep = sizeof(surfvert_t);
1155         m.tex[0] = R_GetTexture(s->currenttexture->texture);
1156         m.texcoords[0] = &s->mesh.vertex->st[0];
1157         m.texcoordstep[0] = sizeof(surfvertex_t);
1158         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1159         {
1160                 softwaretransform(v->v, sv->v);
1161                 VectorCopy(base, c);
1162                 if (s->styles[0] != 255)
1163                 {
1164                         lm = s->samples + v->lightmapoffset;
1165                         scale = d_lightstylevalue[s->styles[0]] * (1.0f / 32768.0f);
1166                         VectorMA(c, scale, lm, c);
1167                         if (s->styles[1] != 255)
1168                         {
1169                                 lm += size3;
1170                                 scale = d_lightstylevalue[s->styles[1]] * (1.0f / 32768.0f);
1171                                 VectorMA(c, scale, lm, c);
1172                                 if (s->styles[2] != 255)
1173                                 {
1174                                         lm += size3;
1175                                         scale = d_lightstylevalue[s->styles[2]] * (1.0f / 32768.0f);
1176                                         VectorMA(c, scale, lm, c);
1177                                         if (s->styles[3] != 255)
1178                                         {
1179                                                 lm += size3;
1180                                                 scale = d_lightstylevalue[s->styles[3]] * (1.0f / 32768.0f);
1181                                                 VectorMA(c, scale, lm, c);
1182                                         }
1183                                 }
1184                         }
1185                 }
1186                 sv->c[0] = c[0];
1187                 sv->c[1] = c[1];
1188                 sv->c[2] = c[2];
1189                 sv->c[3] = currentrenderentity->alpha;
1190         }
1191         if (s->dlightframe == r_framecount)
1192                 RSurf_Light(s->dlightbits, m.numverts);
1193         if (fogenabled)
1194         {
1195                 for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1196                 {
1197                         VectorSubtract(sv->v, r_origin, diff);
1198                         ifog = 1 - exp(fogdensity/DotProduct(diff, diff));
1199                         sv->c[0] *= ifog;
1200                         sv->c[1] *= ifog;
1201                         sv->c[2] *= ifog;
1202                 }
1203         }
1204         R_Mesh_Draw(&m);
1205 }
1206
1207 static void RSurfShader_Wall_Pass_BaseFullbright(msurface_t *s)
1208 {
1209         int                             i;
1210         float                   diff[3], ifog;
1211         surfvertex_t    *v;
1212         surfvert_t              *sv;
1213         rmeshinfo_t             m;
1214
1215         memset(&m, 0, sizeof(m));
1216         if (currentrenderentity->effects & EF_ADDITIVE)
1217         {
1218                 m.transparent = true;
1219                 m.blendfunc1 = GL_SRC_ALPHA;
1220                 m.blendfunc2 = GL_ONE;
1221         }
1222         else if (s->currenttexture->fogtexture != NULL || currentrenderentity->alpha != 1)
1223         {
1224                 m.transparent = true;
1225                 m.blendfunc1 = GL_SRC_ALPHA;
1226                 m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
1227         }
1228         else
1229         {
1230                 m.transparent = false;
1231                 m.blendfunc1 = GL_ONE;
1232                 m.blendfunc2 = GL_ZERO;
1233         }
1234         m.numtriangles = s->mesh.numtriangles;
1235         m.numverts = s->mesh.numverts;
1236         m.index = s->mesh.index;
1237         m.vertex = &svert[0].v[0];
1238         m.vertexstep = sizeof(surfvert_t);
1239         m.tex[0] = R_GetTexture(s->currenttexture->texture);
1240         m.texcoords[0] = &s->mesh.vertex->st[0];
1241         m.texcoordstep[0] = sizeof(surfvertex_t);
1242         if (fogenabled)
1243         {
1244                 m.color = &svert[0].c[0];
1245                 m.colorstep = sizeof(surfvert_t);
1246                 for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1247                 {
1248                         softwaretransform(v->v, sv->v);
1249                         VectorSubtract(sv->v, r_origin, diff);
1250                         ifog = 1 - exp(fogdensity/DotProduct(diff, diff));
1251                         sv->c[0] = ifog;
1252                         sv->c[1] = ifog;
1253                         sv->c[2] = ifog;
1254                         sv->c[3] = currentrenderentity->alpha;
1255                 }
1256         }
1257         else
1258         {
1259                 m.cr = m.cg = m.cb = 1;
1260                 m.ca = currentrenderentity->alpha;
1261                 for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1262                         softwaretransform(v->v, sv->v);
1263         }
1264         R_Mesh_Draw(&m);
1265 }
1266
1267 static void RSurfShader_Wall_Pass_Light(msurface_t *s)
1268 {
1269         int                             i;
1270         float                   diff[3], ifog;
1271         surfvertex_t    *v;
1272         surfvert_t              *sv;
1273         rmeshinfo_t             m;
1274
1275         memset(&m, 0, sizeof(m));
1276         if (currentrenderentity->effects & EF_ADDITIVE)
1277                 m.transparent = true;
1278         else if (s->currenttexture->fogtexture != NULL || currentrenderentity->alpha != 1)
1279                 m.transparent = true;
1280         else
1281                 m.transparent = false;
1282         m.blendfunc1 = GL_SRC_ALPHA;
1283         m.blendfunc2 = GL_ONE;
1284         m.numtriangles = s->mesh.numtriangles;
1285         m.numverts = s->mesh.numverts;
1286         m.index = s->mesh.index;
1287         m.vertex = &svert[0].v[0];
1288         m.vertexstep = sizeof(surfvert_t);
1289         m.color = &svert[0].c[0];
1290         m.colorstep = sizeof(surfvert_t);
1291         m.tex[0] = R_GetTexture(s->currenttexture->texture);
1292         m.texcoords[0] = &s->mesh.vertex->st[0];
1293         m.texcoordstep[0] = sizeof(surfvertex_t);
1294         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1295         {
1296                 softwaretransform(v->v, sv->v);
1297                 sv->c[0] = 0;
1298                 sv->c[1] = 0;
1299                 sv->c[2] = 0;
1300                 sv->c[3] = currentrenderentity->alpha;
1301         }
1302         if (RSurf_Light(s->dlightbits, m.numverts))
1303         {
1304                 if (fogenabled)
1305                 {
1306                         for (i = 0, sv = svert;i < m.numverts;i++, sv++)
1307                         {
1308                                 VectorSubtract(sv->v, r_origin, diff);
1309                                 ifog = 1 - exp(fogdensity/DotProduct(diff, diff));
1310                                 sv->c[0] *= ifog;
1311                                 sv->c[1] *= ifog;
1312                                 sv->c[2] *= ifog;
1313                         }
1314                 }
1315                 R_Mesh_Draw(&m);
1316         }
1317 }
1318
1319 static void RSurfShader_Wall_Pass_Glow(msurface_t *s)
1320 {
1321         int                             i;
1322         float                   diff[3], ifog;
1323         surfvertex_t    *v;
1324         surfvert_t              *sv;
1325         rmeshinfo_t             m;
1326
1327         memset(&m, 0, sizeof(m));
1328         if (currentrenderentity->effects & EF_ADDITIVE)
1329                 m.transparent = true;
1330         else if (s->currenttexture->fogtexture != NULL || currentrenderentity->alpha != 1)
1331                 m.transparent = true;
1332         else
1333                 m.transparent = false;
1334         m.blendfunc1 = GL_SRC_ALPHA;
1335         m.blendfunc2 = GL_ONE;
1336         m.numtriangles = s->mesh.numtriangles;
1337         m.numverts = s->mesh.numverts;
1338         m.index = s->mesh.index;
1339         m.cr = 1;
1340         m.cg = 1;
1341         m.cb = 1;
1342         m.ca = currentrenderentity->alpha;
1343         m.tex[0] = R_GetTexture(s->currenttexture->glowtexture);
1344         m.texcoords[0] = &s->mesh.vertex->st[0];
1345         m.texcoordstep[0] = sizeof(surfvertex_t);
1346         if (fogenabled)
1347         {
1348                 m.color = &svert[0].c[0];
1349                 m.colorstep = sizeof(surfvert_t);
1350                 if (softwaretransform_complexity)
1351                 {
1352                         m.vertex = &svert[0].v[0];
1353                         m.vertexstep = sizeof(surfvert_t);
1354                         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1355                         {
1356                                 softwaretransform(v->v, sv->v);
1357                                 VectorSubtract(sv->v, r_origin, diff);
1358                                 ifog = 1 - exp(fogdensity/DotProduct(diff, diff));
1359                                 sv->c[0] = m.cr * ifog;
1360                                 sv->c[1] = m.cg * ifog;
1361                                 sv->c[2] = m.cb * ifog;
1362                                 sv->c[3] = m.ca;
1363                         }
1364                 }
1365                 else
1366                 {
1367                         m.vertex = &s->mesh.vertex->v[0];
1368                         m.vertexstep = sizeof(surfvertex_t);
1369                         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1370                         {
1371                                 VectorSubtract(v->v, r_origin, diff);
1372                                 ifog = 1 - exp(fogdensity/DotProduct(diff, diff));
1373                                 sv->c[0] = m.cr * ifog;
1374                                 sv->c[1] = m.cg * ifog;
1375                                 sv->c[2] = m.cb * ifog;
1376                                 sv->c[3] = m.ca;
1377                         }
1378                 }
1379         }
1380         else
1381         {
1382                 if (softwaretransform_complexity)
1383                 {
1384                         m.vertex = &svert[0].v[0];
1385                         m.vertexstep = sizeof(surfvert_t);
1386                         for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1387                                 softwaretransform(v->v, sv->v);
1388                 }
1389                 else
1390                 {
1391                         m.vertex = &s->mesh.vertex->v[0];
1392                         m.vertexstep = sizeof(surfvertex_t);
1393                 }
1394         }
1395         R_Mesh_Draw(&m);
1396 }
1397
1398 static void RSurfShader_Wall_Pass_Fog(msurface_t *s)
1399 {
1400         int                             i;
1401         surfvertex_t    *v;
1402         surfvert_t              *sv;
1403         rmeshinfo_t             m;
1404         vec3_t                  diff;
1405
1406         memset(&m, 0, sizeof(m));
1407         if (currentrenderentity->effects & EF_ADDITIVE)
1408                 m.transparent = true;
1409         else if (s->currenttexture->fogtexture != NULL || currentrenderentity->alpha != 1)
1410                 m.transparent = true;
1411         else
1412                 m.transparent = false;
1413         m.blendfunc1 = GL_SRC_ALPHA;
1414         m.blendfunc2 = GL_ONE;
1415         m.numtriangles = s->mesh.numtriangles;
1416         m.numverts = s->mesh.numverts;
1417         m.index = s->mesh.index;
1418         m.color = &svert[0].c[0];
1419         m.colorstep = sizeof(surfvert_t);
1420         m.tex[0] = R_GetTexture(s->currenttexture->fogtexture);
1421         m.texcoords[0] = &s->mesh.vertex->st[0];
1422         m.texcoordstep[0] = sizeof(surfvertex_t);
1423         if (softwaretransform_complexity)
1424         {
1425                 m.vertex = &svert[0].v[0];
1426                 m.vertexstep = sizeof(surfvert_t);
1427                 for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1428                 {
1429                         softwaretransform(v->v, sv->v);
1430                         VectorSubtract(sv->v, r_origin, diff);
1431                         sv->c[0] = fogcolor[0];
1432                         sv->c[1] = fogcolor[1];
1433                         sv->c[2] = fogcolor[2];
1434                         sv->c[3] = currentrenderentity->alpha * exp(fogdensity/DotProduct(diff,diff));
1435                 }
1436         }
1437         else
1438         {
1439                 m.vertex = &s->mesh.vertex->v[0];
1440                 m.vertexstep = sizeof(surfvertex_t);
1441                 for (i = 0, sv = svert, v = s->mesh.vertex;i < m.numverts;i++, sv++, v++)
1442                 {
1443                         VectorSubtract(v->v, r_origin, diff);
1444                         sv->c[0] = fogcolor[0];
1445                         sv->c[1] = fogcolor[1];
1446                         sv->c[2] = fogcolor[2];
1447                         sv->c[3] = currentrenderentity->alpha * exp(fogdensity/DotProduct(diff,diff));
1448                 }
1449         }
1450         R_Mesh_Draw(&m);
1451 }
1452
1453 static int RSurfShader_Wall_Fullbright(int stage, msurface_t *s)
1454 {
1455         switch(stage)
1456         {
1457         case 0:
1458                 RSurfShader_Wall_Pass_BaseFullbright(s);
1459                 return false;
1460         case 1:
1461                 if (s->currenttexture->glowtexture)
1462                         RSurfShader_Wall_Pass_Glow(s);
1463                 return false;
1464         default:
1465                 return true;
1466         }
1467 }
1468
1469 static int RSurfShader_Wall_Vertex(int stage, msurface_t *s)
1470 {
1471         switch(stage)
1472         {
1473         case 0:
1474                 RSurfShader_Wall_Pass_BaseVertex(s);
1475                 return false;
1476         case 1:
1477                 if (s->currenttexture->glowtexture)
1478                         RSurfShader_Wall_Pass_Glow(s);
1479                 return false;
1480         default:
1481                 return true;
1482         }
1483 }
1484
1485 static int RSurfShader_Wall_Lightmap(int stage, msurface_t *s)
1486 {
1487         if (r_vertexsurfaces.integer)
1488         {
1489                 switch(stage)
1490                 {
1491                 case 0:
1492                         RSurfShader_Wall_Pass_BaseVertex(s);
1493                         return false;
1494                 case 1:
1495                         if (s->currenttexture->glowtexture)
1496                                 RSurfShader_Wall_Pass_Glow(s);
1497                         return false;
1498                 default:
1499                         return true;
1500                 }
1501         }
1502         else if (r_multitexture.integer)
1503         {
1504                 if (r_dlightmap.integer)
1505                 {
1506                         switch(stage)
1507                         {
1508                         case 0:
1509                                 RSurfShader_Wall_Pass_BaseMTex(s);
1510                                 return false;
1511                         case 1:
1512                                 if (s->currenttexture->glowtexture)
1513                                         RSurfShader_Wall_Pass_Glow(s);
1514                                 return false;
1515                         default:
1516                                 return true;
1517                         }
1518                 }
1519                 else
1520                 {
1521                         switch(stage)
1522                         {
1523                         case 0:
1524                                 RSurfShader_Wall_Pass_BaseMTex(s);
1525                                 return false;
1526                         case 1:
1527                                 if (s->dlightframe == r_framecount)
1528                                         RSurfShader_Wall_Pass_Light(s);
1529                                 return false;
1530                         case 2:
1531                                 if (s->currenttexture->glowtexture)
1532                                         RSurfShader_Wall_Pass_Glow(s);
1533                                 return false;
1534                         default:
1535                                 return true;
1536                         }
1537                 }
1538         }
1539         else if (s->currenttexture->fogtexture != NULL || currentrenderentity->alpha != 1 || currentrenderentity->effects & EF_ADDITIVE)
1540         {
1541                 switch(stage)
1542                 {
1543                 case 0:
1544                         RSurfShader_Wall_Pass_BaseVertex(s);
1545                         return false;
1546                 case 1:
1547                         if (s->currenttexture->glowtexture)
1548                                 RSurfShader_Wall_Pass_Glow(s);
1549                         return false;
1550                 default:
1551                         return true;
1552                 }
1553         }
1554         else
1555         {
1556                 if (r_dlightmap.integer)
1557                 {
1558                         switch(stage)
1559                         {
1560                         case 0:
1561                                 RSurfShader_Wall_Pass_BaseTexture(s);
1562                                 return false;
1563                         case 1:
1564                                 RSurfShader_Wall_Pass_BaseLightmap(s);
1565                                 return false;
1566                         case 2:
1567                                 if (s->currenttexture->glowtexture)
1568                                         RSurfShader_Wall_Pass_Glow(s);
1569                                 return false;
1570                         default:
1571                                 return true;
1572                         }
1573                 }
1574                 else
1575                 {
1576                         switch(stage)
1577                         {
1578                         case 0:
1579                                 RSurfShader_Wall_Pass_BaseTexture(s);
1580                                 return false;
1581                         case 1:
1582                                 RSurfShader_Wall_Pass_BaseLightmap(s);
1583                                 return false;
1584                         case 2:
1585                                 if (s->dlightframe == r_framecount)
1586                                         RSurfShader_Wall_Pass_Light(s);
1587                                 return false;
1588                         case 3:
1589                                 if (s->currenttexture->glowtexture)
1590                                         RSurfShader_Wall_Pass_Glow(s);
1591                                 return false;
1592                         default:
1593                                 return true;
1594                         }
1595                 }
1596         }
1597 }
1598
1599 static int RSurfShader_Wall_Fog(int stage, msurface_t *s)
1600 {
1601         if (stage == 0 && fogenabled)
1602         {
1603                 RSurfShader_Wall_Pass_Fog(s);
1604                 return false;
1605         }
1606         else
1607                 return true;
1608 }
1609
1610 /*
1611 =============================================================
1612
1613         WORLD MODEL
1614
1615 =============================================================
1616 */
1617
1618 static void RSurf_Callback(void *data, void *junk)
1619 {
1620         ((msurface_t *)data)->visframe = r_framecount;
1621 }
1622
1623 static void R_SolidWorldNode (void)
1624 {
1625         if (r_viewleaf->contents != CONTENTS_SOLID)
1626         {
1627                 int portalstack;
1628                 mportal_t *p, *pstack[8192];
1629                 msurface_t *surf, **mark, **endmark;
1630                 mleaf_t *leaf;
1631                 tinyplane_t plane;
1632                 // LordHavoc: portal-passage worldnode; follows portals leading
1633                 // outward from viewleaf, if a portal leads offscreen it is not
1634                 // followed, in indoor maps this can often cull a great deal of
1635                 // geometry away when pvs data is not present (useful with pvs as well)
1636
1637                 leaf = r_viewleaf;
1638                 leaf->worldnodeframe = r_framecount;
1639                 portalstack = 0;
1640         loc0:
1641                 c_leafs++;
1642
1643                 leaf->visframe = r_framecount;
1644
1645                 if (leaf->nummarksurfaces)
1646                 {
1647                         mark = leaf->firstmarksurface;
1648                         endmark = mark + leaf->nummarksurfaces;
1649                         if (r_ser.integer)
1650                         {
1651                                 do
1652                                 {
1653                                         surf = *mark++;
1654                                         // make sure surfaces are only processed once
1655                                         if (surf->worldnodeframe == r_framecount)
1656                                                 continue;
1657                                         surf->worldnodeframe = r_framecount;
1658                                         if (PlaneDist(r_origin, surf->plane) < surf->plane->dist)
1659                                         {
1660                                                 if (surf->flags & SURF_PLANEBACK)
1661                                                 {
1662                                                         VectorNegate(surf->plane->normal, plane.normal);
1663                                                         plane.dist = -surf->plane->dist;
1664                                                         R_Clip_AddPolygon((float *)surf->poly_verts, surf->poly_numverts, sizeof(float[3]), (surf->flags & SURF_CLIPSOLID) != 0, RSurf_Callback, surf, NULL, &plane);
1665                                                 }
1666                                         }
1667                                         else
1668                                         {
1669                                                 if (!(surf->flags & SURF_PLANEBACK))
1670                                                         R_Clip_AddPolygon((float *)surf->poly_verts, surf->poly_numverts, sizeof(float[3]), (surf->flags & SURF_CLIPSOLID) != 0, RSurf_Callback, surf, NULL, (tinyplane_t *)surf->plane);
1671                                         }
1672                                 }
1673                                 while (mark < endmark);
1674                         }
1675                         else
1676                         {
1677                                 do
1678                                 {
1679                                         surf = *mark++;
1680                                         // make sure surfaces are only processed once
1681                                         if (surf->worldnodeframe == r_framecount)
1682                                                 continue;
1683                                         surf->worldnodeframe = r_framecount;
1684                                         if (PlaneDist(r_origin, surf->plane) < surf->plane->dist)
1685                                         {
1686                                                 if (surf->flags & SURF_PLANEBACK)
1687                                                         surf->visframe = r_framecount;
1688                                         }
1689                                         else
1690                                         {
1691                                                 if (!(surf->flags & SURF_PLANEBACK))
1692                                                         surf->visframe = r_framecount;
1693                                         }
1694                                 }
1695                                 while (mark < endmark);
1696                         }
1697                 }
1698
1699                 // follow portals into other leafs
1700                 p = leaf->portals;
1701                 for (;p;p = p->next)
1702                 {
1703                         if (DotProduct(r_origin, p->plane.normal) < p->plane.dist)
1704                         {
1705                                 leaf = p->past;
1706                                 if (leaf->worldnodeframe != r_framecount)
1707                                 {
1708                                         leaf->worldnodeframe = r_framecount;
1709                                         if (leaf->contents != CONTENTS_SOLID)
1710                                         {
1711                                                 if (R_NotCulledBox(leaf->mins, leaf->maxs))
1712                                                 {
1713                                                         p->visframe = r_framecount;
1714                                                         pstack[portalstack++] = p;
1715                                                         goto loc0;
1716
1717         loc1:
1718                                                         p = pstack[--portalstack];
1719                                                 }
1720                                         }
1721                                 }
1722                         }
1723                 }
1724
1725                 if (portalstack)
1726                         goto loc1;
1727         }
1728         else
1729         {
1730                 mnode_t *nodestack[8192], *node = cl.worldmodel->nodes;
1731                 int nodestackpos = 0;
1732                 // LordHavoc: recursive descending worldnode; if portals are not
1733                 // available, this is a good last resort, can cull large amounts of
1734                 // geometry, but is more time consuming than portal-passage and renders
1735                 // things behind walls
1736
1737 loc2:
1738                 if (R_NotCulledBox(node->mins, node->maxs))
1739                 {
1740                         if (node->numsurfaces)
1741                         {
1742                                 if (r_ser.integer)
1743                                 {
1744                                         msurface_t *surf = cl.worldmodel->surfaces + node->firstsurface, *surfend = surf + node->numsurfaces;
1745                                         tinyplane_t plane;
1746                                         if (PlaneDiff (r_origin, node->plane) < 0)
1747                                         {
1748                                                 for (;surf < surfend;surf++)
1749                                                 {
1750                                                         if (surf->flags & SURF_PLANEBACK)
1751                                                         {
1752                                                                 VectorNegate(surf->plane->normal, plane.normal);
1753                                                                 plane.dist = -surf->plane->dist;
1754                                                                 R_Clip_AddPolygon((float *)surf->poly_verts, surf->poly_numverts, sizeof(float[3]), surf->flags & SURF_CLIPSOLID, RSurf_Callback, surf, NULL, &plane);
1755                                                         }
1756                                                 }
1757                                         }
1758                                         else
1759                                         {
1760                                                 for (;surf < surfend;surf++)
1761                                                 {
1762                                                         if (!(surf->flags & SURF_PLANEBACK))
1763                                                                 R_Clip_AddPolygon((float *)surf->poly_verts, surf->poly_numverts, sizeof(float[3]), surf->flags & SURF_CLIPSOLID, RSurf_Callback, surf, NULL, (tinyplane_t *)surf->plane);
1764                                                 }
1765                                         }
1766                                 }
1767                                 else
1768                                 {
1769                                         msurface_t *surf = cl.worldmodel->surfaces + node->firstsurface, *surfend = surf + node->numsurfaces;
1770                                         if (PlaneDiff (r_origin, node->plane) < 0)
1771                                         {
1772                                                 for (;surf < surfend;surf++)
1773                                                 {
1774                                                         if (surf->flags & SURF_PLANEBACK)
1775                                                                 surf->visframe = r_framecount;
1776                                                 }
1777                                         }
1778                                         else
1779                                         {
1780                                                 for (;surf < surfend;surf++)
1781                                                 {
1782                                                         if (!(surf->flags & SURF_PLANEBACK))
1783                                                                 surf->visframe = r_framecount;
1784                                                 }
1785                                         }
1786                                 }
1787                         }
1788
1789                         // recurse down the children
1790                         if (node->children[0]->contents >= 0)
1791                         {
1792                                 if (node->children[1]->contents >= 0)
1793                                 {
1794                                         if (nodestackpos < 8192)
1795                                                 nodestack[nodestackpos++] = node->children[1];
1796                                         node = node->children[0];
1797                                         goto loc2;
1798                                 }
1799                                 else
1800                                         ((mleaf_t *)node->children[1])->visframe = r_framecount;
1801                                 node = node->children[0];
1802                                 goto loc2;
1803                         }
1804                         else
1805                         {
1806                                 ((mleaf_t *)node->children[0])->visframe = r_framecount;
1807                                 if (node->children[1]->contents >= 0)
1808                                 {
1809                                         node = node->children[1];
1810                                         goto loc2;
1811                                 }
1812                                 else if (nodestackpos > 0)
1813                                 {
1814                                         ((mleaf_t *)node->children[1])->visframe = r_framecount;
1815                                         node = nodestack[--nodestackpos];
1816                                         goto loc2;
1817                                 }
1818                         }
1819                 }
1820                 else if (nodestackpos > 0)
1821                 {
1822                         node = nodestack[--nodestackpos];
1823                         goto loc2;
1824                 }
1825         }
1826 }
1827
1828 static int r_portalframecount = 0;
1829
1830 static void R_PVSWorldNode()
1831 {
1832         int portalstack, i;
1833         mportal_t *p, *pstack[8192];
1834         msurface_t *surf, **mark, **endmark;
1835         mleaf_t *leaf;
1836         tinyplane_t plane;
1837         byte *worldvis;
1838
1839         worldvis = Mod_LeafPVS (r_viewleaf, cl.worldmodel);
1840
1841         leaf = r_viewleaf;
1842         leaf->worldnodeframe = r_framecount;
1843         portalstack = 0;
1844 loc0:
1845         c_leafs++;
1846
1847         leaf->visframe = r_framecount;
1848
1849         if (leaf->nummarksurfaces)
1850         {
1851                 mark = leaf->firstmarksurface;
1852                 endmark = mark + leaf->nummarksurfaces;
1853                 if (r_ser.integer)
1854                 {
1855                         do
1856                         {
1857                                 surf = *mark++;
1858                                 // make sure surfaces are only processed once
1859                                 if (surf->worldnodeframe == r_framecount)
1860                                         continue;
1861                                 surf->worldnodeframe = r_framecount;
1862                                 if (PlaneDist(r_origin, surf->plane) < surf->plane->dist)
1863                                 {
1864                                         if (surf->flags & SURF_PLANEBACK)
1865                                         {
1866                                                 VectorNegate(surf->plane->normal, plane.normal);
1867                                                 plane.dist = -surf->plane->dist;
1868                                                 R_Clip_AddPolygon((float *)surf->poly_verts, surf->poly_numverts, sizeof(float[3]), (surf->flags & SURF_CLIPSOLID) != 0, RSurf_Callback, surf, NULL, &plane);
1869                                         }
1870                                 }
1871                                 else
1872                                 {
1873                                         if (!(surf->flags & SURF_PLANEBACK))
1874                                                 R_Clip_AddPolygon((float *)surf->poly_verts, surf->poly_numverts, sizeof(float[3]), (surf->flags & SURF_CLIPSOLID) != 0, RSurf_Callback, surf, NULL, (tinyplane_t *)surf->plane);
1875                                 }
1876                         }
1877                         while (mark < endmark);
1878                 }
1879                 else
1880                 {
1881                         do
1882                         {
1883                                 surf = *mark++;
1884                                 // make sure surfaces are only processed once
1885                                 if (surf->worldnodeframe == r_framecount)
1886                                         continue;
1887                                 surf->worldnodeframe = r_framecount;
1888                                 if (PlaneDist(r_origin, surf->plane) < surf->plane->dist)
1889                                 {
1890                                         if (surf->flags & SURF_PLANEBACK)
1891                                                 surf->visframe = r_framecount;
1892                                 }
1893                                 else
1894                                 {
1895                                         if (!(surf->flags & SURF_PLANEBACK))
1896                                                 surf->visframe = r_framecount;
1897                                 }
1898                         }
1899                         while (mark < endmark);
1900                 }
1901         }
1902
1903         // follow portals into other leafs
1904         for (p = leaf->portals;p;p = p->next)
1905         {
1906                 if (DotProduct(r_origin, p->plane.normal) < p->plane.dist)
1907                 {
1908                         leaf = p->past;
1909                         if (leaf->worldnodeframe != r_framecount)
1910                         {
1911                                 leaf->worldnodeframe = r_framecount;
1912                                 if (leaf->contents != CONTENTS_SOLID)
1913                                 {
1914                                         i = (leaf - cl.worldmodel->leafs) - 1;
1915                                         if (worldvis[i>>3] & (1<<(i&7)))
1916                                         {
1917                                                 if (R_NotCulledBox(leaf->mins, leaf->maxs))
1918                                                 {
1919                                                         pstack[portalstack++] = p;
1920                                                         goto loc0;
1921
1922 loc1:
1923                                                         p = pstack[--portalstack];
1924                                                 }
1925                                         }
1926                                 }
1927                         }
1928                 }
1929         }
1930
1931         if (portalstack)
1932                 goto loc1;
1933 }
1934
1935 Cshader_t Cshader_wall_vertex = {{NULL, RSurfShader_Wall_Vertex, RSurfShader_Wall_Fog}, NULL};
1936 Cshader_t Cshader_wall_lightmap = {{NULL, RSurfShader_Wall_Lightmap, RSurfShader_Wall_Fog}, NULL};
1937 Cshader_t Cshader_wall_fullbright = {{NULL, RSurfShader_Wall_Fullbright, RSurfShader_Wall_Fog}, NULL};
1938 Cshader_t Cshader_water = {{NULL, RSurfShader_Water, NULL}, NULL};
1939 Cshader_t Cshader_sky = {{RSurfShader_Sky, NULL, NULL}, NULL};
1940
1941 int Cshader_count = 5;
1942 Cshader_t *Cshaders[5] =
1943 {
1944         &Cshader_wall_vertex,
1945         &Cshader_wall_lightmap,
1946         &Cshader_wall_fullbright,
1947         &Cshader_water,
1948         &Cshader_sky
1949 };
1950
1951 void R_PrepareSurfaces(void)
1952 {
1953         int i;
1954         texture_t *t;
1955         model_t *model;
1956         msurface_t *surf;
1957
1958         for (i = 0;i < Cshader_count;i++)
1959                 Cshaders[i]->chain = NULL;
1960
1961         model = currentrenderentity->model;
1962
1963         for (i = 0;i < model->nummodelsurfaces;i++)
1964         {
1965                 surf = model->modelsortedsurfaces[i];
1966                 if (surf->visframe == r_framecount)
1967                 {
1968                         if (surf->insertframe != r_framecount)
1969                         {
1970                                 surf->insertframe = r_framecount;
1971                                 c_faces++;
1972                                 // manually inlined R_TextureAnimation
1973                                 //t = R_TextureAnimation(surf->texinfo->texture);
1974                                 t = surf->texinfo->texture;
1975                                 if (t->alternate_anims != NULL && currentrenderentity->frame)
1976                                         t = t->alternate_anims;
1977                                 if (t->anim_total >= 2)
1978                                         t = t->anim_frames[(int)(cl.time * 5.0f) % t->anim_total];
1979                                 surf->currenttexture = t;
1980                         }
1981
1982                         surf->chain = surf->shader->chain;
1983                         surf->shader->chain = surf;
1984                 }
1985         }
1986 }
1987
1988 void R_DrawSurfaces (int type)
1989 {
1990         int                     i, stage;
1991         msurface_t      *surf;
1992         Cshader_t       *shader;
1993
1994         for (i = 0;i < Cshader_count;i++)
1995         {
1996                 shader = Cshaders[i];
1997                 if (shader->chain && shader->shaderfunc[type])
1998                         for (stage = 0;stage < 1000;stage++)
1999                                 for (surf = shader->chain;surf;surf = surf->chain)
2000                                         if (shader->shaderfunc[type](stage, surf))
2001                                                 goto done;
2002 done:;
2003         }
2004 }
2005
2006 void R_DrawSurfacesAll (void)
2007 {
2008         R_DrawSurfaces(SHADERSTAGE_SKY);
2009         R_DrawSurfaces(SHADERSTAGE_NORMAL);
2010         R_DrawSurfaces(SHADERSTAGE_FOG);
2011 }
2012
2013 static float portalpointbuffer[256][3];
2014
2015 void R_DrawPortals(void)
2016 {
2017         int drawportals, i;
2018 //      mleaf_t *leaf, *endleaf;
2019         mportal_t *portal, *endportal;
2020         mvertex_t *point/*, *endpoint*/;
2021         rmeshinfo_t m;
2022         drawportals = r_drawportals.integer;
2023         if (drawportals < 1)
2024                 return;
2025         /*
2026         leaf = cl.worldmodel->leafs;
2027         endleaf = leaf + cl.worldmodel->numleafs;
2028         for (;leaf < endleaf;leaf++)
2029         {
2030                 if (leaf->visframe == r_framecount && leaf->portals)
2031                 {
2032                         i = leaf - cl.worldmodel->leafs;
2033                         r = (i & 0x0007) << 5;
2034                         g = (i & 0x0038) << 2;
2035                         b = (i & 0x01C0) >> 1;
2036                         portal = leaf->portals;
2037                         while (portal)
2038                         {
2039                                 transpolybegin(0, 0, 0, TPOLYTYPE_ALPHA);
2040                                 point = portal->points + portal->numpoints - 1;
2041                                 endpoint = portal->points;
2042                                 for (;point >= endpoint;point--)
2043                                         transpolyvertub(point->position[0], point->position[1], point->position[2], 0, 0, r, g, b, 32);
2044                                 transpolyend();
2045                                 portal = portal->next;
2046                         }
2047                 }
2048         }
2049         */
2050         memset(&m, 0, sizeof(m));
2051         m.transparent = true;
2052         m.blendfunc1 = GL_SRC_ALPHA;
2053         m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
2054         m.vertex = &portalpointbuffer[0][0];
2055         m.vertexstep = sizeof(float[3]);
2056         m.ca = 0.125;
2057         for (portal = cl.worldmodel->portals, endportal = portal + cl.worldmodel->numportals;portal < endportal;portal++)
2058         {
2059                 if (portal->visframe == r_portalframecount)
2060                 {
2061                         if (portal->numpoints <= 256)
2062                         {
2063                                 i = portal - cl.worldmodel->portals;
2064                                 m.cr = ((i & 0x0007) >> 0) * (1.0f / 7.0f);
2065                                 m.cg = ((i & 0x0038) >> 3) * (1.0f / 7.0f);
2066                                 m.cb = ((i & 0x01C0) >> 6) * (1.0f / 7.0f);
2067                                 point = portal->points;
2068                                 if (PlaneDiff(r_origin, (&portal->plane)) > 0)
2069                                 {
2070                                         for (i = portal->numpoints - 1;i >= 0;i--)
2071                                                 VectorCopy(point[i].position, portalpointbuffer[i]);
2072                                 }
2073                                 else
2074                                 {
2075                                         for (i = 0;i < portal->numpoints;i++)
2076                                                 VectorCopy(point[i].position, portalpointbuffer[i]);
2077                                 }
2078                                 R_Mesh_DrawPolygon(&m, portal->numpoints);
2079                         }
2080                 }
2081         }
2082 }
2083
2084 void R_SetupForBModelRendering(void)
2085 {
2086         int                     i;
2087         msurface_t      *s;
2088         model_t         *model;
2089         vec3_t          modelorg;
2090
2091         // because bmodels can be reused, we have to decide which things to render
2092         // from scratch every time
2093
2094         model = currentrenderentity->model;
2095
2096         softwaretransformforentity (currentrenderentity);
2097         softwareuntransform(r_origin, modelorg);
2098
2099         for (i = 0;i < model->nummodelsurfaces;i++)
2100         {
2101                 s = model->modelsortedsurfaces[i];
2102                 if (((s->flags & SURF_PLANEBACK) == 0) == (PlaneDiff(modelorg, s->plane) >= 0))
2103                         s->visframe = r_framecount;
2104                 else
2105                         s->visframe = -1;
2106                 s->worldnodeframe = -1;
2107                 s->lightframe = -1;
2108                 s->dlightframe = -1;
2109                 s->insertframe = -1;
2110         }
2111 }
2112
2113 void R_SetupForWorldRendering(void)
2114 {
2115         // there is only one instance of the world, but it can be rendered in
2116         // multiple stages
2117
2118         currentrenderentity = &cl_entities[0].render;
2119         softwaretransformidentity();
2120 }
2121
2122 static void R_SurfMarkLights (void)
2123 {
2124         int                     i;
2125         msurface_t      *s;
2126
2127         if (r_dynamic.integer)
2128                 R_MarkLights();
2129
2130         if (!r_vertexsurfaces.integer)
2131         {
2132                 for (i = 0;i < currentrenderentity->model->nummodelsurfaces;i++)
2133                 {
2134                         s = currentrenderentity->model->modelsortedsurfaces[i];
2135                         if (s->visframe == r_framecount && s->lightmaptexture != NULL)
2136                         {
2137                                 if (s->cached_dlight
2138                                  || s->cached_ambient != r_ambient.value
2139                                  || s->cached_lightscalebit != lightscalebit)
2140                                         R_BuildLightMap(s, false); // base lighting changed
2141                                 else if (r_dynamic.integer)
2142                                 {
2143                                         if  (s->styles[0] != 255 && (d_lightstylevalue[s->styles[0]] != s->cached_light[0]
2144                                          || (s->styles[1] != 255 && (d_lightstylevalue[s->styles[1]] != s->cached_light[1]
2145                                          || (s->styles[2] != 255 && (d_lightstylevalue[s->styles[2]] != s->cached_light[2]
2146                                          || (s->styles[3] != 255 && (d_lightstylevalue[s->styles[3]] != s->cached_light[3]))))))))
2147                                         //if (s->cached_light[0] != d_lightstylevalue[s->styles[0]]
2148                                         // || s->cached_light[1] != d_lightstylevalue[s->styles[1]]
2149                                         // || s->cached_light[2] != d_lightstylevalue[s->styles[2]]
2150                                         // || s->cached_light[3] != d_lightstylevalue[s->styles[3]])
2151                                                 R_BuildLightMap(s, false); // base lighting changed
2152                                         else if (s->dlightframe == r_framecount && r_dlightmap.integer)
2153                                                 R_BuildLightMap(s, true); // only dlights
2154                                 }
2155                         }
2156                 }
2157         }
2158 }
2159
2160 void R_MarkWorldLights(void)
2161 {
2162         R_SetupForWorldRendering();
2163         R_SurfMarkLights();
2164 }
2165
2166 /*
2167 =============
2168 R_DrawWorld
2169 =============
2170 */
2171 void R_DrawWorld (void)
2172 {
2173         R_SetupForWorldRendering();
2174
2175         if (r_viewleaf->contents == CONTENTS_SOLID || r_novis.integer || r_viewleaf->compressed_vis == NULL)
2176                 R_SolidWorldNode ();
2177         else
2178                 R_PVSWorldNode ();
2179 }
2180
2181 /*
2182 =================
2183 R_DrawBrushModel
2184 =================
2185 */
2186 void R_DrawBrushModelSky (void)
2187 {
2188         R_SetupForBModelRendering();
2189
2190         R_PrepareSurfaces();
2191         R_DrawSurfaces(SHADERSTAGE_SKY);
2192 }
2193
2194 void R_DrawBrushModelNormal (void)
2195 {
2196         c_bmodels++;
2197
2198         // have to flush queue because of possible lightmap reuse
2199         R_Mesh_Render();
2200
2201         R_SetupForBModelRendering();
2202
2203         R_SurfMarkLights();
2204
2205         R_PrepareSurfaces();
2206
2207         if (!skyrendermasked)
2208                 R_DrawSurfaces(SHADERSTAGE_SKY);
2209         R_DrawSurfaces(SHADERSTAGE_NORMAL);
2210         R_DrawSurfaces(SHADERSTAGE_FOG);
2211 }