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 #include "glext.h"
  36
  37 #include "TextureLoader.h"
  38 #include "Game.h"
  39 #include "Displayer.h"
  40 #include "GarbageFlavorImage.h"
  41 #include "MetaState.h"
  42 #include "Random.h"
  43
  44 const char *garbage_lightmap_files[DC_NUMBER_GARBAGE_LIGHTMAPS]
  45  = { GC_DATA_DIRECTORY("garbage_lightmap_0.png"),
  46      GC_DATA_DIRECTORY("garbage_lightmap_1.png"),
  47      GC_DATA_DIRECTORY("garbage_lightmap_2.png"),
  48      GC_DATA_DIRECTORY("garbage_lightmap_3.png"),
  49      GC_DATA_DIRECTORY("garbage_lightmap_4.png"),
  50      GC_DATA_DIRECTORY("garbage_lightmap_5.png") };
  51
  52 GLuint Displayer::garbage_lightmap;
  53 GLuint Displayer::garbage_texture;
  54
  55 GLuint Displayer::garbage_flavor_list;
  56
  57 GLubyte *Displayer::garbage_texture_data[DC_NUMBER_USE_GARBAGE_TEX];
  58
  59 void Displayer::generateGarbageExtras (   )
  60 {
  61   char file_name[256];
  62
  63   glGenTextures(1, &garbage_lightmap);
  64
  65   glBindTexture(GL_TEXTURE_2D, garbage_lightmap);
  66
  67   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  68   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  69   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  70   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  71
  72   // choose a random lightmap for this game
  73   GLubyte *texture = TextureLoader::loadImageAlpha(
  74    garbage_lightmap_files[Random::number(DC_NUMBER_GARBAGE_LIGHTMAPS)],
  75    DC_GARBAGE_LIGHTMAP_LENGTH, DC_GARBAGE_LIGHTMAP_LENGTH);
  76
  77   for (int s = DC_GARBAGE_LIGHTMAP_LENGTH; s--; )
  78     for (int t = DC_GARBAGE_LIGHTMAP_LENGTH; t--; )
  79       texture[s * DC_GARBAGE_LIGHTMAP_LENGTH + t]
  80        = (GLubyte) (255.0f * (DC_GARBAGE_LIGHTMAP_MIN_LUMINANCE
  81        + ((1.0f - DC_GARBAGE_LIGHTMAP_MIN_LUMINANCE) / 255.0f)
  82        * (float) texture[s * DC_GARBAGE_LIGHTMAP_LENGTH + t]));
  83
  84   glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, DC_GARBAGE_LIGHTMAP_LENGTH,
  85    DC_GARBAGE_LIGHTMAP_LENGTH, GL_FALSE, GL_LUMINANCE, GL_UNSIGNED_BYTE,
  86    texture);
  87
  88   if (texture != null) {
  89     delete [] texture;
  90     texture = null;
  91   }
  92
  93   glGenTextures(1, &garbage_texture);
  94
  95   glBindTexture(GL_TEXTURE_2D, garbage_texture);
  96
  97   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  98   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  99   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 100   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 101
 102   // identify which texture files exist
 103   int texture_file_count = 0;
 104   bool texture_file_flag[GC_GARBAGE_TEX_MAX_NUMBER];
 105   for (int n = GC_GARBAGE_TEX_MAX_NUMBER; n--; ) {
 106     GarbageFlavorImage::buildGarbageTextureFileName(file_name, n);
 107
 108     if (TextureLoader::fileExists(file_name)) {
 109       texture_file_count++;
 110       texture_file_flag[n] = true;
 111     } else
 112       texture_file_flag[n] = false;
 113   }
 114
 115   // if for some reason we don't have enough textures
 116   if (texture_file_count < DC_NUMBER_USE_GARBAGE_TEX) {
 117     GarbageFlavorImage::buildGarbageTextureFileName(file_name, 0);
 118
 119     for (int n = 0; n < DC_NUMBER_USE_GARBAGE_TEX; n++) {
 120       garbage_texture_data[n] = TextureLoader::loadImage(file_name,
 121        DC_GARBAGE_TEX_LENGTH, DC_GARBAGE_TEX_LENGTH);
 122     }
 123
 124   // otherwise, we have plenty
 125   } else {
 126     int use_textures[DC_NUMBER_USE_GARBAGE_TEX];
 127     for (int n = 0; n < DC_NUMBER_USE_GARBAGE_TEX; n++) {
 128
 129       // always put the net tex in zero, if there is one
 130       if (n == 0 && (MetaState::mode & CM_SOLO)
 131        && GarbageFlavorImage::personalGarbageFlavorImageExists())
 132         GarbageFlavorImage::handleNetworkGarbageFlavorImage(
 133          garbage_texture_data[0]
 134          = GarbageFlavorImage::loadPersonalGarbageFlavorImage());
 135
 136       else if (n == 0 && !(MetaState::mode & CM_SOLO)
 137        && GarbageFlavorImage::network_texture) {
 138         char net_tex_file_name[256];
 139         TextureLoader::buildLocalDataFileName(GC_GARBAGE_NET_TEX_FILE_NAME,
 140          net_tex_file_name);
 141
 142         garbage_texture_data[0] = TextureLoader::loadImage(net_tex_file_name,
 143          DC_GARBAGE_TEX_LENGTH, DC_GARBAGE_TEX_LENGTH);
 144
 145       } else {
 146         bool flag;
 147         do {
 148           flag = false;
 149
 150           int i;
 151           int choice = Random::number(texture_file_count);
 152           for (i = 0; choice--; i++)
 153             while (!texture_file_flag[i])
 154               i++;
 155           use_textures[n] = i;
 156
 157           for (int m = 0; m < n; m++)
 158             if (use_textures[n] == use_textures[m]) {
 159               flag = true;
 160               break;
 161             }
 162         } while (flag);
 163
 164         GarbageFlavorImage::buildGarbageTextureFileName(file_name,
 165          use_textures[n]);
 166
 167         garbage_texture_data[n] = TextureLoader::loadImage(file_name,
 168          DC_GARBAGE_TEX_LENGTH, DC_GARBAGE_TEX_LENGTH);
 169       }
 170     }
 171   }
 172
 173   // the logo may replace the second texture
 174   if (Random::chanceIn(DC_CHANCE_IN_NOT_USE_LOGO_FLAVOR_TEX)) {
 175     if (garbage_texture_data[1] != null) {
 176       delete [] garbage_texture_data[1];
 177       garbage_texture_data[1] = null;
 178     }
 179
 180     if (MetaState::mode & CM_X)
 181       garbage_texture_data[1]
 182        = TextureLoader::loadImage(GC_GARBAGE_X_LOGO_TEX_FILE_NAME,
 183        DC_GARBAGE_TEX_LENGTH, DC_GARBAGE_TEX_LENGTH);
 184     else
 185       garbage_texture_data[1]
 186        = TextureLoader::loadImage(GC_GARBAGE_LOGO_TEX_FILE_NAME,
 187        DC_GARBAGE_TEX_LENGTH, DC_GARBAGE_TEX_LENGTH);
 188   }
 189
 190   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, DC_GARBAGE_TEX_LENGTH,
 191    DC_GARBAGE_TEX_LENGTH, GL_FALSE, GL_RGBA, GL_UNSIGNED_BYTE,
 192    garbage_texture_data[GarbageFlavorImage::current_texture]);
 193
 194   GLfloat vertices_0[3 * 6] = {
 195     -1.0f, -1.0f, 1.0f,
 196     1.0f, -1.0f, 1.0f,
 197     -1.0f, 1.0f, 1.0f,
 198     1.0f, 1.0f, 1.0f,
 199     -1.0f, 3.0f, 1.0f,
 200     1.0f, 3.0f, 1.0f
 201   };
 202
 203   GLfloat normals_0[3 * 6] = {
 204     0.0f, 0.0f, 1.0f,
 205     0.0f, 0.0f, 1.0f,
 206     0.0f, 0.0f, 1.0f,
 207     0.0f, 0.0f, 1.0f,
 208     0.0f, 0.0f, 1.0f,
 209     0.0f, 0.0f, 1.0f
 210   };
 211
 212   GLfloat tex_coords_flavor[2 * 6] = {
 213     0.0f, 1.0f,
 214     0.5f, 1.0f,
 215     0.0f, 0.5f,
 216     0.5f, 0.5f,
 217     0.0f, 0.0f,
 218     0.5f, 0.0f
 219   };
 220
 221 #ifndef NO_MULTITEXTURING
 222   GLfloat tex_coords_lightmap[2 * 6] = {
 223     -DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, -DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 224     DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, -DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 225     -DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 226     DC_GARBAGE_LIGHTMAP_COORD_CONVERTER, DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 227     -DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 228      3.0f * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 229     DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 230      3.0f * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER,
 231   };
 232 #endif
 233
 234   garbage_flavor_list = glGenLists(1);
 235
 236   glEnableClientState(GL_VERTEX_ARRAY);
 237   glEnableClientState(GL_NORMAL_ARRAY);
 238   glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 239
 240 #ifndef NO_MULTITEXTURING
 241   // if multitexturing
 242   if (Displayer::state & DS_MULTITEXTURING) {
 243
 244     glActiveTextureARB(GL_TEXTURE1_ARB);
 245
 246     glBindTexture(GL_TEXTURE_2D, garbage_lightmap);
 247     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 248
 249     glActiveTextureARB(GL_TEXTURE0_ARB);
 250
 251     glNewList(garbage_flavor_list, GL_COMPILE);
 252
 253       glVertexPointer(3, GL_FLOAT, 0, vertices_0);
 254       glNormalPointer(GL_FLOAT, 0, normals_0);
 255       glTexCoordPointer(2, GL_FLOAT, 0, tex_coords_flavor);
 256
 257       glClientActiveTextureARB(GL_TEXTURE1_ARB);
 258       glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 259       glTexCoordPointer(2, GL_FLOAT, 0, tex_coords_lightmap);
 260
 261       glDrawArrays(GL_TRIANGLE_STRIP, 0, 6);
 262
 263       for (int n = 6; n--; ) {
 264         vertices_0[3 * n + 0] += 2.0f;
 265         tex_coords_flavor[2 * n + 0] += 0.5f;
 266         tex_coords_lightmap[2 * n + 0]
 267          += 2.0f * DC_GARBAGE_LIGHTMAP_COORD_CONVERTER;
 268       }
 269
 270       glDrawArrays(GL_TRIANGLE_STRIP, 0, 6);
 271
 272       glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 273       glClientActiveTextureARB(GL_TEXTURE0_ARB);
 274
 275     glEndList();
 276
 277   // if no multitexturing
 278   } else {
 279 #endif
 280
 281     glNewList(garbage_flavor_list, GL_COMPILE);
 282
 283       glVertexPointer(3, GL_FLOAT, 0, vertices_0);
 284       glNormalPointer(GL_FLOAT, 0, normals_0);
 285       glTexCoordPointer(2, GL_FLOAT, 0, tex_coords_flavor);
 286       glDrawArrays(GL_TRIANGLE_STRIP, 0, 6);
 287
 288       for (int n = 6; n--; ) {
 289         vertices_0[3 * n + 0] += 2.0f;
 290         tex_coords_flavor[2 * n + 0] += 0.5f;
 291       }
 292
 293       glDrawArrays(GL_TRIANGLE_STRIP, 0, 6);
 294
 295     glEndList();
 296 #ifndef NO_MULTITEXTURING
 297   }
 298 #endif
 299
 300   glDisableClientState(GL_VERTEX_ARRAY);
 301   glDisableClientState(GL_NORMAL_ARRAY);
 302   glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 303 }