Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Jun 11, 2005, 12:55:48 AM (19 years ago)
Author:
bensch
Message:

orxonox/trunk: setClassID implemented in all files

File:
1 edited

Legend:

Unmodified
Added
Removed

  • orxonox/trunk/src/lib/graphics/text_engine.cc

    r4537 r4597  
    1 /* 
     1/*
    22   orxonox - the future of 3D-vertical-scrollers
    33
    … …  
    1616
    1717   !! IMPORTANT !! When using ttf fonts clear the license issues prior to
    18    adding them to orxonox. This is really important, because we do not 
     18   adding them to orxonox. This is really important, because we do not
    1919   want to offend anyone.
    2020*/
    … …  
    4646   \param type The renderType to display this font in
    4747
    48    this constructor is private, because the user should initialize 
     48   this constructor is private, because the user should initialize
    4949   a text with the TextEngine.
    5050*/
    … …  
    6868/**
    6969   \brief deletes a Text out of memory
    70    
     70
    7171   This also ereases the text from the textList of the TextEngine
    7272*/
    … …  
    117117      char* tmpText = this->text;
    118118      while (*tmpText != '\0')
    119         {
    120           if(glyphArray[*tmpText])
    121             {
    122               width += glyphArray[*tmpText]->width;
    123             }
    124           tmpText++;
    125         }
     119        {
     120          if(glyphArray[*tmpText])
     121            {
     122              width += glyphArray[*tmpText]->width;
     123            }
     124          tmpText++;
     125        }
    126126      this->posSize.w = width;
    127127    }
    … …  
    174174  if (likely(this->font != NULL))
    175175    tmpSurf = TTF_RenderText_Blended(this->font->font,
    176                                      this->text,
    177                                      this->color);
     176                                     this->text,
     177                                     this->color);
    178178  if (tmpSurf)
    179179    this->texture = loadTexture(tmpSurf, &this->texCoord);
    … …  
    208208      pos.z = tmp[2];
    209209    }
    210   else 
     210  else
    211211    {
    212212      pos.x = this->posSize.x;
    … …  
    232232      glEnable(GL_TEXTURE_2D);
    233233      glBegin(GL_QUADS);
    234      
     234
    235235      glTexCoord2f(this->texCoord.minU, this->texCoord.minV);
    236236      glVertex2f(pos.x,   pos.y  );
    237      
     237
    238238      glTexCoord2f(this->texCoord.maxU, this->texCoord.minV);
    239239      glVertex2f(pos.x + this->posSize.w, pos.y  );
    240      
     240
    241241      glTexCoord2f(this->texCoord.maxU, this->texCoord.maxV);
    242242      glVertex2f(pos.x + this->posSize.w, pos.y + this->posSize.h);
    243      
     243
    244244      glTexCoord2f(this->texCoord.minU, this->texCoord.maxV);
    245245      glVertex2f(pos.x, pos.y + this->posSize.h);
    246      
     246
    247247      glEnd();
    248248    }
    … …  
    257257      char* tmpText = this->text;
    258258      while (*tmpText != '\0')
    259         {
    260           if(glyphArray[*tmpText])
    261             {
    262               glCallList(glyphArray[*tmpText]->displayList);
    263               glTranslatef(glyphArray[*tmpText]->width, 0, 0);
    264             }
    265           tmpText++;
    266         }
     259        {
     260          if(glyphArray[*tmpText])
     261            {
     262              glCallList(glyphArray[*tmpText]->displayList);
     263              glTranslatef(glyphArray[*tmpText]->width, 0, 0);
     264            }
     265          tmpText++;
     266        }
    267267    }
    268268  glPopMatrix();
    … …  
    299299  Uint32 saved_flags;
    300300  Uint8  saved_alpha;
    301  
     301
    302302  /* Use the surface width and height expanded to powers of 2 */
    303303  w = powerOfTwo(surface->w);
    … …  
    311311    }
    312312  image = SDL_CreateRGBSurface(SDL_SWSURFACE,
    313                                w, h,
    314                                32,
     313                               w, h,
     314                               32,
    315315#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
    316                                0x000000FF,
    317                                0x0000FF00,
    318                                0x00FF0000,
    319                                0xFF000000
     316                               0x000000FF,
     317                               0x0000FF00,
     318                               0x00FF0000,
     319                               0xFF000000
    320320#else
    321                                0xFF000000,
    322                                0x00FF0000,
    323                                0x0000FF00,
    324                                0x000000FF
     321                               0xFF000000,
     322                               0x00FF0000,
     323                               0x0000FF00,
     324                               0x000000FF
    325325#endif
    326                                );
     326                               );
    327327  if ( image == NULL ) {
    328328    return 0;
    329329  }
    330  
     330
    331331  /* Save the alpha blending attributes */
    332332  saved_flags = surface->flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
    … …  
    335335    SDL_SetAlpha(surface, 0, 0);
    336336  }
    337  
     337
    338338  /* Copy the surface into the GL texture image */
    339339  area.x = 0;
    … …  
    342342  area.h = surface->h;
    343343  SDL_BlitSurface(surface, &area, image, &area);
    344  
     344
    345345  /* Restore the alpha blending attributes */
    346346  if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
    347347    SDL_SetAlpha(surface, saved_flags, saved_alpha);
    348348  }
    349  
     349
    350350  /* Create an OpenGL texture for the image */
    351351  glGenTextures(1, &texture);
    … …  
    354354  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    355355  glTexImage2D(GL_TEXTURE_2D,
    356                0,
    357                GL_RGBA,
    358                w, h,
    359                0,
    360                GL_RGBA,
    361                GL_UNSIGNED_BYTE,
    362                image->pixels);
     356               0,
     357               GL_RGBA,
     358               w, h,
     359               0,
     360               GL_RGBA,
     361               GL_UNSIGNED_BYTE,
     362               image->pixels);
    363363  SDL_FreeSurface(image); /* No longer needed */
    364  
     364
    365365  return texture;
    366366}
    367367
    368368/**
    369    \brief Quick utility function for texture creation 
     369   \brief Quick utility function for texture creation
    370370   \param input an integer
    371371   \returns the next bigger 2^n-integer than input
    … …  
    374374{
    375375  int value = 1;
    376  
     376
    377377  while ( value < input ) {
    378378    value <<= 1;
    … …  
    395395Font::Font(const char* fontFile, unsigned int fontSize, Uint8 r, Uint8 g, Uint8 b)
    396396{
     397  this->setClassID(CL_FONT, "Font");
    397398  // setting default values.
    398399  this->font = NULL;
    399400  this->fontFile = NULL;
    400401  this->glyphArray = NULL;
    401   this->fastTextureID = 0; 
    402  
     402  this->fastTextureID = 0;
     403
    403404  this->setSize(fontSize);
    404405
    … …  
    423424    {
    424425      for (int i = 0; i < FONT_HIGHEST_KNOWN_CHAR; i++)
    425         delete this->glyphArray[i];
     426        delete this->glyphArray[i];
    426427      delete []this->glyphArray;
    427428    }
    … …  
    441442  if (!this->fontFile)
    442443    {
     444      this->setName(fontFile);
    443445      this->fontFile = new char[strlen(fontFile)+1];
    444446      strcpy(this->fontFile, fontFile);
    445      
     447
    446448      this->font = TTF_OpenFont(this->fontFile, this->fontSize);
    447449      if(!this->font)
    448         {
    449           PRINTF(1)("TTF_OpenFont: %s\n", TTF_GetError());
    450           return false;
    451         }
     450        {
     451          PRINTF(1)("TTF_OpenFont: %s\n", TTF_GetError());
     452          return false;
     453        }
    452454      else
    453           return true;
     455          return true;
    454456    }
    455457  else
    … …  
    468470{
    469471  this->renderStyle = TTF_STYLE_NORMAL;
    470  
     472
    471473  for (int i = 0; i < strlen(renderStyle); i++)
    472     if (strncmp(renderStyle+i, "b", 1) == 0) 
     474    if (strncmp(renderStyle+i, "b", 1) == 0)
    473475      this->renderStyle |= TTF_STYLE_BOLD;
    474476    else if (strncmp(renderStyle+i, "i", 1) == 0)
    475477      this->renderStyle |= TTF_STYLE_ITALIC;
    476     else if (strncmp(renderStyle+i, "u", 1) == 0) 
     478    else if (strncmp(renderStyle+i, "u", 1) == 0)
    477479      this->renderStyle |= TTF_STYLE_UNDERLINE;
    478480
    … …  
    547549   and MUST be deleted by the user..
    548550
    549    This only works for horizontal fonts. see 
     551   This only works for horizontal fonts. see
    550552   http://freetype.sourceforge.net/freetype2/docs/tutorial/step2.html
    551553   for more info about vertical Fonts
    … …  
    557559  if (likely (this->font!= NULL))
    558560    TTF_GlyphMetrics(this->font, rg->character,
    559                      &rg->minX, &rg->maxX,
    560                      &rg->minY, &rg->maxY,
    561                      &rg->advance);
     561                     &rg->minX, &rg->maxX,
     562                     &rg->minY, &rg->maxY,
     563                     &rg->advance);
    562564  rg->height = rg->maxY - rg->minY;
    563565  rg->width = rg->maxX - rg->minX;
    … …  
    569571GLuint Font::createFastTexture(void)
    570572{
    571   /* interesting GLYPHS: 
     573  /* interesting GLYPHS:
    572574   *  32: space
    573575   *  33-47: Special Characters.
    … …  
    589591  SDL_Rect tmpRect; // this represents a Rectangle for blitting.
    590592  SDL_Surface* tmpSurf =  SDL_CreateRGBSurface(SDL_SWSURFACE,
    591                                                rectSize, rectSize,
    592                                                32,
     593                                               rectSize, rectSize,
     594                                               32,
    593595#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
    594                                                0x000000FF,
    595                                                0x0000FF00,
    596                                                0x00FF0000,
    597                                                0xFF000000
     596                                               0x000000FF,
     597                                               0x0000FF00,
     598                                               0x00FF0000,
     599                                               0xFF000000
    598600#else
    599                                                0xFF000000,
    600                                                0x00FF0000,
    601                                                0x0000FF00,
    602                                                0x000000FF
     601                                               0xFF000000,
     602                                               0x00FF0000,
     603                                               0x0000FF00,
     604                                               0x000000FF
    603605#endif
    604                                                );
     606                                               );
    605607  tmpRect.x = 0; tmpRect.y = 0; tmpRect.w = tmpSurf->w; tmpRect.h = tmpSurf->h;
    606608  SDL_SetClipRect(tmpSurf, &tmpRect);
    … …  
    614616
    615617      if (tmpGlyph = this->glyphArray[i])
    616         {
    617           if (tmpGlyph->height > maxLineHeight)
    618             maxLineHeight = tmpGlyph->height;
    619          
    620           if (tmpRect.x+tmpGlyph->width > tmpSurf->w)
    621             {
    622               tmpRect.x = 0;
    623               tmpRect.y = tmpRect.y + maxLineHeight + 1;
    624               maxLineHeight = 0;
    625             }
    626           if (tmpRect.y + maxLineHeight > tmpSurf->h)
    627             {
    628               PRINTF(1)("Protection, so font cannot write over the boundraries error (this should not heappen\n");
    629               break;
    630             }
    631           // reading in the new Glyph
    632           if (likely(this->font != NULL))
    633             glyphSurf = TTF_RenderGlyph_Blended(this->font, i, this->fastColor);
    634           if( glyphSurf != NULL )
    635             {
    636 
    637               SDL_SetAlpha(glyphSurf, 0, 0);
    638 
    639               SDL_BlitSurface(glyphSurf, NULL, tmpSurf, &tmpRect);
    640               TexCoord tmpTexCoord;
    641               tmpTexCoord.minU = (float)tmpRect.x/(float)tmpSurf->w;
    642               tmpTexCoord.maxU = (float)(tmpRect.x+tmpGlyph->width)/(float)tmpSurf->w;
    643               tmpTexCoord.minV = (float)tmpRect.y/(float)tmpSurf->w;
    644               tmpTexCoord.maxV = (float)(tmpRect.y+tmpGlyph->height)/(float)tmpSurf->w;
    645               tmpGlyph->displayList = glGenLists(1);
    646 
    647               glNewList(tmpGlyph->displayList, GL_COMPILE);
    648               glBegin(GL_QUADS);
    649               glTexCoord2f(tmpTexCoord.minU, tmpTexCoord.minV);
    650               glVertex2d(0, 0);
    651               glTexCoord2f(tmpTexCoord.minU, tmpTexCoord.maxV);
    652               glVertex2d(0, tmpGlyph->height);
    653               glTexCoord2f(tmpTexCoord.maxU, tmpTexCoord.maxV);
    654               glVertex2d(tmpGlyph->width, tmpGlyph->height);
    655               glTexCoord2f(tmpTexCoord.maxU, tmpTexCoord.minV);
    656               glVertex2d(tmpGlyph->width, 0);
    657               glEnd();
    658               glEndList();
    659               SDL_FreeSurface(glyphSurf);
    660 
    661               tmpRect.x += tmpGlyph->width + 1;
    662 
    663               // Outputting Glyphs to BMP-files.
    664               /*
    665                 char outname[64];
    666                 if (i < 10)
    667                 sprintf( outname, "glyph-00%d.bmp", i );
    668                 else if (i <100)
    669                 sprintf( outname, "glyph-0%d.bmp", i );
    670                 else
    671                 sprintf( outname, "glyph-%d.bmp", i );
    672                 SDL_SaveBMP(tmpSurf, outname);
    673               */
    674             }
    675         }
     618        {
     619          if (tmpGlyph->height > maxLineHeight)
     620            maxLineHeight = tmpGlyph->height;
     621
     622          if (tmpRect.x+tmpGlyph->width > tmpSurf->w)
     623            {
     624              tmpRect.x = 0;
     625              tmpRect.y = tmpRect.y + maxLineHeight + 1;
     626              maxLineHeight = 0;
     627            }
     628          if (tmpRect.y + maxLineHeight > tmpSurf->h)
     629            {
     630              PRINTF(1)("Protection, so font cannot write over the boundraries error (this should not heappen\n");
     631              break;
     632            }
     633          // reading in the new Glyph
     634          if (likely(this->font != NULL))
     635            glyphSurf = TTF_RenderGlyph_Blended(this->font, i, this->fastColor);
     636          if( glyphSurf != NULL )
     637            {
     638
     639              SDL_SetAlpha(glyphSurf, 0, 0);
     640
     641              SDL_BlitSurface(glyphSurf, NULL, tmpSurf, &tmpRect);
     642              TexCoord tmpTexCoord;
     643              tmpTexCoord.minU = (float)tmpRect.x/(float)tmpSurf->w;
     644              tmpTexCoord.maxU = (float)(tmpRect.x+tmpGlyph->width)/(float)tmpSurf->w;
     645              tmpTexCoord.minV = (float)tmpRect.y/(float)tmpSurf->w;
     646              tmpTexCoord.maxV = (float)(tmpRect.y+tmpGlyph->height)/(float)tmpSurf->w;
     647              tmpGlyph->displayList = glGenLists(1);
     648
     649              glNewList(tmpGlyph->displayList, GL_COMPILE);
     650              glBegin(GL_QUADS);
     651              glTexCoord2f(tmpTexCoord.minU, tmpTexCoord.minV);
     652              glVertex2d(0, 0);
     653              glTexCoord2f(tmpTexCoord.minU, tmpTexCoord.maxV);
     654              glVertex2d(0, tmpGlyph->height);
     655              glTexCoord2f(tmpTexCoord.maxU, tmpTexCoord.maxV);
     656              glVertex2d(tmpGlyph->width, tmpGlyph->height);
     657              glTexCoord2f(tmpTexCoord.maxU, tmpTexCoord.minV);
     658              glVertex2d(tmpGlyph->width, 0);
     659              glEnd();
     660              glEndList();
     661              SDL_FreeSurface(glyphSurf);
     662
     663              tmpRect.x += tmpGlyph->width + 1;
     664
     665              // Outputting Glyphs to BMP-files.
     666              /*
     667                char outname[64];
     668                if (i < 10)
     669                sprintf( outname, "glyph-00%d.bmp", i );
     670                else if (i <100)
     671                sprintf( outname, "glyph-0%d.bmp", i );
     672                else
     673                sprintf( outname, "glyph-%d.bmp", i );
     674                SDL_SaveBMP(tmpSurf, outname);
     675              */
     676            }
     677        }
    676678    }
    677679
    … …  
    682684  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    683685  glTexImage2D(GL_TEXTURE_2D,
    684                0,
    685                GL_RGBA,
    686                tmpSurf->w, tmpSurf->h,
    687                0,
    688                GL_RGBA,
    689                GL_UNSIGNED_BYTE,
    690                tmpSurf->pixels);
     686               0,
     687               GL_RGBA,
     688               tmpSurf->w, tmpSurf->h,
     689               0,
     690               GL_RGBA,
     691               GL_UNSIGNED_BYTE,
     692               tmpSurf->pixels);
    691693  SDL_FreeSurface(tmpSurf);
    692694  return texture;
    … …  
    707709      this->glyphArray = new Glyph*[FONT_HIGHEST_KNOWN_CHAR];
    708710      for (int i = 0; i < FONT_HIGHEST_KNOWN_CHAR; i++)
    709         this->glyphArray[i] = NULL;
    710     }
    711  
     711        this->glyphArray[i] = NULL;
     712    }
     713
    712714  Uint16 lastGlyph = from + count;
    713  
     715
    714716  for (int i = from; i <= lastGlyph; i++)
    715717    {
    … …  
    723725   \returns the optimal size to use as the texture size
    724726
    725    \todo: this algorithm can be a lot more faster, althought it does 
     727   \todo: this algorithm can be a lot more faster, althought it does
    726728   not really matter within the init-context, and 128 glyphs.
    727729
    728    This function searches for a 2^n sizes texture-size, this is for 
     730   This function searches for a 2^n sizes texture-size, this is for
    729731   openGL-version < 1.2 compatibility ( and because it is realy easy like this :))
    730732*/
    … …  
    743745      maxLineHeight = 0;
    744746      for (i = 0; i < FONT_HIGHEST_KNOWN_CHAR; i++)
    745         {
    746           if(tmpGlyph = this->glyphArray[i])
    747             {
    748               // getting the height of the highest Glyph in the Line.
    749               if (tmpGlyph->height > maxLineHeight)
    750                 maxLineHeight = tmpGlyph->height;
    751 
    752               if (x + tmpGlyph->width > size)
    753                 {
    754                   x = 0;
    755                   y = y + maxLineHeight;
    756                   maxLineHeight = 0;
    757                 }
    758               if (y + maxLineHeight + 1 > size)
    759                 break;
    760               x += tmpGlyph->width + 1;
    761 
    762             }
    763         }
     747        {
     748          if(tmpGlyph = this->glyphArray[i])
     749            {
     750              // getting the height of the highest Glyph in the Line.
     751              if (tmpGlyph->height > maxLineHeight)
     752                maxLineHeight = tmpGlyph->height;
     753
     754              if (x + tmpGlyph->width > size)
     755                {
     756                  x = 0;
     757                  y = y + maxLineHeight;
     758                  maxLineHeight = 0;
     759                }
     760              if (y + maxLineHeight + 1 > size)
     761                break;
     762              x += tmpGlyph->width + 1;
     763
     764            }
     765        }
    764766      if (i == FONT_HIGHEST_KNOWN_CHAR)
    765         sizeOK = true;
     767        sizeOK = true;
    766768      else
    767         size *= 2;
     769        size *= 2;
    768770    }
    769771  return size;
    … …  
    801803   \brief standard constructor
    802804*/
    803 TextEngine::TextEngine () 
     805TextEngine::TextEngine ()
    804806{
    805807   this->setClassID(CL_TEXT_ENGINE, "TextEngine");
     808   this->setName("TextEngine");
    806809   this->enableFonts();
    807810
    … …  
    818821
    819822*/
    820 TextEngine::~TextEngine () 
     823TextEngine::~TextEngine ()
    821824{
    822825  this->disableFonts();
    823  
     826
    824827  delete this->textList;
    825828
    … …  
    835838    {
    836839      if(TTF_Init()==-1)
    837         PRINTF(1)("TTF_Init: %s\n", TTF_GetError());
     840        PRINTF(1)("TTF_Init: %s\n", TTF_GetError());
    838841
    839842      TextEngine::checkVersion();
    … …  
    932935/**
    933936   \brief outputs some nice Debug information
    934    
     937
    935938   \todo there should also be something outputted about Font
    936939*/
    … …  
    941944  PRINT(0)("+-------------------------------+\n");
    942945  PRINT(0)("Reference: %p; Text Counts: %d\n", this, this->textList->getSize());
    943  
     946
    944947  tIterator<Text>* textIterator = textList->getIterator();
    945948  Text* text = textIterator->nextElement();
    … …  
    973976  else
    974977    {
    975       PRINTF(2)("compiled with SDL_ttf version: %d.%d.%d\n", 
    976                 compile_version.major,
    977                 compile_version.minor,
    978                 compile_version.patch);
    979      
    980       PRINTF(2)("running with SDL_ttf version: %d.%d.%d\n", 
    981                 link_version.major,
    982                 link_version.minor,
    983                 link_version.patch);
     978      PRINTF(2)("compiled with SDL_ttf version: %d.%d.%d\n",
     979                compile_version.major,
     980                compile_version.minor,
     981                compile_version.patch);
     982
     983      PRINTF(2)("running with SDL_ttf version: %d.%d.%d\n",
     984                link_version.major,
     985                link_version.minor,
     986                link_version.patch);
    984987      return false;
    985988    }
Note: See TracChangeset for help on using the changeset viewer.