slight cleanup (complete removal) of the "base" variable in surface rendering
[divverent/darkplaces.git] / gl_rmain.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_main.c
21
22 #include "quakedef.h"
23 #include "r_shadow.h"
24 #include "polygon.h"
25
26 // used for dlight push checking and other things
27 int r_framecount;
28
29 mplane_t frustum[5];
30
31 matrix4x4_t r_identitymatrix;
32
33 int c_alias_polys, c_light_polys, c_faces, c_nodes, c_leafs, c_models, c_bmodels, c_sprites, c_particles, c_dlights, c_meshs, c_meshelements, c_rt_lights, c_rt_clears, c_rt_scissored, c_rt_shadowmeshes, c_rt_shadowtris, c_rt_lightmeshes, c_rt_lighttris, c_rtcached_shadowmeshes, c_rtcached_shadowtris, c_bloom, c_bloomcopies, c_bloomcopypixels, c_bloomdraws, c_bloomdrawpixels;
34
35 // true during envmap command capture
36 qboolean envmap;
37
38 // maximum visible distance (recalculated from world box each frame)
39 float r_farclip;
40 // brightness of world lightmaps and related lighting
41 // (often reduced when world rtlights are enabled)
42 float r_lightmapintensity;
43 // whether to draw world lights realtime, dlights realtime, and their shadows
44 qboolean r_rtworld;
45 qboolean r_rtworldshadows;
46 qboolean r_rtdlight;
47 qboolean r_rtdlightshadows;
48
49
50 // forces all rendering to draw triangle outlines
51 int r_showtrispass;
52
53 // view origin
54 vec3_t r_vieworigin;
55 vec3_t r_viewforward;
56 vec3_t r_viewleft;
57 vec3_t r_viewright;
58 vec3_t r_viewup;
59 int r_view_x;
60 int r_view_y;
61 int r_view_z;
62 int r_view_width;
63 int r_view_height;
64 int r_view_depth;
65 float r_view_fov_x;
66 float r_view_fov_y;
67 matrix4x4_t r_view_matrix;
68
69 //
70 // screen size info
71 //
72 refdef_t r_refdef;
73
74 // 8.8 fraction of base light value
75 unsigned short d_lightstylevalue[256];
76
77 cvar_t r_showtris = {0, "r_showtris", "0"};
78 cvar_t r_drawentities = {0, "r_drawentities","1"};
79 cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1"};
80 cvar_t r_speeds = {0, "r_speeds","0"};
81 cvar_t r_fullbright = {0, "r_fullbright","0"};
82 cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1"};
83 cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1"};
84 cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1"};
85 cvar_t r_drawcollisionbrushes = {0, "r_drawcollisionbrushes", "0"};
86
87 cvar_t gl_fogenable = {0, "gl_fogenable", "0"};
88 cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25"};
89 cvar_t gl_fogred = {0, "gl_fogred","0.3"};
90 cvar_t gl_foggreen = {0, "gl_foggreen","0.3"};
91 cvar_t gl_fogblue = {0, "gl_fogblue","0.3"};
92 cvar_t gl_fogstart = {0, "gl_fogstart", "0"};
93 cvar_t gl_fogend = {0, "gl_fogend","0"};
94
95 cvar_t r_textureunits = {0, "r_textureunits", "32"};
96
97 cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1"};
98 cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1"};
99 cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1"};
100 cvar_t r_watershader = {CVAR_SAVE, "r_watershader", "1"};
101
102 cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0"};
103 cvar_t r_bloom_intensity = {CVAR_SAVE, "r_bloom_intensity", "2"};
104 cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "8"};
105 cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320"};
106 cvar_t r_bloom_power = {CVAR_SAVE, "r_bloom_power", "4"};
107
108 cvar_t developer_texturelogging = {0, "developer_texturelogging", "1"};
109
110 cvar_t gl_lightmaps = {0, "gl_lightmaps", "0"};
111
112 rtexturepool_t *r_main_texturepool;
113 rtexture_t *r_bloom_texture_screen;
114 rtexture_t *r_bloom_texture_bloom;
115 rtexture_t *r_texture_blanknormalmap;
116 rtexture_t *r_texture_white;
117 rtexture_t *r_texture_black;
118 rtexture_t *r_texture_notexture;
119 rtexture_t *r_texture_whitecube;
120 rtexture_t *r_texture_normalizationcube;
121 rtexture_t *r_texture_detailtextures[NUM_DETAILTEXTURES];
122 rtexture_t *r_texture_distorttexture[64];
123
124 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
125 {
126         int i;
127         for (i = 0;i < verts;i++)
128         {
129                 out[0] = in[0] * r;
130                 out[1] = in[1] * g;
131                 out[2] = in[2] * b;
132                 out[3] = in[3];
133                 in += 4;
134                 out += 4;
135         }
136 }
137
138 void R_FillColors(float *out, int verts, float r, float g, float b, float a)
139 {
140         int i;
141         for (i = 0;i < verts;i++)
142         {
143                 out[0] = r;
144                 out[1] = g;
145                 out[2] = b;
146                 out[3] = a;
147                 out += 4;
148         }
149 }
150
151 vec3_t fogcolor;
152 vec_t fogdensity;
153 float fog_density, fog_red, fog_green, fog_blue;
154 qboolean fogenabled;
155 qboolean oldgl_fogenable;
156 void R_UpdateFog(void)
157 {
158         if (gamemode == GAME_NEHAHRA)
159         {
160                 if (gl_fogenable.integer)
161                 {
162                         oldgl_fogenable = true;
163                         fog_density = gl_fogdensity.value;
164                         fog_red = gl_fogred.value;
165                         fog_green = gl_foggreen.value;
166                         fog_blue = gl_fogblue.value;
167                 }
168                 else if (oldgl_fogenable)
169                 {
170                         oldgl_fogenable = false;
171                         fog_density = 0;
172                         fog_red = 0;
173                         fog_green = 0;
174                         fog_blue = 0;
175                 }
176         }
177         if (fog_density)
178         {
179                 fogcolor[0] = fog_red   = bound(0.0f, fog_red  , 1.0f);
180                 fogcolor[1] = fog_green = bound(0.0f, fog_green, 1.0f);
181                 fogcolor[2] = fog_blue  = bound(0.0f, fog_blue , 1.0f);
182         }
183         if (fog_density)
184         {
185                 fogenabled = true;
186                 fogdensity = -4000.0f / (fog_density * fog_density);
187                 // fog color was already set
188         }
189         else
190                 fogenabled = false;
191 }
192
193 // FIXME: move this to client?
194 void FOG_clear(void)
195 {
196         if (gamemode == GAME_NEHAHRA)
197         {
198                 Cvar_Set("gl_fogenable", "0");
199                 Cvar_Set("gl_fogdensity", "0.2");
200                 Cvar_Set("gl_fogred", "0.3");
201                 Cvar_Set("gl_foggreen", "0.3");
202                 Cvar_Set("gl_fogblue", "0.3");
203         }
204         fog_density = fog_red = fog_green = fog_blue = 0.0f;
205 }
206
207 // FIXME: move this to client?
208 void FOG_registercvars(void)
209 {
210         if (gamemode == GAME_NEHAHRA)
211         {
212                 Cvar_RegisterVariable (&gl_fogenable);
213                 Cvar_RegisterVariable (&gl_fogdensity);
214                 Cvar_RegisterVariable (&gl_fogred);
215                 Cvar_RegisterVariable (&gl_foggreen);
216                 Cvar_RegisterVariable (&gl_fogblue);
217                 Cvar_RegisterVariable (&gl_fogstart);
218                 Cvar_RegisterVariable (&gl_fogend);
219         }
220 }
221
222 static void R_BuildDetailTextures (void)
223 {
224         int i, x, y, light;
225         float vc[3], vx[3], vy[3], vn[3], lightdir[3];
226 #define DETAILRESOLUTION 256
227         qbyte (*data)[DETAILRESOLUTION][4];
228         qbyte (*noise)[DETAILRESOLUTION];
229
230         // Allocate the buffers dynamically to avoid having such big guys on the stack
231         data = Mem_Alloc(tempmempool, DETAILRESOLUTION * sizeof(*data));
232         noise = Mem_Alloc(tempmempool, DETAILRESOLUTION * sizeof(*noise));
233
234         lightdir[0] = 0.5;
235         lightdir[1] = 1;
236         lightdir[2] = -0.25;
237         VectorNormalize(lightdir);
238         for (i = 0;i < NUM_DETAILTEXTURES;i++)
239         {
240                 fractalnoise(&noise[0][0], DETAILRESOLUTION, DETAILRESOLUTION >> 4);
241                 for (y = 0;y < DETAILRESOLUTION;y++)
242                 {
243                         for (x = 0;x < DETAILRESOLUTION;x++)
244                         {
245                                 vc[0] = x;
246                                 vc[1] = y;
247                                 vc[2] = noise[y][x] * (1.0f / 32.0f);
248                                 vx[0] = x + 1;
249                                 vx[1] = y;
250                                 vx[2] = noise[y][(x + 1) % DETAILRESOLUTION] * (1.0f / 32.0f);
251                                 vy[0] = x;
252                                 vy[1] = y + 1;
253                                 vy[2] = noise[(y + 1) % DETAILRESOLUTION][x] * (1.0f / 32.0f);
254                                 VectorSubtract(vx, vc, vx);
255                                 VectorSubtract(vy, vc, vy);
256                                 CrossProduct(vx, vy, vn);
257                                 VectorNormalize(vn);
258                                 light = 128 - DotProduct(vn, lightdir) * 128;
259                                 light = bound(0, light, 255);
260                                 data[y][x][0] = data[y][x][1] = data[y][x][2] = light;
261                                 data[y][x][3] = 255;
262                         }
263                 }
264                 r_texture_detailtextures[i] = R_LoadTexture2D(r_main_texturepool, va("detailtexture%i", i), DETAILRESOLUTION, DETAILRESOLUTION, &data[0][0][0], TEXTYPE_RGBA, TEXF_MIPMAP | TEXF_PRECACHE, NULL);
265         }
266
267         Mem_Free(noise);
268         Mem_Free(data);
269 }
270
271 static qbyte R_MorphDistortTexture (double y0, double y1, double y2, double y3, double morph)
272 {
273         int m = (int)(((y1 + y3 - (y0 + y2)) * morph * morph * morph) +
274                         ((2 * (y0 - y1) + y2 - y3) * morph * morph) +
275                         ((y2 - y0) * morph) +
276                         (y1));
277         return (qbyte)bound(0, m, 255);
278 }
279
280 static void R_BuildDistortTexture (void)
281 {
282         int x, y, i, j;
283 #define DISTORTRESOLUTION 32
284         qbyte data[5][DISTORTRESOLUTION][DISTORTRESOLUTION][2];
285
286         for (i=0; i<4; i++)
287         {
288                 for (y=0; y<DISTORTRESOLUTION; y++)
289                 {
290                         for (x=0; x<DISTORTRESOLUTION; x++)
291                         {
292                                 data[i][y][x][0] = rand () & 255;
293                                 data[i][y][x][1] = rand () & 255;
294                         }
295                 }
296         }
297
298         for (i=0; i<4; i++)
299         {
300                 for (j=0; j<16; j++)
301                 {
302                         r_texture_distorttexture[i*16+j] = NULL;
303                         if (gl_textureshader)
304                         {
305                                 for (y=0; y<DISTORTRESOLUTION; y++)
306                                 {
307                                         for (x=0; x<DISTORTRESOLUTION; x++)
308                                         {
309                                                 data[4][y][x][0] = R_MorphDistortTexture (data[(i-1)&3][y][x][0], data[i][y][x][0], data[(i+1)&3][y][x][0], data[(i+2)&3][y][x][0], 0.0625*j);
310                                                 data[4][y][x][1] = R_MorphDistortTexture (data[(i-1)&3][y][x][1], data[i][y][x][1], data[(i+1)&3][y][x][1], data[(i+2)&3][y][x][1], 0.0625*j);
311                                         }
312                                 }
313                                 r_texture_distorttexture[i*16+j] = R_LoadTexture2D(r_main_texturepool, va("distorttexture%i", i*16+j), DISTORTRESOLUTION, DISTORTRESOLUTION, &data[4][0][0][0], TEXTYPE_DSDT, TEXF_PRECACHE, NULL);
314                         }
315                 }
316         }
317 }
318
319 static void R_BuildBlankTextures(void)
320 {
321         qbyte data[4];
322         data[0] = 128; // normal X
323         data[1] = 128; // normal Y
324         data[2] = 255; // normal Z
325         data[3] = 128; // height
326         r_texture_blanknormalmap = R_LoadTexture2D(r_main_texturepool, "blankbump", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
327         data[0] = 255;
328         data[1] = 255;
329         data[2] = 255;
330         data[3] = 255;
331         r_texture_white = R_LoadTexture2D(r_main_texturepool, "blankwhite", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
332         data[0] = 0;
333         data[1] = 0;
334         data[2] = 0;
335         data[3] = 255;
336         r_texture_black = R_LoadTexture2D(r_main_texturepool, "blankblack", 1, 1, data, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
337 }
338
339 static void R_BuildNoTexture(void)
340 {
341         int x, y;
342         qbyte pix[16][16][4];
343         // this makes a light grey/dark grey checkerboard texture
344         for (y = 0;y < 16;y++)
345         {
346                 for (x = 0;x < 16;x++)
347                 {
348                         if ((y < 8) ^ (x < 8))
349                         {
350                                 pix[y][x][0] = 128;
351                                 pix[y][x][1] = 128;
352                                 pix[y][x][2] = 128;
353                                 pix[y][x][3] = 255;
354                         }
355                         else
356                         {
357                                 pix[y][x][0] = 64;
358                                 pix[y][x][1] = 64;
359                                 pix[y][x][2] = 64;
360                                 pix[y][x][3] = 255;
361                         }
362                 }
363         }
364         r_texture_notexture = R_LoadTexture2D(r_main_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_RGBA, TEXF_MIPMAP, NULL);
365 }
366
367 static void R_BuildWhiteCube(void)
368 {
369         qbyte data[6*1*1*4];
370         data[ 0] = 255;data[ 1] = 255;data[ 2] = 255;data[ 3] = 255;
371         data[ 4] = 255;data[ 5] = 255;data[ 6] = 255;data[ 7] = 255;
372         data[ 8] = 255;data[ 9] = 255;data[10] = 255;data[11] = 255;
373         data[12] = 255;data[13] = 255;data[14] = 255;data[15] = 255;
374         data[16] = 255;data[17] = 255;data[18] = 255;data[19] = 255;
375         data[20] = 255;data[21] = 255;data[22] = 255;data[23] = 255;
376         r_texture_whitecube = R_LoadTextureCubeMap(r_main_texturepool, "whitecube", 1, data, TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL);
377 }
378
379 static void R_BuildNormalizationCube(void)
380 {
381         int x, y, side;
382         vec3_t v;
383         vec_t s, t, intensity;
384 #define NORMSIZE 64
385         qbyte data[6][NORMSIZE][NORMSIZE][4];
386         for (side = 0;side < 6;side++)
387         {
388                 for (y = 0;y < NORMSIZE;y++)
389                 {
390                         for (x = 0;x < NORMSIZE;x++)
391                         {
392                                 s = (x + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
393                                 t = (y + 0.5f) * (2.0f / NORMSIZE) - 1.0f;
394                                 switch(side)
395                                 {
396                                 case 0:
397                                         v[0] = 1;
398                                         v[1] = -t;
399                                         v[2] = -s;
400                                         break;
401                                 case 1:
402                                         v[0] = -1;
403                                         v[1] = -t;
404                                         v[2] = s;
405                                         break;
406                                 case 2:
407                                         v[0] = s;
408                                         v[1] = 1;
409                                         v[2] = t;
410                                         break;
411                                 case 3:
412                                         v[0] = s;
413                                         v[1] = -1;
414                                         v[2] = -t;
415                                         break;
416                                 case 4:
417                                         v[0] = s;
418                                         v[1] = -t;
419                                         v[2] = 1;
420                                         break;
421                                 case 5:
422                                         v[0] = -s;
423                                         v[1] = -t;
424                                         v[2] = -1;
425                                         break;
426                                 }
427                                 intensity = 127.0f / sqrt(DotProduct(v, v));
428                                 data[side][y][x][0] = 128.0f + intensity * v[0];
429                                 data[side][y][x][1] = 128.0f + intensity * v[1];
430                                 data[side][y][x][2] = 128.0f + intensity * v[2];
431                                 data[side][y][x][3] = 255;
432                         }
433                 }
434         }
435         r_texture_normalizationcube = R_LoadTextureCubeMap(r_main_texturepool, "normalcube", NORMSIZE, &data[0][0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE | TEXF_CLAMP, NULL);
436 }
437
438 void gl_main_start(void)
439 {
440         r_main_texturepool = R_AllocTexturePool();
441         r_bloom_texture_screen = NULL;
442         r_bloom_texture_bloom = NULL;
443         R_BuildBlankTextures();
444         R_BuildNoTexture();
445         R_BuildDetailTextures();
446         R_BuildDistortTexture();
447         if (gl_texturecubemap)
448         {
449                 R_BuildWhiteCube();
450                 R_BuildNormalizationCube();
451         }
452 }
453
454 void gl_main_shutdown(void)
455 {
456         R_FreeTexturePool(&r_main_texturepool);
457         r_bloom_texture_screen = NULL;
458         r_bloom_texture_bloom = NULL;
459         r_texture_blanknormalmap = NULL;
460         r_texture_white = NULL;
461         r_texture_black = NULL;
462         r_texture_whitecube = NULL;
463         r_texture_normalizationcube = NULL;
464 }
465
466 extern void CL_ParseEntityLump(char *entitystring);
467 void gl_main_newmap(void)
468 {
469         // FIXME: move this code to client
470         int l;
471         char *entities, entname[MAX_QPATH];
472         r_framecount = 1;
473         if (cl.worldmodel)
474         {
475                 strlcpy(entname, cl.worldmodel->name, sizeof(entname));
476                 l = strlen(entname) - 4;
477                 if (l >= 0 && !strcmp(entname + l, ".bsp"))
478                 {
479                         strcpy(entname + l, ".ent");
480                         if ((entities = FS_LoadFile(entname, tempmempool, true)))
481                         {
482                                 CL_ParseEntityLump(entities);
483                                 Mem_Free(entities);
484                                 return;
485                         }
486                 }
487                 if (cl.worldmodel->brush.entities)
488                         CL_ParseEntityLump(cl.worldmodel->brush.entities);
489         }
490 }
491
492 void GL_Main_Init(void)
493 {
494         Matrix4x4_CreateIdentity(&r_identitymatrix);
495 // FIXME: move this to client?
496         FOG_registercvars();
497         Cvar_RegisterVariable(&r_showtris);
498         Cvar_RegisterVariable(&r_drawentities);
499         Cvar_RegisterVariable(&r_drawviewmodel);
500         Cvar_RegisterVariable(&r_speeds);
501         Cvar_RegisterVariable(&r_fullbrights);
502         Cvar_RegisterVariable(&r_wateralpha);
503         Cvar_RegisterVariable(&r_dynamic);
504         Cvar_RegisterVariable(&r_fullbright);
505         Cvar_RegisterVariable(&r_textureunits);
506         Cvar_RegisterVariable(&r_lerpsprites);
507         Cvar_RegisterVariable(&r_lerpmodels);
508         Cvar_RegisterVariable(&r_waterscroll);
509         Cvar_RegisterVariable(&r_watershader);
510         Cvar_RegisterVariable(&r_drawcollisionbrushes);
511         Cvar_RegisterVariable(&r_bloom);
512         Cvar_RegisterVariable(&r_bloom_intensity);
513         Cvar_RegisterVariable(&r_bloom_blur);
514         Cvar_RegisterVariable(&r_bloom_resolution);
515         Cvar_RegisterVariable(&r_bloom_power);
516         Cvar_RegisterVariable(&developer_texturelogging);
517         Cvar_RegisterVariable(&gl_lightmaps);
518         if (gamemode == GAME_NEHAHRA || gamemode == GAME_NEXUIZ || gamemode == GAME_TENEBRAE)
519                 Cvar_SetValue("r_fullbrights", 0);
520         R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
521 }
522
523 static vec3_t r_farclip_origin;
524 static vec3_t r_farclip_direction;
525 static vec_t r_farclip_directiondist;
526 static vec_t r_farclip_meshfarclip;
527 static int r_farclip_directionbit0;
528 static int r_farclip_directionbit1;
529 static int r_farclip_directionbit2;
530
531 // enlarge farclip to accomodate box
532 static void R_FarClip_Box(vec3_t mins, vec3_t maxs)
533 {
534         float d;
535         d = (r_farclip_directionbit0 ? mins[0] : maxs[0]) * r_farclip_direction[0]
536           + (r_farclip_directionbit1 ? mins[1] : maxs[1]) * r_farclip_direction[1]
537           + (r_farclip_directionbit2 ? mins[2] : maxs[2]) * r_farclip_direction[2];
538         if (r_farclip_meshfarclip < d)
539                 r_farclip_meshfarclip = d;
540 }
541
542 // return farclip value
543 static float R_FarClip(vec3_t origin, vec3_t direction, vec_t startfarclip)
544 {
545         int i;
546
547         VectorCopy(origin, r_farclip_origin);
548         VectorCopy(direction, r_farclip_direction);
549         r_farclip_directiondist = DotProduct(r_farclip_origin, r_farclip_direction);
550         r_farclip_directionbit0 = r_farclip_direction[0] < 0;
551         r_farclip_directionbit1 = r_farclip_direction[1] < 0;
552         r_farclip_directionbit2 = r_farclip_direction[2] < 0;
553         r_farclip_meshfarclip = r_farclip_directiondist + startfarclip;
554
555         if (r_refdef.worldmodel)
556                 R_FarClip_Box(r_refdef.worldmodel->normalmins, r_refdef.worldmodel->normalmaxs);
557         for (i = 0;i < r_refdef.numentities;i++)
558                 R_FarClip_Box(r_refdef.entities[i]->mins, r_refdef.entities[i]->maxs);
559
560         return r_farclip_meshfarclip - r_farclip_directiondist;
561 }
562
563 extern void R_Textures_Init(void);
564 extern void GL_Draw_Init(void);
565 extern void GL_Main_Init(void);
566 extern void R_Shadow_Init(void);
567 extern void R_Sky_Init(void);
568 extern void GL_Surf_Init(void);
569 extern void R_Crosshairs_Init(void);
570 extern void R_Light_Init(void);
571 extern void R_Particles_Init(void);
572 extern void R_Explosion_Init(void);
573 extern void gl_backend_init(void);
574 extern void Sbar_Init(void);
575 extern void R_LightningBeams_Init(void);
576 extern void Mod_RenderInit(void);
577
578 void Render_Init(void)
579 {
580         gl_backend_init();
581         R_Textures_Init();
582         Mod_RenderInit();
583         R_MeshQueue_Init();
584         GL_Main_Init();
585         GL_Draw_Init();
586         R_Shadow_Init();
587         R_Sky_Init();
588         GL_Surf_Init();
589         R_Crosshairs_Init();
590         R_Light_Init();
591         R_Particles_Init();
592         R_Explosion_Init();
593         UI_Init();
594         Sbar_Init();
595         R_LightningBeams_Init();
596 }
597
598 /*
599 ===============
600 GL_Init
601 ===============
602 */
603 extern char *ENGINE_EXTENSIONS;
604 void GL_Init (void)
605 {
606         VID_CheckExtensions();
607
608         // LordHavoc: report supported extensions
609         Con_DPrintf("\nengine extensions: %s\n", ENGINE_EXTENSIONS);
610
611         // clear to black (loading plaque will be seen over this)
612         qglClearColor(0,0,0,1);
613         qglClear(GL_COLOR_BUFFER_BIT);
614 }
615
616 int R_CullBox(const vec3_t mins, const vec3_t maxs)
617 {
618         int i;
619         mplane_t *p;
620         for (i = 0;i < 4;i++)
621         {
622                 p = frustum + i;
623                 switch(p->signbits)
624                 {
625                 default:
626                 case 0:
627                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
628                                 return true;
629                         break;
630                 case 1:
631                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
632                                 return true;
633                         break;
634                 case 2:
635                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
636                                 return true;
637                         break;
638                 case 3:
639                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
640                                 return true;
641                         break;
642                 case 4:
643                         if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
644                                 return true;
645                         break;
646                 case 5:
647                         if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
648                                 return true;
649                         break;
650                 case 6:
651                         if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
652                                 return true;
653                         break;
654                 case 7:
655                         if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
656                                 return true;
657                         break;
658                 }
659         }
660         return false;
661 }
662
663 //==================================================================================
664
665 static void R_MarkEntities (void)
666 {
667         int i, renderimask;
668         entity_render_t *ent;
669
670         if (!r_drawentities.integer)
671                 return;
672
673         r_refdef.worldentity->visframe = r_framecount;
674         renderimask = envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : (chase_active.integer ? 0 : RENDER_EXTERIORMODEL);
675         if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs)
676         {
677                 // worldmodel can check visibility
678                 for (i = 0;i < r_refdef.numentities;i++)
679                 {
680                         ent = r_refdef.entities[i];
681                         Mod_CheckLoaded(ent->model);
682                         // some of the renderer still relies on origin...
683                         Matrix4x4_OriginFromMatrix(&ent->matrix, ent->origin);
684                         // some of the renderer still relies on scale...
685                         ent->scale = Matrix4x4_ScaleFromMatrix(&ent->matrix);
686                         if (!(ent->flags & renderimask) && !R_CullBox(ent->mins, ent->maxs) && ((ent->effects & EF_NODEPTHTEST) || r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.worldmodel, r_worldleafvisible, ent->mins, ent->maxs)))
687                         {
688                                 R_UpdateEntLights(ent);
689                                 ent->visframe = r_framecount;
690                         }
691                 }
692         }
693         else
694         {
695                 // no worldmodel or it can't check visibility
696                 for (i = 0;i < r_refdef.numentities;i++)
697                 {
698                         ent = r_refdef.entities[i];
699                         Mod_CheckLoaded(ent->model);
700                         // some of the renderer still relies on origin...
701                         Matrix4x4_OriginFromMatrix(&ent->matrix, ent->origin);
702                         // some of the renderer still relies on scale...
703                         ent->scale = Matrix4x4_ScaleFromMatrix(&ent->matrix);
704                         if (!(ent->flags & renderimask) && !R_CullBox(ent->mins, ent->maxs) && (ent->effects & EF_NODEPTHTEST))
705                         {
706                                 R_UpdateEntLights(ent);
707                                 ent->visframe = r_framecount;
708                         }
709                 }
710         }
711 }
712
713 // only used if skyrendermasked, and normally returns false
714 int R_DrawBrushModelsSky (void)
715 {
716         int i, sky;
717         entity_render_t *ent;
718
719         if (!r_drawentities.integer)
720                 return false;
721
722         sky = false;
723         for (i = 0;i < r_refdef.numentities;i++)
724         {
725                 ent = r_refdef.entities[i];
726                 if (ent->visframe == r_framecount && ent->model && ent->model->DrawSky)
727                 {
728                         ent->model->DrawSky(ent);
729                         sky = true;
730                 }
731         }
732         return sky;
733 }
734
735 void R_DrawNoModel(entity_render_t *ent);
736 void R_DrawModels(void)
737 {
738         int i;
739         entity_render_t *ent;
740
741         if (!r_drawentities.integer)
742                 return;
743
744         for (i = 0;i < r_refdef.numentities;i++)
745         {
746                 ent = r_refdef.entities[i];
747                 if (ent->visframe == r_framecount)
748                 {
749                         if (ent->model && ent->model->Draw != NULL)
750                                 ent->model->Draw(ent);
751                         else
752                                 R_DrawNoModel(ent);
753                 }
754         }
755 }
756
757 static void R_SetFrustum(void)
758 {
759         // break apart the view matrix into vectors for various purposes
760         Matrix4x4_ToVectors(&r_view_matrix, r_viewforward, r_viewleft, r_viewup, r_vieworigin);
761         VectorNegate(r_viewleft, r_viewright);
762
763         // LordHavoc: note to all quake engine coders, the special case for 90
764         // degrees assumed a square view (wrong), so I removed it, Quake2 has it
765         // disabled as well.
766
767         // rotate R_VIEWFORWARD right by FOV_X/2 degrees
768         RotatePointAroundVector( frustum[0].normal, r_viewup, r_viewforward, -(90 - r_view_fov_x / 2));
769         frustum[0].dist = DotProduct (r_vieworigin, frustum[0].normal);
770         PlaneClassify(&frustum[0]);
771
772         // rotate R_VIEWFORWARD left by FOV_X/2 degrees
773         RotatePointAroundVector( frustum[1].normal, r_viewup, r_viewforward, (90 - r_view_fov_x / 2));
774         frustum[1].dist = DotProduct (r_vieworigin, frustum[1].normal);
775         PlaneClassify(&frustum[1]);
776
777         // rotate R_VIEWFORWARD up by FOV_X/2 degrees
778         RotatePointAroundVector( frustum[2].normal, r_viewleft, r_viewforward, -(90 - r_view_fov_y / 2));
779         frustum[2].dist = DotProduct (r_vieworigin, frustum[2].normal);
780         PlaneClassify(&frustum[2]);
781
782         // rotate R_VIEWFORWARD down by FOV_X/2 degrees
783         RotatePointAroundVector( frustum[3].normal, r_viewleft, r_viewforward, (90 - r_view_fov_y / 2));
784         frustum[3].dist = DotProduct (r_vieworigin, frustum[3].normal);
785         PlaneClassify(&frustum[3]);
786
787         // nearclip plane
788         VectorCopy(r_viewforward, frustum[4].normal);
789         frustum[4].dist = DotProduct (r_vieworigin, frustum[4].normal) + 1.0f;
790         PlaneClassify(&frustum[4]);
791 }
792
793 static void R_BlendView(void)
794 {
795         rmeshstate_t m;
796
797         if (r_refdef.viewblend[3] < 0.01f && !r_bloom.integer)
798                 return;
799
800         GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
801         GL_DepthMask(true);
802         GL_DepthTest(false);
803         R_Mesh_Matrix(&r_identitymatrix);
804         // vertex coordinates for a quad that covers the screen exactly
805         varray_vertex3f[0] = 0;varray_vertex3f[1] = 0;varray_vertex3f[2] = 0;
806         varray_vertex3f[3] = 1;varray_vertex3f[4] = 0;varray_vertex3f[5] = 0;
807         varray_vertex3f[6] = 1;varray_vertex3f[7] = 1;varray_vertex3f[8] = 0;
808         varray_vertex3f[9] = 0;varray_vertex3f[10] = 1;varray_vertex3f[11] = 0;
809         if (r_bloom.integer && r_bloom_resolution.value >= 32 && r_bloom_power.integer >= 1 && r_bloom_power.integer < 100 && r_bloom_blur.value >= 0 && r_bloom_blur.value < 512)
810         {
811                 int screenwidth, screenheight, bloomwidth, bloomheight, x, dobloomblend, range;
812                 float xoffset, yoffset, r;
813                 c_bloom++;
814                 // set the (poorly named) screenwidth and screenheight variables to
815                 // a power of 2 at least as large as the screen, these will define the
816                 // size of the texture to allocate
817                 for (screenwidth = 1;screenwidth < vid.width;screenwidth *= 2);
818                 for (screenheight = 1;screenheight < vid.height;screenheight *= 2);
819                 // allocate textures as needed
820                 if (!r_bloom_texture_screen)
821                         r_bloom_texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", screenwidth, screenheight, NULL, TEXTYPE_RGBA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
822                 if (!r_bloom_texture_bloom)
823                         r_bloom_texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", screenwidth, screenheight, NULL, TEXTYPE_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
824                 // set bloomwidth and bloomheight to the bloom resolution that will be
825                 // used (often less than the screen resolution for faster rendering)
826                 bloomwidth = min(r_view_width, r_bloom_resolution.integer);
827                 bloomheight = min(r_view_height, bloomwidth * r_view_height / r_view_width);
828                 // set up a texcoord array for the full resolution screen image
829                 // (we have to keep this around to copy back during final render)
830                 varray_texcoord2f[0][0] = 0;
831                 varray_texcoord2f[0][1] = (float)r_view_height / (float)screenheight;
832                 varray_texcoord2f[0][2] = (float)r_view_width / (float)screenwidth;
833                 varray_texcoord2f[0][3] = (float)r_view_height / (float)screenheight;
834                 varray_texcoord2f[0][4] = (float)r_view_width / (float)screenwidth;
835                 varray_texcoord2f[0][5] = 0;
836                 varray_texcoord2f[0][6] = 0;
837                 varray_texcoord2f[0][7] = 0;
838                 // set up a texcoord array for the reduced resolution bloom image
839                 // (which will be additive blended over the screen image)
840                 varray_texcoord2f[1][0] = 0;
841                 varray_texcoord2f[1][1] = (float)bloomheight / (float)screenheight;
842                 varray_texcoord2f[1][2] = (float)bloomwidth / (float)screenwidth;
843                 varray_texcoord2f[1][3] = (float)bloomheight / (float)screenheight;
844                 varray_texcoord2f[1][4] = (float)bloomwidth / (float)screenwidth;
845                 varray_texcoord2f[1][5] = 0;
846                 varray_texcoord2f[1][6] = 0;
847                 varray_texcoord2f[1][7] = 0;
848                 memset(&m, 0, sizeof(m));
849                 m.pointer_vertex = varray_vertex3f;
850                 m.pointer_texcoord[0] = varray_texcoord2f[0];
851                 m.tex[0] = R_GetTexture(r_bloom_texture_screen);
852                 R_Mesh_State(&m);
853                 // copy view into the full resolution screen image texture
854                 GL_ActiveTexture(0);
855                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view_x, vid.height - (r_view_y + r_view_height), r_view_width, r_view_height);
856                 c_bloomcopies++;
857                 c_bloomcopypixels += r_view_width * r_view_height;
858                 // now scale it down to the bloom size and raise to a power of itself
859                 // to darken it (this leaves the really bright stuff bright, and
860                 // everything else becomes very dark)
861                 // TODO: optimize with multitexture or GLSL
862                 qglViewport(r_view_x, vid.height - (r_view_y + bloomheight), bloomwidth, bloomheight);
863                 GL_BlendFunc(GL_ONE, GL_ZERO);
864                 GL_Color(1, 1, 1, 1);
865                 R_Mesh_Draw(0, 4, 2, polygonelements);
866                 c_bloomdraws++;
867                 c_bloomdrawpixels += bloomwidth * bloomheight;
868                 // render multiple times with a multiply blendfunc to raise to a power
869                 GL_BlendFunc(GL_DST_COLOR, GL_ZERO);
870                 for (x = 1;x < r_bloom_power.integer;x++)
871                 {
872                         R_Mesh_Draw(0, 4, 2, polygonelements);
873                         c_bloomdraws++;
874                         c_bloomdrawpixels += bloomwidth * bloomheight;
875                 }
876                 // we now have a darkened bloom image in the framebuffer, copy it into
877                 // the bloom image texture for more processing
878                 memset(&m, 0, sizeof(m));
879                 m.pointer_vertex = varray_vertex3f;
880                 m.tex[0] = R_GetTexture(r_bloom_texture_bloom);
881                 m.pointer_texcoord[0] = varray_texcoord2f[2];
882                 R_Mesh_State(&m);
883                 GL_ActiveTexture(0);
884                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view_x, vid.height - (r_view_y + bloomheight), bloomwidth, bloomheight);
885                 c_bloomcopies++;
886                 c_bloomcopypixels += bloomwidth * bloomheight;
887                 // blend on at multiple vertical offsets to achieve a vertical blur
888                 // TODO: do offset blends using GLSL
889                 range = r_bloom_blur.integer * bloomwidth / 320;
890                 GL_BlendFunc(GL_ONE, GL_ZERO);
891                 for (x = -range;x <= range;x++)
892                 {
893                         xoffset = 0 / (float)bloomwidth * (float)bloomwidth / (float)screenwidth;
894                         yoffset = x / (float)bloomheight * (float)bloomheight / (float)screenheight;
895                         // compute a texcoord array with the specified x and y offset
896                         varray_texcoord2f[2][0] = xoffset+0;
897                         varray_texcoord2f[2][1] = yoffset+(float)bloomheight / (float)screenheight;
898                         varray_texcoord2f[2][2] = xoffset+(float)bloomwidth / (float)screenwidth;
899                         varray_texcoord2f[2][3] = yoffset+(float)bloomheight / (float)screenheight;
900                         varray_texcoord2f[2][4] = xoffset+(float)bloomwidth / (float)screenwidth;
901                         varray_texcoord2f[2][5] = yoffset+0;
902                         varray_texcoord2f[2][6] = xoffset+0;
903                         varray_texcoord2f[2][7] = yoffset+0;
904                         // this r value looks like a 'dot' particle, fading sharply to
905                         // black at the edges
906                         // (probably not realistic but looks good enough)
907                         r = r_bloom_intensity.value/(range*2+1)*(1 - x*x/(float)(range*range));
908                         if (r < 0.01f)
909                                 continue;
910                         GL_Color(r, r, r, 1);
911                         R_Mesh_Draw(0, 4, 2, polygonelements);
912                         c_bloomdraws++;
913                         c_bloomdrawpixels += bloomwidth * bloomheight;
914                         GL_BlendFunc(GL_ONE, GL_ONE);
915                 }
916                 // copy the vertically blurred bloom view to a texture
917                 GL_ActiveTexture(0);
918                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view_x, vid.height - (r_view_y + bloomheight), bloomwidth, bloomheight);
919                 c_bloomcopies++;
920                 c_bloomcopypixels += bloomwidth * bloomheight;
921                 // blend the vertically blurred image at multiple offsets horizontally
922                 // to finish the blur effect
923                 // TODO: do offset blends using GLSL
924                 range = r_bloom_blur.integer * bloomwidth / 320;
925                 GL_BlendFunc(GL_ONE, GL_ZERO);
926                 for (x = -range;x <= range;x++)
927                 {
928                         xoffset = x / (float)bloomwidth * (float)bloomwidth / (float)screenwidth;
929                         yoffset = 0 / (float)bloomheight * (float)bloomheight / (float)screenheight;
930                         // compute a texcoord array with the specified x and y offset
931                         varray_texcoord2f[2][0] = xoffset+0;
932                         varray_texcoord2f[2][1] = yoffset+(float)bloomheight / (float)screenheight;
933                         varray_texcoord2f[2][2] = xoffset+(float)bloomwidth / (float)screenwidth;
934                         varray_texcoord2f[2][3] = yoffset+(float)bloomheight / (float)screenheight;
935                         varray_texcoord2f[2][4] = xoffset+(float)bloomwidth / (float)screenwidth;
936                         varray_texcoord2f[2][5] = yoffset+0;
937                         varray_texcoord2f[2][6] = xoffset+0;
938                         varray_texcoord2f[2][7] = yoffset+0;
939                         // this r value looks like a 'dot' particle, fading sharply to
940                         // black at the edges
941                         // (probably not realistic but looks good enough)
942                         r = r_bloom_intensity.value/(range*2+1)*(1 - x*x/(float)(range*range));
943                         if (r < 0.01f)
944                                 continue;
945                         GL_Color(r, r, r, 1);
946                         R_Mesh_Draw(0, 4, 2, polygonelements);
947                         c_bloomdraws++;
948                         c_bloomdrawpixels += bloomwidth * bloomheight;
949                         GL_BlendFunc(GL_ONE, GL_ONE);
950                 }
951                 // copy the blurred bloom view to a texture
952                 GL_ActiveTexture(0);
953                 qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view_x, vid.height - (r_view_y + bloomheight), bloomwidth, bloomheight);
954                 c_bloomcopies++;
955                 c_bloomcopypixels += bloomwidth * bloomheight;
956                 // go back to full view area
957                 qglViewport(r_view_x, vid.height - (r_view_y + r_view_height), r_view_width, r_view_height);
958                 // put the original screen image back in place and blend the bloom
959                 // texture on it
960                 memset(&m, 0, sizeof(m));
961                 m.pointer_vertex = varray_vertex3f;
962                 m.tex[0] = R_GetTexture(r_bloom_texture_screen);
963                 m.pointer_texcoord[0] = varray_texcoord2f[0];
964 #if 0
965                 dobloomblend = false;
966 #else
967                 // do both in one pass if possible
968                 if (r_textureunits.integer >= 2 && gl_combine.integer)
969                 {
970                         dobloomblend = false;
971                         m.texcombinergb[1] = GL_ADD;
972                         m.tex[1] = R_GetTexture(r_bloom_texture_bloom);
973                         m.pointer_texcoord[1] = varray_texcoord2f[1];
974                 }
975                 else
976                         dobloomblend = true;
977 #endif
978                 R_Mesh_State(&m);
979                 GL_BlendFunc(GL_ONE, GL_ZERO);
980                 GL_Color(1,1,1,1);
981                 R_Mesh_Draw(0, 4, 2, polygonelements);
982                 c_bloomdraws++;
983                 c_bloomdrawpixels += r_view_width * r_view_height;
984                 // now blend on the bloom texture if multipass
985                 if (dobloomblend)
986                 {
987                         memset(&m, 0, sizeof(m));
988                         m.pointer_vertex = varray_vertex3f;
989                         m.tex[0] = R_GetTexture(r_bloom_texture_bloom);
990                         m.pointer_texcoord[0] = varray_texcoord2f[1];
991                         R_Mesh_State(&m);
992                         GL_BlendFunc(GL_ONE, GL_ONE);
993                         GL_Color(1,1,1,1);
994                         R_Mesh_Draw(0, 4, 2, polygonelements);
995                         c_bloomdraws++;
996                         c_bloomdrawpixels += r_view_width * r_view_height;
997                 }
998         }
999         if (r_refdef.viewblend[3] >= 0.01f)
1000         {
1001                 // apply a color tint to the whole view
1002                 memset(&m, 0, sizeof(m));
1003                 m.pointer_vertex = varray_vertex3f;
1004                 R_Mesh_State(&m);
1005                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1006                 GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
1007                 R_Mesh_Draw(0, 4, 2, polygonelements);
1008         }
1009 }
1010
1011 void R_RenderScene(void);
1012
1013 matrix4x4_t r_waterscrollmatrix;
1014
1015 /*
1016 ================
1017 R_RenderView
1018 ================
1019 */
1020 void R_RenderView(void)
1021 {
1022         if (!r_refdef.entities/* || !r_refdef.worldmodel*/)
1023                 return; //Host_Error ("R_RenderView: NULL worldmodel");
1024
1025         r_view_width = bound(0, r_refdef.width, vid.width);
1026         r_view_height = bound(0, r_refdef.height, vid.height);
1027         r_view_depth = 1;
1028         r_view_x = bound(0, r_refdef.x, vid.width - r_refdef.width);
1029         r_view_y = bound(0, r_refdef.y, vid.height - r_refdef.height);
1030         r_view_z = 0;
1031         r_view_fov_x = bound(1, r_refdef.fov_x, 170);
1032         r_view_fov_y = bound(1, r_refdef.fov_y, 170);
1033         r_view_matrix = r_refdef.viewentitymatrix;
1034         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
1035         r_rtworld = r_shadow_realtime_world.integer;
1036         r_rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil;
1037         r_rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer;
1038         r_rtdlightshadows = r_rtdlight && (r_rtworld ? r_shadow_realtime_world_dlightshadows.integer : r_shadow_realtime_dlight_shadows.integer) && gl_stencil;
1039         r_lightmapintensity = r_rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
1040
1041         // GL is weird because it's bottom to top, r_view_y is top to bottom
1042         qglViewport(r_view_x, vid.height - (r_view_y + r_view_height), r_view_width, r_view_height);
1043         GL_Scissor(r_view_x, r_view_y, r_view_width, r_view_height);
1044         GL_ScissorTest(true);
1045         GL_DepthMask(true);
1046         R_ClearScreen();
1047         R_Textures_Frame();
1048         R_UpdateFog();
1049         R_UpdateLights();
1050         R_TimeReport("setup");
1051
1052         qglDepthFunc(GL_LEQUAL);
1053         qglPolygonOffset(0, 0);
1054         qglEnable(GL_POLYGON_OFFSET_FILL);
1055
1056         R_RenderScene();
1057
1058         qglPolygonOffset(0, 0);
1059         qglDisable(GL_POLYGON_OFFSET_FILL);
1060
1061         R_BlendView();
1062         R_TimeReport("blendview");
1063
1064         GL_Scissor(0, 0, vid.width, vid.height);
1065         GL_ScissorTest(false);
1066 }
1067
1068 extern void R_DrawLightningBeams (void);
1069 void R_RenderScene(void)
1070 {
1071         // don't let sound skip if going slow
1072         if (r_refdef.extraupdate)
1073                 S_ExtraUpdate ();
1074
1075         r_framecount++;
1076
1077         R_MeshQueue_BeginScene();
1078
1079         GL_ShowTrisColor(0.05, 0.05, 0.05, 1);
1080
1081         R_SetFrustum();
1082
1083         r_farclip = R_FarClip(r_vieworigin, r_viewforward, 768.0f) + 256.0f;
1084         if (r_rtworldshadows || r_rtdlightshadows)
1085                 GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_view_fov_x, r_view_fov_y, 1.0f);
1086         else
1087                 GL_SetupView_Mode_Perspective(r_view_fov_x, r_view_fov_y, 1.0f, r_farclip);
1088
1089         GL_SetupView_Orientation_FromEntity(&r_view_matrix);
1090
1091         Matrix4x4_CreateTranslate(&r_waterscrollmatrix, sin(r_refdef.time) * 0.025 * r_waterscroll.value, sin(r_refdef.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
1092
1093         R_SkyStartFrame();
1094
1095         R_WorldVisibility();
1096         R_TimeReport("worldvis");
1097
1098         R_MarkEntities();
1099         R_TimeReport("markentity");
1100
1101         R_Shadow_UpdateWorldLightSelection();
1102
1103         // don't let sound skip if going slow
1104         if (r_refdef.extraupdate)
1105                 S_ExtraUpdate ();
1106
1107         GL_ShowTrisColor(0.025, 0.025, 0, 1);
1108         if (r_refdef.worldmodel && r_refdef.worldmodel->DrawSky)
1109         {
1110                 r_refdef.worldmodel->DrawSky(r_refdef.worldentity);
1111                 R_TimeReport("worldsky");
1112         }
1113
1114         if (R_DrawBrushModelsSky())
1115                 R_TimeReport("bmodelsky");
1116
1117         GL_ShowTrisColor(0.05, 0.05, 0.05, 1);
1118         if (r_refdef.worldmodel && r_refdef.worldmodel->Draw)
1119         {
1120                 r_refdef.worldmodel->Draw(r_refdef.worldentity);
1121                 R_TimeReport("world");
1122         }
1123
1124         // don't let sound skip if going slow
1125         if (r_refdef.extraupdate)
1126                 S_ExtraUpdate ();
1127
1128         GL_ShowTrisColor(0, 0.015, 0, 1);
1129
1130         R_DrawModels();
1131         R_TimeReport("models");
1132
1133         // don't let sound skip if going slow
1134         if (r_refdef.extraupdate)
1135                 S_ExtraUpdate ();
1136
1137         GL_ShowTrisColor(0, 0, 0.033, 1);
1138         R_ShadowVolumeLighting(false);
1139         R_TimeReport("rtlights");
1140
1141         // don't let sound skip if going slow
1142         if (r_refdef.extraupdate)
1143                 S_ExtraUpdate ();
1144
1145         GL_ShowTrisColor(0.1, 0, 0, 1);
1146
1147         R_DrawLightningBeams();
1148         R_TimeReport("lightning");
1149
1150         R_DrawParticles();
1151         R_TimeReport("particles");
1152
1153         R_DrawExplosions();
1154         R_TimeReport("explosions");
1155
1156         R_MeshQueue_RenderTransparent();
1157         R_TimeReport("drawtrans");
1158
1159         R_DrawCoronas();
1160         R_TimeReport("coronas");
1161
1162         R_DrawWorldCrosshair();
1163         R_TimeReport("crosshair");
1164
1165         R_MeshQueue_Render();
1166         R_MeshQueue_EndScene();
1167
1168         if ((r_shadow_visiblelighting.integer || r_shadow_visiblevolumes.integer) && !r_showtrispass)
1169         {
1170                 R_ShadowVolumeLighting(true);
1171                 R_TimeReport("visiblevolume");
1172         }
1173
1174         GL_ShowTrisColor(0.05, 0.05, 0.05, 1);
1175
1176         // don't let sound skip if going slow
1177         if (r_refdef.extraupdate)
1178                 S_ExtraUpdate ();
1179 }
1180
1181 /*
1182 void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
1183 {
1184         int i;
1185         float *v, *c, f1, f2, diff[3], vertex3f[8*3], color4f[8*4];
1186         rmeshstate_t m;
1187         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1188         GL_DepthMask(false);
1189         GL_DepthTest(true);
1190         R_Mesh_Matrix(&r_identitymatrix);
1191
1192         vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2];
1193         vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
1194         vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
1195         vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
1196         vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
1197         vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
1198         vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
1199         vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
1200         R_FillColors(color, 8, cr, cg, cb, ca);
1201         if (fogenabled)
1202         {
1203                 for (i = 0, v = vertex, c = color;i < 8;i++, v += 4, c += 4)
1204                 {
1205                         VectorSubtract(v, r_vieworigin, diff);
1206                         f2 = exp(fogdensity/DotProduct(diff, diff));
1207                         f1 = 1 - f2;
1208                         c[0] = c[0] * f1 + fogcolor[0] * f2;
1209                         c[1] = c[1] * f1 + fogcolor[1] * f2;
1210                         c[2] = c[2] * f1 + fogcolor[2] * f2;
1211                 }
1212         }
1213         memset(&m, 0, sizeof(m));
1214         m.pointer_vertex = vertex3f;
1215         m.pointer_color = color;
1216         R_Mesh_State(&m);
1217         R_Mesh_Draw(8, 12);
1218 }
1219 */
1220
1221 int nomodelelements[24] =
1222 {
1223         5, 2, 0,
1224         5, 1, 2,
1225         5, 0, 3,
1226         5, 3, 1,
1227         0, 2, 4,
1228         2, 1, 4,
1229         3, 0, 4,
1230         1, 3, 4
1231 };
1232
1233 float nomodelvertex3f[6*3] =
1234 {
1235         -16,   0,   0,
1236          16,   0,   0,
1237           0, -16,   0,
1238           0,  16,   0,
1239           0,   0, -16,
1240           0,   0,  16
1241 };
1242
1243 float nomodelcolor4f[6*4] =
1244 {
1245         0.0f, 0.0f, 0.5f, 1.0f,
1246         0.0f, 0.0f, 0.5f, 1.0f,
1247         0.0f, 0.5f, 0.0f, 1.0f,
1248         0.0f, 0.5f, 0.0f, 1.0f,
1249         0.5f, 0.0f, 0.0f, 1.0f,
1250         0.5f, 0.0f, 0.0f, 1.0f
1251 };
1252
1253 void R_DrawNoModelCallback(const void *calldata1, int calldata2)
1254 {
1255         const entity_render_t *ent = calldata1;
1256         int i;
1257         float f1, f2, *c, diff[3];
1258         float color4f[6*4];
1259         rmeshstate_t m;
1260         R_Mesh_Matrix(&ent->matrix);
1261
1262         memset(&m, 0, sizeof(m));
1263         m.pointer_vertex = nomodelvertex3f;
1264
1265         if (ent->flags & EF_ADDITIVE)
1266         {
1267                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1268                 GL_DepthMask(false);
1269         }
1270         else if (ent->alpha < 1)
1271         {
1272                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1273                 GL_DepthMask(false);
1274         }
1275         else
1276         {
1277                 GL_BlendFunc(GL_ONE, GL_ZERO);
1278                 GL_DepthMask(true);
1279         }
1280         GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
1281         if (fogenabled)
1282         {
1283                 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
1284                 m.pointer_color = color4f;
1285                 VectorSubtract(ent->origin, r_vieworigin, diff);
1286                 f2 = exp(fogdensity/DotProduct(diff, diff));
1287                 f1 = 1 - f2;
1288                 for (i = 0, c = color4f;i < 6;i++, c += 4)
1289                 {
1290                         c[0] = (c[0] * f1 + fogcolor[0] * f2);
1291                         c[1] = (c[1] * f1 + fogcolor[1] * f2);
1292                         c[2] = (c[2] * f1 + fogcolor[2] * f2);
1293                         c[3] *= ent->alpha;
1294                 }
1295         }
1296         else if (ent->alpha != 1)
1297         {
1298                 memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
1299                 m.pointer_color = color4f;
1300                 for (i = 0, c = color4f;i < 6;i++, c += 4)
1301                         c[3] *= ent->alpha;
1302         }
1303         else
1304                 m.pointer_color = nomodelcolor4f;
1305         R_Mesh_State(&m);
1306         R_Mesh_Draw(0, 6, 8, nomodelelements);
1307 }
1308
1309 void R_DrawNoModel(entity_render_t *ent)
1310 {
1311         //if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
1312                 R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_vieworigin : ent->origin, R_DrawNoModelCallback, ent, 0);
1313         //else
1314         //      R_DrawNoModelCallback(ent, 0);
1315 }
1316
1317 void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
1318 {
1319         vec3_t right1, right2, diff, normal;
1320
1321         VectorSubtract (org2, org1, normal);
1322
1323         // calculate 'right' vector for start
1324         VectorSubtract (r_vieworigin, org1, diff);
1325         CrossProduct (normal, diff, right1);
1326         VectorNormalize (right1);
1327
1328         // calculate 'right' vector for end
1329         VectorSubtract (r_vieworigin, org2, diff);
1330         CrossProduct (normal, diff, right2);
1331         VectorNormalize (right2);
1332
1333         vert[ 0] = org1[0] + width * right1[0];
1334         vert[ 1] = org1[1] + width * right1[1];
1335         vert[ 2] = org1[2] + width * right1[2];
1336         vert[ 3] = org1[0] - width * right1[0];
1337         vert[ 4] = org1[1] - width * right1[1];
1338         vert[ 5] = org1[2] - width * right1[2];
1339         vert[ 6] = org2[0] - width * right2[0];
1340         vert[ 7] = org2[1] - width * right2[1];
1341         vert[ 8] = org2[2] - width * right2[2];
1342         vert[ 9] = org2[0] + width * right2[0];
1343         vert[10] = org2[1] + width * right2[1];
1344         vert[11] = org2[2] + width * right2[2];
1345 }
1346
1347 float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
1348
1349 void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, int depthdisable, const vec3_t origin, const vec3_t left, const vec3_t up, float scalex1, float scalex2, float scaley1, float scaley2, float cr, float cg, float cb, float ca)
1350 {
1351         float diff[3];
1352         rmeshstate_t m;
1353
1354         if (fogenabled)
1355         {
1356                 VectorSubtract(origin, r_vieworigin, diff);
1357                 ca *= 1 - exp(fogdensity/DotProduct(diff,diff));
1358         }
1359
1360         R_Mesh_Matrix(&r_identitymatrix);
1361         GL_BlendFunc(blendfunc1, blendfunc2);
1362         GL_DepthMask(false);
1363         GL_DepthTest(!depthdisable);
1364
1365         varray_vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
1366         varray_vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
1367         varray_vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
1368         varray_vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
1369         varray_vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
1370         varray_vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
1371         varray_vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
1372         varray_vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
1373         varray_vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
1374         varray_vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
1375         varray_vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
1376         varray_vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
1377
1378         memset(&m, 0, sizeof(m));
1379         m.tex[0] = R_GetTexture(texture);
1380         m.pointer_texcoord[0] = spritetexcoord2f;
1381         m.pointer_vertex = varray_vertex3f;
1382         R_Mesh_State(&m);
1383         GL_Color(cr, cg, cb, ca);
1384         R_Mesh_Draw(0, 4, 2, polygonelements);
1385 }
1386
1387 int R_Mesh_AddVertex3f(rmesh_t *mesh, const float *v)
1388 {
1389         int i;
1390         float *vertex3f;
1391         for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
1392                 if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
1393                         break;
1394         if (i == mesh->numvertices)
1395         {
1396                 if (mesh->numvertices < mesh->maxvertices)
1397                 {
1398                         VectorCopy(v, vertex3f);
1399                         mesh->numvertices++;
1400                 }
1401                 return mesh->numvertices;
1402         }
1403         else
1404                 return i;
1405 }
1406
1407 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
1408 {
1409         int i;
1410         int *e, element[3];
1411         element[0] = R_Mesh_AddVertex3f(mesh, vertex3f);vertex3f += 3;
1412         element[1] = R_Mesh_AddVertex3f(mesh, vertex3f);vertex3f += 3;
1413         e = mesh->element3i + mesh->numtriangles * 3;
1414         for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
1415         {
1416                 element[2] = R_Mesh_AddVertex3f(mesh, vertex3f);
1417                 if (mesh->numtriangles < mesh->maxtriangles)
1418                 {
1419                         *e++ = element[0];
1420                         *e++ = element[1];
1421                         *e++ = element[2];
1422                         mesh->numtriangles++;
1423                 }
1424                 element[1] = element[2];
1425         }
1426 }
1427
1428 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
1429 {
1430         int planenum, planenum2;
1431         int w;
1432         int tempnumpoints;
1433         mplane_t *plane, *plane2;
1434         float temppoints[2][256*3];
1435         for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
1436         {
1437                 w = 0;
1438                 tempnumpoints = 4;
1439                 PolygonF_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->normal[3], 1024.0*1024.0*1024.0);
1440                 for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
1441                 {
1442                         if (planenum2 == planenum)
1443                                 continue;
1444                         PolygonF_Divide(tempnumpoints, temppoints[w], plane2->normal[0], plane2->normal[1], plane2->normal[2], plane2->dist, 1.0/32.0, 0, NULL, NULL, 256, temppoints[!w], &tempnumpoints);
1445                         w = !w;
1446                 }
1447                 if (tempnumpoints < 3)
1448                         continue;
1449                 // generate elements forming a triangle fan for this polygon
1450                 R_Mesh_AddPolygon3f(mesh, tempnumpoints, temppoints[w]);
1451         }
1452 }
1453
1454 void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
1455 {
1456         texture_t *texture = t;
1457         model_t *model = ent->model;
1458         int s = ent->skinnum;
1459         if ((unsigned int)s >= (unsigned int)model->numskins)
1460                 s = 0;
1461         if (s >= 1)
1462                 c_models++;
1463         if (model->skinscenes)
1464         {
1465                 if (model->skinscenes[s].framecount > 1)
1466                         s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
1467                 else
1468                         s = model->skinscenes[s].firstframe;
1469         }
1470         if (s > 0)
1471                 t = t + s * model->num_surfaces;
1472         if (t->animated)
1473                 t = t->anim_frames[ent->frame != 0][(t->anim_total[ent->frame != 0] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[ent->frame != 0]) : 0];
1474         texture->currentframe = t;
1475         t->currentmaterialflags = t->basematerialflags;
1476         t->currentalpha = ent->alpha;
1477         if (t->basematerialflags & MATERIALFLAG_WATERALPHA)
1478                 t->currentalpha *= r_wateralpha.value;
1479         if (!(ent->flags & RENDER_LIGHT))
1480                 t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
1481         if (ent->effects & EF_ADDITIVE)
1482                 t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_TRANSPARENT;
1483         else if (t->currentalpha < 1)
1484                 t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_TRANSPARENT;
1485 }
1486
1487 void R_UpdateAllTextureInfo(entity_render_t *ent)
1488 {
1489         int i;
1490         if (ent->model)
1491                 for (i = 0;i < ent->model->num_textures;i++)
1492                         R_UpdateTextureInfo(ent, ent->model->data_textures + i);
1493 }
1494
1495 float *rsurface_vertex3f;
1496 float *rsurface_svector3f;
1497 float *rsurface_tvector3f;
1498 float *rsurface_normal3f;
1499 float *rsurface_lightmapcolor4f;
1500
1501 void RSurf_SetVertexPointer(const entity_render_t *ent, const texture_t *texture, const msurface_t *surface, const vec3_t modelorg)
1502 {
1503         int i, j;
1504         float center[3], forward[3], right[3], up[3], v[4][3];
1505         matrix4x4_t matrix1, imatrix1;
1506         if ((ent->frameblend[0].lerp != 1 || ent->frameblend[0].frame != 0) && (surface->groupmesh->data_morphvertex3f || surface->groupmesh->data_vertexboneweights))
1507         {
1508                 rsurface_vertex3f = varray_vertex3f;
1509                 rsurface_svector3f = NULL;
1510                 rsurface_tvector3f = NULL;
1511                 rsurface_normal3f = NULL;
1512                 Mod_Alias_GetMesh_Vertex3f(ent->model, ent->frameblend, surface->groupmesh, rsurface_vertex3f);
1513         }
1514         else
1515         {
1516                 rsurface_vertex3f = surface->groupmesh->data_vertex3f;
1517                 rsurface_svector3f = surface->groupmesh->data_svector3f;
1518                 rsurface_tvector3f = surface->groupmesh->data_tvector3f;
1519                 rsurface_normal3f = surface->groupmesh->data_normal3f;
1520         }
1521         if (texture->textureflags & Q3TEXTUREFLAG_AUTOSPRITE2)
1522         {
1523                 if (!rsurface_svector3f)
1524                 {
1525                         rsurface_svector3f = varray_svector3f;
1526                         rsurface_tvector3f = varray_tvector3f;
1527                         rsurface_normal3f = varray_normal3f;
1528                         Mod_BuildTextureVectorsAndNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_vertex3f, surface->groupmesh->data_texcoordtexture2f, surface->groupmesh->data_element3i + surface->num_firsttriangle * 3, rsurface_svector3f, rsurface_tvector3f, rsurface_normal3f);
1529                 }
1530                 // a single autosprite surface can contain multiple sprites...
1531                 VectorClear(forward);
1532                 VectorClear(right);
1533                 VectorSet(up, 0, 0, 1);
1534                 for (j = 0;j < surface->num_vertices - 3;j += 4)
1535                 {
1536                         VectorClear(center);
1537                         for (i = 0;i < 4;i++)
1538                                 VectorAdd(center, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
1539                         VectorScale(center, 0.25f, center);
1540                         // FIXME: calculate vectors from triangle edges instead of using texture vectors as an easy way out?
1541                         Matrix4x4_FromVectors(&matrix1, (rsurface_normal3f + 3 * surface->num_firstvertex) + j*3, (rsurface_svector3f + 3 * surface->num_firstvertex) + j*3, (rsurface_tvector3f + 3 * surface->num_firstvertex) + j*3, center);
1542                         Matrix4x4_Invert_Simple(&imatrix1, &matrix1);
1543                         for (i = 0;i < 4;i++)
1544                                 Matrix4x4_Transform(&imatrix1, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, v[i]);
1545                         forward[0] = modelorg[0] - center[0];
1546                         forward[1] = modelorg[1] - center[1];
1547                         VectorNormalize(forward);
1548                         right[0] = forward[1];
1549                         right[1] = -forward[0];
1550                         for (i = 0;i < 4;i++)
1551                                 VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, varray_vertex3f + (surface->num_firstvertex+i+j) * 3);
1552                 }
1553                 rsurface_vertex3f = varray_vertex3f;
1554                 rsurface_svector3f = NULL;
1555                 rsurface_tvector3f = NULL;
1556                 rsurface_normal3f = NULL;
1557         }
1558         else if (texture->textureflags & Q3TEXTUREFLAG_AUTOSPRITE)
1559         {
1560                 if (!rsurface_svector3f)
1561                 {
1562                         rsurface_svector3f = varray_svector3f;
1563                         rsurface_tvector3f = varray_tvector3f;
1564                         rsurface_normal3f = varray_normal3f;
1565                         Mod_BuildTextureVectorsAndNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_vertex3f, surface->groupmesh->data_texcoordtexture2f, surface->groupmesh->data_element3i + surface->num_firsttriangle * 3, rsurface_svector3f, rsurface_tvector3f, rsurface_normal3f);
1566                 }
1567                 Matrix4x4_Transform(&ent->inversematrix, r_viewforward, forward);
1568                 Matrix4x4_Transform(&ent->inversematrix, r_viewright, right);
1569                 Matrix4x4_Transform(&ent->inversematrix, r_viewup, up);
1570                 // a single autosprite surface can contain multiple sprites...
1571                 for (j = 0;j < surface->num_vertices - 3;j += 4)
1572                 {
1573                         VectorClear(center);
1574                         for (i = 0;i < 4;i++)
1575                                 VectorAdd(center, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
1576                         VectorScale(center, 0.25f, center);
1577                         // FIXME: calculate vectors from triangle edges instead of using texture vectors as an easy way out?
1578                         Matrix4x4_FromVectors(&matrix1, (rsurface_normal3f + 3 * surface->num_firstvertex) + j*3, (rsurface_svector3f + 3 * surface->num_firstvertex) + j*3, (rsurface_tvector3f + 3 * surface->num_firstvertex) + j*3, center);
1579                         Matrix4x4_Invert_Simple(&imatrix1, &matrix1);
1580                         for (i = 0;i < 4;i++)
1581                                 Matrix4x4_Transform(&imatrix1, (rsurface_vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, v[i]);
1582                         for (i = 0;i < 4;i++)
1583                                 VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, varray_vertex3f + (surface->num_firstvertex+i+j) * 3);
1584                 }
1585                 rsurface_vertex3f = varray_vertex3f;
1586                 rsurface_svector3f = NULL;
1587                 rsurface_tvector3f = NULL;
1588                 rsurface_normal3f = NULL;
1589         }
1590         R_Mesh_VertexPointer(rsurface_vertex3f);
1591 }
1592
1593 void RSurf_SetColorPointer(const entity_render_t *ent, const msurface_t *surface, const vec3_t modelorg, float r, float g, float b, float a, qboolean lightmodel, qboolean vertexlight, qboolean applycolor, qboolean applyfog)
1594 {
1595         int i;
1596         float f;
1597         float *v, *c, *c2;
1598         vec3_t diff;
1599         if (lightmodel)
1600         {
1601                 vec4_t ambientcolor4f;
1602                 vec3_t diffusecolor;
1603                 vec3_t diffusenormal;
1604                 if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, r, g, b, a, false))
1605                 {
1606                         rsurface_lightmapcolor4f = varray_color4f;
1607                         if (rsurface_normal3f == NULL)
1608                         {
1609                                 rsurface_normal3f = varray_normal3f;
1610                                 Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_vertex3f, surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle, rsurface_normal3f);
1611                         }
1612                         R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, surface->groupmesh->num_vertices, rsurface_vertex3f + 3 * surface->num_firstvertex, rsurface_normal3f + 3 * surface->num_firstvertex, rsurface_lightmapcolor4f + 4 * surface->num_firstvertex);
1613                         r = 1;
1614                         g = 1;
1615                         b = 1;
1616                         a = 1;
1617                         applycolor = false;
1618                 }
1619                 else
1620                 {
1621                         r = ambientcolor4f[0];
1622                         g = ambientcolor4f[1];
1623                         b = ambientcolor4f[2];
1624                         a = ambientcolor4f[3];
1625                         rsurface_lightmapcolor4f = NULL;
1626                 }
1627         }
1628         else if (vertexlight)
1629         {
1630                 if (surface->lightmapinfo)
1631                 {
1632                         rsurface_lightmapcolor4f = varray_color4f;
1633                         for (i = 0, c = rsurface_lightmapcolor4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
1634                         {
1635                                 const qbyte *lm = surface->lightmapinfo->samples + (surface->groupmesh->data_lightmapoffsets + surface->num_firstvertex)[i];
1636                                 float scale = d_lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f);
1637                                 VectorScale(lm, scale, c);
1638                                 if (surface->lightmapinfo->styles[1] != 255)
1639                                 {
1640                                         int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
1641                                         lm += size3;
1642                                         scale = d_lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
1643                                         VectorMA(c, scale, lm, c);
1644                                         if (surface->lightmapinfo->styles[2] != 255)
1645                                         {
1646                                                 lm += size3;
1647                                                 scale = d_lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
1648                                                 VectorMA(c, scale, lm, c);
1649                                                 if (surface->lightmapinfo->styles[3] != 255)
1650                                                 {
1651                                                         lm += size3;
1652                                                         scale = d_lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
1653                                                         VectorMA(c, scale, lm, c);
1654                                                 }
1655                                         }
1656                                 }
1657                         }
1658                 }
1659                 else
1660                         rsurface_lightmapcolor4f = surface->groupmesh->data_lightmapcolor4f;
1661         }
1662         else
1663                 rsurface_lightmapcolor4f = NULL;
1664         if (applyfog)
1665         {
1666                 if (rsurface_lightmapcolor4f)
1667                 {
1668                         for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (rsurface_lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (varray_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4, c2 += 4)
1669                         {
1670                                 VectorSubtract(v, modelorg, diff);
1671                                 f = 1 - exp(fogdensity/DotProduct(diff, diff));
1672                                 c2[0] = c[0] * f;
1673                                 c2[1] = c[1] * f;
1674                                 c2[2] = c[2] * f;
1675                                 c2[3] = c[3];
1676                         }
1677                 }
1678                 else
1679                 {
1680                         for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c2 = (varray_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c2 += 4)
1681                         {
1682                                 VectorSubtract(v, modelorg, diff);
1683                                 f = 1 - exp(fogdensity/DotProduct(diff, diff));
1684                                 c2[0] = f;
1685                                 c2[1] = f;
1686                                 c2[2] = f;
1687                                 c2[3] = 1;
1688                         }
1689                 }
1690                 rsurface_lightmapcolor4f = varray_color4f;
1691         }
1692         if (applycolor && rsurface_lightmapcolor4f)
1693         {
1694                 for (i = 0, c = (rsurface_lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (varray_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, c += 4, c2 += 4)
1695                 {
1696                         c2[0] = c[0] * r;
1697                         c2[1] = c[1] * g;
1698                         c2[2] = c[2] * b;
1699                         c2[3] = c[3] * a;
1700                 }
1701         }
1702         R_Mesh_ColorPointer(rsurface_lightmapcolor4f);
1703         GL_Color(r, g, b, a);
1704 }
1705
1706
1707 static void R_DrawTextureSurfaceList(const entity_render_t *ent, texture_t *texture, int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t modelorg)
1708 {
1709         int i;
1710         int texturesurfaceindex;
1711         const float *v;
1712         float *c;
1713         float diff[3];
1714         float colorpants[3], colorshirt[3];
1715         float f, r, g, b, a, colorscale;
1716         const msurface_t *surface;
1717         qboolean dolightmap;
1718         qboolean doambient;
1719         qboolean dodetail;
1720         qboolean doglow;
1721         qboolean dofogpass;
1722         qboolean fogallpasses;
1723         qboolean waterscrolling;
1724         qboolean dopants;
1725         qboolean doshirt;
1726         qboolean dofullbrightpants;
1727         qboolean dofullbrightshirt;
1728         qboolean applycolor;
1729         qboolean lightmodel = false;
1730         rtexture_t *basetexture;
1731         rmeshstate_t m;
1732         if (texture->currentmaterialflags & MATERIALFLAG_NODRAW)
1733                 return;
1734         c_faces += texturenumsurfaces;
1735         // FIXME: identify models using a better check than ent->model->shadowmesh
1736         if (!(ent->effects & EF_FULLBRIGHT) && !ent->model->brush.shadowmesh)
1737                 lightmodel = true;
1738         // gl_lightmaps debugging mode skips normal texturing
1739         if (gl_lightmaps.integer)
1740         {
1741                 GL_BlendFunc(GL_ONE, GL_ZERO);
1742                 GL_DepthMask(true);
1743                 GL_DepthTest(true);
1744                 qglDisable(GL_CULL_FACE);
1745                 GL_Color(1, 1, 1, 1);
1746                 memset(&m, 0, sizeof(m));
1747                 R_Mesh_State(&m);
1748                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1749                 {
1750                         surface = texturesurfacelist[texturesurfaceindex];
1751                         R_Mesh_TexBind(0, R_GetTexture(surface->lightmaptexture));
1752                         R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordlightmap2f);
1753                         RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1754                         RSurf_SetColorPointer(ent, surface, modelorg, 1, 1, 1, 1, lightmodel, !surface->lightmaptexture, false, false);
1755                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1756                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1757                         GL_LockArrays(0, 0);
1758                 }
1759                 qglEnable(GL_CULL_FACE);
1760                 return;
1761         }
1762         GL_DepthTest(!(texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
1763         GL_DepthMask(!(texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT));
1764         if (texture->currentmaterialflags & MATERIALFLAG_ADD)
1765                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1766         else if (texture->currentmaterialflags & MATERIALFLAG_ALPHA)
1767                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1768         else
1769                 GL_BlendFunc(GL_ONE, GL_ZERO);
1770         // water waterscrolling in texture matrix
1771         waterscrolling = (texture->currentmaterialflags & MATERIALFLAG_WATER) && r_waterscroll.value != 0;
1772         if (texture->textureflags & Q3TEXTUREFLAG_TWOSIDED)
1773                 qglDisable(GL_CULL_FACE);
1774         if (texture->currentmaterialflags & MATERIALFLAG_SKY)
1775         {
1776                 if (skyrendernow)
1777                 {
1778                         skyrendernow = false;
1779                         if (skyrendermasked)
1780                                 R_Sky();
1781                 }
1782                 // LordHavoc: HalfLife maps have freaky skypolys...
1783                 //if (!ent->model->brush.ishlbsp)
1784                 {
1785                         R_Mesh_Matrix(&ent->matrix);
1786                         GL_Color(fogcolor[0], fogcolor[1], fogcolor[2], 1);
1787                         if (skyrendermasked)
1788                         {
1789                                 // depth-only (masking)
1790                                 GL_ColorMask(0,0,0,0);
1791                                 // just to make sure that braindead drivers don't draw anything
1792                                 // despite that colormask...
1793                                 GL_BlendFunc(GL_ZERO, GL_ONE);
1794                         }
1795                         else
1796                         {
1797                                 // fog sky
1798                                 GL_BlendFunc(GL_ONE, GL_ZERO);
1799                         }
1800                         GL_DepthMask(true);
1801                         GL_DepthTest(true);
1802                         memset(&m, 0, sizeof(m));
1803                         R_Mesh_State(&m);
1804                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1805                         {
1806                                 surface = texturesurfacelist[texturesurfaceindex];
1807                                 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1808                                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1809                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1810                                 GL_LockArrays(0, 0);
1811                         }
1812                         GL_ColorMask(r_refdef.colormask[0], r_refdef.colormask[1], r_refdef.colormask[2], 1);
1813                 }
1814         }
1815         else if ((texture->currentmaterialflags & MATERIALFLAG_WATER) && r_watershader.value && gl_textureshader && !texture->skin.glow && !fogenabled && ent->colormod[0] == 1 && ent->colormod[1] == 1 && ent->colormod[2] == 1)
1816         {
1817                 // NVIDIA Geforce3 distortion texture shader on water
1818                 float args[4] = {0.05f,0,0,0.04f};
1819                 memset(&m, 0, sizeof(m));
1820                 m.tex[0] = R_GetTexture(r_texture_distorttexture[(int)(r_refdef.time * 16)&63]);
1821                 m.tex[1] = R_GetTexture(texture->skin.base);
1822                 m.texcombinergb[0] = GL_REPLACE;
1823                 m.texcombinergb[1] = GL_REPLACE;
1824                 Matrix4x4_CreateFromQuakeEntity(&m.texmatrix[0], 0, 0, 0, 0, 0, 0, r_watershader.value);
1825                 m.texmatrix[1] = r_waterscrollmatrix;
1826                 R_Mesh_State(&m);
1827
1828                 GL_Color(1, 1, 1, texture->currentalpha);
1829                 GL_ActiveTexture(0);
1830                 qglTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
1831                 GL_ActiveTexture(1);
1832                 qglTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_OFFSET_TEXTURE_2D_NV);
1833                 qglTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB);
1834                 qglTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, &args[0]);
1835                 qglEnable(GL_TEXTURE_SHADER_NV);
1836
1837                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1838                 {
1839                         surface = texturesurfacelist[texturesurfaceindex];
1840                         RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1841                         R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
1842                         R_Mesh_TexCoordPointer(1, 2, surface->groupmesh->data_texcoordtexture2f);
1843                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1844                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1845                         GL_LockArrays(0, 0);
1846                 }
1847
1848                 qglDisable(GL_TEXTURE_SHADER_NV);
1849                 qglTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
1850                 GL_ActiveTexture(0);
1851         }
1852         else if (texture->currentmaterialflags & (MATERIALFLAG_WATER | MATERIALFLAG_WALL))
1853         {
1854                 // normal surface (wall or water)
1855                 dolightmap = !(texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT);
1856                 doambient = r_ambient.value >= (1/64.0f);
1857                 dodetail = r_detailtextures.integer && texture->skin.detail != NULL && !(texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT);
1858                 doglow = texture->skin.glow != NULL;
1859                 dofogpass = fogenabled && !(texture->currentmaterialflags & MATERIALFLAG_ADD);
1860                 fogallpasses = fogenabled && !(texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT);
1861                 if (ent->colormap >= 0)
1862                 {
1863                         int b;
1864                         qbyte *bcolor;
1865                         basetexture = texture->skin.base;
1866                         dopants = texture->skin.pants != NULL;
1867                         doshirt = texture->skin.shirt != NULL;
1868                         // 128-224 are backwards ranges
1869                         b = (ent->colormap & 0xF) << 4;b += (b >= 128 && b < 224) ? 4 : 12;
1870                         dofullbrightpants = b >= 224;
1871                         bcolor = (qbyte *) (&palette_complete[b]);
1872                         VectorScale(bcolor, (1.0f / 255.0f), colorpants);
1873                         // 128-224 are backwards ranges
1874                         b = (ent->colormap & 0xF0);b += (b >= 128 && b < 224) ? 4 : 12;
1875                         dofullbrightshirt = b >= 224;
1876                         bcolor = (qbyte *) (&palette_complete[b]);
1877                         VectorScale(bcolor, (1.0f / 255.0f), colorshirt);
1878                 }
1879                 else
1880                 {
1881                         basetexture = texture->skin.merged ? texture->skin.merged : texture->skin.base;
1882                         dopants = false;
1883                         doshirt = false;
1884                         dofullbrightshirt = false;
1885                         dofullbrightpants = false;
1886                 }
1887                 if (dolightmap && r_textureunits.integer >= 2 && gl_combine.integer)
1888                 {
1889                         memset(&m, 0, sizeof(m));
1890                         m.tex[1] = R_GetTexture(basetexture);
1891                         if (waterscrolling)
1892                                 m.texmatrix[1] = r_waterscrollmatrix;
1893                         m.texrgbscale[1] = 2;
1894                         m.pointer_color = varray_color4f;
1895                         R_Mesh_State(&m);
1896                         // transparent is not affected by r_lightmapintensity
1897                         if (!(texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
1898                                 colorscale = r_lightmapintensity;
1899                         else
1900                                 colorscale = 1;
1901                         r = ent->colormod[0] * colorscale;
1902                         g = ent->colormod[1] * colorscale;
1903                         b = ent->colormod[2] * colorscale;
1904                         a = texture->currentalpha;
1905                         // q3bsp has no lightmap updates, so the lightstylevalue that
1906                         // would normally be baked into the lightmaptexture must be
1907                         // applied to the color
1908                         if (ent->model->brushq3.data_lightmaps)
1909                         {
1910                                 float scale = d_lightstylevalue[0] * (1.0f / 128.0f);
1911                                 r *= scale;
1912                                 g *= scale;
1913                                 b *= scale;
1914                         }
1915                         applycolor = r != 1 || g != 1 || b != 1 || a != 1;
1916                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1917                         {
1918                                 surface = texturesurfacelist[texturesurfaceindex];
1919                                 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1920                                 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordlightmap2f);
1921                                 R_Mesh_TexCoordPointer(1, 2, surface->groupmesh->data_texcoordtexture2f);
1922                                 if (surface->lightmaptexture)
1923                                         R_Mesh_TexBind(0, R_GetTexture(surface->lightmaptexture));
1924                                 else
1925                                         R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
1926                                 RSurf_SetColorPointer(ent, surface, modelorg, r, g, b, a, lightmodel, !surface->lightmaptexture, applycolor, fogallpasses);
1927                                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1928                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1929                                 GL_LockArrays(0, 0);
1930                         }
1931                 }
1932                 else if (dolightmap && !(texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT) && !lightmodel)
1933                 {
1934                         // single texture
1935                         GL_BlendFunc(GL_ONE, GL_ZERO);
1936                         GL_DepthMask(true);
1937                         GL_Color(1, 1, 1, 1);
1938                         memset(&m, 0, sizeof(m));
1939                         R_Mesh_State(&m);
1940                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1941                         {
1942                                 surface = texturesurfacelist[texturesurfaceindex];
1943                                 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1944                                 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordlightmap2f);
1945                                 if (surface->lightmaptexture)
1946                                 {
1947                                         R_Mesh_TexBind(0, R_GetTexture(surface->lightmaptexture));
1948                                         R_Mesh_ColorPointer(NULL);
1949                                 }
1950                                 else
1951                                 {
1952                                         R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
1953                                         R_Mesh_ColorPointer(surface->groupmesh->data_lightmapcolor4f);
1954                                 }
1955                                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1956                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1957                                 GL_LockArrays(0, 0);
1958                         }
1959                         GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
1960                         GL_DepthMask(false);
1961                         GL_Color(r_lightmapintensity * ent->colormod[0], r_lightmapintensity * ent->colormod[1], r_lightmapintensity * ent->colormod[2], 1);
1962                         memset(&m, 0, sizeof(m));
1963                         m.tex[0] = R_GetTexture(basetexture);
1964                         if (waterscrolling)
1965                                 m.texmatrix[0] = r_waterscrollmatrix;
1966                         R_Mesh_State(&m);
1967                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
1968                         {
1969                                 surface = texturesurfacelist[texturesurfaceindex];
1970                                 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
1971                                 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
1972                                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
1973                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
1974                                 GL_LockArrays(0, 0);
1975                         }
1976                 }
1977                 else
1978                 {
1979                         memset(&m, 0, sizeof(m));
1980                         m.tex[0] = R_GetTexture(basetexture);
1981                         if (waterscrolling)
1982                                 m.texmatrix[0] = r_waterscrollmatrix;
1983                         m.pointer_color = varray_color4f;
1984                         colorscale = 2;
1985                         if (gl_combine.integer)
1986                         {
1987                                 m.texrgbscale[0] = 2;
1988                                 colorscale = 1;
1989                         }
1990                         // transparent is not affected by r_lightmapintensity
1991                         if (!(texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
1992                                 colorscale *= r_lightmapintensity;
1993                         R_Mesh_State(&m);
1994                         r = ent->colormod[0] * colorscale;
1995                         g = ent->colormod[1] * colorscale;
1996                         b = ent->colormod[2] * colorscale;
1997                         a = texture->currentalpha;
1998                         if (dolightmap)
1999                         {
2000                                 // q3bsp has no lightmap updates, so the lightstylevalue that
2001                                 // would normally be baked into the lightmaptexture must be
2002                                 // applied to the color
2003                                 if (ent->model->brushq3.data_lightmaps)
2004                                 {
2005                                         float scale = d_lightstylevalue[0] * (1.0f / 128.0f);
2006                                         r *= scale;
2007                                         g *= scale;
2008                                         b *= scale;
2009                                 }
2010                                 applycolor = r != 1 || g != 1 || b != 1 || a != 1;
2011                                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2012                                 {
2013                                         surface = texturesurfacelist[texturesurfaceindex];
2014                                         RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2015                                         R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
2016                                         RSurf_SetColorPointer(ent, surface, modelorg, r, g, b, a, lightmodel, true, applycolor, fogallpasses);
2017                                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2018                                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2019                                         GL_LockArrays(0, 0);
2020                                 }
2021                         }
2022                         else
2023                         {
2024                                 applycolor = r != 1 || g != 1 || b != 1 || a != 1;
2025                                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2026                                 {
2027                                         surface = texturesurfacelist[texturesurfaceindex];
2028                                         RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2029                                         R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
2030                                         RSurf_SetColorPointer(ent, surface, modelorg, r, g, b, a, false, false, applycolor, fogallpasses);
2031                                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2032                                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2033                                         GL_LockArrays(0, 0);
2034                                 }
2035                         }
2036                 }
2037                 if (dopants)
2038                 {
2039                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2040                         memset(&m, 0, sizeof(m));
2041                         m.tex[0] = R_GetTexture(texture->skin.pants);
2042                         if (waterscrolling)
2043                                 m.texmatrix[0] = r_waterscrollmatrix;
2044                         m.pointer_color = varray_color4f;
2045                         colorscale = 1;
2046                         if (gl_combine.integer)
2047                         {
2048                                 m.texrgbscale[0] = 2;
2049                                 colorscale *= 0.5f;
2050                         }
2051                         // transparent is not affected by r_lightmapintensity
2052                         if (!(texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
2053                                 colorscale *= r_lightmapintensity;
2054                         R_Mesh_State(&m);
2055                         r = ent->colormod[0] * colorpants[0] * colorscale;
2056                         g = ent->colormod[1] * colorpants[1] * colorscale;
2057                         b = ent->colormod[2] * colorpants[2] * colorscale;
2058                         a = texture->currentalpha;
2059                         if (dolightmap && !dofullbrightpants)
2060                         {
2061                                 // q3bsp has no lightmap updates, so the lightstylevalue that
2062                                 // would normally be baked into the lightmaptexture must be
2063                                 // applied to the color
2064                                 if (ent->model->brushq3.data_lightmaps)
2065                                 {
2066                                         float scale = d_lightstylevalue[0] * (1.0f / 128.0f);
2067                                         r *= scale;
2068                                         g *= scale;
2069                                         b *= scale;
2070                                 }
2071                                 applycolor = r != 1 || g != 1 || b != 1 || a != 1;
2072                                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2073                                 {
2074                                         surface = texturesurfacelist[texturesurfaceindex];
2075                                         RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2076                                         R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
2077                                         RSurf_SetColorPointer(ent, surface, modelorg, r, g, b, a, lightmodel, true, applycolor, fogallpasses);
2078                                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2079                                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2080                                         GL_LockArrays(0, 0);
2081                                 }
2082                         }
2083                         else
2084                         {
2085                                 applycolor = r != 1 || g != 1 || b != 1 || a != 1;
2086                                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2087                                 {
2088                                         surface = texturesurfacelist[texturesurfaceindex];
2089                                         RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2090                                         R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
2091                                         RSurf_SetColorPointer(ent, surface, modelorg, r, g, b, a, false, false, applycolor, fogallpasses);
2092                                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2093                                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2094                                         GL_LockArrays(0, 0);
2095                                 }
2096                         }
2097                 }
2098                 if (doshirt)
2099                 {
2100                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2101                         memset(&m, 0, sizeof(m));
2102                         m.tex[0] = R_GetTexture(texture->skin.shirt);
2103                         if (waterscrolling)
2104                                 m.texmatrix[0] = r_waterscrollmatrix;
2105                         m.pointer_color = varray_color4f;
2106                         colorscale = 1;
2107                         if (gl_combine.integer)
2108                         {
2109                                 m.texrgbscale[0] = 2;
2110                                 colorscale *= 0.5f;
2111                         }
2112                         // transparent is not affected by r_lightmapintensity
2113                         if (!(texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
2114                                 colorscale *= r_lightmapintensity;
2115                         R_Mesh_State(&m);
2116                         r = ent->colormod[0] * colorshirt[0] * colorscale;
2117                         g = ent->colormod[1] * colorshirt[1] * colorscale;
2118                         b = ent->colormod[2] * colorshirt[2] * colorscale;
2119                         a = texture->currentalpha;
2120                         if (dolightmap && !dofullbrightshirt)
2121                         {
2122                                 // q3bsp has no lightmap updates, so the lightstylevalue that
2123                                 // would normally be baked into the lightmaptexture must be
2124                                 // applied to the color
2125                                 if (ent->model->brushq3.data_lightmaps)
2126                                 {
2127                                         float scale = d_lightstylevalue[0] * (1.0f / 128.0f);
2128                                         r *= scale;
2129                                         g *= scale;
2130                                         b *= scale;
2131                                 }
2132                                 applycolor = r != 1 || g != 1 || b != 1 || a != 1;
2133                                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2134                                 {
2135                                         surface = texturesurfacelist[texturesurfaceindex];
2136                                         RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2137                                         R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
2138                                         RSurf_SetColorPointer(ent, surface, modelorg, r, g, b, a, lightmodel, true, applycolor, fogallpasses);
2139                                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2140                                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2141                                         GL_LockArrays(0, 0);
2142                                 }
2143                         }
2144                         else
2145                         {
2146                                 applycolor = r != 1 || g != 1 || b != 1 || a != 1;
2147                                 for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2148                                 {
2149                                         surface = texturesurfacelist[texturesurfaceindex];
2150                                         RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2151                                         R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
2152                                         RSurf_SetColorPointer(ent, surface, modelorg, r, g, b, a, false, false, applycolor, fogallpasses);
2153                                         GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2154                                         R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2155                                         GL_LockArrays(0, 0);
2156                                 }
2157                         }
2158                 }
2159                 if (doambient)
2160                 {
2161                         doambient = false;
2162                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2163                         GL_DepthMask(false);
2164                         memset(&m, 0, sizeof(m));
2165                         m.tex[0] = R_GetTexture(texture->skin.base);
2166                         if (waterscrolling)
2167                                 m.texmatrix[0] = r_waterscrollmatrix;
2168                         m.pointer_color = varray_color4f;
2169                         colorscale = 1;
2170                         if (gl_combine.integer)
2171                         {
2172                                 m.texrgbscale[0] = 2;
2173                                 colorscale *= 0.5f;
2174                         }
2175                         R_Mesh_State(&m);
2176                         colorscale *= r_ambient.value * (1.0f / 64.0f);
2177                         r = ent->colormod[0] * colorscale;
2178                         g = ent->colormod[1] * colorscale;
2179                         b = ent->colormod[2] * colorscale;
2180                         a = texture->currentalpha;
2181                         applycolor = r != 1 || g != 1 || b != 1 || a != 1;
2182                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2183                         {
2184                                 surface = texturesurfacelist[texturesurfaceindex];
2185                                 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2186                                 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
2187                                 RSurf_SetColorPointer(ent, surface, modelorg, r, g, b, a, false, false, applycolor, fogallpasses);
2188                                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2189                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2190                                 GL_LockArrays(0, 0);
2191                         }
2192                 }
2193                 if (dodetail)
2194                 {
2195                         GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
2196                         GL_DepthMask(false);
2197                         GL_Color(1, 1, 1, 1);
2198                         memset(&m, 0, sizeof(m));
2199                         m.tex[0] = R_GetTexture(texture->skin.detail);
2200                         R_Mesh_State(&m);
2201                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2202                         {
2203                                 surface = texturesurfacelist[texturesurfaceindex];
2204                                 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2205                                 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoorddetail2f);
2206                                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2207                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2208                                 GL_LockArrays(0, 0);
2209                         }
2210                 }
2211                 if (doglow)
2212                 {
2213                         // if glow was not already done using multitexture, do it now.
2214                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2215                         GL_DepthMask(false);
2216                         memset(&m, 0, sizeof(m));
2217                         m.tex[0] = R_GetTexture(texture->skin.glow);
2218                         if (waterscrolling)
2219                                 m.texmatrix[0] = r_waterscrollmatrix;
2220                         m.pointer_color = varray_color4f;
2221                         R_Mesh_State(&m);
2222                         colorscale = 1;
2223                         r = ent->colormod[0] * colorscale;
2224                         g = ent->colormod[1] * colorscale;
2225                         b = ent->colormod[2] * colorscale;
2226                         a = texture->currentalpha;
2227                         applycolor = r != 1 || g != 1 || b != 1 || a != 1;
2228                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2229                         {
2230                                 surface = texturesurfacelist[texturesurfaceindex];
2231                                 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2232                                 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
2233                                 RSurf_SetColorPointer(ent, surface, modelorg, r, g, b, a, false, false, applycolor, fogallpasses);
2234                                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2235                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2236                                 GL_LockArrays(0, 0);
2237                         }
2238                 }
2239                 if (dofogpass)
2240                 {
2241                         // if this is opaque use alpha blend which will darken the earlier
2242                         // passes cheaply.
2243                         //
2244                         // if this is an alpha blended material, all the earlier passes
2245                         // were darkened by fog already, so we only need to add the fog
2246                         // color ontop through the fog mask texture
2247                         //
2248                         // if this is an additive blended material, all the earlier passes
2249                         // were darkened by fog already, and we should not add fog color
2250                         // (because the background was not darkened, there is no fog color
2251                         // that was lost behind it).
2252                         if (fogallpasses)
2253                                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2254                         else
2255                                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2256                         GL_DepthMask(false);
2257                         memset(&m, 0, sizeof(m));
2258                         m.tex[0] = R_GetTexture(texture->skin.fog);
2259                         if (waterscrolling)
2260                                 m.texmatrix[0] = r_waterscrollmatrix;
2261                         R_Mesh_State(&m);
2262                         r = fogcolor[0];
2263                         g = fogcolor[1];
2264                         b = fogcolor[2];
2265                         a = texture->currentalpha;
2266                         applycolor = r != 1 || g != 1 || b != 1 || a != 1;
2267                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2268                         {
2269                                 surface = texturesurfacelist[texturesurfaceindex];
2270                                 RSurf_SetVertexPointer(ent, texture, surface, modelorg);
2271                                 R_Mesh_TexCoordPointer(0, 2, surface->groupmesh->data_texcoordtexture2f);
2272                                 R_Mesh_ColorPointer(varray_color4f);
2273                                 //RSurf_FogPassColors_Vertex3f_Color4f((surface->groupmesh->data_vertex3f + 3 * surface->num_firstvertex), varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], texture->currentalpha, 1, surface->num_vertices, modelorg);
2274                                 if (!surface->lightmaptexture && surface->groupmesh->data_lightmapcolor4f && (texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT))
2275                                 {
2276                                         for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (varray_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
2277                                         {
2278                                                 VectorSubtract(v, modelorg, diff);
2279                                                 f = exp(fogdensity/DotProduct(diff, diff));
2280                                                 c[0] = r;
2281                                                 c[1] = g;
2282                                                 c[2] = b;
2283                                                 c[3] = (surface->groupmesh->data_lightmapcolor4f + 4 * surface->num_firstvertex)[i*4+3] * f * a;
2284                                         }
2285                                 }
2286                                 else
2287                                 {
2288                                         for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (varray_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
2289                                         {
2290                                                 VectorSubtract(v, modelorg, diff);
2291                                                 f = exp(fogdensity/DotProduct(diff, diff));
2292                                                 c[0] = r;
2293                                                 c[1] = g;
2294                                                 c[2] = b;
2295                                                 c[3] = f * a;
2296                                         }
2297                                 }
2298                                 GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
2299                                 R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle));
2300                                 GL_LockArrays(0, 0);
2301                         }
2302                 }
2303         }
2304         if (texture->textureflags & Q3TEXTUREFLAG_TWOSIDED)
2305                 qglEnable(GL_CULL_FACE);
2306 }
2307
2308 static void RSurfShader_Transparent_Callback(const void *calldata1, int calldata2)
2309 {
2310         const entity_render_t *ent = calldata1;
2311         const msurface_t *surface = ent->model->data_surfaces + calldata2;
2312         vec3_t modelorg;
2313         texture_t *texture;
2314
2315         texture = surface->texture;
2316         if (texture->basematerialflags & MATERIALFLAG_SKY)
2317                 return; // transparent sky is too difficult
2318         R_UpdateTextureInfo(ent, texture);
2319
2320         R_Mesh_Matrix(&ent->matrix);
2321         Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
2322         R_DrawTextureSurfaceList(ent, texture->currentframe, 1, &surface, modelorg);
2323 }
2324
2325 void R_QueueTextureSurfaceList(entity_render_t *ent, texture_t *texture, int texturenumsurfaces, const msurface_t **texturesurfacelist, const vec3_t modelorg)
2326 {
2327         int texturesurfaceindex;
2328         const msurface_t *surface;
2329         vec3_t tempcenter, center;
2330         if (texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT)
2331         {
2332                 // drawing sky transparently would be too difficult
2333                 if (!(texture->currentmaterialflags & MATERIALFLAG_SKY))
2334                 {
2335                         for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
2336                         {
2337                                 surface = texturesurfacelist[texturesurfaceindex];
2338                                 tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f;
2339                                 tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f;
2340                                 tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f;
2341                                 Matrix4x4_Transform(&ent->matrix, tempcenter, center);
2342                                 R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_vieworigin : center, RSurfShader_Transparent_Callback, ent, surface - ent->model->data_surfaces);
2343                         }
2344                 }
2345         }
2346         else
2347                 R_DrawTextureSurfaceList(ent, texture, texturenumsurfaces, texturesurfacelist, modelorg);
2348 }
2349
2350 extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
2351 void R_DrawSurfaces(entity_render_t *ent, qboolean skysurfaces)
2352 {
2353         int i, j, f, flagsmask;
2354         msurface_t *surface, **surfacechain;
2355         texture_t *t, *texture;
2356         model_t *model = ent->model;
2357         vec3_t modelorg;
2358         const int maxsurfacelist = 1024;
2359         int numsurfacelist = 0;
2360         const msurface_t *surfacelist[1024];
2361         if (model == NULL)
2362                 return;
2363         R_Mesh_Matrix(&ent->matrix);
2364         Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
2365
2366         // update light styles
2367         if (!skysurfaces && model->brushq1.light_styleupdatechains)
2368         {
2369                 for (i = 0;i < model->brushq1.light_styles;i++)
2370                 {
2371                         if (model->brushq1.light_stylevalue[i] != d_lightstylevalue[model->brushq1.light_style[i]])
2372                         {
2373                                 model->brushq1.light_stylevalue[i] = d_lightstylevalue[model->brushq1.light_style[i]];
2374                                 if ((surfacechain = model->brushq1.light_styleupdatechains[i]))
2375                                         for (;(surface = *surfacechain);surfacechain++)
2376                                                 surface->cached_dlight = true;
2377                         }
2378                 }
2379         }
2380
2381         R_UpdateAllTextureInfo(ent);
2382         flagsmask = skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL);
2383         f = 0;
2384         t = NULL;
2385         texture = NULL;
2386         numsurfacelist = 0;
2387         if (ent == r_refdef.worldentity)
2388         {
2389                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
2390                 {
2391                         if (!r_worldsurfacevisible[j])
2392                                 continue;
2393                         if (t != surface->texture)
2394                         {
2395                                 if (numsurfacelist)
2396                                 {
2397                                         R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2398                                         numsurfacelist = 0;
2399                                 }
2400                                 t = surface->texture;
2401                                 texture = t->currentframe;
2402                                 f = texture->currentmaterialflags & flagsmask;
2403                         }
2404                         if (f && surface->num_triangles)
2405                         {
2406                                 // if lightmap parameters changed, rebuild lightmap texture
2407                                 if (surface->cached_dlight && surface->lightmapinfo->samples)
2408                                         R_BuildLightMap(ent, surface);
2409                                 // add face to draw list
2410                                 surfacelist[numsurfacelist++] = surface;
2411                                 if (numsurfacelist >= maxsurfacelist)
2412                                 {
2413                                         R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2414                                         numsurfacelist = 0;
2415                                 }
2416                         }
2417                 }
2418         }
2419         else
2420         {
2421                 for (i = 0, j = model->firstmodelsurface, surface = model->data_surfaces + j;i < model->nummodelsurfaces;i++, j++, surface++)
2422                 {
2423                         if (t != surface->texture)
2424                         {
2425                                 if (numsurfacelist)
2426                                 {
2427                                         R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2428                                         numsurfacelist = 0;
2429                                 }
2430                                 t = surface->texture;
2431                                 texture = t->currentframe;
2432                                 f = texture->currentmaterialflags & flagsmask;
2433                         }
2434                         if (f && surface->num_triangles)
2435                         {
2436                                 // if lightmap parameters changed, rebuild lightmap texture
2437                                 if (surface->cached_dlight && surface->lightmapinfo->samples)
2438                                         R_BuildLightMap(ent, surface);
2439                                 // add face to draw list
2440                                 surfacelist[numsurfacelist++] = surface;
2441                                 if (numsurfacelist >= maxsurfacelist)
2442                                 {
2443                                         R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2444                                         numsurfacelist = 0;
2445                                 }
2446                         }
2447                 }
2448         }
2449         if (numsurfacelist)
2450                 R_QueueTextureSurfaceList(ent, texture, numsurfacelist, surfacelist, modelorg);
2451 }
2452