src/obj_score_record.cxx

   1 /*
   2  * score_record.cxx
   3  * Daniel Nelson - 12/8/1
   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
  26 #include <GL/glut.h>
  27 #include <cmath>
  28 #include <sstream>
  29
  30 #include "glext.h"
  31
  32 #include "Game.h"
  33 #include "Displayer.h"
  34 #include "MetaState.h"
  35 #include "String.h"
  36 #include "Score.h"
  37
  38 GLuint Displayer::score_to_beat_texture;
  39 GLuint Displayer::record_textures[DC_SCORE_REC_NUMBER_DRAW];
  40 GLubyte **Displayer::record_texture_data;
  41 GLubyte *Displayer::player_rank_texture_data;
  42
  43 void Displayer::copyRecordSubTexture ( GLubyte *texture, GLubyte *subtexture,
  44  int subtex_width, int s_location, int copy_width )
  45 {
  46   for (int t = DC_LETTER_TEX_LENGTH; t--; )
  47     for (int s = copy_width; s--; ) {
  48       int ds = s_location + s;
  49
  50       texture[(t * DC_SCORE_REC_TEX_LENGTH_S + ds) * 4 + 0]
  51        = subtexture[(t * subtex_width + s) * 4 + 0];
  52       texture[(t * DC_SCORE_REC_TEX_LENGTH_S + ds) * 4 + 1]
  53        = subtexture[(t * subtex_width + s) * 4 + 1];
  54       texture[(t * DC_SCORE_REC_TEX_LENGTH_S + ds) * 4 + 2]
  55        = subtexture[(t * subtex_width + s) * 4 + 2];
  56       texture[(t * DC_SCORE_REC_TEX_LENGTH_S + ds) * 4 + 3]
  57        = subtexture[(t * subtex_width + s) * 4 + 3];
  58     }
  59 }
  60
  61 void Displayer::rerankScoreRecord (   )
  62 {
  63   GLubyte *subtexture
  64    = new GLubyte[DC_LETTER_TEX_LENGTH * DC_SCORE_REC_RANK_STRING_TEX_WIDTH * 4];
  65
  66   for (int n = Score::player_rank; n--; ) {
  67     std::ostringstream rank_string;
  68     rank_string << (GC_SCORE_REC_LENGTH - n) << std::ends;
  69
  70     for (int i = DC_LETTER_TEX_LENGTH * DC_SCORE_REC_RANK_STRING_TEX_WIDTH * 4;
  71      i--; )
  72       subtexture[i] = 0;
  73
  74     String::fillStringTexture(rank_string.str().data(), subtexture,
  75      DC_SCORE_REC_RANK_STRING_TEX_WIDTH, true);
  76     copyRecordSubTexture(record_texture_data[n], subtexture,
  77      DC_SCORE_REC_RANK_STRING_TEX_WIDTH, DC_SCORE_REC_RANK_TEX_MARGIN,
  78      DC_SCORE_REC_RANK_STRING_TEX_WIDTH);
  79   }
  80
  81   if (subtexture != null) {
  82     delete [] subtexture;
  83     subtexture = null;
  84   }
  85 }
  86
  87 void Displayer::generateScoreRankTexture ( int rank, int score,
  88  const char *name, GLubyte *texture )
  89 {
  90   std::ostringstream score_string;
  91   score_string << score << std::ends;
  92
  93   std::ostringstream rank_string;
  94   rank_string << (GC_SCORE_REC_LENGTH - rank) << std::ends;
  95
  96   int score_width
  97    = String::stringWidth(score_string.str().data(), DC_SCORE_REC_TEX_LENGTH_S -
  98    2 * DC_SCORE_REC_RANK_TEX_MARGIN);
  99
 100   int max_name_width = (DC_SCORE_REC_TEX_LENGTH_S
 101    - 2 * DC_SCORE_REC_RANK_TEX_MARGIN - DC_SCORE_REC_RANK_MIN_SPACE
 102    - DC_SCORE_REC_RANK_STRING_TEX_WIDTH) - score_width;
 103   int name_width = String::stringWidth(name, max_name_width);
 104
 105   int subtex_width = name_width > score_width ? name_width : score_width;
 106   if (DC_SCORE_REC_RANK_STRING_TEX_WIDTH > subtex_width)
 107     subtex_width = DC_SCORE_REC_RANK_STRING_TEX_WIDTH;
 108   GLubyte *subtexture
 109    = new GLubyte[DC_LETTER_TEX_LENGTH * subtex_width * 4];
 110
 111   for (int i = DC_LETTER_TEX_LENGTH * subtex_width * 4; i--; )
 112     subtexture[i] = 0;
 113   String::fillStringTexture(rank_string.str().data(), subtexture,
 114    DC_SCORE_REC_RANK_STRING_TEX_WIDTH, true, subtex_width);
 115   copyRecordSubTexture(texture, subtexture, subtex_width ,
 116    DC_SCORE_REC_RANK_TEX_MARGIN, DC_SCORE_REC_RANK_STRING_TEX_WIDTH);
 117
 118   for (int i = DC_LETTER_TEX_LENGTH * subtex_width * 4; i--; )
 119     subtexture[i] = 0;
 120   String::fillStringTexture(name, subtexture, name_width, true, subtex_width);
 121   copyRecordSubTexture(texture, subtexture, subtex_width,
 122    DC_SCORE_REC_RANK_STRING_TEX_WIDTH + DC_SCORE_REC_RANK_TEX_MARGIN,
 123    name_width);
 124
 125   for (int i = DC_LETTER_TEX_LENGTH * subtex_width * 4; i--; )
 126     subtexture[i] = 0;
 127   String::fillStringTexture(score_string.str().data(), subtexture, score_width, true,
 128    subtex_width);
 129   copyRecordSubTexture(texture, subtexture, subtex_width,
 130    (DC_SCORE_REC_TEX_LENGTH_S - DC_SCORE_REC_RANK_TEX_MARGIN)
 131    - score_width, score_width);
 132
 133   if (subtexture != null) {
 134     delete [] subtexture;
 135     subtexture = null;
 136   }
 137 }
 138
 139 void Displayer::generateScoreRecord (   )
 140 {
 141   if (!(MetaState::mode & CM_SOLO)) return;
 142
 143   // generate score to beat message
 144
 145   glGenTextures(1, &score_to_beat_texture);
 146
 147   glBindTexture(GL_TEXTURE_2D, score_to_beat_texture);
 148
 149   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 150   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 151   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 152   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 153
 154   GLubyte texture[DC_SCORE_TO_BEAT_TEX_LENGTH_T]
 155    [DC_SCORE_TO_BEAT_TEX_LENGTH_S][3];
 156   for (int t = DC_SCORE_TO_BEAT_TEX_LENGTH_T; t--; )
 157     for (int s = DC_SCORE_TO_BEAT_TEX_LENGTH_S; s--; )
 158       texture[t][s][0] = texture[t][s][1] = texture[t][s][2] = 0;
 159
 160   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, DC_SCORE_TO_BEAT_TEX_LENGTH_S,
 161    DC_SCORE_TO_BEAT_TEX_LENGTH_T, GL_FALSE, GL_RGB, GL_UNSIGNED_BYTE,
 162    texture);
 163
 164   int width = String::stringWidth(DC_SCORE_TO_BEAT_MESSAGE,
 165    DC_SCORE_TO_BEAT_TEX_LENGTH_S);
 166   GLubyte *subtexture = new GLubyte[DC_LETTER_TEX_LENGTH * width * 4];
 167   String::fillStringTexture(DC_SCORE_TO_BEAT_MESSAGE, subtexture, width);
 168   glTexSubImage2D(GL_TEXTURE_2D, 0, (DC_SCORE_TO_BEAT_TEX_LENGTH_S - width)
 169    / 2, (30 * DC_SCORE_TO_BEAT_TEX_LENGTH_T / 100 - DC_LETTER_TEX_LENGTH) / 2,
 170    width, DC_LETTER_TEX_LENGTH, GL_RGBA, GL_UNSIGNED_BYTE, subtexture);
 171   if (subtexture != null) {
 172     delete [] subtexture;
 173     subtexture = null;
 174   }
 175
 176   width = String::stringWidth(Score::record[GC_SCORE_REC_LENGTH - 1].name,
 177    DC_SCORE_TO_BEAT_TEX_LENGTH_S);
 178   subtexture = new GLubyte[DC_LETTER_TEX_LENGTH * width * 4];
 179   String::fillStringTexture(Score::record[GC_SCORE_REC_LENGTH - 1].name,
 180    subtexture, width);
 181   glTexSubImage2D(GL_TEXTURE_2D, 0, (DC_SCORE_TO_BEAT_TEX_LENGTH_S - width)
 182    / 2, (117 * DC_SCORE_TO_BEAT_TEX_LENGTH_T / 100 - DC_LETTER_TEX_LENGTH) / 2,
 183    width, DC_LETTER_TEX_LENGTH, GL_RGBA, GL_UNSIGNED_BYTE, subtexture);
 184   if (subtexture != null) {
 185     delete [] subtexture;
 186     subtexture = null;
 187   }
 188
 189   std::ostringstream score;
 190   score << Score::record[GC_SCORE_REC_LENGTH - 1].score << std::ends;
 191
 192   width = String::stringWidth(score.str().data(), DC_SCORE_TO_BEAT_TEX_LENGTH_S);
 193   subtexture = new GLubyte[DC_LETTER_TEX_LENGTH * width * 4];
 194   String::fillStringTexture(score.str().data(), subtexture, width);
 195   glTexSubImage2D(GL_TEXTURE_2D, 0, (DC_SCORE_TO_BEAT_TEX_LENGTH_S - width)
 196    / 2, (170 * DC_SCORE_TO_BEAT_TEX_LENGTH_T / 100 - DC_LETTER_TEX_LENGTH) / 2,
 197    width, DC_LETTER_TEX_LENGTH, GL_RGBA, GL_UNSIGNED_BYTE, subtexture);
 198   if (subtexture != null) {
 199     delete [] subtexture;
 200     subtexture = null;
 201   }
 202
 203   // generate rank textures
 204
 205   record_texture_data = new GLubyte *[GC_SCORE_REC_LENGTH - 1];
 206
 207   for (int n = GC_SCORE_REC_LENGTH - 1; n--; ) {
 208     record_texture_data[n]
 209      = new GLubyte[DC_LETTER_TEX_LENGTH * DC_SCORE_REC_TEX_LENGTH_S * 4];
 210     for (int i = DC_LETTER_TEX_LENGTH * DC_SCORE_REC_TEX_LENGTH_S * 4;
 211      i--; )
 212       record_texture_data[n][i] = 0;
 213
 214     generateScoreRankTexture(n + 1, Score::record[n + 1].score,
 215      Score::record[n + 1].name, record_texture_data[n]);
 216   }
 217
 218   // ready space for the player's rank texture
 219
 220   player_rank_texture_data
 221    = new GLubyte[DC_LETTER_TEX_LENGTH * DC_SCORE_REC_TEX_LENGTH_S * 4];
 222   for (int i = DC_LETTER_TEX_LENGTH * DC_SCORE_REC_TEX_LENGTH_S * 4; i--; )
 223     player_rank_texture_data[i] = 0;
 224 }