3 transvert_t *transvert;
4 transpoly_t *transpoly;
5 unsigned short *transpolyindex;
7 wallvertcolor_t *wallvertcolor;
19 cvar_t gl_multitexture = {"gl_multitexture", "1"};
21 typedef struct translistitem_s
24 struct translistitem_s *next;
28 translistitem translist[MAX_TRANSPOLYS];
29 translistitem *currenttranslist;
31 translistitem *translisthash[4096];
33 float transviewdist; // distance of view origin along the view normal
35 float transreciptable[256];
40 transvert = qmalloc(MAX_TRANSVERTS * sizeof(transvert_t));
41 transpoly = qmalloc(MAX_TRANSPOLYS * sizeof(transpoly_t));
42 transpolyindex = qmalloc(MAX_TRANSPOLYS * sizeof(unsigned short));
43 wallvert = qmalloc(MAX_WALLVERTS * sizeof(wallvert_t));
44 wallvertcolor = qmalloc(MAX_WALLVERTS * sizeof(wallvertcolor_t));
45 wallpoly = qmalloc(MAX_WALLPOLYS * sizeof(wallpoly_t));
46 skyvert = qmalloc(MAX_SKYVERTS * sizeof(skyvert_t));
47 skypoly = qmalloc(MAX_SKYPOLYS * sizeof(skypoly_t));
48 transreciptable[0] = 0.0f;
49 for (i = 1;i < 256;i++)
50 transreciptable[i] = 1.0f / i;
53 void gl_poly_shutdown()
57 qfree(transpolyindex);
71 Cvar_RegisterVariable (&gl_multitexture);
72 R_RegisterModule("GL_Poly", gl_poly_start, gl_poly_shutdown, gl_poly_newmap);
77 currenttranspoly = currenttransvert = 0;
78 currenttranslist = translist;
79 memset(translisthash, 0, sizeof(translisthash));
80 transviewdist = DotProduct(r_refdef.vieworg, vpn);
83 // turned into a #define
85 void transpolybegin(int texnum, int glowtexnum, int fogtexnum, int transpolytype)
87 if (currenttranspoly >= MAX_TRANSPOLYS || currenttransvert >= MAX_TRANSVERTS)
89 transpoly[currenttranspoly].texnum = (unsigned short) texnum;
90 transpoly[currenttranspoly].glowtexnum = (unsigned short) glowtexnum;
91 transpoly[currenttranspoly].fogtexnum = (unsigned short) fogtexnum;
92 transpoly[currenttranspoly].transpolytype = (unsigned short) transpolytype;
93 transpoly[currenttranspoly].firstvert = currenttransvert;
94 transpoly[currenttranspoly].verts = 0;
95 // transpoly[currenttranspoly].ndist = 0; // clear the normal
99 // turned into a #define
101 void transpolyvert(float x, float y, float z, float s, float t, int r, int g, int b, int a)
104 if (currenttranspoly >= MAX_TRANSPOLYS || currenttransvert >= MAX_TRANSVERTS)
106 transvert[currenttransvert].s = s;
107 transvert[currenttransvert].t = t;
108 transvert[currenttransvert].r = bound(0, r, 255);
109 transvert[currenttransvert].g = bound(0, g, 255);
110 transvert[currenttransvert].b = bound(0, b, 255);
111 transvert[currenttransvert].a = bound(0, a, 255);
112 transvert[currenttransvert].v[0] = x;
113 transvert[currenttransvert].v[1] = y;
114 transvert[currenttransvert].v[2] = z;
116 transpoly[currenttranspoly].verts++;
122 float center, d, maxdist;
125 if (currenttranspoly >= MAX_TRANSPOLYS || currenttransvert >= MAX_TRANSVERTS)
127 if (transpoly[currenttranspoly].verts < 3) // skip invalid polygons
129 currenttransvert = transpoly[currenttranspoly].firstvert; // reset vert pointer
133 maxdist = -1000000000000000.0f; // eh, it's definitely behind it, so...
134 for (i = 0,v = &transvert[transpoly[currenttranspoly].firstvert];i < transpoly[currenttranspoly].verts;i++, v++)
136 d = DotProduct(v->v, vpn);
141 maxdist -= transviewdist;
142 if (maxdist < 4.0f) // behind view
144 currenttransvert = transpoly[currenttranspoly].firstvert; // reset vert pointer
147 center *= transreciptable[transpoly[currenttranspoly].verts];
148 center -= transviewdist;
149 i = bound(0, (int) center, 4095);
150 currenttranslist->next = translisthash[i];
151 currenttranslist->poly = transpoly + currenttranspoly;
152 translisthash[i] = currenttranslist;
157 int transpolyindices;
160 void transpolyrenderminmax()
162 int i, j, k, lastvert;
163 vec_t d, min, max, viewdist, s, average;
166 transpolyindices = 0;
167 viewdist = DotProduct(r_refdef.vieworg, vpn);
168 for (i = 0;i < currenttranspoly;i++)
170 if (transpoly[i].verts < 3) // only process valid polygons
172 min = 1000000;max = -1000000;
173 s = 1.0f / transpoly[i].verts;
174 lastvert = transpoly[i].firstvert + transpoly[i].verts;
176 for (j = transpoly[i].firstvert;j < lastvert;j++)
178 d = DotProduct(transvert[j].v, vpn)-viewdist;
179 if (d < min) min = d;
180 if (d > max) max = d;
183 if (max < 4) // free to check here, so skip polys behind the view
185 transpoly[i].distance = average;
188 transpoly[i].mindistance = min;
189 transpoly[i].maxdistance = max;
190 // calculate normal (eek)
191 VectorSubtract(transvert[transpoly[i].firstvert ].v, transvert[transpoly[i].firstvert+1].v, v1);
192 VectorSubtract(transvert[transpoly[i].firstvert+2].v, transvert[transpoly[i].firstvert+1].v, v2);
195 if (transpoly[i].verts > 3 && fabs(DotProduct(v1, v2)) >= (1.0f - (1.0f / 256.0f))) // colinear edges, find a better triple
197 VectorSubtract(transvert[transpoly[i].firstvert + transpoly[i].verts - 1].v, transvert[transpoly[i].firstvert].v, v1);
198 VectorSubtract(transvert[transpoly[i].firstvert + 1].v, transvert[transpoly[i].firstvert].v, v2);
201 if (fabs(DotProduct(v1, v2)) < (1.0f - (1.0f / 256.0f))) // found a good triple
203 for (k = transpoly[i].firstvert + 2;k < (transpoly[i].firstvert + transpoly[i].verts - 1);k++)
205 VectorSubtract(transvert[k-1].v, transvert[k].v, v1);
206 VectorSubtract(transvert[k+1].v, transvert[k].v, v2);
209 if (fabs(DotProduct(v1, v2)) < (1.0f - (1.0f / 256.0f))) // found a good triple
212 VectorSubtract(transvert[k-1].v, transvert[k].v, v1);
213 VectorSubtract(transvert[transpoly[i].firstvert].v, transvert[k].v, v2);
216 if (fabs(DotProduct(v1, v2)) >= (1.0f - (1.0f / 256.0f))) // no good triples; the polygon is a line, skip it
220 CrossProduct(v1, v2, n);
222 ndist = DotProduct(transvert[transpoly[i].firstvert+1].v, n);
224 for (j = 0;j < transpolyindices;j++)
227 if (transpoly[transpolyindex[j]].mindistance > max)
229 if (transpoly[transpolyindex[j]].maxdistance < min)
231 // hard case, check side
232 for (k = transpoly[transpolyindex[j]].firstvert;k < (transpoly[transpolyindex[j]].firstvert + transpoly[transpolyindex[j]].verts);k++)
233 if (DotProduct(transvert[k].v, n) < ndist)
242 for (j = 0;j < transpolyindices;j++)
243 if (transpoly[transpolyindex[j]].distance < average)
245 for (k = transpolyindices;k > j;k--)
246 transpolyindex[k] = transpolyindex[k-1];
248 transpolyindex[j] = i;
253 // LordHavoc: qsort compare function
254 int transpolyqsort(const void *ia, const void *ib)
258 a = &transpoly[*((unsigned short *)ia)];
259 b = &transpoly[*((unsigned short *)ib)];
261 if (a->mindistance > b->mindistance && a->maxdistance > b->maxdistance)
263 if (a->mindistance < b->mindistance && a->maxdistance < b->maxdistance)
268 // calculate normal (eek)
270 VectorSubtract(transvert[a->firstvert ].v, transvert[a->firstvert+1].v, v1);
271 VectorSubtract(transvert[a->firstvert+2].v, transvert[a->firstvert+1].v, v2);
272 CrossProduct(v1, v2, a->n);
273 VectorNormalize(a->n);
274 a->ndist = DotProduct(transvert[a->firstvert ].v, a->n);
277 for (i = b->firstvert, j = 0;i < (b->firstvert + b->verts);i++)
278 j += DotProduct(transvert[i].v, a->n) < a->ndist; // (1) b is infront of a
280 return -1; // (-1) a is behind b
281 return j == b->verts; // (1) a is infront of b (0) a and b intersect
282 // return (transpoly[*((unsigned short *)ib)].mindistance + transpoly[*((unsigned short *)ib)].maxdistance) - (transpoly[*((unsigned short *)ia)].mindistance + transpoly[*((unsigned short *)ia)].maxdistance);
285 return ((transpoly_t*)ia)->distance - ((transpoly_t*)ib)->distance;
290 int transpolyqsort(const void *ia, const void *ib)
292 return (transpoly[*((unsigned short *)ib)].distance - transpoly[*((unsigned short *)ia)].distance);
297 void transpolyrenderminmax()
300 vec_t d, max, viewdist, average;
301 transpolyindices = 0;
302 viewdist = DotProduct(r_refdef.vieworg, vpn);
303 for (i = 0;i < currenttranspoly;i++)
305 if (transpoly[i].verts < 3) // only process valid polygons
308 lastvert = transpoly[i].firstvert + transpoly[i].verts;
310 for (j = transpoly[i].firstvert;j < lastvert;j++)
312 d = DotProduct(transvert[j].v, vpn)-viewdist;
317 if (max < 4) // free to check here, so skip polys behind the view
319 transpoly[i].distance = average / transpoly[i].verts;
320 transpolyindex[transpolyindices++] = i;
322 qsort(&transpolyindex[0], transpolyindices, sizeof(unsigned short), transpolyqsort);
331 for (i = 1;i < transpolyindices;i++)
334 if (transpoly[transpolyindex[i - 1]].mindistance > transpoly[transpolyindex[i]].mindistance && transpoly[transpolyindex[i - 1]].maxdistance > transpoly[transpolyindex[i]].maxdistance)
335 continue; // previous is behind (no swap)
336 if (transpoly[transpolyindex[i - 1]].mindistance < transpoly[transpolyindex[i]].mindistance && transpoly[transpolyindex[i - 1]].maxdistance < transpoly[transpolyindex[i]].maxdistance)
337 goto swap; // previous is infront (swap)
341 if (!transpoly[transpolyindex[i - 1]].ndist)
343 // calculate normal (eek)
345 VectorSubtract(transvert[transpoly[transpolyindex[i - 1]].firstvert ].v, transvert[transpoly[transpolyindex[i - 1]].firstvert+1].v, v1);
346 VectorSubtract(transvert[transpoly[transpolyindex[i - 1]].firstvert+2].v, transvert[transpoly[transpolyindex[i - 1]].firstvert+1].v, v2);
347 CrossProduct(v1, v2, transpoly[transpolyindex[i - 1]].n);
348 VectorNormalize(transpoly[transpolyindex[i - 1]].n);
349 transpoly[transpolyindex[i - 1]].ndist = DotProduct(transvert[transpoly[transpolyindex[i - 1]].firstvert ].v, transpoly[transpolyindex[i - 1]].n);
351 if (DotProduct(transpoly[transpolyindex[i - 1]].n, vpn) >= 0.0f) // backface
356 for (i = transpoly[transpolyindex[i]].firstvert;i < (transpoly[transpolyindex[i]].firstvert + transpoly[transpolyindex[i]].verts);i++)
357 if (DotProduct(transvert[i].v, transpoly[transpolyindex[i - 1]].n) >= transpoly[transpolyindex[i - 1]].ndist)
358 goto noswap; // previous is behind or they intersect
360 // previous is infront (swap)
361 j = transpolyindex[i];
362 transpolyindex[i] = transpolyindex[i - 1];
363 transpolyindex[i - 1] = j;
372 void transpolyrender()
374 int i, j, tpolytype, texnum;
378 if (currenttranspoly < 1)
380 // transpolyrenderminmax();
381 // if (transpolyindices < 1)
384 // Con_DPrintf("transpolyrender: %i polys %i infront %i vertices\n", currenttranspoly, transpolyindices, currenttransvert);
385 // if (transpolyindices >= 2)
387 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
389 glShadeModel(GL_SMOOTH);
390 glDepthMask(0); // disable zbuffer updates
391 glDisable(GL_ALPHA_TEST);
392 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
393 tpolytype = TPOLYTYPE_ALPHA;
396 if (gl_vertexarrays.value)
398 // set up the vertex array
399 glInterleavedArrays(GL_T2F_C4UB_V3F, 0, transvert);
400 for (i = 0;i < transpolyindices;i++)
402 p = &transpoly[transpolyindex[i]];
403 if (p->texnum != texnum || p->transpolytype != tpolytype)
405 if (p->texnum != texnum)
408 glBindTexture(GL_TEXTURE_2D, texnum);
410 if (p->transpolytype != tpolytype)
412 tpolytype = p->transpolytype;
413 if (tpolytype == TPOLYTYPE_ADD) // additive
414 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
416 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
419 glDrawArrays(GL_POLYGON, p->firstvert, p->verts);
422 texnum = p->glowtexnum; // highly unlikely to match next poly, but...
423 glBindTexture(GL_TEXTURE_2D, texnum);
424 tpolytype = TPOLYTYPE_ADD; // might match next poly
425 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
426 glDrawArrays(GL_POLYGON, p->firstvert, p->verts);
429 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
430 glDisableClientState(GL_COLOR_ARRAY);
431 glDisableClientState(GL_VERTEX_ARRAY);
439 for (i = 4095;i >= 0;i--)
441 item = translisthash[i];
446 if (p->texnum != texnum || p->verts != points || p->transpolytype != tpolytype)
451 // LordHavoc: Matrox G200 cards can't handle per pixel alpha
453 glEnable(GL_ALPHA_TEST);
455 glDisable(GL_ALPHA_TEST);
457 if (p->texnum != texnum)
460 glBindTexture(GL_TEXTURE_2D, texnum);
462 if (p->transpolytype != tpolytype)
464 tpolytype = p->transpolytype;
465 if (tpolytype == TPOLYTYPE_ADD) // additive
466 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
468 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
474 glBegin(GL_TRIANGLES);
481 points = -1; // to force a reinit on the next poly
485 for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++)
487 // would be 2fv, but windoze Matrox G200 and probably G400 drivers don't support that (dumb...)
488 glTexCoord2f(vert->s, vert->t);
489 // again, vector version isn't supported I think
490 glColor4ub(vert->r, vert->g, vert->b, vert->a);
491 glVertex3fv(vert->v);
496 texnum = p->glowtexnum; // highly unlikely to match next poly, but...
497 glBindTexture(GL_TEXTURE_2D, texnum);
498 if (tpolytype != TPOLYTYPE_ADD)
500 tpolytype = TPOLYTYPE_ADD; // might match next poly
501 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
505 for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++)
507 glColor4ub(255,255,255,vert->a);
508 // would be 2fv, but windoze Matrox G200 and probably G400 drivers don't support that (dumb...)
509 glTexCoord2f(vert->s, vert->t);
510 glVertex3fv(vert->v);
514 if (fogenabled && p->transpolytype == TPOLYTYPE_ALPHA)
518 points = -1; // to force a reinit on the next poly
519 if (tpolytype != TPOLYTYPE_ALPHA)
521 tpolytype = TPOLYTYPE_ALPHA; // probably matchs next poly
522 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
526 if (texnum != p->fogtexnum) // highly unlikely to match next poly, but...
528 texnum = p->fogtexnum;
529 glBindTexture(GL_TEXTURE_2D, texnum);
532 for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++)
534 VectorSubtract(vert->v, r_refdef.vieworg,diff);
535 glTexCoord2f(vert->s, vert->t);
536 glColor4f(fogcolor[0], fogcolor[1], fogcolor[2], vert->a*(1.0f/255.0f)*exp(fogdensity/DotProduct(diff,diff)));
537 glVertex3fv(vert->v);
543 glDisable(GL_TEXTURE_2D);
545 for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++)
547 VectorSubtract(vert->v, r_refdef.vieworg,diff);
548 glColor4f(fogcolor[0], fogcolor[1], fogcolor[2], vert->a*(1.0f/255.0f)*exp(fogdensity/DotProduct(diff,diff)));
549 glVertex3fv(vert->v);
552 glEnable(GL_TEXTURE_2D);
560 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
561 glDepthMask(1); // enable zbuffer updates
562 glDisable(GL_ALPHA_TEST);
567 currentwallpoly = currentwallvert = 0;
570 void wallpolyrender()
572 int i, j, texnum, lighttexnum;
575 wallvertcolor_t *vertcolor;
578 if (currentwallpoly < 1)
580 c_brush_polys += currentwallpoly;
582 //Con_DPrintf("wallpolyrender: %i polys %i vertices\n", currentwallpoly, currentwallvert);
584 gl_multitexture.value = 0;
586 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
587 glShadeModel(GL_FLAT);
588 // make sure zbuffer is enabled
589 glEnable(GL_DEPTH_TEST);
590 // glDisable(GL_ALPHA_TEST);
593 if (r_fullbright.value) // LordHavoc: easy to do fullbright...
595 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
597 for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++)
599 if (p->texnum != texnum)
602 glBindTexture(GL_TEXTURE_2D, texnum);
604 vert = &wallvert[p->firstvert];
606 for (j=0 ; j<p->numverts ; j++, vert++)
608 glTexCoord2f (vert->vert[3], vert->vert[4]);
609 glVertex3fv (vert->vert);
614 else if (gl_multitexture.value)
616 qglSelectTexture(gl_mtex_enum+0);
617 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
618 glEnable(GL_TEXTURE_2D);
619 qglSelectTexture(gl_mtex_enum+1);
620 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
621 glEnable(GL_TEXTURE_2D);
624 for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++)
626 if (p->texnum != texnum || p->lighttexnum != lighttexnum)
629 lighttexnum = p->lighttexnum;
630 qglSelectTexture(gl_mtex_enum+0);
631 glBindTexture(GL_TEXTURE_2D, texnum);
632 qglSelectTexture(gl_mtex_enum+1);
633 glBindTexture(GL_TEXTURE_2D, lighttexnum);
635 vert = &wallvert[p->firstvert];
637 for (j=0 ; j<p->numverts ; j++, vert++)
639 qglMTexCoord2f(gl_mtex_enum, vert->vert[3], vert->vert[4]); // texture
640 qglMTexCoord2f((gl_mtex_enum+1), vert->vert[5], vert->vert[6]); // lightmap
641 glVertex3fv (vert->vert);
646 qglSelectTexture(gl_mtex_enum+1);
647 glDisable(GL_TEXTURE_2D);
648 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
649 qglSelectTexture(gl_mtex_enum+0);
650 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
654 // first do the textures
655 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
657 for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++)
659 if (p->texnum != texnum)
662 glBindTexture(GL_TEXTURE_2D, texnum);
664 vert = &wallvert[p->firstvert];
666 for (j=0 ; j<p->numverts ; j++, vert++)
668 glTexCoord2f (vert->vert[3], vert->vert[4]);
669 glVertex3fv (vert->vert);
673 // then modulate using the lightmaps
674 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
675 glBlendFunc(GL_ZERO, GL_SRC_COLOR);
678 for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++)
680 if (p->lighttexnum != texnum)
682 texnum = p->lighttexnum;
683 glBindTexture(GL_TEXTURE_2D, texnum);
685 vert = &wallvert[p->firstvert];
687 for (j=0 ; j<p->numverts ; j++, vert++)
689 glTexCoord2f (vert->vert[5], vert->vert[6]);
690 glVertex3fv (vert->vert);
695 // switch to additive mode settings
697 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
698 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
700 // glDisable(GL_ALPHA_TEST);
701 glShadeModel(GL_SMOOTH);
702 // render vertex lit overlays ontop
704 for (i = 0, p = wallpoly;i < currentwallpoly;i++, p++)
708 for (j = 0,vertcolor = &wallvertcolor[p->firstvert];j < p->numverts;j++, vertcolor++)
709 if (vertcolor->r || vertcolor->g || vertcolor->b)
714 if (p->texnum != texnum)
717 glBindTexture(GL_TEXTURE_2D, texnum);
720 for (j = 0,vert = &wallvert[p->firstvert], vertcolor = &wallvertcolor[p->firstvert];j < p->numverts;j++, vert++, vertcolor++)
722 // would be 2fv, but windoze Matrox G200 and probably G400 drivers don't support that (dumb...)
723 glTexCoord2f(vert->vert[3], vert->vert[4]);
724 // again, vector version isn't supported I think
725 glColor3ub(vertcolor->r, vertcolor->g, vertcolor->b);
726 glVertex3fv(vert->vert);
730 // render glow textures
731 glShadeModel(GL_FLAT);
732 glBlendFunc(GL_ONE, GL_ONE);
734 glColor3f(0.5,0.5,0.5);
738 for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++)
742 if (p->glowtexnum != texnum)
744 texnum = p->glowtexnum;
745 glBindTexture(GL_TEXTURE_2D, texnum);
747 vert = &wallvert[p->firstvert];
749 for (j=0 ; j<p->numverts ; j++, vert++)
751 glTexCoord2f (vert->vert[3], vert->vert[4]);
752 glVertex3fv (vert->vert);
757 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
758 glShadeModel(GL_SMOOTH);
762 glDisable(GL_TEXTURE_2D);
763 for (i = 0,p = &wallpoly[0];i < currentwallpoly;i++, p++)
765 vert = &wallvert[p->firstvert];
767 for (j=0 ; j<p->numverts ; j++, vert++)
769 VectorSubtract(vert->vert, r_refdef.vieworg,diff);
770 glColor4f(fogcolor[0], fogcolor[1], fogcolor[2], exp(fogdensity/DotProduct(diff,diff)));
771 glVertex3fv (vert->vert);
775 glEnable(GL_TEXTURE_2D);
777 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
778 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
779 // glDisable(GL_ALPHA_TEST);
780 glShadeModel(GL_SMOOTH);
787 currentskypoly = currentskyvert = 0;
790 extern char skyname[];
791 extern rtexture_t *solidskytexture, *alphaskytexture;
797 float length, speedscale;
801 if (currentskypoly < 1)
804 // Con_DPrintf("skypolyrender: %i polys %i vertices\n", currentskypoly, currentskyvert);
805 // glDisable(GL_ALPHA_TEST);
807 // make sure zbuffer is enabled
808 glEnable(GL_DEPTH_TEST);
810 if (!fogenabled && !skyname[0]) // normal quake sky
812 glInterleavedArrays(GL_T2F_V3F, 0, skyvert);
813 // glTexCoordPointer(2, GL_FLOAT, sizeof(skyvert_t), &skyvert[0].tex[0]);
814 // glEnableClientState(GL_TEXTURE_COORD_ARRAY);
815 // glVertexPointer(3, GL_FLOAT, sizeof(skyvert_t), &skyvert[0].v[0]);
816 // glEnableClientState(GL_VERTEX_ARRAY);
818 glColor3f(0.5f, 0.5f, 0.5f);
820 glColor3f(1.0f,1.0f,1.0f);
821 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
822 glEnable(GL_TEXTURE_2D);
824 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
825 glBindTexture(GL_TEXTURE_2D, R_GetTexture(solidskytexture)); // upper clouds
826 speedscale = cl.time*8;
827 speedscale -= (int)speedscale & ~127 ;
828 for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++)
830 vert = skyvert + p->firstvert;
831 for (j = 0;j < p->verts;j++, vert++)
833 VectorSubtract (vert->v, r_origin, dir);
834 dir[2] *= 3; // flatten the sphere
836 length = dir[0]*dir[0] + dir[1]*dir[1] + dir[2]*dir[2];
837 length = sqrt (length);
838 length = 6*63/length;
840 vert->tex[0] = (speedscale + dir[0] * length) * (1.0/128);
841 vert->tex[1] = (speedscale + dir[1] * length) * (1.0/128);
844 GL_LockArray(0, currentskyvert);
845 for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++)
846 glDrawArrays(GL_POLYGON, p->firstvert, p->verts);
850 glBindTexture(GL_TEXTURE_2D, R_GetTexture(alphaskytexture)); // lower clouds
851 speedscale = cl.time*16;
852 speedscale -= (int)speedscale & ~127 ;
853 for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++)
855 vert = skyvert + p->firstvert;
856 for (j = 0;j < p->verts;j++, vert++)
858 VectorSubtract (vert->v, r_origin, dir);
859 dir[2] *= 3; // flatten the sphere
861 length = dir[0]*dir[0] + dir[1]*dir[1] + dir[2]*dir[2];
862 length = sqrt (length);
863 length = 6*63/length;
865 vert->tex[0] = (speedscale + dir[0] * length) * (1.0/128);
866 vert->tex[1] = (speedscale + dir[1] * length) * (1.0/128);
869 GL_LockArray(0, currentskyvert);
870 for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++)
871 glDrawArrays(GL_POLYGON, p->firstvert, p->verts);
876 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
877 glDisableClientState(GL_VERTEX_ARRAY);
881 glVertexPointer(3, GL_FLOAT, sizeof(skyvert_t), &skyvert[0].v[0]);
882 glEnableClientState(GL_VERTEX_ARRAY);
883 glDisable(GL_TEXTURE_2D);
884 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
885 glColor3fv(fogcolor); // note: gets rendered over by skybox if fog is not enabled
886 GL_LockArray(0, currentskyvert);
887 for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++)
888 glDrawArrays(GL_POLYGON, p->firstvert, p->verts);
891 glEnable(GL_TEXTURE_2D);
892 glDisableClientState(GL_VERTEX_ARRAY);