src/obj_garbage.cxx

   1 /*
   2  * garbage.cxx
   3  * Daniel Nelson - 10/1/0
   4  *
   5  * Copyright (C) 2000  Daniel Nelson
   6  * Copyright (C) 2004  Andrew Sayman
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21  *
  22  * Daniel Nelson - aluminumangel.org
  23  * 174 W. 18th Ave.
  24  * Columbus, OH  43210
  25  *
  26  * Generates the lightmap and flavor textures for the garbage.
  27  */
  28
  29 #define GL_GLEXT_LEGACY
  30 #define GL_GLEXT_PROTOTYPES
  31
  32 #include <GL/glut.h>
  33 #include <GL/glext.h>
  34
  35 #ifndef _WIN32
  36 #else
  37 #  include <glext.h>
  38 #endif
  39
  40 using namespace std;
  41
  42 #include "TextureLoader.h"
  43 #include "Game.h"
  44 #include "Displayer.h"
  45 #include "GarbageFlavorImage.h"
  46 #include "MetaState.h"
  47 #include "Random.h"
  48
  49 const char *garbage_lightmap_files[DC_NUMBER_GARBAGE_LIGHTMAPS]
  50  = { GC_DATA_DIRECTORY("garbage_lightmap_0.tga"),
  51      GC_DATA_DIRECTORY("garbage_lightmap_1.tga"),
  52      GC_DATA_DIRECTORY("garbage_lightmap_2.tga"),
  53      GC_DATA_DIRECTORY("garbage_lightmap_3.tga"),
  54      GC_DATA_DIRECTORY("garbage_lightmap_4.tga"),
  55      GC_DATA_DIRECTORY("garbage_lightmap_5.tga") };
  56
  57 GLuint Displayer::garbage_lightmap;
  58 GLuint Displayer::garbage_texture;
  59
  60 GLuint Displayer::garbage_flavor_list;
  61
  62 GLubyte *Displayer::garbage_texture_data[DC_NUMBER_USE_GARBAGE_TEX];
  63
  64 void Displayer::generateGarbageExtras (   )
  65 {
  66   char file_name[256];
  67
  68   glGenTextures(1, &garbage_lightmap);
  69
  70   glBindTexture(GL_TEXTURE_2D, garbage_lightmap);
  71
  72   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  73   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  74   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  75   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  76
  77   // choose a random lightmap for this game
  78   GLubyte *texture = TextureLoader::loadAlphaTGA(
  79    garbage_lightmap_files[Random::number(DC_NUMBER_GARBAGE_LIGHTMAPS)],
  80    DC_GARBAGE_LIGHTMAP_LENGTH, DC_GARBAGE_LIGHTMAP_LENGTH);
  81
  82   for (int s = DC_GARBAGE_LIGHTMAP_LENGTH; s--; )
  83     for (int t = DC_GARBAGE_LIGHTMAP_LENGTH; t--; )
  84       texture[s * DC_GARBAGE_LIGHTMAP_LENGTH + t]
  85        = (GLubyte) (255.0f * (DC_GARBAGE_LIGHTMAP_MIN_LUMINANCE
  86        + ((1.0f - DC_GARBAGE_LIGHTMAP_MIN_LUMINANCE) / 255.0f)
  87        * (float) texture[s * DC_GARBAGE_LIGHTMAP_LENGTH + t]));
  88
  89   glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, DC_GARBAGE_LIGHTMAP_LENGTH,
  90    DC_GARBAGE_LIGHTMAP_LENGTH, GL_FALSE, GL_LUMINANCE, GL_UNSIGNED_BYTE,
  91    texture);
  92
  93   if (texture != null) {
  94     delete [] texture;
  95     texture = null;
  96   }
  97
  98   glGenTextures(1, &garbage_texture);
  99
 100   glBindTexture(GL_TEXTURE_2D, garbage_texture);
 101
 102   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 103   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 104   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 105   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 106
 107   // identify which texture files exist
 108   int texture_file_count = 0;
 109   bool texture_file_flag[GC_GARBAGE_TEX_MAX_NUMBER];
 110   for (int n = GC_GARBAGE_TEX_MAX_NUMBER; n--; ) {
 111     GarbageFlavorImage::buildGarbageTextureFileName(file_name, n);
 112
 113     if (TextureLoader::fileExists(file_name)) {
 114       texture_file_count++;
 115       texture_file_flag[n] = true;
 116     } else
 117       texture_file_flag[n] = false;
 118   }
 119
 120   // if for some reason we don't have enough textures
 121   if (texture_file_count < DC_NUMBER_USE_GARBAGE_TEX) {
 122     GarbageFlavorImage::buildGarbageTextureFileName(file_name, 0);
 123
 124     for (int n = 0; n < DC_NUMBER_USE_GARBAGE_TEX; n++) {
 125       garbage_texture_data[n] = TextureLoader::loadTGA(file_name,
 126        DC_GARBAGE_TEX_LENGTH, DC_GARBAGE_TEX_LENGTH);
 127     }
 128
 129   // otherwise, we have plenty
 130   } else {
 131     int use_textures[DC_NUMBER_USE_GARBAGE_TEX];
 132     for (int n = 0; n < DC_NUMBER_USE_GARBAGE_TEX; n++) {
 133
 134       // always put the net tex in zero, if there is one
 135       if (n == 0 && (MetaState::mode & CM_SOLO)
 136        && GarbageFlavorImage::personalGarbageFlavorImageExists())
 137         GarbageFlavorImage::handleNetworkGarbageFlavorImage(
 138          garbage_texture_data[0]
 139          = GarbageFlavorImage::loadPersonalGarbageFlavorImage());
 140
 141       else if (n == 0 && !(MetaState::mode & CM_SOLO)
 142        && GarbageFlavorImage::network_texture) {
 143         char net_tex_file_name[256];
 144         TextureLoader::buildLocalDataFileName(GC_GARBAGE_NET_TEX_FILE_NAME,
 145          net_tex_file_name);
 146
 147         garbage_texture_data[0] = TextureLoader::loadTGA(net_tex_file_name,
 148          DC_GARBAGE_TEX_LENGTH, DC_GARBAGE_TEX_LENGTH);
 149
 150       } else {
 151         bool flag;
 152         do {
 153           flag = false;
 154
 155           int i;
 156           int choice = Random::number(texture_file_count);
 157           for (i = 0; choice--; i++)
 158             while (!texture_file_flag[i])
 159               i++;
 160           use_textures[n] = i;
 161
 162           for (int m = 0; m < n; m++)
 163             if (use_textures[n] == use_textures[m]) {
 164               flag = true;
 165               break;
 166             }
 167         } while (flag);
 168
 169         GarbageFlavorImage::buildGarbageTextureFileName(file_name,
 170          use_textures[n]);
 171
 172         garbage_texture_data[n] = TextureLoader::loadTGA(file_name,
 173          DC_GARBAGE_TEX_LENGTH, DC_GARBAGE_TEX_LENGTH);
 174       }
 175     }
 176   }
 177
 178   // the logo may replace the second texture
 179   if (Random::chanceIn(DC_CHANCE_IN_NOT_USE_LOGO_FLAVOR_TEX)) {
 180     if (garbage_texture_data[1] != null) {
 181       delete [] garbage_texture_data[1];
 182       garbage_texture_data[1] = null;
 183     }
 184
 185     if (MetaState::mode & CM_X)
 186       garbage_texture_data[1]
 187        = TextureLoader::loadTGA(GC_GARBAGE_X_LOGO_TEX_FILE_NAME,
 188        DC_GARBAGE_TEX_LENGTH, DC_GARBAGE_TEX_LENGTH);
 189     else
 190       garbage_texture_data[1]
 191        = TextureLoader::loadTGA(GC_GARBAGE_LOGO_TEX_FILE_NAME,
 192        DC_GARBAGE_TEX_LENGTH, DC_GARBAGE_TEX_LENGTH);
 193   }
 194
 195   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, DC_GARBAGE_TEX_LENGTH,
 196    DC_GARBAGE_TEX_LENGTH, GL_FALSE, GL_RGBA, GL_UNSIGNED_BYTE,
 197    garbage_texture_data[GarbageFlavorImage::current_texture]);
 198
 199   GLfloat vertices_0[3 * 6] = {
 200     -1.0f, -1.0f, 1.0f,
 201     1.0f, -1.0f, 1.0f,
 202     -1.0f, 1.0f, 1.0f,
 203     1.0f, 1.0f, 1.0f,
 204     -1.0f, 3.0f, 1.0f,
 205     1.0f, 3.0f, 1.0f
 206   };
 207
 208   GLfloat normals_0[3 * 6] = {
 209     0.0f, 0.0f, 1.0f,
 210     0.0f, 0.0f, 1.0f,
 211     0.0f, 0.0f, 1.0f,
 212     0.0f, 0.0f, 1.0f,
 213     0.0f, 0.0f, 1.0f,
 214     0.0f, 0.0f, 1.0f
 215   };
 216
 217   GLfloat tex_coords_flavor[2 * 6] = {
 218     0.0f, 1.0f,
 219     0.5f, 1.0f,
 220     0.0f, 0.5f,
 221     0.5f, 0.5f,
 222     0.0f, 0.0f,
 223     0.5f, 0.0f
 224   };
 225
 226 #ifndef NO_MULTITEXTURING
 227   GLfloat tex_coords_lightmap[2 * 6] = {
 228     -DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, -DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 229     DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, -DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 230     -DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 231     DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 232     -DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 233      3.0f * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 234     DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 235      3.0f * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 236   };
 237 #endif
 238
 239   garbage_flavor_list = glGenLists(1);
 240
 241   glEnableClientState(GL_VERTEX_ARRAY);
 242   glEnableClientState(GL_NORMAL_ARRAY);
 243   glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 244
 245 #ifndef NO_MULTITEXTURING
 246   // if multitexturing
 247   if (Displayer::state & DS_MULTITEXTURING) {
 248
 249     glActiveTextureARB(GL_TEXTURE1_ARB);
 250
 251     glBindTexture(GL_TEXTURE_2D, garbage_lightmap);
 252     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 253
 254     glActiveTextureARB(GL_TEXTURE0_ARB);
 255
 256     glNewList(garbage_flavor_list, GL_COMPILE);
 257
 258       glVertexPointer(3, GL_FLOAT, 0, vertices_0);
 259       glNormalPointer(GL_FLOAT, 0, normals_0);
 260       glTexCoordPointer(2, GL_FLOAT, 0, tex_coords_flavor);
 261
 262       glClientActiveTextureARB(GL_TEXTURE1_ARB);
 263       glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 264       glTexCoordPointer(2, GL_FLOAT, 0, tex_coords_lightmap);
 265
 266       glDrawArrays(GL_TRIANGLE_STRIP, 0, 6);
 267
 268       for (int n = 6; n--; ) {
 269         vertices_0[3 * n + 0] += 2.0f;
 270         tex_coords_flavor[2 * n + 0] += 0.5f;
 271         tex_coords_lightmap[2 * n + 0]
 272          += 2.0f * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER;
 273       }
 274
 275       glDrawArrays(GL_TRIANGLE_STRIP, 0, 6);
 276
 277       glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 278       glClientActiveTextureARB(GL_TEXTURE0_ARB);
 279
 280     glEndList();
 281
 282   // if no multitexturing
 283   } else {
 284 #endif
 285
 286     glNewList(garbage_flavor_list, GL_COMPILE);
 287
 288       glVertexPointer(3, GL_FLOAT, 0, vertices_0);
 289       glNormalPointer(GL_FLOAT, 0, normals_0);
 290       glTexCoordPointer(2, GL_FLOAT, 0, tex_coords_flavor);
 291       glDrawArrays(GL_TRIANGLE_STRIP, 0, 6);
 292
 293       for (int n = 6; n--; ) {
 294         vertices_0[3 * n + 0] += 2.0f;
 295         tex_coords_flavor[2 * n + 0] += 0.5f;
 296       }
 297
 298       glDrawArrays(GL_TRIANGLE_STRIP, 0, 6);
 299
 300     glEndList();
 301 #ifndef NO_MULTITEXTURING
 302   }
 303 #endif
 304
 305   glDisableClientState(GL_VERTEX_ARRAY);
 306   glDisableClientState(GL_NORMAL_ARRAY);
 307   glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 308 };