g_src/graphics.cpp

   1 #include "platform.h"
   2 #include <string.h>
   3 #include <math.h>
   4 #include <iosfwd>
   5 #include <iostream>
   6 #include <ios>
   7 #include <streambuf>
   8 #include <istream>
   9 #include <ostream>
  10 #include <iomanip>
  11 #include <sstream>
  12 #include <cstdlib>
  13 #include <fstream>
  14 #include <zlib.h>
  15 #include <cassert>
  16
  17 #include "svector.h"
  18 #include "ttf_manager.hpp"
  19
  20 #ifdef WIN32
  21
  22 /*
  23 #ifndef INTEGER_TYPES
  24         #define INTEGER_TYPES
  25         typedef short int16_t;
  26         typedef int int32_t;
  27         typedef long long int64_t;
  28         typedef unsigned short uint16_t;
  29         typedef unsigned int uint32_t;
  30         typedef unsigned long long uint64_t;
  31 #endif
  32 */
  33
  34 typedef int32_t VIndex;
  35 typedef int32_t Ordinal;
  36
  37 #endif
  38
  39 #include "random.h"
  40
  41 #include "endian.h"
  42
  43 #include "files.h"
  44
  45 #include "enabler.h"
  46
  47 #include "textlines.h"
  48
  49 #include "find_files.h"
  50
  51 #include "basics.h"
  52
  53 #include "g_basics.h"
  54
  55 #include "texture_handler.h"
  56
  57 #include "graphics.h"
  58
  59 #include "music_and_sound_g.h"
  60
  61 #include "init.h"
  62
  63 #include "interface.h"
  64
  65 #include "curses.h"
  66
  67 using namespace std;
  68
  69
  70 #pragma comment( lib, "opengl32.lib" )                  // Search For OpenGL32.lib While Linking
  71 #pragma comment( lib, "glu32.lib" )                             // Search For GLu32.lib While Linking
  72
  73 extern enablerst enabler;
  74 extern texture_handlerst texture;
  75 graphicst gps;
  76 extern interfacest gview;
  77
  78 extern string errorlog_prefix;
  79
  80 void process_object_lines(textlinesst &lines,string &chktype,string &graphics_dir);
  81
  82 // Add, then increment to the (possible) PBO alignment requirement
  83 static void align(size_t &sz, off_t inc) {
  84   sz += inc;
  85   while (sz%64) sz++; // So.. tired.. FIXME.
  86 }
  87
  88 void graphicst::resize(int x, int y)  {
  89   dimx = x; dimy = y;
  90   init.display.grid_x = x;
  91   init.display.grid_y = y;
  92   setclipping(0, x-1, 0, y-1);
  93   force_full_display_count++;
  94   screen_limit = screen + dimx * dimy * 4;
  95 }
  96
  97 void graphicst::addcoloredst(const char *str,const char *colorstr)
  98 {
  99   const int slen = strlen(str);
 100   int s;
 101   for(s=0; s < slen && screenx < init.display.grid_x; s++)
 102     {
 103       if(screenx<0)
 104         {
 105           s-=screenx;
 106           screenx=0;
 107           if (s >= slen) break;
 108         }
 109
 110       changecolor((colorstr[s] & 7),((colorstr[s] & 56))>>3,((colorstr[s] & 64))>>6);
 111       addchar(str[s]);
 112     }
 113 }
 114
 115 static list<ttf_id> ttfstr;
 116
 117 static void abbreviate_string_helper_hackaroundmissingcode(string &str, int len) {
 118        if(str.length()>=2)
 119                 {
 120                 if((str[0]=='A'||str[0]=='a')&&
 121                         str[1]==' ')
 122                         {
 123                         str.erase(str.begin()+1);
 124                         str.erase(str.begin());
 125
 126                         if(str.length()<=len)return;
 127                         }
 128
 129                 if(str.length()>=3)
 130                         {
 131                         if((str[0]=='A'||str[0]=='a')&&
 132                                 (str[1]=='N'||str[1]=='n')&&
 133                                 str[2]==' ')
 134                                 {
 135                                 str.erase(str.begin()+2);
 136                                 str.erase(str.begin()+1);
 137                                 str.erase(str.begin());
 138
 139                                 if(str.length()<=len)return;
 140                                 }
 141
 142                         if(str.length()>=4)
 143                                 {
 144                                 if((str[0]=='T'||str[0]=='t')&&
 145                                         (str[1]=='H'||str[1]=='h')&&
 146                                         (str[2]=='E'||str[2]=='e')&&
 147                                         str[3]==' ')
 148                                         {
 149                                         str.erase(str.begin()+3);
 150                                         str.erase(str.begin()+2);
 151                                         str.erase(str.begin()+1);
 152                                         str.erase(str.begin());
 153
 154                                         if(str.length()<=len)return;
 155                                         }
 156                                 }
 157                         }
 158                 }
 159
 160         int32_t l;
 161         for(l=(int32_t)str.length()-1;l>=1;l--)
 162                 {
 163                 if(str[l-1]==' ')continue;
 164
 165                 if(str[l]=='a'||
 166                         str[l]=='e'||
 167                         str[l]=='i'||
 168                         str[l]=='o'||
 169                         str[l]=='u'||
 170                         str[l]=='A'||
 171                         str[l]=='E'||
 172                         str[l]=='I'||
 173                         str[l]=='O'||
 174                         str[l]=='U')
 175                         {
 176                         str.erase(str.begin()+l);
 177                         if(str.length()<=len)return;
 178                         }
 179                 }
 180
 181         if(str.length()>len)str.resize(len);
 182 }
 183
 184
 185 static void abbreviate_string_hackaroundmissingcode(string &str, int32_t len)
 186 {
 187   if (ttf_manager.ttf_active()) {
 188     // We'll need to use TTF-aware text shrinking.
 189     while (ttf_manager.size_text(str) > len)
 190       abbreviate_string_helper_hackaroundmissingcode(str, str.length() - 1);
 191   } else if(str.length()>len){
 192     // 1 letter = 1 tile.
 193     abbreviate_string_helper_hackaroundmissingcode(str, len);
 194   }
 195 }
 196
 197
 198 void graphicst::addst(const string &str_orig, justification just, int space)
 199 {
 200   if (!str_orig.size())
 201     return;
 202   string str = str_orig;
 203   if (space)
 204     abbreviate_string_hackaroundmissingcode(str, space);
 205   if (just == not_truetype || !ttf_manager.ttf_active()) {
 206     int s;
 207     for(s=0;s<str.length()&&screenx<init.display.grid_x;s++)
 208       {
 209         if(screenx<0)
 210           {
 211             s-=screenx;
 212             screenx=0;
 213             if(s>=str.length())break;
 214           }
 215
 216         addchar(str[s]);
 217       }
 218   } else {
 219     // Truetype
 220     if (str.size() > 2 && str[0] == ':' && str[1] == ' ')
 221       str[1] = '\t'; // EVIL HACK
 222     struct ttf_id id = {str, screenf, screenb, screenbright};
 223     ttfstr.push_back(id);
 224     // if (str.size() == 80) {
 225     //   cout << "(" << int(str[0]) << ") ";
 226     // }
 227     // cout << screeny << "," << str.size() << ":" << str;
 228     // if (just == justify_cont)
 229     //   cout << "|";
 230     // else
 231     //   cout << endl;
 232     if (just == justify_cont)
 233       return; // More later
 234     // This string is done. Time to render.
 235     ttf_details details = ttf_manager.get_handle(ttfstr, just);
 236     const int handle = details.handle;
 237     const int offset = details.offset;
 238     int width = details.width;
 239     const int ourx = screenx + offset;
 240     unsigned int * const s = ((unsigned int*)screen + ourx*dimy + screeny);
 241     if (s < (unsigned int*)screen_limit)
 242       s[0] = (((unsigned int)GRAPHICSTYPE_TTF) << 24) | handle;
 243     // Also set the other tiles this text covers, but don't write past the end.
 244     if (width + ourx >= dimx)
 245       width = dimx - ourx - 1;
 246     for (int x = 1; x < width; ++x)
 247       s[x * dimy] = (((unsigned int)GRAPHICSTYPE_TTFCONT) << 24) | handle;
 248     // Clean up, prepare for next string.
 249     screenx = ourx + width;
 250     ttfstr.clear();
 251   }
 252 }
 253
 254 void graphicst::erasescreen_clip()
 255 {
 256         changecolor(0,0,0);
 257         short x2,y2;
 258         for(x2=clipx[0];x2<=clipx[1];x2++)
 259                 {
 260                 for(y2=clipy[0];y2<=clipy[1];y2++)
 261                         {
 262                         locate(y2,x2);
 263                         addchar(' ');
 264                         }
 265                 }
 266 }
 267
 268 void graphicst::erasescreen_rect(int x1, int x2, int y1, int y2)
 269 {
 270   changecolor(0,0,0);
 271   for (int x = x1; x <= x2; x++) {
 272     for (int y = y1; y <= y2; y++) {
 273       locate(y, x);
 274       addchar(' ');
 275     }
 276   }
 277 }
 278
 279 void graphicst::erasescreen()
 280 {
 281         memset(screen, 0, dimx*dimy*4);
 282
 283         memset(screentexpos, 0, dimx*dimy*sizeof(long));
 284 }
 285
 286 void graphicst::setclipping(long x1,long x2,long y1,long y2)
 287 {
 288         if(x1<0)x1=0;
 289         if(x2>init.display.grid_x-1)x2=init.display.grid_x-1;
 290         if(y1<0)y1=0;
 291         if(y2>init.display.grid_y-1)y2=init.display.grid_y-1;
 292
 293         clipx[0]=x1;
 294         clipx[1]=x2;
 295         clipy[0]=y1;
 296         clipy[1]=y2;
 297 }
 298
 299 void graphicst::dim_colors(long x,long y,char dim)
 300 {
 301         if(x>=clipx[0]&&x<=clipx[1]&&
 302                 y>=clipy[0]&&y<=clipy[1])
 303                 {
 304                 switch(dim)
 305                         {
 306                         case 4:
 307                                 switch(screen[x*dimy*4 + y*4 + 2])
 308                                         {
 309                                         case 4:
 310                                         case 5:
 311                                         case 6:
 312                                                 screen[x*dimy*4 + y*4 + 2]=1;
 313                                                 break;
 314                                         case 2:
 315                                         case 7:
 316                                                 screen[x*dimy*4 + y*4 + 2]=3;
 317                                                 break;
 318                                         }
 319                                 switch(screen[x*dimy*4 + y*4 + 1])
 320                                         {
 321                                         case 4:
 322                                         case 5:
 323                                         case 6:
 324                                                 screen[x*dimy*4 + y*4 + 1]=1;
 325                                                 break;
 326                                         case 2:
 327                                         case 7:
 328                                                 screen[x*dimy*4 + y*4 + 1]=3;
 329                                                 break;
 330                                         }
 331                                 if(screen[x*dimy*4 + y*4 + 1]==screen[x*dimy*4 + y*4 + 2])screen[x*dimy*4 + y*4 + 1]=0;
 332                                 screen[x*dimy*4 + y*4 + 3]=0;
 333                                 if(screen[x*dimy*4 + y*4 + 1]==0&&screen[x*dimy*4 + y*4 + 2]==0&&screen[x*dimy*4 + y*4 + 3]==0)screen[x*dimy*4 + y*4 + 3]=1;
 334                                 break;
 335                         case 3:
 336                                 switch(screen[x*dimy*4 + y*4 + 2])
 337                                         {
 338                                         case 4:
 339                                         case 5:
 340                                                 screen[x*dimy*4 + y*4 + 2]=6;
 341                                                 break;
 342                                         case 2:
 343                                         case 7:
 344                                                 screen[x*dimy*4 + y*4 + 2]=3;
 345                                                 break;
 346                                         }
 347                                 switch(screen[x*dimy*4 + y*4 + 1])
 348                                         {
 349                                         case 1:
 350                                                 screen[x*dimy*4 + y*4 + 3]=0;
 351                                                 break;
 352                                         case 4:
 353                                         case 5:
 354                                                 screen[x*dimy*4 + y*4 + 1]=6;
 355                                                 break;
 356                                         case 2:
 357                                                 screen[x*dimy*4 + y*4 + 1]=3;
 358                                                 break;
 359                                         case 7:
 360                                                 screen[x*dimy*4 + y*4 + 1]=3;
 361                                                 break;
 362                                         }
 363                                 if(screen[x*dimy*4 + y*4 + 1]!=7)screen[x*dimy*4 + y*4 + 3]=0;
 364                                 if(screen[x*dimy*4 + y*4 + 1]==screen[x*dimy*4 + y*4 + 2]&&
 365                                         screen[x*dimy*4 + y*4 + 3]==0)screen[x*dimy*4 + y*4 + 1]=0;
 366                                 if(screen[x*dimy*4 + y*4 + 1]==0&&screen[x*dimy*4 + y*4 + 2]==0&&screen[x*dimy*4 + y*4 + 3]==0)screen[x*dimy*4 + y*4 + 3]=1;
 367                                 break;
 368                         case 2:
 369                                 switch(screen[x*dimy*4 + y*4 + 2])
 370                                         {
 371                                         case 4:
 372                                         case 5:
 373                                                 screen[x*dimy*4 + y*4 + 2]=6;
 374                                                 break;
 375                                         }
 376                                 switch(screen[x*dimy*4 + y*4 + 1])
 377                                         {
 378                                         case 4:
 379                                         case 5:
 380                                                 screen[x*dimy*4 + y*4 + 1]=6;
 381                                                 break;
 382                                         }
 383                                 if(screen[x*dimy*4 + y*4 + 1]!=7)screen[x*dimy*4 + y*4 + 3]=0;
 384                                 if(screen[x*dimy*4 + y*4 + 1]==screen[x*dimy*4 + y*4 + 2]&&
 385                                         screen[x*dimy*4 + y*4 + 3]==0)screen[x*dimy*4 + y*4 + 1]=0;
 386                                 if(screen[x*dimy*4 + y*4 + 1]==0&&screen[x*dimy*4 + y*4 + 2]==0&&screen[x*dimy*4 + y*4 + 3]==0)screen[x*dimy*4 + y*4 + 3]=1;
 387                                 break;
 388                         case 1:
 389                                 if(screen[x*dimy*4 + y*4 + 1]!=7)screen[x*dimy*4 + y*4 + 3]=0;
 390                                 if(screen[x*dimy*4 + y*4 + 1]==screen[x*dimy*4 + y*4 + 2]&&
 391                                         screen[x*dimy*4 + y*4 + 3]==0)screen[x*dimy*4 + y*4 + 1]=0;
 392                                 if(screen[x*dimy*4 + y*4 + 1]==0&&screen[x*dimy*4 + y*4 + 2]==0&&screen[x*dimy*4 + y*4 + 3]==0)screen[x*dimy*4 + y*4 + 3]=1;
 393                                 break;
 394                         }
 395                 }
 396 }
 397
 398 void graphicst::rain_color_square(long x,long y)
 399 {
 400         if(x>=clipx[0]&&x<=clipx[1]&&
 401                 y>=clipy[0]&&y<=clipy[1])
 402                 {
 403                 screen[x*dimy*4 + y*4 + 1]=1;
 404                 screen[x*dimy*4 + y*4 + 2]=0;
 405                 screen[x*dimy*4 + y*4 + 3]=1;
 406                 }
 407 }
 408
 409 void graphicst::snow_color_square(long x,long y)
 410 {
 411         if(x>=clipx[0]&&x<=clipx[1]&&
 412                 y>=clipy[0]&&y<=clipy[1])
 413                 {
 414                 screen[x*dimy*4 + y*4 + 1]=7;
 415                 screen[x*dimy*4 + y*4 + 2]=0;
 416                 screen[x*dimy*4 + y*4 + 3]=1;
 417                 }
 418 }
 419
 420 void graphicst::color_square(long x,long y,unsigned char f,unsigned char b,unsigned char br)
 421 {
 422         if(x>=clipx[0]&&x<=clipx[1]&&
 423                 y>=clipy[0]&&y<=clipy[1])
 424                 {
 425                 screen[x*dimy*4 + y*4 + 1]=f;
 426                 screen[x*dimy*4 + y*4 + 2]=b;
 427                 screen[x*dimy*4 + y*4 + 3]=br;
 428                 }
 429 }
 430
 431 void graphicst::prepare_graphics(string &src_dir)
 432 {
 433         if(!init.display.flag.has_flag(INIT_DISPLAY_FLAG_USE_GRAPHICS))return;
 434
 435         texture.clean();
 436
 437         //GET READY TO LOAD
 438         svector<char *> processfilename;
 439         long f;
 440         textlinesst setuplines;
 441         char str[400];
 442
 443         //LOAD THE OBJECT FILES UP INTO MEMORY
 444                 //MUST INSURE THAT THEY ARE LOADED IN THE PROPER ORDER, IN CASE THEY REFER TO EACH OTHER
 445         string chk=src_dir;
 446         chk+="graphics/graphics_*";
 447 #ifdef WIN32
 448         chk+=".*";
 449 #endif
 450         find_files_by_pattern_with_exception(chk.c_str(),processfilename,"text");
 451
 452         string chktype="GRAPHICS";
 453         for(f=0;f<processfilename.size();f++)
 454                 {
 455                 strcpy(str,src_dir.c_str());
 456                 strcat(str,"graphics/");
 457                 strcat(str,processfilename[f]);
 458                 setuplines.load_raw_to_lines(str);
 459
 460                 errorlog_prefix="*** Error(s) found in the file \"";
 461                 errorlog_prefix+=str;
 462                 errorlog_prefix+='\"';
 463                 process_object_lines(setuplines,chktype,src_dir);
 464                 errorlog_prefix.clear();
 465
 466
 467                 delete[] processfilename[f];
 468                 }
 469         processfilename.clear();
 470
 471         enabler.reset_textures();
 472 }
 473
 474 void graphicst::add_tile(long texp,char addcolor)
 475 {
 476         if(screenx>=clipx[0]&&screenx<=clipx[1]&&
 477                 screeny>=clipy[0]&&screeny<=clipy[1])
 478                 {
 479                 screentexpos[screenx*dimy + screeny]=texp;
 480                 screentexpos_addcolor[screenx*dimy + screeny]=addcolor;
 481                 screentexpos_grayscale[screenx*dimy + screeny]=0;
 482                 }
 483 }
 484
 485 void graphicst::add_tile_grayscale(long texp,char cf,char cbr)
 486 {
 487         if(screenx>=clipx[0]&&screenx<=clipx[1]&&
 488                 screeny>=clipy[0]&&screeny<=clipy[1])
 489                 {
 490                 screentexpos[screenx*dimy + screeny]=texp;
 491                 screentexpos_addcolor[screenx*dimy + screeny]=0;
 492                 screentexpos_grayscale[screenx*dimy + screeny]=1;
 493                 screentexpos_cf[screenx*dimy + screeny]=cf;
 494                 screentexpos_cbr[screenx*dimy + screeny]=cbr;
 495                 }
 496 }
 497
 498 void graphicst::draw_border(int x1, int x2, int y1, int y2) {
 499   // Upper and lower
 500   for (int x = x1; x <= x2; x++) {
 501     locate(y1, x);
 502     addchar(' ');
 503     locate(y2, x);
 504     addchar(' ');
 505   }
 506   // Left and right
 507   for (int y = y1+1; y < y2; y++) {
 508     locate(y, x1);
 509     addchar(' ');
 510     locate(y, x2);
 511     addchar(' ');
 512   }
 513 }
 514
 515 void graphicst::get_mouse_text_coords(int32_t &mx, int32_t &my) {
 516   mx = mouse_x; my = mouse_y;
 517 }
 518
 519 void render_things()
 520 {
 521   //GRAB CURRENT SCREEN AT THE END OF THE LIST
 522   viewscreenst *currentscreen=&gview.view;
 523   while(currentscreen->child!=NULL)currentscreen=currentscreen->child;
 524
 525   //NO INTERFACE LEFT, LEAVE
 526   if(currentscreen==&gview.view)return;
 527
 528   if(currentscreen->breakdownlevel==INTERFACE_BREAKDOWN_NONE)
 529         {
 530         currentscreen->render();
 531         }
 532   else gps.erasescreen();
 533
 534   // Render REC when recording macros. Definitely want this screen-specific. Or do we?
 535   const Time now = SDL_GetTicks();
 536   if (enabler.is_recording() && now % 1000 > 500) {
 537     gps.locate(0, 20);
 538     gps.changecolor(4,1,1);
 539     gps.addst("REC");
 540   }
 541   // Render PLAY when playing a macro
 542   if (enabler.is_macro_playing() && now % 1000 <= 500) {
 543     gps.locate(0,20);
 544     gps.changecolor(2,1,1);
 545     gps.addst("PLAY");
 546   }
 547   // Render # <i> when building a repetition prefix
 548   if (enabler.prefix_building()) {
 549     gps.locate(0,20);
 550     gps.changecolor(3,1,1);
 551     gps.addst("#" + enabler.prefix());
 552   }
 553   if (gps.display_frames) {
 554     ostringstream fps_stream;
 555     fps_stream << "FPS: " << setw(3) << enabler.calculate_fps() << " (" << enabler.calculate_gfps() << ")";
 556     string fps = fps_stream.str();
 557     gps.changecolor(7,3,1);
 558     static gps_locator fps_locator(0, 25);
 559     fps_locator(fps.size());
 560     gps.addst(fps);
 561   }
 562 }