gl_poly.c

   1 #include "quakedef.h"
   2
   3 transvert_t *transvert;
   4 transpoly_t *transpoly;
   5 unsigned short *transpolyindex;
   6 wallvert_t *wallvert;
   7 wallpoly_t *wallpoly;
   8 skyvert_t *skyvert;
   9 skypoly_t *skypoly;
  10
  11 unsigned short currenttranspoly;
  12 unsigned short currenttransvert;
  13 unsigned short currentwallpoly;
  14 unsigned short currentwallvert;
  15 unsigned short currentskypoly;
  16 unsigned short currentskyvert;
  17
  18 cvar_t gl_multitexture = {"gl_multitexture", "1"};
  19 cvar_t gl_vertexarrays = {"gl_vertexarrays", "1"};
  20
  21 void glpoly_init()
  22 {
  23         Cvar_RegisterVariable (&gl_multitexture);
  24         Cvar_RegisterVariable (&gl_vertexarrays);
  25         transvert = malloc(MAX_TRANSVERTS * sizeof(transvert_t));
  26         transpoly = malloc(MAX_TRANSPOLYS * sizeof(transpoly_t));
  27         transpolyindex = malloc(MAX_TRANSPOLYS * sizeof(unsigned short));
  28         wallvert = malloc(MAX_WALLVERTS * sizeof(wallvert_t));
  29         wallpoly = malloc(MAX_WALLPOLYS * sizeof(wallpoly_t));
  30         skyvert = malloc(MAX_SKYVERTS * sizeof(skyvert_t));
  31         skypoly = malloc(MAX_SKYPOLYS * sizeof(skypoly_t));
  32 }
  33
  34 void transpolyclear()
  35 {
  36         currenttranspoly = currenttransvert = 0;
  37 }
  38
  39 void transpolybegin(int texnum, int glowtexnum, int fogtexnum, int transpolytype)
  40 {
  41         if (currenttranspoly >= MAX_TRANSPOLYS || currenttransvert >= MAX_TRANSVERTS)
  42                 return;
  43         transpoly[currenttranspoly].texnum = (unsigned short) texnum;
  44         transpoly[currenttranspoly].glowtexnum = (unsigned short) glowtexnum;
  45         transpoly[currenttranspoly].fogtexnum = (unsigned short) fogtexnum;
  46         transpoly[currenttranspoly].transpolytype = (unsigned short) transpolytype;
  47         transpoly[currenttranspoly].firstvert = currenttransvert;
  48         transpoly[currenttranspoly].verts = 0;
  49 //      transpoly[currenttranspoly].ndist = 0; // clear the normal
  50 }
  51
  52 // turned into a #define
  53 /*
  54 void transpolyvert(float x, float y, float z, float s, float t, int r, int g, int b, int a)
  55 {
  56         int i;
  57         if (currenttranspoly >= MAX_TRANSPOLYS || currenttransvert >= MAX_TRANSVERTS)
  58                 return;
  59         transvert[currenttransvert].s = s;
  60         transvert[currenttransvert].t = t;
  61         transvert[currenttransvert].r = bound(0, r, 255);
  62         transvert[currenttransvert].g = bound(0, g, 255);
  63         transvert[currenttransvert].b = bound(0, b, 255);
  64         transvert[currenttransvert].a = bound(0, a, 255);
  65         transvert[currenttransvert].v[0] = x;
  66         transvert[currenttransvert].v[1] = y;
  67         transvert[currenttransvert].v[2] = z;
  68         currenttransvert++;
  69         transpoly[currenttranspoly].verts++;
  70 }
  71 */
  72
  73 void transpolyend()
  74 {
  75         if (currenttranspoly >= MAX_TRANSPOLYS)
  76                 return;
  77         if (transpoly[currenttranspoly].verts < 3) // skip invalid polygons
  78         {
  79                 currenttransvert = transpoly[currenttranspoly].firstvert; // reset vert pointer
  80                 return;
  81         }
  82         if (currenttransvert >= MAX_TRANSVERTS)
  83                 return;
  84         currenttranspoly++;
  85 }
  86
  87 int transpolyindices;
  88 extern qboolean isG200;
  89
  90 /*
  91 void transpolyrenderminmax()
  92 {
  93         int i, j, k, lastvert;
  94         vec_t d, min, max, viewdist, s, average;
  95         //vec_t ndist;
  96         //vec3_t v1, v2, n;
  97         transpolyindices = 0;
  98         viewdist = DotProduct(r_refdef.vieworg, vpn);
  99         for (i = 0;i < currenttranspoly;i++)
 100         {
 101                 if (transpoly[i].verts < 3) // only process valid polygons
 102                         continue;
 103                 min = 1000000;max = -1000000;
 104                 s = 1.0f / transpoly[i].verts;
 105                 lastvert = transpoly[i].firstvert + transpoly[i].verts;
 106                 average = 0;
 107                 for (j = transpoly[i].firstvert;j < lastvert;j++)
 108                 {
 109                         d = DotProduct(transvert[j].v, vpn)-viewdist;
 110                         if (d < min) min = d;
 111                         if (d > max) max = d;
 112                         average += d * s;
 113                 }
 114                 if (max < 4) // free to check here, so skip polys behind the view
 115                         continue;
 116                 transpoly[i].distance = average;
 117 */
 118                 /*
 119                 transpoly[i].mindistance = min;
 120                 transpoly[i].maxdistance = max;
 121                 // calculate normal (eek)
 122                 VectorSubtract(transvert[transpoly[i].firstvert  ].v, transvert[transpoly[i].firstvert+1].v, v1);
 123                 VectorSubtract(transvert[transpoly[i].firstvert+2].v, transvert[transpoly[i].firstvert+1].v, v2);
 124                 VectorNormalize(v1);
 125                 VectorNormalize(v2);
 126                 if (transpoly[i].verts > 3 && fabs(DotProduct(v1, v2)) >= (1.0f - (1.0f / 256.0f))) // colinear edges, find a better triple
 127                 {
 128                         VectorSubtract(transvert[transpoly[i].firstvert + transpoly[i].verts - 1].v, transvert[transpoly[i].firstvert].v, v1);
 129                         VectorSubtract(transvert[transpoly[i].firstvert + 1].v, transvert[transpoly[i].firstvert].v, v2);
 130                         VectorNormalize(v1);
 131                         VectorNormalize(v2);
 132                         if (fabs(DotProduct(v1, v2)) < (1.0f - (1.0f / 256.0f))) // found a good triple
 133                                 goto foundtriple;
 134                         for (k = transpoly[i].firstvert + 2;k < (transpoly[i].firstvert + transpoly[i].verts - 1);k++)
 135                         {
 136                                 VectorSubtract(transvert[k-1].v, transvert[k].v, v1);
 137                                 VectorSubtract(transvert[k+1].v, transvert[k].v, v2);
 138                                 VectorNormalize(v1);
 139                                 VectorNormalize(v2);
 140                                 if (fabs(DotProduct(v1, v2)) < (1.0f - (1.0f / 256.0f))) // found a good triple
 141                                         goto foundtriple;
 142                         }
 143                         VectorSubtract(transvert[k-1].v, transvert[k].v, v1);
 144                         VectorSubtract(transvert[transpoly[i].firstvert].v, transvert[k].v, v2);
 145                         VectorNormalize(v1);
 146                         VectorNormalize(v2);
 147                         if (fabs(DotProduct(v1, v2)) >= (1.0f - (1.0f / 256.0f))) // no good triples; the polygon is a line, skip it
 148                                 continue;
 149                 }
 150 foundtriple:
 151                 CrossProduct(v1, v2, n);
 152                 VectorNormalize(n);
 153                 ndist = DotProduct(transvert[transpoly[i].firstvert+1].v, n);
 154                 // sorted insert
 155                 for (j = 0;j < transpolyindices;j++)
 156                 {
 157                         // easy cases
 158                         if (transpoly[transpolyindex[j]].mindistance > max)
 159                                 continue;
 160                         if (transpoly[transpolyindex[j]].maxdistance < min)
 161                                 break;
 162                         // hard case, check side
 163                         for (k = transpoly[transpolyindex[j]].firstvert;k < (transpoly[transpolyindex[j]].firstvert + transpoly[transpolyindex[j]].verts);k++)
 164                                 if (DotProduct(transvert[k].v, n) < ndist)
 165                                         goto skip;
 166                         break;
 167 skip:
 168                         ;
 169                 }
 170                 */
 171 /*
 172                 // sorted insert
 173                 for (j = 0;j < transpolyindices;j++)
 174                         if (transpoly[transpolyindex[j]].distance < average)
 175                                 break;
 176                 for (k = transpolyindices;k > j;k--)
 177                         transpolyindex[k] = transpolyindex[k-1];
 178                 transpolyindices++;
 179                 transpolyindex[j] = i;
 180         }
 181 }
 182 */
 183 /*
 184 // LordHavoc: qsort compare function
 185 int transpolyqsort(const void *ia, const void *ib)
 186 {
 187         transpoly_t *a, *b;
 188         int i, j;
 189         a = &transpoly[*((unsigned short *)ia)];
 190         b = &transpoly[*((unsigned short *)ib)];
 191         // easy cases
 192         if (a->mindistance > b->mindistance && a->maxdistance > b->maxdistance)
 193                 return -1; // behind
 194         if (a->mindistance < b->mindistance && a->maxdistance < b->maxdistance)
 195                 return 1; // infront
 196         // hard case
 197         if (!a->ndist)
 198         {
 199                 // calculate normal (eek)
 200                 vec3_t v1, v2;
 201                 VectorSubtract(transvert[a->firstvert  ].v, transvert[a->firstvert+1].v, v1);
 202                 VectorSubtract(transvert[a->firstvert+2].v, transvert[a->firstvert+1].v, v2);
 203                 CrossProduct(v1, v2, a->n);
 204                 VectorNormalize(a->n);
 205                 a->ndist = DotProduct(transvert[a->firstvert  ].v, a->n);
 206         }
 207         // check side
 208         for (i = b->firstvert, j = 0;i < (b->firstvert + b->verts);i++)
 209                 j += DotProduct(transvert[i].v, a->n) < a->ndist; // (1) b is infront of a
 210         if (j == 0)
 211                 return -1; // (-1) a is behind b
 212         return j == b->verts; // (1) a is infront of b    (0) a and b intersect
 213 //      return (transpoly[*((unsigned short *)ib)].mindistance + transpoly[*((unsigned short *)ib)].maxdistance) - (transpoly[*((unsigned short *)ia)].mindistance + transpoly[*((unsigned short *)ia)].maxdistance);
 214         */
 215 /*
 216         return ((transpoly_t*)ia)->distance - ((transpoly_t*)ib)->distance;
 217 }
 218 */
 219
 220 int transpolyqsort(const void *ia, const void *ib)
 221 {
 222         return (transpoly[*((unsigned short *)ib)].distance - transpoly[*((unsigned short *)ia)].distance);
 223 }
 224
 225 void transpolyrenderminmax()
 226 {
 227         int i, j, lastvert;
 228         vec_t d, max, viewdist, average;
 229         transpolyindices = 0;
 230         viewdist = DotProduct(r_refdef.vieworg, vpn);
 231         for (i = 0;i < currenttranspoly;i++)
 232         {
 233                 if (transpoly[i].verts < 3) // only process valid polygons
 234                         continue;
 235                 max = -1000000;
 236                 lastvert = transpoly[i].firstvert + transpoly[i].verts;
 237                 average = 0;
 238                 for (j = transpoly[i].firstvert;j < lastvert;j++)
 239                 {
 240                         d = DotProduct(transvert[j].v, vpn)-viewdist;
 241                         average += d;
 242                         if (d > max)
 243                                 max = d;
 244                 }
 245                 if (max < 4) // free to check here, so skip polys behind the view
 246                         continue;
 247                 transpoly[i].distance = average / transpoly[i].verts;
 248                 transpolyindex[transpolyindices++] = i;
 249         }
 250         qsort(&transpolyindex[0], transpolyindices, sizeof(unsigned short), transpolyqsort);
 251 }
 252 /*
 253         int i, j, a;
 254         a = true;
 255         while(a)
 256         {
 257                 a = false;
 258                 for (i = 1;i < transpolyindices;i++)
 259                 {
 260                         // easy cases
 261                         if (transpoly[transpolyindex[i - 1]].mindistance > transpoly[transpolyindex[i]].mindistance && transpoly[transpolyindex[i - 1]].maxdistance > transpoly[transpolyindex[i]].maxdistance)
 262                                 continue; // previous is behind (no swap)
 263                         if (transpoly[transpolyindex[i - 1]].mindistance < transpoly[transpolyindex[i]].mindistance && transpoly[transpolyindex[i - 1]].maxdistance < transpoly[transpolyindex[i]].maxdistance)
 264                                 goto swap; // previous is infront (swap)
 265                         // hard case
 266 */
 267                         /*
 268                         if (!transpoly[transpolyindex[i - 1]].ndist)
 269                         {
 270                                 // calculate normal (eek)
 271                                 vec3_t v1, v2;
 272                                 VectorSubtract(transvert[transpoly[transpolyindex[i - 1]].firstvert  ].v, transvert[transpoly[transpolyindex[i - 1]].firstvert+1].v, v1);
 273                                 VectorSubtract(transvert[transpoly[transpolyindex[i - 1]].firstvert+2].v, transvert[transpoly[transpolyindex[i - 1]].firstvert+1].v, v2);
 274                                 CrossProduct(v1, v2, transpoly[transpolyindex[i - 1]].n);
 275                                 VectorNormalize(transpoly[transpolyindex[i - 1]].n);
 276                                 transpoly[transpolyindex[i - 1]].ndist = DotProduct(transvert[transpoly[transpolyindex[i - 1]].firstvert  ].v, transpoly[transpolyindex[i - 1]].n);
 277                         }
 278                         if (DotProduct(transpoly[transpolyindex[i - 1]].n, vpn) >= 0.0f) // backface
 279                                 continue;
 280                         */
 281 /*
 282                         // check side
 283                         for (i = transpoly[transpolyindex[i]].firstvert;i < (transpoly[transpolyindex[i]].firstvert + transpoly[transpolyindex[i]].verts);i++)
 284                                 if (DotProduct(transvert[i].v, transpoly[transpolyindex[i - 1]].n) >= transpoly[transpolyindex[i - 1]].ndist)
 285                                         goto noswap; // previous is behind or they intersect
 286 swap:
 287                         // previous is infront (swap)
 288                         j = transpolyindex[i];
 289                         transpolyindex[i] = transpolyindex[i - 1];
 290                         transpolyindex[i - 1] = j;
 291                         a = true;
 292 noswap:
 293                         ;
 294                 }
 295         }
 296 }
 297 */
 298
 299 void transpolyrender()
 300 {
 301         int i, j, tpolytype, texnum;
 302         transpoly_t *p;
 303         if (currenttranspoly < 1)
 304                 return;
 305         transpolyrenderminmax();
 306         if (transpolyindices < 1)
 307                 return;
 308         // testing
 309 //      Con_DPrintf("transpolyrender: %i polys %i infront %i vertices\n", currenttranspoly, transpolyindices, currenttransvert);
 310 //      if (transpolyindices >= 2)
 311 //              transpolysort();
 312         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 313         glEnable(GL_BLEND);
 314         glShadeModel(GL_SMOOTH);
 315         glDepthMask(0); // disable zbuffer updates
 316         if (isG200) // Matrox G200 cards can't handle per pixel alpha
 317                 glEnable(GL_ALPHA_TEST);
 318         else
 319                 glDisable(GL_ALPHA_TEST);
 320         // later note: wasn't working on my TNT drivers...  strangely...  used a cheaper hack in transpolyvert
 321         //// offset by 16 depth units so decal sprites appear infront of walls
 322         //glPolygonOffset(1, -16);
 323         //glEnable(GL_POLYGON_OFFSET_FILL);
 324         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 325         tpolytype = TPOLYTYPE_ALPHA;
 326         texnum = -1;
 327         /*
 328         if (gl_vertexarrays.value)
 329         {
 330                 // set up the vertex array
 331                 qglInterleavedArrays(GL_T2F_C4UB_V3F, 0, transvert);
 332                 for (i = 0;i < transpolyindices;i++)
 333                 {
 334                         p = &transpoly[transpolyindex[i]];
 335                         if (p->texnum != texnum || p->transpolytype != tpolytype)
 336                         {
 337                                 if (p->texnum != texnum)
 338                                 {
 339                                         texnum = p->texnum;
 340                                         glBindTexture(GL_TEXTURE_2D, texnum);
 341                                 }
 342                                 if (p->transpolytype != tpolytype)
 343                                 {
 344                                         tpolytype = p->transpolytype;
 345                                         if (tpolytype == TPOLYTYPE_ADD) // additive
 346                                                 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 347                                         else // alpha
 348                                                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 349                                 }
 350                         }
 351                         qglDrawArrays(GL_TRIANGLE_FAN, p->firstvert, p->verts);
 352                         if (p->glowtexnum)
 353                         {
 354                                 texnum = p->glowtexnum; // highly unlikely to match next poly, but...
 355                                 glBindTexture(GL_TEXTURE_2D, texnum);
 356                                 tpolytype = TPOLYTYPE_ADD; // might match next poly
 357                                 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 358                                 qglDrawArrays(GL_TRIANGLE_FAN, p->firstvert, p->verts);
 359                         }
 360                 }
 361                 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 362                 glDisableClientState(GL_COLOR_ARRAY);
 363                 glDisableClientState(GL_VERTEX_ARRAY);
 364         }
 365         else
 366         */
 367         {
 368                 int points = -1;
 369                 transvert_t *vert;
 370                 for (i = 0;i < transpolyindices;i++)
 371                 {
 372                         p = &transpoly[transpolyindex[i]];
 373                         if (p->texnum != texnum || p->verts != points || p->transpolytype != tpolytype)
 374                         {
 375                                 glEnd();
 376                                 if (isG200)
 377                                 {
 378                                         if (p->fogtexnum) // alpha
 379                                                 glEnable(GL_ALPHA_TEST);
 380                                         else
 381                                                 glDisable(GL_ALPHA_TEST);
 382                                 }
 383                                 if (p->texnum != texnum)
 384                                 {
 385                                         texnum = p->texnum;
 386                                         glBindTexture(GL_TEXTURE_2D, texnum);
 387                                 }
 388                                 if (p->transpolytype != tpolytype)
 389                                 {
 390                                         tpolytype = p->transpolytype;
 391                                         if (tpolytype == TPOLYTYPE_ADD) // additive
 392                                                 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 393                                         else // alpha
 394                                                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 395                                 }
 396                                 points = p->verts;
 397                                 switch (points)
 398                                 {
 399                                 case 3:
 400                                         glBegin(GL_TRIANGLES);
 401                                         break;
 402                                 case 4:
 403                                         glBegin(GL_QUADS);
 404                                         break;
 405                                 default:
 406                                         glBegin(GL_TRIANGLE_FAN);
 407                                         points = -1; // to force a reinit on the next poly
 408                                         break;
 409                                 }
 410                         }
 411                         for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++)
 412                         {
 413                                 // would be 2fv, but windoze Matrox G200 and probably G400 drivers don't support that (dumb...)
 414                                 glTexCoord2f(vert->s, vert->t);
 415                                 // again, vector version isn't supported I think
 416                                 glColor4ub(vert->r, vert->g, vert->b, vert->a);
 417                                 glVertex3fv(vert->v);
 418                         }
 419                         if (p->glowtexnum)
 420                         {
 421                                 glEnd();
 422                                 texnum = p->glowtexnum; // highly unlikely to match next poly, but...
 423                                 glBindTexture(GL_TEXTURE_2D, texnum);
 424                                 if (tpolytype != TPOLYTYPE_ADD)
 425                                 {
 426                                         tpolytype = TPOLYTYPE_ADD; // might match next poly
 427                                         glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 428                                 }
 429                                 points = -1;
 430                                 glBegin(GL_TRIANGLE_FAN);
 431                                 for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++)
 432                                 {
 433                                         glColor4ub(255,255,255,vert->a);
 434                                         // would be 2fv, but windoze Matrox G200 and probably G400 drivers don't support that (dumb...)
 435                                         glTexCoord2f(vert->s, vert->t);
 436                                         glVertex3fv(vert->v);
 437                                 }
 438                                 glEnd();
 439                         }
 440                         if (fogenabled && p->transpolytype == TPOLYTYPE_ALPHA)
 441                         {
 442                                 vec3_t diff;
 443                                 glEnd();
 444                                 points = -1; // to force a reinit on the next poly
 445                                 if (tpolytype != TPOLYTYPE_ALPHA)
 446                                 {
 447                                         tpolytype = TPOLYTYPE_ALPHA; // probably matchs next poly
 448                                         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 449                                 }
 450                                 if (p->fogtexnum)
 451                                 {
 452                                         if (texnum != p->fogtexnum) // highly unlikely to match next poly, but...
 453                                         {
 454                                                 texnum = p->fogtexnum;
 455                                                 glBindTexture(GL_TEXTURE_2D, texnum);
 456                                         }
 457                                         glBegin(GL_TRIANGLE_FAN);
 458                                         for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++)
 459                                         {
 460                                                 VectorSubtract(vert->v, r_refdef.vieworg,diff);
 461                                                 glTexCoord2f(vert->s, vert->t);
 462                                                 glColor4f(fogcolor[0], fogcolor[1], fogcolor[2], vert->a*(1.0f/255.0f)*exp(fogdensity/DotProduct(diff,diff)));
 463                                                 glVertex3fv(vert->v);
 464                                         }
 465                                         glEnd ();
 466                                 }
 467                                 else
 468                                 {
 469                                         glDisable(GL_TEXTURE_2D);
 470                                         glBegin(GL_TRIANGLE_FAN);
 471                                         for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++)
 472                                         {
 473                                                 VectorSubtract(vert->v, r_refdef.vieworg,diff);
 474                                                 glColor4f(fogcolor[0], fogcolor[1], fogcolor[2], vert->a*(1.0f/255.0f)*exp(fogdensity/DotProduct(diff,diff)));
 475                                                 glVertex3fv(vert->v);
 476                                         }
 477                                         glEnd ();
 478                                         glEnable(GL_TEXTURE_2D);
 479                                 }
 480                         }
 481                 }
 482                 glEnd();
 483         }
 484
 485         //glDisable(GL_POLYGON_OFFSET_FILL);
 486         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 487         glDepthMask(1); // enable zbuffer updates
 488         glDisable(GL_ALPHA_TEST);
 489 }
 490
 491 void wallpolyclear()
 492 {
 493         currentwallpoly = currentwallvert = 0;
 494 }
 495
 496 extern qboolean lighthalf;
 497 void wallpolyrender()
 498 {
 499         int i, j, texnum, lighttexnum;
 500         wallpoly_t *p;
 501         wallvert_t *vert;
 502         if (currentwallpoly < 1)
 503                 return;
 504         c_brush_polys += currentwallpoly;
 505         // testing
 506         //Con_DPrintf("wallpolyrender: %i polys %i vertices\n", currentwallpoly, currentwallvert);
 507         if (!gl_mtexable)
 508                 gl_multitexture.value = 0;
 509         glDisable(GL_BLEND);
 510         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 511         glShadeModel(GL_FLAT);
 512         // make sure zbuffer is enabled
 513         glEnable(GL_DEPTH_TEST);
 514         glDisable(GL_ALPHA_TEST);
 515         glDepthMask(1);
 516         glColor3f(1,1,1);
 517         if (r_fullbright.value) // LordHavoc: easy to do fullbright...
 518         {
 519                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 520                 texnum = -1;
 521                 for (i = 0,p = &wallpoly[0];i < currentwallpoly;i++, p++)
 522                 {
 523                         if (p->texnum != texnum)
 524                         {
 525                                 texnum = p->texnum;
 526                                 glBindTexture(GL_TEXTURE_2D, texnum);
 527                         }
 528                         vert = &wallvert[p->firstvert];
 529                         glBegin(GL_POLYGON);
 530                         for (j=0 ; j<p->verts ; j++, vert++)
 531                         {
 532                                 glTexCoord2f (vert->s, vert->t);
 533                                 glVertex3fv (vert->vert);
 534                         }
 535                         glEnd ();
 536                 }
 537         }
 538         else if (gl_multitexture.value)
 539         {
 540                 qglSelectTexture(gl_mtex_enum+0);
 541                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 542                 glEnable(GL_TEXTURE_2D);
 543                 qglSelectTexture(gl_mtex_enum+1);
 544                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 545                 glEnable(GL_TEXTURE_2D);
 546                 texnum = -1;
 547                 lighttexnum = -1;
 548                 for (i = 0,p = &wallpoly[0];i < currentwallpoly;i++, p++)
 549                 {
 550 //                      if (p->texnum != texnum || p->lighttexnum != lighttexnum)
 551 //                      {
 552                                 texnum = p->texnum;
 553                                 lighttexnum = p->lighttexnum;
 554                                 qglSelectTexture(gl_mtex_enum+0);
 555                                 glBindTexture(GL_TEXTURE_2D, texnum);
 556                                 qglSelectTexture(gl_mtex_enum+1);
 557                                 glBindTexture(GL_TEXTURE_2D, lighttexnum);
 558 //                      }
 559                         vert = &wallvert[p->firstvert];
 560                         glBegin(GL_POLYGON);
 561                         for (j=0 ; j<p->verts ; j++, vert++)
 562                         {
 563                                 qglMTexCoord2f(gl_mtex_enum, vert->s, vert->t); // texture
 564                                 qglMTexCoord2f((gl_mtex_enum+1), vert->u, vert->v); // lightmap
 565                                 glVertex3fv (vert->vert);
 566                         }
 567                         glEnd ();
 568                 }
 569
 570                 qglSelectTexture(gl_mtex_enum+1);
 571                 glDisable(GL_TEXTURE_2D);
 572                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 573                 qglSelectTexture(gl_mtex_enum+0);
 574                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 575         }
 576         else
 577         {
 578                 // first do the textures
 579                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 580                 texnum = -1;
 581                 for (i = 0,p = &wallpoly[0];i < currentwallpoly;i++, p++)
 582                 {
 583                         if (p->texnum != texnum)
 584                         {
 585                                 texnum = p->texnum;
 586                                 glBindTexture(GL_TEXTURE_2D, texnum);
 587                         }
 588                         vert = &wallvert[p->firstvert];
 589                         glBegin(GL_POLYGON);
 590                         for (j=0 ; j<p->verts ; j++, vert++)
 591                         {
 592                                 glTexCoord2f (vert->s, vert->t);
 593                                 glVertex3fv (vert->vert);
 594                         }
 595                         glEnd ();
 596                 }
 597                 // then modulate using the lightmaps
 598                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 599                 glBlendFunc(GL_ZERO, GL_SRC_COLOR);
 600                 glEnable(GL_BLEND);
 601                 texnum = -1;
 602                 for (i = 0,p = &wallpoly[0];i < currentwallpoly;i++, p++)
 603                 {
 604                         if (p->lighttexnum != texnum)
 605                         {
 606                                 texnum = p->lighttexnum;
 607                                 glBindTexture(GL_TEXTURE_2D, texnum);
 608                         }
 609                         vert = &wallvert[p->firstvert];
 610                         glBegin(GL_POLYGON);
 611                         for (j=0 ; j<p->verts ; j++, vert++)
 612                         {
 613                                 glTexCoord2f (vert->u, vert->v);
 614                                 glVertex3fv (vert->vert);
 615                         }
 616                         glEnd ();
 617                 }
 618         }
 619         // render glow textures
 620         glDepthMask(0);
 621         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 622         glBlendFunc(GL_ONE, GL_ONE);
 623         glEnable(GL_BLEND);
 624         if (lighthalf)
 625                 glColor3f(0.5,0.5,0.5);
 626         else
 627                 glColor3f(1,1,1);
 628         texnum = -1;
 629         for (i = 0,p = &wallpoly[0];i < currentwallpoly;i++, p++)
 630         {
 631                 if (!p->glowtexnum)
 632                         continue;
 633                 if (p->glowtexnum != texnum)
 634                 {
 635                         texnum = p->glowtexnum;
 636                         glBindTexture(GL_TEXTURE_2D, texnum);
 637                 }
 638                 vert = &wallvert[p->firstvert];
 639                 glBegin(GL_POLYGON);
 640                 for (j=0 ; j<p->verts ; j++, vert++)
 641                 {
 642                         glTexCoord2f (vert->s, vert->t);
 643                         glVertex3fv (vert->vert);
 644                 }
 645                 glEnd ();
 646         }
 647         glColor3f(1,1,1);
 648         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 649         glShadeModel(GL_SMOOTH);
 650         if (fogenabled)
 651         {
 652                 vec3_t diff;
 653                 glDisable(GL_TEXTURE_2D);
 654                 for (i = 0,p = &wallpoly[0];i < currentwallpoly;i++, p++)
 655                 {
 656                         vert = &wallvert[p->firstvert];
 657                         glBegin(GL_POLYGON);
 658                         for (j=0 ; j<p->verts ; j++, vert++)
 659                         {
 660                                 VectorSubtract(vert->vert, r_refdef.vieworg,diff);
 661                                 glColor4f(fogcolor[0], fogcolor[1], fogcolor[2], exp(fogdensity/DotProduct(diff,diff)));
 662                                 glVertex3fv (vert->vert);
 663                         }
 664                         glEnd ();
 665                 }
 666                 glEnable(GL_TEXTURE_2D);
 667         }
 668         glDisable(GL_BLEND);
 669         glDepthMask(1);
 670 }
 671
 672 void skypolyclear()
 673 {
 674         currentskypoly = currentskyvert = 0;
 675 }
 676
 677 extern qboolean isATI;
 678
 679 extern char skyname[];
 680 extern int solidskytexture, alphaskytexture;
 681 void skypolyrender()
 682 {
 683         int i, j;
 684         skypoly_t *p;
 685         skyvert_t *vert;
 686         float length, speedscale;
 687         vec3_t dir;
 688         if (currentskypoly < 1)
 689                 return;
 690         // testing
 691 //      Con_DPrintf("skypolyrender: %i polys %i vertices\n", currentskypoly, currentskyvert);
 692         glDisable(GL_ALPHA_TEST);
 693         glDisable(GL_BLEND);
 694         // make sure zbuffer is enabled
 695         glEnable(GL_DEPTH_TEST);
 696         glDepthMask(1);
 697         if (!fogenabled && !skyname[0]) // normal quake sky
 698         {
 699                 glColor3f(0.5f, 0.5f, 0.5f);
 700                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 701                 glEnable(GL_TEXTURE_2D);
 702                 glDisable(GL_BLEND);
 703                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 704                 glBindTexture(GL_TEXTURE_2D, solidskytexture); // upper clouds
 705                 speedscale = realtime*8;
 706                 speedscale -= (int)speedscale & ~127 ;
 707                 for (i = 0,p = &skypoly[0];i < currentskypoly;i++, p++)
 708                 {
 709                         vert = &skyvert[p->firstvert];
 710                         glBegin(GL_POLYGON);
 711                         for (j=0 ; j<p->verts ; j++, vert++)
 712                         {
 713                                 VectorSubtract (vert->v, r_origin, dir);
 714                                 dir[2] *= 3;    // flatten the sphere
 715
 716                                 length = dir[0]*dir[0] + dir[1]*dir[1] + dir[2]*dir[2];
 717                                 length = sqrt (length);
 718                                 length = 6*63/length;
 719
 720                                 glTexCoord2f ((speedscale + dir[0] * length) * (1.0/128), (speedscale + dir[1] * length) * (1.0/128));
 721                                 glVertex3fv (vert->v);
 722                         }
 723                         glEnd ();
 724                 }
 725                 glEnable(GL_BLEND);
 726                 glDepthMask(0);
 727                 glBindTexture(GL_TEXTURE_2D, alphaskytexture); // lower clouds
 728                 speedscale = realtime*16;
 729                 speedscale -= (int)speedscale & ~127 ;
 730                 for (i = 0,p = &skypoly[0];i < currentskypoly;i++, p++)
 731                 {
 732                         vert = &skyvert[p->firstvert];
 733                         glBegin(GL_POLYGON);
 734                         for (j=0 ; j<p->verts ; j++, vert++)
 735                         {
 736                                 VectorSubtract (vert->v, r_origin, dir);
 737                                 dir[2] *= 3;    // flatten the sphere
 738
 739                                 length = dir[0]*dir[0] + dir[1]*dir[1] + dir[2]*dir[2];
 740                                 length = sqrt (length);
 741                                 length = 6*63/length;
 742
 743                                 glTexCoord2f ((speedscale + dir[0] * length) * (1.0/128), (speedscale + dir[1] * length) * (1.0/128));
 744                                 glVertex3fv (vert->v);
 745                         }
 746                         glEnd ();
 747                 }
 748                 glDisable(GL_BLEND);
 749                 glColor3f(1,1,1);
 750                 glDepthMask(1);
 751         }
 752         else
 753         {
 754                 glDisable(GL_TEXTURE_2D);
 755                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 756                 glColor3fv(fogcolor); // note: gets rendered over by skybox if fog is not enabled
 757                 for (i = 0,p = &skypoly[0];i < currentskypoly;i++, p++)
 758                 {
 759                         vert = &skyvert[p->firstvert];
 760                         glBegin(GL_POLYGON);
 761                         for (j=0 ; j<p->verts ; j++, vert++)
 762                                 glVertex3fv (vert->v);
 763                         glEnd ();
 764                 }
 765                 glColor3f(1,1,1);
 766                 glEnable(GL_TEXTURE_2D);
 767         }
 768 }