opengl/ogl_rl.c

   1
   2 //**************************************************************************
   3 //**
   4 //** OGL_RL.C
   5 //**
   6 //**************************************************************************
   7
   8 // HEADER FILES ------------------------------------------------------------
   9
  10 #ifdef __WIN32
  11 #define WIN32_LEAN_AND_MEAN
  12 #include <windows.h>
  13 #endif
  14
  15 #include <math.h>
  16 #include <GL/gl.h>
  17 #include <stdlib.h>
  18 #include "h2def.h"
  19 #include "ogl_def.h"
  20 #include "ogl_rl.h"
  21
  22 // MACROS ------------------------------------------------------------------
  23
  24 // TYPES -------------------------------------------------------------------
  25
  26 // EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
  27
  28 // PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
  29
  30 // PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
  31
  32 // EXTERNAL DATA DECLARATIONS ----------------------------------------------
  33
  34 extern int                      skyhemispheres;
  35 extern int                      dlMaxRad; // Dynamic lights maximum radius.
  36
  37 // PUBLIC DATA DEFINITIONS -------------------------------------------------
  38
  39 int numrlists=0;                        // Number of rendering lists.
  40 float maxLightDist = 1024;
  41
  42 // PRIVATE DATA DEFINITIONS ------------------------------------------------
  43
  44 static rendlist_t *rlists=0;    // The list of rendering lists.
  45 static rendlist_t masked_rlist; // Rendering list for masked textures.
  46 static rendlist_t invsky_rlist; // List for invisible sky triangles.
  47 static rendlist_t invskywall_rlist; // List for invisible sky walls (w/skyfix).
  48 static rendlist_t dlwall_rlist, dlflat_rlist; // Dynamic lighting for walls/flats.
  49
  50 // CODE --------------------------------------------------------------------
  51
  52 void RL_Init()
  53 {
  54         numrlists = 0;
  55         rlists = 0;
  56         memset(&masked_rlist, 0, sizeof(masked_rlist));
  57         memset(&invsky_rlist, 0, sizeof(invsky_rlist));
  58         memset(&invskywall_rlist, 0, sizeof(invskywall_rlist));
  59         memset(&dlwall_rlist, 0, sizeof(dlwall_rlist));
  60         memset(&dlflat_rlist, 0, sizeof(dlflat_rlist));
  61 }
  62
  63 void RL_DestroyList(rendlist_t *rl)
  64 {
  65         // All the list data will be destroyed.
  66         free(rl->quads);
  67         memset(rl, 0, sizeof(rendlist_t));
  68 }
  69
  70 void RL_DeleteLists()
  71 {
  72         int             i;
  73
  74         // Delete all lists.
  75         for(i=0; i<numrlists; i++) RL_DestroyList(rlists+i);
  76         RL_DestroyList(&masked_rlist);
  77         RL_DestroyList(&invsky_rlist);
  78         RL_DestroyList(&invskywall_rlist);
  79         RL_DestroyList(&dlwall_rlist);
  80         RL_DestroyList(&dlflat_rlist);
  81
  82         free(rlists);
  83         rlists = 0;
  84         numrlists = 0;
  85 }
  86
  87 // Reset the indices.
  88 void RL_ClearLists()
  89 {
  90         int             i;
  91         for(i=0; i<numrlists; i++) rlists[i].numquads = 0;
  92         masked_rlist.numquads = 0;
  93         invsky_rlist.numquads = 0;
  94         invskywall_rlist.numquads = 0;
  95         dlwall_rlist.numquads = 0;
  96         dlflat_rlist.numquads = 0;
  97         skyhemispheres = 0;
  98 }
  99
 100 static void RL_DynLightQuad(rendquad_t *quad, lumobj_t *lum)
 101 {
 102         //rendquad_t    dlq;
 103
 104         // Prepare the texture so we know its dimensions.
 105         OGL_PrepareLightTexture();
 106 //      glBindTexture(GL_TEXTURE_2D, 0);
 107         //glPointSize(5);
 108         // Is the quad a wall or a flat?
 109         if(quad->flags & RQF_FLAT)
 110         {
 111                 // Process all marked light sources.
 112 /*              for(i=0; i<numLuminous; i++)
 113                 {
 114                         lumobj_t *lum = luminousList + i;*/
 115
 116                         // This is a light.
 117                         quad->flags |= RQF_LIGHT;
 118                         quad->texw = texw*2;
 119                         quad->texh = texh*2;
 120
 121                         // Determine the light level.
 122
 123                         // The texture offset is what actually determines where the
 124                         // dynamic light map will be rendered. For light quads the
 125                         // texture offset is global.
 126                         quad->texoffx = FIX2FLT(lum->thing->x) + dlMaxRad;
 127                         quad->texoffy = FIX2FLT(lum->thing->y) + dlMaxRad;
 128                         // Add a slight offset to the height to avoid Z buffer fighting.
 129                         //quad->top += quad->flags & RQF_FLOOR_FACING? .5 : -.5;
 130                         // Add the flat to the dlflat rendering list.
 131                         //RL_AddQuad(&dlq, 0);
 132
 133                         /*glBegin(GL_POINTS);
 134                         glColor3f(1, 1, 1);
 135                         glVertex3f(FIX2FLT(lum->thing->x), FIX2FLT(lum->thing->y), z32);
 136                         glEnd();*/
 137 //              }
 138         }
 139 }
 140
 141 static rendlist_t *RL_FindList(GLuint tex)
 142 {
 143         int     i;
 144         rendlist_t *dest;
 145
 146         for(i=0; i<numrlists; i++)
 147                 if(rlists[i].tex == tex)
 148                         return rlists+i;
 149
 150         // Then create a new list.
 151         rlists = (rendlist_t*)realloc(rlists, sizeof(rendlist_t) * ++numrlists);
 152         dest = rlists + numrlists-1;
 153         memset(dest, 0, sizeof(rendlist_t));
 154         dest->tex = tex;
 155         return dest;
 156 }
 157
 158 // Here we will add the quad to the correct rendering list, creating
 159 // a new list if necessary.
 160 void RL_AddQuad(rendquad_t *quad, GLuint quadtex)
 161 {
 162         rendlist_t      *dest = 0;      // The destination list.
 163         rendquad_t      *dq;            // Quad in the dest list.
 164
 165         // Masked quads go to the masked list.
 166         if(quad->flags & RQF_MASKED)
 167                 dest = &masked_rlist;
 168         else if(quad->flags & RQF_SKY_MASK_WALL)
 169                 dest = &invskywall_rlist;
 170         else if(quad->flags & RQF_LIGHT) // Dynamic lights?
 171                 dest = &dlwall_rlist;
 172         else
 173         {
 174                 // Find a suitable list. This can get a bit redundant for large
 175                 // numbers of primitives of the same texture (oh yeah, this is
 176                 // a real cycle-eater).
 177                 dest = RL_FindList(quadtex);
 178         }
 179         // Now we have a destination list. This is the only place where
 180         // quads are added.
 181         if(++dest->numquads > dest->listsize)           // See if we have to allocate more memory.
 182         {
 183                 dest->listsize = dest->numquads+10;
 184                 dest->quads = (rendquad_t*)realloc(dest->quads,
 185                         sizeof(rendquad_t) * dest->listsize);
 186         }
 187         dq = dest->quads + dest->numquads-1;
 188         memcpy(dq, quad, sizeof(rendquad_t));
 189
 190         // Let a masked quad know its texture.
 191         if(quad->flags & RQF_MASKED)
 192         {
 193                 dq->masktex = quadtex;
 194                 if(!quadtex) I_Error("RL_AddQuad: There can't be a masked quad with no texture.\n");
 195         }
 196 }
 197
 198 subsector_t *currentssec;
 199
 200 // Adds a series of flat quads (triangles) as a fan.
 201 void RL_AddFlatQuads(rendquad_t *base, GLuint quadtex, int numvrts,
 202                                          fvertex_t *origvrts, int dir)
 203 {
 204         fvertex_t       *vtx;
 205         rendlist_t      *dest;
 206         rendquad_t      *qi;
 207         int                     i, firstquad;
 208         float           *distances, middist;
 209         fvertex_t       *vrts;
 210
 211         if(!numvrts) return;    // No data, can't do anything.
 212
 213         if(base->flags & RQF_SKY_MASK)
 214                 dest = &invsky_rlist;
 215         else if(base->flags & RQF_LIGHT)
 216                 dest = &dlflat_rlist;
 217         else
 218                 // First find the right list.
 219                 dest = RL_FindList(quadtex);
 220
 221         // Check that there's enough room.
 222         firstquad = dest->numquads;
 223         dest->numquads += numvrts-2;
 224         if(dest->numquads > dest->listsize)
 225         {
 226                 // Allocate more memory.
 227                 dest->listsize = dest->numquads + 20;
 228                 dest->quads = (rendquad_t*)realloc(dest->quads,
 229                         sizeof(rendquad_t) * dest->listsize);
 230         }
 231
 232         // Calculate the distance to each vertex.
 233         distances = _alloca(sizeof(float)*numvrts);
 234         for(i=0; i<numvrts; i++) distances[i] = PointDist2D(&origvrts[i].x);
 235
 236         // Make a distance modification.
 237         vrts = _alloca(sizeof(fvertex_t)*numvrts);
 238         memcpy(vrts, origvrts, sizeof(fvertex_t)*numvrts);
 239         middist = PointDist2D(&currentssec->midpoint.x);
 240         if(!(base->flags & RQF_LIGHT) && middist > 256)
 241         {
 242                 for(i=0; i<numvrts; i++)
 243                 {
 244                         float dx = vrts[i].x - currentssec->midpoint.x,
 245                                 dy = vrts[i].y - currentssec->midpoint.y,
 246                                 dlen = sqrt(dx*dx + dy*dy);
 247                         if(!dlen) continue;
 248                         vrts[i].x += dx/dlen * (middist-256)/128;
 249                         vrts[i].y += dy/dlen * (middist-256)/128;
 250                 }
 251         }
 252
 253         // Add them as a fan.
 254         if(dir == 0)    // Normal direction.
 255         {
 256                 // All triangles share the first vertex.
 257                 base->v1[VX] = vrts->x;
 258                 base->v1[VY] = vrts->y;
 259                 base->dist[0] = distances[0];
 260
 261                 for(i=2, qi=dest->quads+firstquad; i<numvrts; i++, qi++)
 262                 {
 263                         memcpy(qi, base, sizeof(rendquad_t));
 264                         // The second vertex is the previous from this one.
 265                         vtx = vrts+i-1;
 266                         qi->v2[VX] = vtx->x;
 267                         qi->v2[VY] = vtx->y;
 268                         qi->dist[1] = distances[i-1];
 269                         // The third vertex is naturally the current one.
 270                         vtx = vrts+i;
 271                         qi->u.v3[VX] = vtx->x;
 272                         qi->u.v3[VY] = vtx->y;
 273                         qi->dist[2] = distances[i];
 274
 275                         if(base->flags & RQF_LIGHT) RL_DynLightQuad(qi, (lumobj_t*)quadtex);
 276                 }
 277         }
 278         else    // Reverse direction?
 279         {
 280                 // All triangles share the last vertex.
 281                 vtx = vrts + numvrts-1;
 282                 base->v1[VX] = vtx->x;
 283                 base->v1[VY] = vtx->y;
 284                 base->dist[0] = distances[numvrts-1];
 285
 286                 for(i=numvrts-3, qi=dest->quads+firstquad; i>=0; i--, qi++)
 287                 {
 288                         memcpy(qi, base, sizeof(rendquad_t));
 289                         // The second vertex is the next from this one.
 290                         vtx = vrts+i+1;
 291                         qi->v2[VX] = vtx->x;
 292                         qi->v2[VY] = vtx->y;
 293                         qi->dist[1] = distances[i+1];
 294                         // The third vertex is naturally the current one.
 295                         vtx = vrts+i;
 296                         qi->u.v3[VX] = vtx->x;
 297                         qi->u.v3[VY] = vtx->y;
 298                         qi->dist[2] = distances[i];
 299
 300 //                      if(useDynLights) RL_DynLightQuad(qi);
 301                         if(base->flags & RQF_LIGHT) RL_DynLightQuad(qi, (lumobj_t*)quadtex);
 302                 }
 303         }
 304 }
 305
 306 void SetVertexColor(float light, float dist, float alpha)
 307 {
 308         float real = light - (dist-32)/maxLightDist * (1-light);
 309         float minimum = light*light + (light-.63)/2;
 310         if(real < minimum) real = minimum; // Clamp it.
 311         // Add extra light.
 312         real += extralight/16.0;
 313         // Check for torch.
 314         if(viewplayer->fixedcolormap)
 315         {
 316                 // Colormap 1 is the brightest. I'm guessing 16 would be the darkest.
 317                 int ll = 16-viewplayer->fixedcolormap;
 318                 float d = (1024-dist)/512.0;
 319                 float newmin = d*ll/15.0;
 320                 if(real < newmin) real = newmin;
 321         }
 322         glColor4f(real, real, real, alpha);     // Too real? Hope real gets clamped.
 323 }
 324
 325 // This is only for solid, non-masked primitives.
 326 void RL_RenderList(rendlist_t *rl)
 327 {
 328         int                     i;
 329         float           tcleft, tcright, tctop, tcbottom;
 330         rendquad_t      *cq;
 331
 332         if(!rl->numquads) return;       // The list is empty.
 333
 334         // Bind the right texture.
 335         glBindTexture(GL_TEXTURE_2D, curtex=rl->tex);
 336
 337         // Check what kind of primitives there are on the list.
 338         // There can only be one kind on each list.
 339         if(rl->quads->flags & RQF_FLAT) // Check the first primitive.
 340         {
 341                 // There's only triangles here, I see.
 342                 glBegin(GL_TRIANGLES);
 343                 for(i=0; i<rl->numquads; i++)
 344                 {
 345                         cq = rl->quads+i;
 346                         if(cq->flags & RQF_MISSING_WALL)
 347                         {
 348                                 // This triangle is REALLY a quad that originally had no
 349                                 // texture. We have to render it as two triangles.
 350                                 tcright = (tcleft=0) + cq->u.q.len/cq->texw;
 351                                 tcbottom = (tctop=0) + (cq->top - cq->u.q.bottom)/cq->texh;
 352
 353                                 SetVertexColor(cq->light, cq->dist[0], 1);
 354                                 glTexCoord2f(tcleft, tctop);
 355                                 glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 356
 357                                 SetVertexColor(cq->light, cq->dist[1], 1);
 358                                 glTexCoord2f(tcright, tctop);
 359                                 glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 360
 361                                 glTexCoord2f(tcright, tcbottom);
 362                                 glVertex3f(cq->v2[VX], cq->u.q.bottom, cq->v2[VY]);
 363
 364                                 // The other triangle.
 365                                 glTexCoord2f(tcright, tcbottom);
 366                                 glVertex3f(cq->v2[VX], cq->u.q.bottom, cq->v2[VY]);
 367
 368                                 SetVertexColor(cq->light, cq->dist[0], 1);
 369                                 glTexCoord2f(tcleft, tcbottom);
 370                                 glVertex3f(cq->v1[VX], cq->u.q.bottom, cq->v1[VY]);
 371
 372                                 glTexCoord2f(tcleft, tctop);
 373                                 glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 374                                 continue;
 375                         }
 376
 377                         // The vertices.
 378                         SetVertexColor(cq->light, cq->dist[0], 1);
 379                         glTexCoord2f((cq->v1[VX]+cq->texoffx)/cq->texw,
 380                                 (cq->v1[VY]+cq->texoffy)/cq->texh);
 381                         glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 382
 383                         SetVertexColor(cq->light, cq->dist[1], 1);
 384                         glTexCoord2f((cq->v2[VX]+cq->texoffx)/cq->texw,
 385                                 (cq->v2[VY]+cq->texoffy)/cq->texh);
 386                         glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 387
 388                         SetVertexColor(cq->light, cq->dist[2], 1);
 389                         glTexCoord2f((cq->u.v3[VX]+cq->texoffx)/cq->texw,
 390                                 (cq->u.v3[VY]+cq->texoffy)/cq->texh);
 391                         glVertex3f(cq->u.v3[VX], cq->top, cq->u.v3[VY]);
 392                 }
 393                 glEnd();
 394         }
 395         else
 396         {
 397                 // Render quads.
 398                 glBegin(GL_QUADS);
 399                 for(i=0; i<rl->numquads; i++)
 400                 {
 401                         cq = rl->quads+i;
 402
 403                         // Calculate relative texture coordinates.
 404                         tcright = (tcleft=cq->texoffx/(float)cq->texw) + cq->u.q.len/cq->texw;
 405                         tcbottom = (tctop=cq->texoffy/cq->texh) + (cq->top - cq->u.q.bottom)/cq->texh;
 406
 407                         // The vertices.
 408                         SetVertexColor(cq->light, cq->dist[0], 1);
 409                         glTexCoord2f(tcleft, tcbottom);
 410                         glVertex3f(cq->v1[VX], cq->u.q.bottom, cq->v1[VY]);
 411
 412                         glTexCoord2f(tcleft, tctop);
 413                         glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 414
 415                         SetVertexColor(cq->light, cq->dist[1], 1);
 416                         glTexCoord2f(tcright, tctop);
 417                         glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 418
 419                         glTexCoord2f(tcright, tcbottom);
 420                         glVertex3f(cq->v2[VX], cq->u.q.bottom, cq->v2[VY]);
 421                 }
 422                 glEnd();
 423         }
 424 }
 425
 426 // Masked lists only include quads.
 427 void RL_RenderMaskedList(rendlist_t *mrl)
 428 {
 429         int                     i;
 430         float           tcleft, tcright, tctop, tcbottom;
 431         rendquad_t      *cq;
 432
 433         if(!mrl->numquads) return;      // No quads to render, I'm afraid.
 434
 435         // Curtex is used to keep track of the current texture.
 436         // Zero also denotes that no glBegin() has yet been called.
 437         curtex = 0;
 438
 439         // Render quads.
 440         for(i=mrl->numquads-1; i>=0; i--)       // Render back to front.
 441         {
 442                 cq = mrl->quads+i;
 443
 444                 // Calculate relative texture coordinates.
 445                 tcright = (tcleft=cq->texoffx/cq->texw) + cq->u.q.len/cq->texw;
 446                 tcbottom = (tctop=cq->texoffy/cq->texh) + (cq->top - cq->u.q.bottom)/cq->texh;
 447
 448                 // Is there a need to change the texture?
 449                 if(curtex != cq->masktex)
 450                 {
 451                         if(curtex) glEnd();     // Finish with the old texture.
 452                         glBindTexture(GL_TEXTURE_2D, curtex=cq->masktex);
 453                         glBegin(GL_QUADS);      // I love OpenGL.
 454                 }
 455
 456                 // The vertices.
 457                 SetVertexColor(cq->light, cq->dist[0], 1);
 458                 glTexCoord2f(tcleft, tcbottom);
 459                 glVertex3f(cq->v1[VX], cq->u.q.bottom, cq->v1[VY]);
 460
 461                 glTexCoord2f(tcleft, tctop);
 462                 glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 463
 464                 SetVertexColor(cq->light, cq->dist[1], 1);
 465                 glTexCoord2f(tcright, tctop);
 466                 glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 467
 468                 glTexCoord2f(tcright, tcbottom);
 469                 glVertex3f(cq->v2[VX], cq->u.q.bottom, cq->v2[VY]);
 470         }
 471         if(curtex) glEnd();     // If something was drawn, finish with it.
 472 }
 473
 474 void RL_RenderSkyMaskLists()
 475 {
 476 #if 0
 477         int                     i;
 478         rendlist_t      *smrl = &invsky_rlist, *skyw = &invskywall_rlist;
 479         rendquad_t      *cq;
 480
 481         if(!smrl->numquads && !skyw->numquads) return; // Nothing to do here.
 482
 483         // Nothing gets written to the color buffer.
 484
 485     // NOTE: glEnd() below causes segfault in Mesa 3.0 if binding texture 0.
 486     // I don't think texture 0 is defined when this is called.
 487         //glBindTexture(GL_TEXTURE_2D, 0);
 488     glDisable( GL_TEXTURE_2D );
 489
 490         glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 491         glColor4f(1, 1, 1, 1);  // Just to be sure.
 492
 493
 494         if(smrl->numquads)
 495         {
 496                 glBegin(GL_TRIANGLES);
 497                 for(i=0; i<smrl->numquads; i++)
 498                 {
 499                         cq = smrl->quads+i;
 500                         // ONLY the vertices, please.
 501                         glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 502                         glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 503                         glVertex3f(cq->u.v3[VX], cq->top, cq->u.v3[VY]);
 504                 }
 505                 glEnd();
 506         }
 507
 508         // Then the walls.
 509         if(skyw->numquads)
 510         {
 511                 glBegin(GL_QUADS);
 512                 for(i=0; i<skyw->numquads; i++)
 513                 {
 514                         cq = skyw->quads + i;
 515                         // Only the verts.
 516                         glVertex3f(cq->v1[VX], cq->u.q.bottom, cq->v1[VY]);
 517                         glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 518                         glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 519                         glVertex3f(cq->v2[VX], cq->u.q.bottom, cq->v2[VY]);
 520                 }
 521                 glEnd();
 522         }
 523
 524     glEnable( GL_TEXTURE_2D );
 525
 526         // Restore normal write mode.
 527         glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 528 #endif
 529 }
 530
 531 void RL_RenderDynLightLists()
 532 {
 533         int                     i;
 534         rendlist_t      *frl = &dlflat_rlist, *wrl = &dlwall_rlist;
 535         rendquad_t      *cq;
 536
 537         if(!frl->numquads && !wrl->numquads) return; // Nothing to do.
 538
 539         // Setup the correct rendering state.
 540         glPushAttrib(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ENABLE_BIT);
 541         // Disable fog.
 542         glDisable(GL_FOG);
 543         // This'll allow multiple light quads to be rendered on top of each other.
 544         glDepthMask(GL_FALSE);
 545         glDepthFunc(GL_LEQUAL);
 546         // Set up addition blending. The source is added to the destination.
 547         glBlendFunc(GL_DST_COLOR, GL_ONE);
 548
 549         // The light texture.
 550         glBindTexture(GL_TEXTURE_2D, curtex=OGL_PrepareLightTexture());
 551
 552         // The flats.
 553         if(frl->numquads)
 554         {
 555                 glBegin(GL_TRIANGLES);
 556                 for(i=0; i<frl->numquads; i++)
 557                 {
 558                         cq = frl->quads + i;
 559                         // Set the color.
 560                         glColor3f(cq->light, cq->light, cq->light);
 561                         // The vertices.
 562                         glTexCoord2f((cq->texoffx - cq->v1[VX])/cq->texw,
 563                                 (cq->texoffy - cq->v1[VY])/cq->texh);
 564                         glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 565
 566                         glTexCoord2f((cq->texoffx - cq->v2[VX])/cq->texw,
 567                                 (cq->texoffy - cq->v2[VY])/cq->texh);
 568                         glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 569
 570                         glTexCoord2f((cq->texoffx - cq->u.v3[VX])/cq->texw,
 571                                 (cq->texoffy - cq->u.v3[VY])/cq->texh);
 572                         glVertex3f(cq->u.v3[VX], cq->top, cq->u.v3[VY]);
 573                 }
 574                 glEnd();
 575         }
 576
 577         // The walls.
 578         if(wrl->numquads)
 579         {
 580                 float tctl[2], tcbr[2]; // Top left and bottom right.
 581                 glBegin(GL_QUADS);
 582                 for(i=0; i<wrl->numquads; i++)
 583                 {
 584                         cq = wrl->quads + i;
 585                         // Set the color.
 586                         glColor3f(cq->light, cq->light, cq->light);
 587
 588                         // Calculate the texture coordinates.
 589                         tcbr[VX] = (tctl[VX]=-cq->texoffx/cq->texw) + cq->u.q.len/cq->texw;
 590                         tcbr[VY] = (tctl[VY]=cq->texoffy/cq->texh) + (cq->top - cq->u.q.bottom)/cq->texh;
 591
 592                         // The vertices.
 593                         glTexCoord2f(tctl[VX], tcbr[VY]);
 594                         glVertex3f(cq->v1[VX], cq->u.q.bottom, cq->v1[VY]);
 595
 596                         glTexCoord2f(tctl[VX], tctl[VY]);
 597                         glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 598
 599                         glTexCoord2f(tcbr[VX], tctl[VY]);
 600                         glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 601
 602                         glTexCoord2f(tcbr[VX], tcbr[VY]);
 603                         glVertex3f(cq->v2[VX], cq->u.q.bottom, cq->v2[VY]);
 604                 }
 605                 glEnd();
 606         }
 607
 608         // Restore the original rendering state.
 609         glPopAttrib();
 610 }
 611
 612
 613 void RL_RenderAllLists()
 614 {
 615         int     i;
 616
 617         // The sky might be visible. Render the needed hemispheres.
 618         R_RenderSkyHemispheres(skyhemispheres);
 619         RL_RenderSkyMaskLists(); //&invsky_rlist, &invskywall_rlist);
 620         for(i=0; i<numrlists; i++) RL_RenderList(rlists+i);
 621         RL_RenderDynLightLists();
 622         RL_RenderMaskedList(&masked_rlist);
 623 }
 624