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 = (float *)malloc(sizeof(float)*numvrts);
 234         for(i=0; i<numvrts; i++) distances[i] = PointDist2D(&origvrts[i].x);
 235
 236         // Make a distance modification.
 237         vrts = (fvertex_t *)malloc(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         free (vrts);
 305         free (distances);
 306 }
 307
 308 void SetVertexColor(float light, float dist, float alpha)
 309 {
 310         float real = light - (dist-32)/maxLightDist * (1-light);
 311         float minimum = light*light + (light-.63)/2;
 312         if(real < minimum) real = minimum; // Clamp it.
 313         // Add extra light.
 314         real += extralight/16.0;
 315         // Check for torch.
 316         if(viewplayer->fixedcolormap)
 317         {
 318                 // Colormap 1 is the brightest. I'm guessing 16 would be the darkest.
 319                 int ll = 16-viewplayer->fixedcolormap;
 320                 float d = (1024-dist)/512.0;
 321                 float newmin = d*ll/15.0;
 322                 if(real < newmin) real = newmin;
 323         }
 324         glColor4f(real, real, real, alpha);     // Too real? Hope real gets clamped.
 325 }
 326
 327 // This is only for solid, non-masked primitives.
 328 void RL_RenderList(rendlist_t *rl)
 329 {
 330         int                     i;
 331         float           tcleft, tcright, tctop, tcbottom;
 332         rendquad_t      *cq;
 333
 334         if(!rl->numquads) return;       // The list is empty.
 335
 336         // Bind the right texture.
 337         glBindTexture(GL_TEXTURE_2D, curtex=rl->tex);
 338
 339         // Check what kind of primitives there are on the list.
 340         // There can only be one kind on each list.
 341         if(rl->quads->flags & RQF_FLAT) // Check the first primitive.
 342         {
 343                 // There's only triangles here, I see.
 344                 glBegin(GL_TRIANGLES);
 345                 for(i=0; i<rl->numquads; i++)
 346                 {
 347                         cq = rl->quads+i;
 348                         if(cq->flags & RQF_MISSING_WALL)
 349                         {
 350                                 // This triangle is REALLY a quad that originally had no
 351                                 // texture. We have to render it as two triangles.
 352                                 tcright = (tcleft=0) + cq->u.q.len/cq->texw;
 353                                 tcbottom = (tctop=0) + (cq->top - cq->u.q.bottom)/cq->texh;
 354
 355                                 SetVertexColor(cq->light, cq->dist[0], 1);
 356                                 glTexCoord2f(tcleft, tctop);
 357                                 glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 358
 359                                 SetVertexColor(cq->light, cq->dist[1], 1);
 360                                 glTexCoord2f(tcright, tctop);
 361                                 glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 362
 363                                 glTexCoord2f(tcright, tcbottom);
 364                                 glVertex3f(cq->v2[VX], cq->u.q.bottom, cq->v2[VY]);
 365
 366                                 // The other triangle.
 367                                 glTexCoord2f(tcright, tcbottom);
 368                                 glVertex3f(cq->v2[VX], cq->u.q.bottom, cq->v2[VY]);
 369
 370                                 SetVertexColor(cq->light, cq->dist[0], 1);
 371                                 glTexCoord2f(tcleft, tcbottom);
 372                                 glVertex3f(cq->v1[VX], cq->u.q.bottom, cq->v1[VY]);
 373
 374                                 glTexCoord2f(tcleft, tctop);
 375                                 glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 376                                 continue;
 377                         }
 378
 379                         // The vertices.
 380                         SetVertexColor(cq->light, cq->dist[0], 1);
 381                         glTexCoord2f((cq->v1[VX]+cq->texoffx)/cq->texw,
 382                                 (cq->v1[VY]+cq->texoffy)/cq->texh);
 383                         glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 384
 385                         SetVertexColor(cq->light, cq->dist[1], 1);
 386                         glTexCoord2f((cq->v2[VX]+cq->texoffx)/cq->texw,
 387                                 (cq->v2[VY]+cq->texoffy)/cq->texh);
 388                         glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 389
 390                         SetVertexColor(cq->light, cq->dist[2], 1);
 391                         glTexCoord2f((cq->u.v3[VX]+cq->texoffx)/cq->texw,
 392                                 (cq->u.v3[VY]+cq->texoffy)/cq->texh);
 393                         glVertex3f(cq->u.v3[VX], cq->top, cq->u.v3[VY]);
 394                 }
 395                 glEnd();
 396         }
 397         else
 398         {
 399                 // Render quads.
 400                 glBegin(GL_QUADS);
 401                 for(i=0; i<rl->numquads; i++)
 402                 {
 403                         cq = rl->quads+i;
 404
 405                         // Calculate relative texture coordinates.
 406                         tcright = (tcleft=cq->texoffx/(float)cq->texw) + cq->u.q.len/cq->texw;
 407                         tcbottom = (tctop=cq->texoffy/cq->texh) + (cq->top - cq->u.q.bottom)/cq->texh;
 408
 409                         // The vertices.
 410                         SetVertexColor(cq->light, cq->dist[0], 1);
 411                         glTexCoord2f(tcleft, tcbottom);
 412                         glVertex3f(cq->v1[VX], cq->u.q.bottom, cq->v1[VY]);
 413
 414                         glTexCoord2f(tcleft, tctop);
 415                         glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 416
 417                         SetVertexColor(cq->light, cq->dist[1], 1);
 418                         glTexCoord2f(tcright, tctop);
 419                         glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 420
 421                         glTexCoord2f(tcright, tcbottom);
 422                         glVertex3f(cq->v2[VX], cq->u.q.bottom, cq->v2[VY]);
 423                 }
 424                 glEnd();
 425         }
 426 }
 427
 428 // Masked lists only include quads.
 429 void RL_RenderMaskedList(rendlist_t *mrl)
 430 {
 431         int                     i;
 432         float           tcleft, tcright, tctop, tcbottom;
 433         rendquad_t      *cq;
 434
 435         if(!mrl->numquads) return;      // No quads to render, I'm afraid.
 436
 437         // Curtex is used to keep track of the current texture.
 438         // Zero also denotes that no glBegin() has yet been called.
 439         curtex = 0;
 440
 441         // Render quads.
 442         for(i=mrl->numquads-1; i>=0; i--)       // Render back to front.
 443         {
 444                 cq = mrl->quads+i;
 445
 446                 // Calculate relative texture coordinates.
 447                 tcright = (tcleft=cq->texoffx/cq->texw) + cq->u.q.len/cq->texw;
 448                 tcbottom = (tctop=cq->texoffy/cq->texh) + (cq->top - cq->u.q.bottom)/cq->texh;
 449
 450                 // Is there a need to change the texture?
 451                 if(curtex != cq->masktex)
 452                 {
 453                         if(curtex) glEnd();     // Finish with the old texture.
 454                         glBindTexture(GL_TEXTURE_2D, curtex=cq->masktex);
 455                         glBegin(GL_QUADS);      // I love OpenGL.
 456                 }
 457
 458                 // The vertices.
 459                 SetVertexColor(cq->light, cq->dist[0], 1);
 460                 glTexCoord2f(tcleft, tcbottom);
 461                 glVertex3f(cq->v1[VX], cq->u.q.bottom, cq->v1[VY]);
 462
 463                 glTexCoord2f(tcleft, tctop);
 464                 glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 465
 466                 SetVertexColor(cq->light, cq->dist[1], 1);
 467                 glTexCoord2f(tcright, tctop);
 468                 glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 469
 470                 glTexCoord2f(tcright, tcbottom);
 471                 glVertex3f(cq->v2[VX], cq->u.q.bottom, cq->v2[VY]);
 472         }
 473         if(curtex) glEnd();     // If something was drawn, finish with it.
 474 }
 475
 476 void RL_RenderSkyMaskLists()
 477 {
 478 #if 0
 479         int                     i;
 480         rendlist_t      *smrl = &invsky_rlist, *skyw = &invskywall_rlist;
 481         rendquad_t      *cq;
 482
 483         if(!smrl->numquads && !skyw->numquads) return; // Nothing to do here.
 484
 485         // Nothing gets written to the color buffer.
 486
 487     // NOTE: glEnd() below causes segfault in Mesa 3.0 if binding texture 0.
 488     // I don't think texture 0 is defined when this is called.
 489         //glBindTexture(GL_TEXTURE_2D, 0);
 490     glDisable( GL_TEXTURE_2D );
 491
 492         glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 493         glColor4f(1, 1, 1, 1);  // Just to be sure.
 494
 495
 496         if(smrl->numquads)
 497         {
 498                 glBegin(GL_TRIANGLES);
 499                 for(i=0; i<smrl->numquads; i++)
 500                 {
 501                         cq = smrl->quads+i;
 502                         // ONLY the vertices, please.
 503                         glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 504                         glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 505                         glVertex3f(cq->u.v3[VX], cq->top, cq->u.v3[VY]);
 506                 }
 507                 glEnd();
 508         }
 509
 510         // Then the walls.
 511         if(skyw->numquads)
 512         {
 513                 glBegin(GL_QUADS);
 514                 for(i=0; i<skyw->numquads; i++)
 515                 {
 516                         cq = skyw->quads + i;
 517                         // Only the verts.
 518                         glVertex3f(cq->v1[VX], cq->u.q.bottom, cq->v1[VY]);
 519                         glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 520                         glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 521                         glVertex3f(cq->v2[VX], cq->u.q.bottom, cq->v2[VY]);
 522                 }
 523                 glEnd();
 524         }
 525
 526     glEnable( GL_TEXTURE_2D );
 527
 528         // Restore normal write mode.
 529         glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 530 #endif
 531 }
 532
 533 void RL_RenderDynLightLists()
 534 {
 535         int                     i;
 536         rendlist_t      *frl = &dlflat_rlist, *wrl = &dlwall_rlist;
 537         rendquad_t      *cq;
 538
 539         if(!frl->numquads && !wrl->numquads) return; // Nothing to do.
 540
 541         // Setup the correct rendering state.
 542         glPushAttrib(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ENABLE_BIT);
 543         // Disable fog.
 544         glDisable(GL_FOG);
 545         // This'll allow multiple light quads to be rendered on top of each other.
 546         glDepthMask(GL_FALSE);
 547         glDepthFunc(GL_LEQUAL);
 548         // Set up addition blending. The source is added to the destination.
 549         glBlendFunc(GL_DST_COLOR, GL_ONE);
 550
 551         // The light texture.
 552         glBindTexture(GL_TEXTURE_2D, curtex=OGL_PrepareLightTexture());
 553
 554         // The flats.
 555         if(frl->numquads)
 556         {
 557                 glBegin(GL_TRIANGLES);
 558                 for(i=0; i<frl->numquads; i++)
 559                 {
 560                         cq = frl->quads + i;
 561                         // Set the color.
 562                         glColor3f(cq->light, cq->light, cq->light);
 563                         // The vertices.
 564                         glTexCoord2f((cq->texoffx - cq->v1[VX])/cq->texw,
 565                                 (cq->texoffy - cq->v1[VY])/cq->texh);
 566                         glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 567
 568                         glTexCoord2f((cq->texoffx - cq->v2[VX])/cq->texw,
 569                                 (cq->texoffy - cq->v2[VY])/cq->texh);
 570                         glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 571
 572                         glTexCoord2f((cq->texoffx - cq->u.v3[VX])/cq->texw,
 573                                 (cq->texoffy - cq->u.v3[VY])/cq->texh);
 574                         glVertex3f(cq->u.v3[VX], cq->top, cq->u.v3[VY]);
 575                 }
 576                 glEnd();
 577         }
 578
 579         // The walls.
 580         if(wrl->numquads)
 581         {
 582                 float tctl[2], tcbr[2]; // Top left and bottom right.
 583                 glBegin(GL_QUADS);
 584                 for(i=0; i<wrl->numquads; i++)
 585                 {
 586                         cq = wrl->quads + i;
 587                         // Set the color.
 588                         glColor3f(cq->light, cq->light, cq->light);
 589
 590                         // Calculate the texture coordinates.
 591                         tcbr[VX] = (tctl[VX]=-cq->texoffx/cq->texw) + cq->u.q.len/cq->texw;
 592                         tcbr[VY] = (tctl[VY]=cq->texoffy/cq->texh) + (cq->top - cq->u.q.bottom)/cq->texh;
 593
 594                         // The vertices.
 595                         glTexCoord2f(tctl[VX], tcbr[VY]);
 596                         glVertex3f(cq->v1[VX], cq->u.q.bottom, cq->v1[VY]);
 597
 598                         glTexCoord2f(tctl[VX], tctl[VY]);
 599                         glVertex3f(cq->v1[VX], cq->top, cq->v1[VY]);
 600
 601                         glTexCoord2f(tcbr[VX], tctl[VY]);
 602                         glVertex3f(cq->v2[VX], cq->top, cq->v2[VY]);
 603
 604                         glTexCoord2f(tcbr[VX], tcbr[VY]);
 605                         glVertex3f(cq->v2[VX], cq->u.q.bottom, cq->v2[VY]);
 606                 }
 607                 glEnd();
 608         }
 609
 610         // Restore the original rendering state.
 611         glPopAttrib();
 612 }
 613
 614
 615 void RL_RenderAllLists()
 616 {
 617         int     i;
 618
 619         // The sky might be visible. Render the needed hemispheres.
 620         R_RenderSkyHemispheres(skyhemispheres);
 621         RL_RenderSkyMaskLists(); //&invsky_rlist, &invskywall_rlist);
 622         for(i=0; i<numrlists; i++) RL_RenderList(rlists+i);
 623         RL_RenderDynLightLists();
 624         RL_RenderMaskedList(&masked_rlist);
 625 }
 626