src/DrawGarbage.cxx

   1 /*
   2  * DrawGarbages.cxx
   3  * Daniel Nelson - 9/1/0
   4  *
   5  * Copyright (C) 2000  Daniel Nelson
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20  *
  21  * Daniel Nelson - aluminumangel.org
  22  * 174 W. 18th Ave.
  23  * Columbus, OH  43210
  24  *
  25  * Handle's the displaying of the garbage.
  26  */
  27
  28 #define GL_GLEXT_LEGACY
  29 #define GL_GLEXT_PROTOTYPES
  30
  31 #include <GL/glut.h>
  32 #include <GL/glext.h>
  33
  34 #include "glext.h"
  35
  36 using namespace std;
  37
  38 #include "Game.h"
  39 #include "Block.h"
  40 #include "Creep.h"
  41 #include "Displayer.h"
  42 #include "Garbage.h"
  43 #include "GarbageManager.h"
  44 #include "LightManager.h"
  45 #include "GarbageFlavorImage.h"
  46
  47 const GLfloat white[3]
  48  = { 1.0f, 1.0f, 1.0f };
  49
  50 const GLfloat Displayer::garbage_colors[GF_NUMBER][3]
  51  = { { 1.0f, 0.0f, 0.0f },    // normal
  52      { 0.4f, 0.4f, 0.4f },    // gray
  53      { 0.05f, 0.05f, 0.05f }, // black
  54      { 0.95f, 0.95f, 0.95f }, // white
  55      { 0.73f, 0.0f, 0.73f },  // purple
  56      { 0.2f, 0.2f, 0.8f },    // blue
  57      { 0.0f, 0.6f, 0.05f },   // green
  58      { 0.85f, 0.85f, 0.0f },  // yellow
  59      { 1.0f, 0.4f, 0.0f } };  // orange
  60
  61 const GLfloat xy_swap_matrix[]
  62  = { 0.0f, 1.0f, 0.0f, 0.0f,
  63      1.0f, 0.0f, 0.0f, 0.0f,
  64      0.0f, 0.0f, -1.0f, 0.0f,
  65      0.0f, 0.0f, 0.0f, 1.0f };
  66
  67 GLdouble shatter_clip_plane[4]
  68  = { 0.0, 1.0, 0.0, 0.0 };
  69
  70 void Displayer::drawGarbage (   )
  71 {
  72   GLfloat x, y;
  73
  74   glBindTexture(GL_TEXTURE_2D, garbage_lightmap);
  75
  76   // blocks have already been drawn, so we use their material calls
  77
  78   glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
  79
  80 #ifdef DC_CLIP_SHATTER
  81   bool clipping = false;
  82 #else
  83   bool fading = false;
  84   GLfloat alpha = 0.0f;
  85 #endif
  86
  87   int c = GarbageManager::garbage_count;
  88   for (int n = 0; c; n++)
  89     if (GarbageManager::storeMap[n]) {
  90       Garbage &garbage = GarbageManager::garbageStore[n];
  91       c--;
  92
  93       if (garbage.y > GC_SAFE_HEIGHT) continue;
  94
  95       glPushMatrix();
  96
  97         y = garbage.y * DC_GRID_ELEMENT_LENGTH
  98          + garbage.f_y * (DC_GRID_ELEMENT_LENGTH / (GLfloat) GC_STEPS_PER_GRID)
  99          + play_offset_y;
 100         x = garbage.x * DC_GRID_ELEMENT_LENGTH + DC_PLAY_OFFSET_X;
 101
 102         // awaking; it is assumed that awaking garbage is always grid wide
 103         if (garbage.state & GS_AWAKING) {
 104
 105           // if still popping our internal sections
 106           if (garbage.alarm - Game::time_step > DC_UNSHATTER_TIME) {
 107
 108             // no garbage lightmap for blocks
 109             glDisable(GL_TEXTURE_2D);
 110
 111             int popped = garbage.sections_popped;
 112
 113             for (int h = 0; h < garbage.height; h++)
 114               for (int w = 0; w < GC_PLAY_WIDTH; w++) {
 115
 116                 glPushMatrix();
 117
 118                 LightManager::setupBlockLights(x + w * DC_GRID_ELEMENT_LENGTH,
 119                  y + h * DC_GRID_ELEMENT_LENGTH);
 120                 glTranslatef(x + w * DC_GRID_ELEMENT_LENGTH,
 121                  y + h * DC_GRID_ELEMENT_LENGTH, DC_PLAY_OFFSET_Z);
 122
 123                 // if this section is about to pop; this code here mimics code
 124                 // found in DrawBlocks.cxx
 125                 if (popped == 0
 126                  && garbage.pop_alarm - Game::time_step < DC_POP_ROTATE_TIME) {
 127                   GLfloat p = (garbage.pop_alarm - Game::time_step)
 128                    * (1.0f / (GLfloat) DC_POP_ROTATE_TIME);
 129
 130                   // each block rotates a different direction
 131                   if (garbage.pop_direction & BR_DIRECTION_1) {
 132                     glRotatef(45.0f * p, 1.0f, 0.0f, 0.0f);
 133                     glRotatef(45.0f * p, 0.0f, 1.0f, 0.0f);
 134                   } else if (garbage.pop_direction & BR_DIRECTION_2) {
 135                     glRotatef(90.0f - 45.0f * p, 1.0f, 0.0f, 0.0f);
 136                     glRotatef(45.0f * p, 0.0f, 1.0f, 0.0f);
 137                   } else if (garbage.pop_direction & BR_DIRECTION_3) {
 138                     glRotatef(90.0f - 45.0f * p, 1.0f, 0.0f, 0.0f);
 139                     glRotatef(-45.0f * p, 0.0f, 1.0f, 0.0f);
 140                   } else {
 141                     glRotatef(45.0f * p, 1.0f, 0.0f, 0.0f);
 142                     glRotatef(-45.0f * p, 0.0f, 1.0f, 0.0f);
 143                   }
 144
 145                   GLfloat scale = 1.0f - 0.5f * p;
 146                   glScalef(scale, scale, scale);
 147
 148                   if (garbage.pop_color == garbage.flavor)
 149                     glColor3fv(garbage_colors[garbage.flavor]);
 150                   else
 151                     glColor3f( (1.0f - p) * garbage_colors[garbage.flavor][0]
 152                      + p * garbage_colors[garbage.pop_color][0],
 153                      (1.0f - p) * garbage_colors[garbage.flavor][1]
 154                      + p * garbage_colors[garbage.pop_color][1],
 155                      (1.0f - p) * garbage_colors[garbage.flavor][2]
 156                      + p * garbage_colors[garbage.pop_color][2]);
 157
 158                   glEnable(rescale_method);
 159                   glCallList(block_list);
 160                   glDisable(rescale_method);
 161
 162                 // if this section has popped
 163                 } else if (popped > 0) {
 164                   glColor3fv(garbage_colors[garbage.flavor]);
 165
 166                   glCallList(block_list);
 167
 168                 // if this section has not popped
 169                 } else {
 170                   glColor3fv(garbage_colors[garbage.pop_color]);
 171
 172                   // the small block is pre-rotated
 173                   glCallList(small_block_list);
 174                 }
 175
 176                 popped--;
 177                 glPopMatrix();
 178               }
 179
 180             // don't draw a shell
 181             glPopMatrix();
 182
 183             glEnable(GL_TEXTURE_2D);
 184
 185             continue;
 186
 187           // if we're about to awake; all sections have popped
 188           } else {
 189             // crunch our sections back up
 190
 191             // no garbage lightmap for blocks
 192             glDisable(GL_TEXTURE_2D);
 193
 194             GLfloat p = (DC_UNSHATTER_TIME - garbage.alarm + Game::time_step)
 195              * (1.0f / (GLfloat) DC_UNSHATTER_TIME);
 196             GLfloat scale = 1.0f - 0.5f * p;
 197
 198             glColor3fv(garbage_colors[garbage.flavor]);
 199
 200             glEnable(rescale_method);
 201
 202             for (int h = 0; h < garbage.height; h++)
 203               for (int w = 0; w < GC_PLAY_WIDTH; w++) {
 204
 205                 glPushMatrix();
 206
 207                 LightManager::setupBlockLights(x + w * DC_GRID_ELEMENT_LENGTH,
 208                  y + h * DC_GRID_ELEMENT_LENGTH);
 209                 glTranslatef(x + w * DC_GRID_ELEMENT_LENGTH,
 210                  y + h * DC_GRID_ELEMENT_LENGTH, DC_PLAY_OFFSET_Z);
 211
 212                 glRotatef(45.0f * p, 1.0f, 0.0f, 0.0f);
 213                 glRotatef(45.0f * p, 0.0f, 1.0f, 0.0f);
 214
 215                 glScalef(scale, scale, scale);
 216
 217                 glCallList(block_list);
 218
 219                 glPopMatrix();
 220               }
 221
 222             glDisable(rescale_method);
 223
 224             glEnable(GL_TEXTURE_2D);
 225
 226             // if we're in the first half of the unshatter
 227             if (garbage.alarm - Game::time_step > DC_UNSHATTER_TIME / 4) {
 228               // don't draw a shell
 229               glPopMatrix();
 230               continue;
 231             }
 232
 233             LightManager::setupGarbageLights(x, y, garbage.height,
 234              garbage.width);
 235
 236             glTranslatef(x, y, DC_PLAY_OFFSET_Z);
 237
 238             // only push texture matrix once we know we're using it
 239             glMatrixMode(GL_TEXTURE);
 240             glPushMatrix();
 241             glTranslatef(0.5f + x * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 242              0.5f + y * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, 0.0f);
 243             glMatrixMode(GL_MODELVIEW);
 244
 245             // clip pane into existance
 246
 247 #ifdef DC_CLIP_SHATTER
 248             clipping = true;
 249             glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
 250             glDisable(GL_CULL_FACE);
 251
 252             glEnable(GL_CLIP_PLANE_SHATTERING);
 253             shatter_clip_plane[3] = -(garbage.alarm - Game::time_step)
 254              * garbage.height * (DC_GRID_ELEMENT_LENGTH * 4.0f
 255              / (GLfloat) DC_UNSHATTER_TIME)
 256              + (DC_GRID_ELEMENT_LENGTH / 2.0f);
 257             glClipPlane(GL_CLIP_PLANE_SHATTERING, shatter_clip_plane);
 258 #else
 259             fading = true;
 260             alpha = (DC_UNSHATTER_TIME / 4 - garbage.alarm + Game::time_step)
 261              * (4.0f / (GLfloat) DC_UNSHATTER_TIME);
 262             glEnable(GL_BLEND);
 263 #endif
 264           }
 265
 266         } else {
 267           LightManager::setupGarbageLights(x, y, garbage.height,
 268            garbage.width);
 269
 270           glTranslatef(x, y, DC_PLAY_OFFSET_Z);
 271
 272           // only push texture matrix once we know we're using it
 273           glMatrixMode(GL_TEXTURE);
 274           glPushMatrix();
 275           glTranslatef(0.5f + x * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 276            0.5f + y * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, 0.0f);
 277           glMatrixMode(GL_MODELVIEW);
 278         }
 279
 280         // normal and shattering
 281
 282         // if we're shattering
 283         if (garbage.state & GS_SHATTERING) {
 284
 285           // first we flash
 286           if (Game::time_step - garbage.alarm
 287            < (DC_SHATTER_FLASH_TIME - DC_SHATTER_TIME)) {
 288
 289             GLfloat flash = ((GLfloat) DC_SHATTER_TIME - garbage.alarm
 290              + Game::time_step) * (4.0f / (GLfloat) DC_SHATTER_FLASH_TIME);
 291             if (flash > 2.0f) flash = 4.0f - flash;
 292             if (flash > 1.0f) flash = 2.0f - flash;
 293             glColor3f(garbage_colors[garbage.flavor][0] + flash
 294              * (DC_FLASH_COLOR_RED - garbage_colors[garbage.flavor][0]),
 295              garbage_colors[garbage.flavor][1] + flash
 296              * (DC_FLASH_COLOR_GREEN - garbage_colors[garbage.flavor][1]),
 297              garbage_colors[garbage.flavor][2] + flash
 298              * (DC_FLASH_COLOR_BLUE - garbage_colors[garbage.flavor][2]));
 299
 300           } else {
 301             // then we clip plane away
 302
 303 #ifdef DC_CLIP_SHATTER
 304             clipping = true;
 305             glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
 306             glDisable(GL_CULL_FACE);
 307
 308             glEnable(GL_CLIP_PLANE_SHATTERING);
 309             shatter_clip_plane[3] = -((DC_SHATTER_TIME - DC_SHATTER_FLASH_TIME)
 310              - garbage.alarm + Game::time_step) * garbage.height
 311              * (DC_GRID_ELEMENT_LENGTH / (GLfloat) (DC_SHATTER_TIME
 312              - DC_SHATTER_FLASH_TIME))
 313              + (DC_GRID_ELEMENT_LENGTH / 2.0f);
 314             glClipPlane(GL_CLIP_PLANE_SHATTERING, shatter_clip_plane);
 315
 316             glColor3fv(garbage_colors[garbage.flavor]);
 317           }
 318
 319         } else
 320           glColor3fv(garbage_colors[garbage.flavor]);
 321 #else
 322             fading = true;
 323             alpha = (garbage.alarm - Game::time_step)
 324              * (1.0f / (GLfloat) (DC_SHATTER_TIME - DC_SHATTER_FLASH_TIME));
 325             glEnable(GL_BLEND);
 326             glColor4f(garbage_colors[garbage.flavor][0],
 327              garbage_colors[garbage.flavor][1],
 328              garbage_colors[garbage.flavor][2], alpha);
 329           }
 330
 331         } else if (fading)
 332           glColor4f(garbage_colors[garbage.flavor][0],
 333            garbage_colors[garbage.flavor][1],
 334            garbage_colors[garbage.flavor][2], alpha);
 335         else
 336           glColor3fv(garbage_colors[garbage.flavor]);
 337 #endif
 338
 339         // thin garbage
 340         if (garbage.height == 1) {
 341
 342           if (garbage.width != 1) {
 343
 344             glCallList(garbage_thin_cap_list);
 345             for (int w = garbage.width - 1; --w; ) {
 346               glTranslatef(DC_GRID_ELEMENT_LENGTH, 0.0f, 0.0f);
 347
 348               glMatrixMode(GL_TEXTURE);
 349               glTranslatef(DC_GRID_ELEMENT_LENGTH
 350                * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, 0.0f, 0.0f);
 351               glMatrixMode(GL_MODELVIEW);
 352
 353               glCallList(garbage_thin_middle_list);
 354             }
 355             glTranslatef(DC_GRID_ELEMENT_LENGTH, 0.0f, 0.0f);
 356             glScalef(-1.0f, 1.0f, -1.0f);
 357
 358             glMatrixMode(GL_TEXTURE);
 359             glTranslatef(DC_GRID_ELEMENT_LENGTH
 360              * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, 0.0f, 0.0f);
 361             glScalef(-1.0f, 1.0f, -1.0f);
 362             glMatrixMode(GL_MODELVIEW);
 363
 364             glCallList(garbage_thin_cap_list);
 365
 366           // tiny garbage
 367           } else
 368             glCallList(garbage_small_list);
 369
 370         // thick garbage
 371         } else {
 372
 373           // draw the bottom
 374           glPushMatrix();
 375
 376           glMatrixMode(GL_TEXTURE);
 377           glPushMatrix();
 378
 379             glScalef(1.0f, -1.0f, -1.0f);
 380             glMatrixMode(GL_MODELVIEW);
 381
 382             glScalef(1.0f, -1.0f, -1.0f);
 383
 384             glCallList(garbage_thick_corner_list);
 385             for (int w = garbage.width - 1; --w; ) {
 386               glTranslatef(DC_GRID_ELEMENT_LENGTH, 0.0f, 0.0f);
 387
 388               glMatrixMode(GL_TEXTURE);
 389               glTranslatef(DC_GRID_ELEMENT_LENGTH
 390                * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, 0.0f, 0.0f);
 391               glMatrixMode(GL_MODELVIEW);
 392
 393               glCallList(garbage_thick_edge_list);
 394             }
 395             glTranslatef(DC_GRID_ELEMENT_LENGTH, 0.0f, 0.0f);
 396             glScalef(-1.0f, 1.0f, -1.0f);
 397
 398             glMatrixMode(GL_TEXTURE);
 399             glTranslatef(DC_GRID_ELEMENT_LENGTH
 400              * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, 0.0f, 0.0f);
 401             glScalef(-1.0f, 1.0f, -1.0f);
 402
 403             glCallList(garbage_thick_corner_list);
 404
 405           glPopMatrix();
 406           glMatrixMode(GL_MODELVIEW);
 407
 408           glPopMatrix();
 409
 410           // draw the middle
 411           for (int h = garbage.height - 1; --h;) {
 412             glPushMatrix();
 413
 414             glMatrixMode(GL_TEXTURE);
 415             glPushMatrix();
 416             glMatrixMode(GL_MODELVIEW);
 417
 418               int w = garbage.width - 1;
 419               glTranslatef(w * DC_GRID_ELEMENT_LENGTH,
 420                h * DC_GRID_ELEMENT_LENGTH, 0.0f);
 421               glMultMatrixf(xy_swap_matrix);
 422
 423               glMatrixMode(GL_TEXTURE);
 424               glTranslatef(w * (DC_GRID_ELEMENT_LENGTH
 425                * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER), h
 426                * (DC_GRID_ELEMENT_LENGTH * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER),
 427                0.0f);
 428               glMultMatrixf(xy_swap_matrix);
 429               glMatrixMode(GL_MODELVIEW);
 430
 431               glCallList(garbage_thick_edge_list);
 432               while (--w) {
 433                 glTranslatef(0.0f, -DC_GRID_ELEMENT_LENGTH, 0.0f);
 434
 435                 glMatrixMode(GL_TEXTURE);
 436                 glTranslatef(0.0f, -DC_GRID_ELEMENT_LENGTH
 437                  * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, 0.0f);
 438                 glMatrixMode(GL_MODELVIEW);
 439
 440                 glCallList(garbage_thick_middle_list);
 441               }
 442               glTranslatef(0.0f, -DC_GRID_ELEMENT_LENGTH, 0.0f);
 443               glScalef(1.0f, -1.0f, -1.0f);
 444
 445               glMatrixMode(GL_TEXTURE);
 446               glTranslatef(0.0f, -DC_GRID_ELEMENT_LENGTH
 447                * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, 0.0f);
 448               glScalef(1.0f, -1.0f, -1.0f);
 449               glMatrixMode(GL_MODELVIEW);
 450
 451               glCallList(garbage_thick_edge_list);
 452
 453             glPopMatrix();
 454
 455             glMatrixMode(GL_TEXTURE);
 456             glPopMatrix();
 457             glMatrixMode(GL_MODELVIEW);
 458           }
 459
 460           // draw the top
 461           glPushMatrix();
 462
 463           glMatrixMode(GL_TEXTURE);
 464           glPushMatrix();
 465
 466             glTranslatef(0.0f, (garbage.height - 1) * (DC_GRID_ELEMENT_LENGTH
 467              * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER), 0.0f);
 468
 469             glMatrixMode(GL_MODELVIEW);
 470             glTranslatef(0.0f, (garbage.height - 1) * DC_GRID_ELEMENT_LENGTH,
 471              0.0f);
 472
 473             glCallList(garbage_thick_corner_list);
 474             for (int w = garbage.width - 1; --w; ) {
 475               glTranslatef(DC_GRID_ELEMENT_LENGTH, 0.0f, 0.0f);
 476
 477               glMatrixMode(GL_TEXTURE);
 478               glTranslatef(DC_GRID_ELEMENT_LENGTH
 479                * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, 0.0f, 0.0f);
 480               glMatrixMode(GL_MODELVIEW);
 481
 482               glCallList(garbage_thick_edge_list);
 483             }
 484             glTranslatef(DC_GRID_ELEMENT_LENGTH, 0.0f, 0.0f);
 485             glScalef(-1.0f, 1.0f, -1.0f);
 486
 487             glMatrixMode(GL_TEXTURE);
 488             glTranslatef(DC_GRID_ELEMENT_LENGTH
 489              * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, 0.0f, 0.0f);
 490             glScalef(-1.0f, 1.0f, -1.0f);
 491
 492             glCallList(garbage_thick_corner_list);
 493
 494           glPopMatrix();
 495           glMatrixMode(GL_MODELVIEW);
 496
 497           glPopMatrix();
 498
 499           if (!(MetaState::mode & CM_REALLY_LOW_GRAPHICS)) {
 500             // draw flavor image; if any
 501             if (GarbageFlavorImage::associated_garbage_id == garbage.id) {
 502 #ifndef NO_MULTITEXTURING
 503               if (state & DS_MULTITEXTURING) {
 504                 glPushAttrib(GL_LIGHTING_BIT | GL_ENABLE_BIT);
 505
 506                   glMatrixMode(GL_TEXTURE);
 507                   glLoadIdentity();
 508
 509                   glBindTexture(GL_TEXTURE_2D, garbage_texture);
 510
 511                   glActiveTextureARB(GL_TEXTURE1_ARB);
 512                   glPushMatrix();
 513                   glTranslatef(0.5f + (x + 2.0f * GarbageFlavorImage::x)
 514                    * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 515                    0.5f + (y + 2.0f * GarbageFlavorImage::y)
 516                    * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, 0.0f);
 517
 518                   glEnable(GL_TEXTURE_2D);
 519                   glEnable(GL_BLEND);
 520
 521                   glColor3fv(white);
 522
 523                   glMatrixMode(GL_MODELVIEW);
 524                   glTranslatef(GarbageFlavorImage::x * DC_GRID_ELEMENT_LENGTH,
 525                    GarbageFlavorImage::y * DC_GRID_ELEMENT_LENGTH,
 526                    DC_GARBAGE_FLAVOR_TEX_OFFSET_Z);
 527
 528                   glCallList(garbage_flavor_list);
 529
 530                   glMatrixMode(GL_TEXTURE);
 531                   glPopMatrix();
 532                   glActiveTextureARB(GL_TEXTURE0_ARB);
 533                   glMatrixMode(GL_MODELVIEW);
 534
 535                 glPopAttrib();
 536
 537                 glBindTexture(GL_TEXTURE_2D, garbage_lightmap);
 538
 539               } else {
 540 #endif
 541                 glPushAttrib(GL_LIGHTING_BIT | GL_ENABLE_BIT);
 542
 543                   glMatrixMode(GL_TEXTURE);
 544                   glLoadIdentity();
 545
 546                   glBindTexture(GL_TEXTURE_2D, garbage_texture);
 547
 548                   glEnable(GL_BLEND);
 549
 550                   glColor3fv(white);
 551
 552                   glMatrixMode(GL_MODELVIEW);
 553                   glTranslatef(GarbageFlavorImage::x * DC_GRID_ELEMENT_LENGTH,
 554                    GarbageFlavorImage::y * DC_GRID_ELEMENT_LENGTH,
 555                    DC_GARBAGE_FLAVOR_TEX_OFFSET_Z);
 556
 557                   glCallList(garbage_flavor_list);
 558
 559                   glBindTexture(GL_TEXTURE_2D, garbage_lightmap);
 560
 561                 glPopAttrib();
 562 #ifndef NO_MULTITEXTURING
 563               }
 564 #endif
 565             }
 566           }
 567         }
 568
 569         // turn off the clip plane
 570 #ifdef DC_CLIP_SHATTER
 571         if (clipping) {
 572           clipping = false;
 573
 574           glDisable(GL_CLIP_PLANE_SHATTERING);
 575           glEnable(GL_CULL_FACE);
 576           glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
 577 #else
 578         if (fading) {
 579           fading = false;
 580
 581           glDisable(GL_BLEND);
 582 #endif
 583
 584           // delete fully shattered garbage; note that we can't assume
 585           // we'll display each time step
 586           if (garbage.alarm <= Game::time_step)
 587             GarbageManager::deleteGarbage(&garbage);
 588         }
 589
 590       glPopMatrix();
 591       glMatrixMode(GL_TEXTURE);
 592       glPopMatrix();
 593       glMatrixMode(GL_MODELVIEW);
 594     }
 595 }