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;
52 void gl_poly_shutdown()
56 qfree(transpolyindex);
66 Cvar_RegisterVariable (&gl_multitexture);
67 R_RegisterModule("GL_Poly", gl_poly_start, gl_poly_shutdown);
72 currenttranspoly = currenttransvert = 0;
73 currenttranslist = translist;
74 memset(translisthash, 0, sizeof(translisthash));
75 transviewdist = DotProduct(r_refdef.vieworg, vpn);
78 // turned into a #define
80 void transpolybegin(int texnum, int glowtexnum, int fogtexnum, int transpolytype)
82 if (currenttranspoly >= MAX_TRANSPOLYS || currenttransvert >= MAX_TRANSVERTS)
84 transpoly[currenttranspoly].texnum = (unsigned short) texnum;
85 transpoly[currenttranspoly].glowtexnum = (unsigned short) glowtexnum;
86 transpoly[currenttranspoly].fogtexnum = (unsigned short) fogtexnum;
87 transpoly[currenttranspoly].transpolytype = (unsigned short) transpolytype;
88 transpoly[currenttranspoly].firstvert = currenttransvert;
89 transpoly[currenttranspoly].verts = 0;
90 // transpoly[currenttranspoly].ndist = 0; // clear the normal
94 // turned into a #define
96 void transpolyvert(float x, float y, float z, float s, float t, int r, int g, int b, int a)
99 if (currenttranspoly >= MAX_TRANSPOLYS || currenttransvert >= MAX_TRANSVERTS)
101 transvert[currenttransvert].s = s;
102 transvert[currenttransvert].t = t;
103 transvert[currenttransvert].r = bound(0, r, 255);
104 transvert[currenttransvert].g = bound(0, g, 255);
105 transvert[currenttransvert].b = bound(0, b, 255);
106 transvert[currenttransvert].a = bound(0, a, 255);
107 transvert[currenttransvert].v[0] = x;
108 transvert[currenttransvert].v[1] = y;
109 transvert[currenttransvert].v[2] = z;
111 transpoly[currenttranspoly].verts++;
117 float center, d, maxdist;
120 if (currenttranspoly >= MAX_TRANSPOLYS || currenttransvert >= MAX_TRANSVERTS)
122 if (transpoly[currenttranspoly].verts < 3) // skip invalid polygons
124 currenttransvert = transpoly[currenttranspoly].firstvert; // reset vert pointer
128 maxdist = -1000000000000000.0f; // eh, it's definitely behind it, so...
129 for (i = 0,v = &transvert[transpoly[currenttranspoly].firstvert];i < transpoly[currenttranspoly].verts;i++, v++)
131 d = DotProduct(v->v, vpn);
136 maxdist -= transviewdist;
137 if (maxdist < 4.0f) // behind view
139 currenttransvert = transpoly[currenttranspoly].firstvert; // reset vert pointer
142 center *= transreciptable[transpoly[currenttranspoly].verts];
143 center -= transviewdist;
144 i = bound(0, (int) center, 4095);
145 currenttranslist->next = translisthash[i];
146 currenttranslist->poly = transpoly + currenttranspoly;
147 translisthash[i] = currenttranslist;
152 int transpolyindices;
155 void transpolyrenderminmax()
157 int i, j, k, lastvert;
158 vec_t d, min, max, viewdist, s, average;
161 transpolyindices = 0;
162 viewdist = DotProduct(r_refdef.vieworg, vpn);
163 for (i = 0;i < currenttranspoly;i++)
165 if (transpoly[i].verts < 3) // only process valid polygons
167 min = 1000000;max = -1000000;
168 s = 1.0f / transpoly[i].verts;
169 lastvert = transpoly[i].firstvert + transpoly[i].verts;
171 for (j = transpoly[i].firstvert;j < lastvert;j++)
173 d = DotProduct(transvert[j].v, vpn)-viewdist;
174 if (d < min) min = d;
175 if (d > max) max = d;
178 if (max < 4) // free to check here, so skip polys behind the view
180 transpoly[i].distance = average;
183 transpoly[i].mindistance = min;
184 transpoly[i].maxdistance = max;
185 // calculate normal (eek)
186 VectorSubtract(transvert[transpoly[i].firstvert ].v, transvert[transpoly[i].firstvert+1].v, v1);
187 VectorSubtract(transvert[transpoly[i].firstvert+2].v, transvert[transpoly[i].firstvert+1].v, v2);
190 if (transpoly[i].verts > 3 && fabs(DotProduct(v1, v2)) >= (1.0f - (1.0f / 256.0f))) // colinear edges, find a better triple
192 VectorSubtract(transvert[transpoly[i].firstvert + transpoly[i].verts - 1].v, transvert[transpoly[i].firstvert].v, v1);
193 VectorSubtract(transvert[transpoly[i].firstvert + 1].v, transvert[transpoly[i].firstvert].v, v2);
196 if (fabs(DotProduct(v1, v2)) < (1.0f - (1.0f / 256.0f))) // found a good triple
198 for (k = transpoly[i].firstvert + 2;k < (transpoly[i].firstvert + transpoly[i].verts - 1);k++)
200 VectorSubtract(transvert[k-1].v, transvert[k].v, v1);
201 VectorSubtract(transvert[k+1].v, transvert[k].v, v2);
204 if (fabs(DotProduct(v1, v2)) < (1.0f - (1.0f / 256.0f))) // found a good triple
207 VectorSubtract(transvert[k-1].v, transvert[k].v, v1);
208 VectorSubtract(transvert[transpoly[i].firstvert].v, transvert[k].v, v2);
211 if (fabs(DotProduct(v1, v2)) >= (1.0f - (1.0f / 256.0f))) // no good triples; the polygon is a line, skip it
215 CrossProduct(v1, v2, n);
217 ndist = DotProduct(transvert[transpoly[i].firstvert+1].v, n);
219 for (j = 0;j < transpolyindices;j++)
222 if (transpoly[transpolyindex[j]].mindistance > max)
224 if (transpoly[transpolyindex[j]].maxdistance < min)
226 // hard case, check side
227 for (k = transpoly[transpolyindex[j]].firstvert;k < (transpoly[transpolyindex[j]].firstvert + transpoly[transpolyindex[j]].verts);k++)
228 if (DotProduct(transvert[k].v, n) < ndist)
237 for (j = 0;j < transpolyindices;j++)
238 if (transpoly[transpolyindex[j]].distance < average)
240 for (k = transpolyindices;k > j;k--)
241 transpolyindex[k] = transpolyindex[k-1];
243 transpolyindex[j] = i;
248 // LordHavoc: qsort compare function
249 int transpolyqsort(const void *ia, const void *ib)
253 a = &transpoly[*((unsigned short *)ia)];
254 b = &transpoly[*((unsigned short *)ib)];
256 if (a->mindistance > b->mindistance && a->maxdistance > b->maxdistance)
258 if (a->mindistance < b->mindistance && a->maxdistance < b->maxdistance)
263 // calculate normal (eek)
265 VectorSubtract(transvert[a->firstvert ].v, transvert[a->firstvert+1].v, v1);
266 VectorSubtract(transvert[a->firstvert+2].v, transvert[a->firstvert+1].v, v2);
267 CrossProduct(v1, v2, a->n);
268 VectorNormalize(a->n);
269 a->ndist = DotProduct(transvert[a->firstvert ].v, a->n);
272 for (i = b->firstvert, j = 0;i < (b->firstvert + b->verts);i++)
273 j += DotProduct(transvert[i].v, a->n) < a->ndist; // (1) b is infront of a
275 return -1; // (-1) a is behind b
276 return j == b->verts; // (1) a is infront of b (0) a and b intersect
277 // return (transpoly[*((unsigned short *)ib)].mindistance + transpoly[*((unsigned short *)ib)].maxdistance) - (transpoly[*((unsigned short *)ia)].mindistance + transpoly[*((unsigned short *)ia)].maxdistance);
280 return ((transpoly_t*)ia)->distance - ((transpoly_t*)ib)->distance;
285 int transpolyqsort(const void *ia, const void *ib)
287 return (transpoly[*((unsigned short *)ib)].distance - transpoly[*((unsigned short *)ia)].distance);
292 void transpolyrenderminmax()
295 vec_t d, max, viewdist, average;
296 transpolyindices = 0;
297 viewdist = DotProduct(r_refdef.vieworg, vpn);
298 for (i = 0;i < currenttranspoly;i++)
300 if (transpoly[i].verts < 3) // only process valid polygons
303 lastvert = transpoly[i].firstvert + transpoly[i].verts;
305 for (j = transpoly[i].firstvert;j < lastvert;j++)
307 d = DotProduct(transvert[j].v, vpn)-viewdist;
312 if (max < 4) // free to check here, so skip polys behind the view
314 transpoly[i].distance = average / transpoly[i].verts;
315 transpolyindex[transpolyindices++] = i;
317 qsort(&transpolyindex[0], transpolyindices, sizeof(unsigned short), transpolyqsort);
326 for (i = 1;i < transpolyindices;i++)
329 if (transpoly[transpolyindex[i - 1]].mindistance > transpoly[transpolyindex[i]].mindistance && transpoly[transpolyindex[i - 1]].maxdistance > transpoly[transpolyindex[i]].maxdistance)
330 continue; // previous is behind (no swap)
331 if (transpoly[transpolyindex[i - 1]].mindistance < transpoly[transpolyindex[i]].mindistance && transpoly[transpolyindex[i - 1]].maxdistance < transpoly[transpolyindex[i]].maxdistance)
332 goto swap; // previous is infront (swap)
336 if (!transpoly[transpolyindex[i - 1]].ndist)
338 // calculate normal (eek)
340 VectorSubtract(transvert[transpoly[transpolyindex[i - 1]].firstvert ].v, transvert[transpoly[transpolyindex[i - 1]].firstvert+1].v, v1);
341 VectorSubtract(transvert[transpoly[transpolyindex[i - 1]].firstvert+2].v, transvert[transpoly[transpolyindex[i - 1]].firstvert+1].v, v2);
342 CrossProduct(v1, v2, transpoly[transpolyindex[i - 1]].n);
343 VectorNormalize(transpoly[transpolyindex[i - 1]].n);
344 transpoly[transpolyindex[i - 1]].ndist = DotProduct(transvert[transpoly[transpolyindex[i - 1]].firstvert ].v, transpoly[transpolyindex[i - 1]].n);
346 if (DotProduct(transpoly[transpolyindex[i - 1]].n, vpn) >= 0.0f) // backface
351 for (i = transpoly[transpolyindex[i]].firstvert;i < (transpoly[transpolyindex[i]].firstvert + transpoly[transpolyindex[i]].verts);i++)
352 if (DotProduct(transvert[i].v, transpoly[transpolyindex[i - 1]].n) >= transpoly[transpolyindex[i - 1]].ndist)
353 goto noswap; // previous is behind or they intersect
355 // previous is infront (swap)
356 j = transpolyindex[i];
357 transpolyindex[i] = transpolyindex[i - 1];
358 transpolyindex[i - 1] = j;
367 void transpolyrender()
369 int i, j, tpolytype, texnum;
373 if (currenttranspoly < 1)
375 // transpolyrenderminmax();
376 // if (transpolyindices < 1)
379 // Con_DPrintf("transpolyrender: %i polys %i infront %i vertices\n", currenttranspoly, transpolyindices, currenttransvert);
380 // if (transpolyindices >= 2)
382 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
384 glShadeModel(GL_SMOOTH);
385 glDepthMask(0); // disable zbuffer updates
386 glDisable(GL_ALPHA_TEST);
387 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
388 tpolytype = TPOLYTYPE_ALPHA;
391 if (gl_vertexarrays.value)
393 // set up the vertex array
394 glInterleavedArrays(GL_T2F_C4UB_V3F, 0, transvert);
395 for (i = 0;i < transpolyindices;i++)
397 p = &transpoly[transpolyindex[i]];
398 if (p->texnum != texnum || p->transpolytype != tpolytype)
400 if (p->texnum != texnum)
403 glBindTexture(GL_TEXTURE_2D, texnum);
405 if (p->transpolytype != tpolytype)
407 tpolytype = p->transpolytype;
408 if (tpolytype == TPOLYTYPE_ADD) // additive
409 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
411 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
414 glDrawArrays(GL_POLYGON, p->firstvert, p->verts);
417 texnum = p->glowtexnum; // highly unlikely to match next poly, but...
418 glBindTexture(GL_TEXTURE_2D, texnum);
419 tpolytype = TPOLYTYPE_ADD; // might match next poly
420 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
421 glDrawArrays(GL_POLYGON, p->firstvert, p->verts);
424 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
425 glDisableClientState(GL_COLOR_ARRAY);
426 glDisableClientState(GL_VERTEX_ARRAY);
434 for (i = 4095;i >= 0;i--)
436 item = translisthash[i];
441 if (p->texnum != texnum || p->verts != points || p->transpolytype != tpolytype)
446 // LordHavoc: Matrox G200 cards can't handle per pixel alpha
448 glEnable(GL_ALPHA_TEST);
450 glDisable(GL_ALPHA_TEST);
452 if (p->texnum != texnum)
455 glBindTexture(GL_TEXTURE_2D, texnum);
457 if (p->transpolytype != tpolytype)
459 tpolytype = p->transpolytype;
460 if (tpolytype == TPOLYTYPE_ADD) // additive
461 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
463 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
469 glBegin(GL_TRIANGLES);
476 points = -1; // to force a reinit on the next poly
480 for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++)
482 // would be 2fv, but windoze Matrox G200 and probably G400 drivers don't support that (dumb...)
483 glTexCoord2f(vert->s, vert->t);
484 // again, vector version isn't supported I think
485 glColor4ub(vert->r, vert->g, vert->b, vert->a);
486 glVertex3fv(vert->v);
491 texnum = p->glowtexnum; // highly unlikely to match next poly, but...
492 glBindTexture(GL_TEXTURE_2D, texnum);
493 if (tpolytype != TPOLYTYPE_ADD)
495 tpolytype = TPOLYTYPE_ADD; // might match next poly
496 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
500 for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++)
502 glColor4ub(255,255,255,vert->a);
503 // would be 2fv, but windoze Matrox G200 and probably G400 drivers don't support that (dumb...)
504 glTexCoord2f(vert->s, vert->t);
505 glVertex3fv(vert->v);
509 if (fogenabled && p->transpolytype == TPOLYTYPE_ALPHA)
513 points = -1; // to force a reinit on the next poly
514 if (tpolytype != TPOLYTYPE_ALPHA)
516 tpolytype = TPOLYTYPE_ALPHA; // probably matchs next poly
517 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
521 if (texnum != p->fogtexnum) // highly unlikely to match next poly, but...
523 texnum = p->fogtexnum;
524 glBindTexture(GL_TEXTURE_2D, texnum);
527 for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++)
529 VectorSubtract(vert->v, r_refdef.vieworg,diff);
530 glTexCoord2f(vert->s, vert->t);
531 glColor4f(fogcolor[0], fogcolor[1], fogcolor[2], vert->a*(1.0f/255.0f)*exp(fogdensity/DotProduct(diff,diff)));
532 glVertex3fv(vert->v);
538 glDisable(GL_TEXTURE_2D);
540 for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++)
542 VectorSubtract(vert->v, r_refdef.vieworg,diff);
543 glColor4f(fogcolor[0], fogcolor[1], fogcolor[2], vert->a*(1.0f/255.0f)*exp(fogdensity/DotProduct(diff,diff)));
544 glVertex3fv(vert->v);
547 glEnable(GL_TEXTURE_2D);
555 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
556 glDepthMask(1); // enable zbuffer updates
557 glDisable(GL_ALPHA_TEST);
562 currentwallpoly = currentwallvert = 0;
565 void wallpolyrender()
567 int i, j, texnum, lighttexnum;
570 wallvertcolor_t *vertcolor;
573 if (currentwallpoly < 1)
575 c_brush_polys += currentwallpoly;
577 //Con_DPrintf("wallpolyrender: %i polys %i vertices\n", currentwallpoly, currentwallvert);
579 gl_multitexture.value = 0;
581 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
582 glShadeModel(GL_FLAT);
583 // make sure zbuffer is enabled
584 glEnable(GL_DEPTH_TEST);
585 // glDisable(GL_ALPHA_TEST);
588 if (r_fullbright.value) // LordHavoc: easy to do fullbright...
590 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
592 for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++)
594 if (p->texnum != texnum)
597 glBindTexture(GL_TEXTURE_2D, texnum);
599 vert = &wallvert[p->firstvert];
601 for (j=0 ; j<p->numverts ; j++, vert++)
603 glTexCoord2f (vert->vert[3], vert->vert[4]);
604 glVertex3fv (vert->vert);
609 else if (gl_multitexture.value)
611 qglSelectTexture(gl_mtex_enum+0);
612 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
613 glEnable(GL_TEXTURE_2D);
614 qglSelectTexture(gl_mtex_enum+1);
615 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
616 glEnable(GL_TEXTURE_2D);
619 for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++)
621 if (p->texnum != texnum || p->lighttexnum != lighttexnum)
624 lighttexnum = p->lighttexnum;
625 qglSelectTexture(gl_mtex_enum+0);
626 glBindTexture(GL_TEXTURE_2D, texnum);
627 qglSelectTexture(gl_mtex_enum+1);
628 glBindTexture(GL_TEXTURE_2D, lighttexnum);
630 vert = &wallvert[p->firstvert];
632 for (j=0 ; j<p->numverts ; j++, vert++)
634 qglMTexCoord2f(gl_mtex_enum, vert->vert[3], vert->vert[4]); // texture
635 qglMTexCoord2f((gl_mtex_enum+1), vert->vert[5], vert->vert[6]); // lightmap
636 glVertex3fv (vert->vert);
641 qglSelectTexture(gl_mtex_enum+1);
642 glDisable(GL_TEXTURE_2D);
643 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
644 qglSelectTexture(gl_mtex_enum+0);
645 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
649 // first do the textures
650 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
652 for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++)
654 if (p->texnum != texnum)
657 glBindTexture(GL_TEXTURE_2D, texnum);
659 vert = &wallvert[p->firstvert];
661 for (j=0 ; j<p->numverts ; j++, vert++)
663 glTexCoord2f (vert->vert[3], vert->vert[4]);
664 glVertex3fv (vert->vert);
668 // then modulate using the lightmaps
669 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
670 glBlendFunc(GL_ZERO, GL_SRC_COLOR);
673 for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++)
675 if (p->lighttexnum != texnum)
677 texnum = p->lighttexnum;
678 glBindTexture(GL_TEXTURE_2D, texnum);
680 vert = &wallvert[p->firstvert];
682 for (j=0 ; j<p->numverts ; j++, vert++)
684 glTexCoord2f (vert->vert[5], vert->vert[6]);
685 glVertex3fv (vert->vert);
690 // switch to additive mode settings
692 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
693 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
695 // glDisable(GL_ALPHA_TEST);
696 glShadeModel(GL_SMOOTH);
697 // render vertex lit overlays ontop
699 for (i = 0, p = wallpoly;i < currentwallpoly;i++, p++)
703 for (j = 0,vertcolor = &wallvertcolor[p->firstvert];j < p->numverts;j++, vertcolor++)
704 if (vertcolor->r || vertcolor->g || vertcolor->b)
709 if (p->texnum != texnum)
712 glBindTexture(GL_TEXTURE_2D, texnum);
715 for (j = 0,vert = &wallvert[p->firstvert], vertcolor = &wallvertcolor[p->firstvert];j < p->numverts;j++, vert++, vertcolor++)
717 // would be 2fv, but windoze Matrox G200 and probably G400 drivers don't support that (dumb...)
718 glTexCoord2f(vert->vert[3], vert->vert[4]);
719 // again, vector version isn't supported I think
720 glColor3ub(vertcolor->r, vertcolor->g, vertcolor->b);
721 glVertex3fv(vert->vert);
725 // render glow textures
726 glShadeModel(GL_FLAT);
727 glBlendFunc(GL_ONE, GL_ONE);
729 glColor3f(0.5,0.5,0.5);
733 for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++)
737 if (p->glowtexnum != texnum)
739 texnum = p->glowtexnum;
740 glBindTexture(GL_TEXTURE_2D, texnum);
742 vert = &wallvert[p->firstvert];
744 for (j=0 ; j<p->numverts ; j++, vert++)
746 glTexCoord2f (vert->vert[3], vert->vert[4]);
747 glVertex3fv (vert->vert);
752 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
753 glShadeModel(GL_SMOOTH);
757 glDisable(GL_TEXTURE_2D);
758 for (i = 0,p = &wallpoly[0];i < currentwallpoly;i++, p++)
760 vert = &wallvert[p->firstvert];
762 for (j=0 ; j<p->numverts ; j++, vert++)
764 VectorSubtract(vert->vert, r_refdef.vieworg,diff);
765 glColor4f(fogcolor[0], fogcolor[1], fogcolor[2], exp(fogdensity/DotProduct(diff,diff)));
766 glVertex3fv (vert->vert);
770 glEnable(GL_TEXTURE_2D);
772 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
773 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
774 // glDisable(GL_ALPHA_TEST);
775 glShadeModel(GL_SMOOTH);
782 currentskypoly = currentskyvert = 0;
785 extern char skyname[];
786 extern rtexture_t *solidskytexture, *alphaskytexture;
789 int i, j, numskyverts;
792 float length, speedscale;
796 if (currentskypoly < 1)
799 // Con_DPrintf("skypolyrender: %i polys %i vertices\n", currentskypoly, currentskyvert);
800 // glDisable(GL_ALPHA_TEST);
802 // make sure zbuffer is enabled
803 glEnable(GL_DEPTH_TEST);
805 if (!fogenabled && !skyname[0]) // normal quake sky
807 glInterleavedArrays(GL_T2F_V3F, 0, skyvert);
808 // glTexCoordPointer(2, GL_FLOAT, sizeof(skyvert_t) - sizeof(float) * 2, &skyvert[0].tex[0]);
809 // glEnableClientState(GL_TEXTURE_COORD_ARRAY);
810 // glVertexPointer(3, GL_FLOAT, sizeof(skyvert_t) - sizeof(float) * 3, &skyvert[0].v[0]);
811 // glEnableClientState(GL_VERTEX_ARRAY);
813 glColor3f(0.5f, 0.5f, 0.5f);
815 glColor3f(1.0f,1.0f,1.0f);
816 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
817 glEnable(GL_TEXTURE_2D);
819 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
820 glBindTexture(GL_TEXTURE_2D, R_GetTexture(solidskytexture)); // upper clouds
821 speedscale = cl.time*8;
822 speedscale -= (int)speedscale & ~127 ;
824 for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++)
826 vert = skyvert + p->firstvert;
827 for (j = 0;j < p->verts;j++, vert++)
829 VectorSubtract (vert->v, r_origin, dir);
830 dir[2] *= 3; // flatten the sphere
832 length = dir[0]*dir[0] + dir[1]*dir[1] + dir[2]*dir[2];
833 length = sqrt (length);
834 length = 6*63/length;
836 vert->tex[0] = (speedscale + dir[0] * length) * (1.0/128);
837 vert->tex[1] = (speedscale + dir[1] * length) * (1.0/128);
839 numskyverts += p->verts;
841 GL_LockArray(0, numskyverts);
842 for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++)
843 glDrawArrays(GL_POLYGON, p->firstvert, p->verts);
847 glBindTexture(GL_TEXTURE_2D, R_GetTexture(alphaskytexture)); // lower clouds
848 speedscale = cl.time*16;
849 speedscale -= (int)speedscale & ~127 ;
850 for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++)
852 vert = skyvert + p->firstvert;
853 for (j = 0;j < p->verts;j++, vert++)
855 VectorSubtract (vert->v, r_origin, dir);
856 dir[2] *= 3; // flatten the sphere
858 length = dir[0]*dir[0] + dir[1]*dir[1] + dir[2]*dir[2];
859 length = sqrt (length);
860 length = 6*63/length;
862 vert->tex[0] = (speedscale + dir[0] * length) * (1.0/128);
863 vert->tex[1] = (speedscale + dir[1] * length) * (1.0/128);
866 GL_LockArray(0, numskyverts);
867 for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++)
868 glDrawArrays(GL_POLYGON, p->firstvert, p->verts);
873 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
874 glDisableClientState(GL_VERTEX_ARRAY);
878 glVertexPointer(3, GL_FLOAT, sizeof(skyvert_t) - sizeof(float) * 3, &skyvert[0].v[0]);
879 glEnableClientState(GL_VERTEX_ARRAY);
880 glDisable(GL_TEXTURE_2D);
881 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
882 glColor3fv(fogcolor); // note: gets rendered over by skybox if fog is not enabled
884 for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++)
885 numskyverts += p->verts;
886 GL_LockArray(0, numskyverts);
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);