gfxinit.cpp

Go to the documentation of this file.
00001 /* $Id: gfxinit.cpp 16597 2009-06-18 22:14:13Z rubidium $ */
00002 
00005 #include "stdafx.h"
00006 #include "debug.h"
00007 #include "spritecache.h"
00008 #include "fileio_func.h"
00009 #include "fios.h"
00010 #include "newgrf.h"
00011 #include "md5.h"
00012 #include "fontcache.h"
00013 #include "gfx_func.h"
00014 #include "settings_type.h"
00015 #include "string_func.h"
00016 #include "ini_type.h"
00017 
00018 #include "table/sprites.h"
00019 #include "table/palette_convert.h"
00020 
00022 PaletteType _use_palette = PAL_AUTODETECT;
00024 bool _palette_remap_grf[MAX_FILE_SLOTS];
00026 const byte *_palette_remap = NULL;
00028 const byte *_palette_reverse_remap = NULL;
00029 
00030 char *_ini_graphics_set;
00031 
00033 struct MD5File {
00034   const char *filename;        
00035   uint8 hash[16];              
00036   const char *missing_warning; 
00037 };
00038 
00040 enum GraphicsFileType {
00041   GFT_BASE,     
00042   GFT_LOGOS,    
00043   GFT_ARCTIC,   
00044   GFT_TROPICAL, 
00045   GFT_TOYLAND,  
00046   GFT_EXTRA,    
00047   MAX_GFT       
00048 };
00049 
00051 struct GraphicsSet {
00052   const char *name;          
00053   const char *description;   
00054   uint32 shortname;          
00055   uint32 version;            
00056   PaletteType palette;       
00057 
00058   MD5File files[MAX_GFT];    
00059   uint found_grfs;           
00060 
00061   GraphicsSet *next;         
00062 
00064   ~GraphicsSet()
00065   {
00066     free((void*)this->name);
00067     free((void*)this->description);
00068     for (uint i = 0; i < MAX_GFT; i++) {
00069       free((void*)this->files[i].filename);
00070       free((void*)this->files[i].missing_warning);
00071     }
00072 
00073     delete this->next;
00074   }
00075 };
00076 
00078 static GraphicsSet *_available_graphics_sets = NULL;
00080 static const GraphicsSet *_used_graphics_set = NULL;
00081 
00082 #include "table/files.h"
00083 #include "table/landscape_sprite.h"
00084 
00085 static const SpriteID * const _landscape_spriteindexes[] = {
00086   _landscape_spriteindexes_1,
00087   _landscape_spriteindexes_2,
00088   _landscape_spriteindexes_3,
00089 };
00090 
00091 static uint LoadGrfFile(const char *filename, uint load_index, int file_index)
00092 {
00093   uint load_index_org = load_index;
00094   uint sprite_id = 0;
00095 
00096   FioOpenFile(file_index, filename);
00097 
00098   DEBUG(sprite, 2, "Reading grf-file '%s'", filename);
00099 
00100   while (LoadNextSprite(load_index, file_index, sprite_id)) {
00101     load_index++;
00102     sprite_id++;
00103     if (load_index >= MAX_SPRITES) {
00104       usererror("Too many sprites. Recompile with higher MAX_SPRITES value or remove some custom GRF files.");
00105     }
00106   }
00107   DEBUG(sprite, 2, "Currently %i sprites are loaded", load_index);
00108 
00109   return load_index - load_index_org;
00110 }
00111 
00112 
00113 void LoadSpritesIndexed(int file_index, uint *sprite_id, const SpriteID *index_tbl)
00114 {
00115   uint start;
00116   while ((start = *index_tbl++) != END) {
00117     uint end = *index_tbl++;
00118 
00119     do {
00120       bool b = LoadNextSprite(start, file_index, *sprite_id);
00121       assert(b);
00122       (*sprite_id)++;
00123     } while (++start <= end);
00124   }
00125 }
00126 
00127 static void LoadGrfIndexed(const char *filename, const SpriteID *index_tbl, int file_index)
00128 {
00129   uint sprite_id = 0;
00130 
00131   FioOpenFile(file_index, filename);
00132 
00133   DEBUG(sprite, 2, "Reading indexed grf-file '%s'", filename);
00134 
00135   LoadSpritesIndexed(file_index, &sprite_id, index_tbl);
00136 }
00137 
00138 
00144 static bool FileMD5(const MD5File file)
00145 {
00146   size_t size;
00147   FILE *f = FioFOpenFile(file.filename, "rb", DATA_DIR, &size);
00148 
00149   if (f != NULL) {
00150     Md5 checksum;
00151     uint8 buffer[1024];
00152     uint8 digest[16];
00153     size_t len;
00154 
00155     while ((len = fread(buffer, 1, (size > sizeof(buffer)) ? sizeof(buffer) : size, f)) != 0 && size != 0) {
00156       size -= len;
00157       checksum.Append(buffer, len);
00158     }
00159 
00160     FioFCloseFile(f);
00161 
00162     checksum.Finish(digest);
00163     return memcmp(file.hash, digest, sizeof(file.hash)) == 0;
00164   } else { // file not found
00165     return false;
00166   }
00167 }
00168 
00173 static bool DetermineGraphicsPack()
00174 {
00175   if (_used_graphics_set != NULL) return true;
00176 
00177   const GraphicsSet *best = _available_graphics_sets;
00178   for (const GraphicsSet *c = _available_graphics_sets; c != NULL; c = c->next) {
00179     if (best->found_grfs < c->found_grfs ||
00180         (best->found_grfs == c->found_grfs && (
00181           (best->shortname == c->shortname && best->version < c->version) ||
00182           (best->palette != _use_palette && c->palette == _use_palette)))) {
00183       best = c;
00184     }
00185   }
00186 
00187   _used_graphics_set = best;
00188   return _used_graphics_set != NULL;
00189 }
00190 
00191 extern void UpdateNewGRFConfigPalette();
00192 
00198 static void DeterminePalette()
00199 {
00200   assert(_used_graphics_set != NULL);
00201   if (_use_palette >= MAX_PAL) _use_palette = _used_graphics_set->palette;
00202 
00203   switch (_use_palette) {
00204     case PAL_DOS:
00205       _palette_remap = _palmap_w2d;
00206       _palette_reverse_remap = _palmap_d2w;
00207       break;
00208 
00209     case PAL_WINDOWS:
00210       _palette_remap = _palmap_d2w;
00211       _palette_reverse_remap = _palmap_w2d;
00212       break;
00213 
00214     default:
00215       NOT_REACHED();
00216   }
00217 
00218   UpdateNewGRFConfigPalette();
00219 }
00220 
00226 void CheckExternalFiles()
00227 {
00228   DeterminePalette();
00229 
00230   DEBUG(grf, 1, "Using the %s base graphics set with the %s palette", _used_graphics_set->name, _use_palette == PAL_DOS ? "DOS" : "Windows");
00231 
00232   static const size_t ERROR_MESSAGE_LENGTH = 128;
00233   char error_msg[ERROR_MESSAGE_LENGTH * (MAX_GFT + 1)];
00234   error_msg[0] = '\0';
00235   char *add_pos = error_msg;
00236   const char *last = lastof(error_msg);
00237 
00238   for (uint i = 0; i < lengthof(_used_graphics_set->files); i++) {
00239     if (!FileMD5(_used_graphics_set->files[i])) {
00240       add_pos += seprintf(add_pos, last, "Your '%s' file is corrupted or missing! %s\n", _used_graphics_set->files[i].filename, _used_graphics_set->files[i].missing_warning);
00241     }
00242   }
00243 
00244   bool sound = false;
00245   for (uint i = 0; !sound && i < lengthof(_sound_sets); i++) {
00246     sound = FileMD5(_sound_sets[i]);
00247   }
00248 
00249   if (!sound) {
00250     add_pos += seprintf(add_pos, last, "Your 'sample.cat' file is corrupted or missing! You can find 'sample.cat' on your Transport Tycoon Deluxe CD-ROM.\n");
00251   }
00252 
00253   if (add_pos != error_msg) ShowInfoF("%s", error_msg);
00254 }
00255 
00256 
00257 static void LoadSpriteTables()
00258 {
00259   memset(_palette_remap_grf, 0, sizeof(_palette_remap_grf));
00260   uint i = FIRST_GRF_SLOT;
00261 
00262   _palette_remap_grf[i] = (_use_palette != _used_graphics_set->palette);
00263   LoadGrfFile(_used_graphics_set->files[GFT_BASE].filename, 0, i++);
00264 
00265   /*
00266    * The second basic file always starts at the given location and does
00267    * contain a different amount of sprites depending on the "type"; DOS
00268    * has a few sprites less. However, we do not care about those missing
00269    * sprites as they are not shown anyway (logos in intro game).
00270    */
00271   _palette_remap_grf[i] = (_use_palette != _used_graphics_set->palette);
00272   LoadGrfFile(_used_graphics_set->files[GFT_LOGOS].filename, 4793, i++);
00273 
00274   /*
00275    * Load additional sprites for climates other than temperate.
00276    * This overwrites some of the temperate sprites, such as foundations
00277    * and the ground sprites.
00278    */
00279   if (_settings_game.game_creation.landscape != LT_TEMPERATE) {
00280     _palette_remap_grf[i] = (_use_palette != _used_graphics_set->palette);
00281     LoadGrfIndexed(
00282       _used_graphics_set->files[GFT_ARCTIC + _settings_game.game_creation.landscape - 1].filename,
00283       _landscape_spriteindexes[_settings_game.game_creation.landscape - 1],
00284       i++
00285     );
00286   }
00287 
00288   /* Initialize the unicode to sprite mapping table */
00289   InitializeUnicodeGlyphMap();
00290 
00291   /*
00292    * Load the base NewGRF with OTTD required graphics as first NewGRF.
00293    * However, we do not want it to show up in the list of used NewGRFs,
00294    * so we have to manually add it, and then remove it later.
00295    */
00296   GRFConfig *top = _grfconfig;
00297   GRFConfig *master = CallocT<GRFConfig>(1);
00298   master->filename = strdup(_used_graphics_set->files[GFT_EXTRA].filename);
00299   FillGRFDetails(master, false);
00300   master->windows_paletted = (_used_graphics_set->palette == PAL_WINDOWS);
00301   ClrBit(master->flags, GCF_INIT_ONLY);
00302   master->next = top;
00303   _grfconfig = master;
00304 
00305   LoadNewGRF(SPR_NEWGRFS_BASE, i);
00306 
00307   /* Free and remove the top element. */
00308   ClearGRFConfig(&master);
00309   _grfconfig = top;
00310 }
00311 
00312 
00313 void GfxLoadSprites()
00314 {
00315   DEBUG(sprite, 2, "Loading sprite set %d", _settings_game.game_creation.landscape);
00316 
00317   GfxInitSpriteMem();
00318   LoadSpriteTables();
00319   GfxInitPalettes();
00320 }
00321 
00326 #define fetch_metadata(name) \
00327   item = metadata->GetItem(name, false); \
00328   if (item == NULL || strlen(item->value) == 0) { \
00329     DEBUG(grf, 0, "Base graphics set detail loading: %s field missing", name); \
00330     return false; \
00331   }
00332 
00334 static const char *_gft_names[MAX_GFT] = { "base", "logos", "arctic", "tropical", "toyland", "extra" };
00335 
00343 static bool FillGraphicsSetDetails(GraphicsSet *graphics, IniFile *ini, const char *path)
00344 {
00345   memset(graphics, 0, sizeof(*graphics));
00346 
00347   IniGroup *metadata = ini->GetGroup("metadata");
00348   IniItem *item;
00349 
00350   fetch_metadata("name");
00351   graphics->name = strdup(item->value);
00352 
00353   fetch_metadata("description");
00354   graphics->description = strdup(item->value);
00355 
00356   fetch_metadata("shortname");
00357   for (uint i = 0; item->value[i] != '\0' && i < 4; i++) {
00358     graphics->shortname |= ((uint8)item->value[i]) << (i * 8);
00359   }
00360 
00361   fetch_metadata("version");
00362   graphics->version = atoi(item->value);
00363 
00364   fetch_metadata("palette");
00365   graphics->palette = (*item->value == 'D' || *item->value == 'd') ? PAL_DOS : PAL_WINDOWS;
00366 
00367   /* For each of the graphics file types we want to find the file, MD5 checksums and warning messages. */
00368   IniGroup *files  = ini->GetGroup("files");
00369   IniGroup *md5s   = ini->GetGroup("md5s");
00370   IniGroup *origin = ini->GetGroup("origin");
00371   for (uint i = 0; i < MAX_GFT; i++) {
00372     MD5File *file = &graphics->files[i];
00373     /* Find the filename first. */
00374     item = files->GetItem(_gft_names[i], false);
00375     if (item == NULL) {
00376       DEBUG(grf, 0, "No graphics file for: %s", _gft_names[i]);
00377       return false;
00378     }
00379 
00380     const char *filename = item->value;
00381     file->filename = MallocT<char>(strlen(filename) + strlen(path) + 1);
00382     sprintf((char*)file->filename, "%s%s", path, filename);
00383 
00384     /* Then find the MD5 checksum */
00385     item = md5s->GetItem(filename, false);
00386     if (item == NULL) {
00387       DEBUG(grf, 0, "No MD5 checksum specified for: %s", filename);
00388       return false;
00389     }
00390     char *c = item->value;
00391     for (uint i = 0; i < sizeof(file->hash) * 2; i++, c++) {
00392       uint j;
00393       if ('0' <= *c && *c <= '9') {
00394         j = *c - '0';
00395       } else if ('a' <= *c && *c <= 'f') {
00396         j = *c - 'a' + 10;
00397       } else if ('A' <= *c && *c <= 'F') {
00398         j = *c - 'A' + 10;
00399       } else {
00400         DEBUG(grf, 0, "Malformed MD5 checksum specified for: %s", filename);
00401         return false;
00402       }
00403       if (i % 2 == 0) {
00404         file->hash[i / 2] = j << 4;
00405       } else {
00406         file->hash[i / 2] |= j;
00407       }
00408     }
00409 
00410     /* Then find the warning message when the file's missing */
00411     item = origin->GetItem(filename, false);
00412     if (item == NULL) item = origin->GetItem("default", false);
00413     if (item == NULL) {
00414       DEBUG(grf, 1, "No origin warning message specified for: %s", filename);
00415       file->missing_warning = strdup("");
00416     } else {
00417       file->missing_warning = strdup(item->value);
00418     }
00419 
00420     if (FileMD5(*file)) graphics->found_grfs++;
00421   }
00422 
00423   return true;
00424 }
00425 
00427 class OBGFileScanner : FileScanner {
00428 public:
00429   /* virtual */ bool AddFile(const char *filename, size_t basepath_length);
00430 
00432   static uint DoScan()
00433   {
00434     OBGFileScanner fs;
00435     return fs.Scan(".obg", DATA_DIR);
00436   }
00437 };
00438 
00445 bool OBGFileScanner::AddFile(const char *filename, size_t basepath_length)
00446 {
00447   bool ret = false;
00448   DEBUG(grf, 1, "Checking %s for base graphics set", filename);
00449 
00450   GraphicsSet *graphics = new GraphicsSet();;
00451   IniFile *ini = new IniFile();
00452   ini->LoadFromDisk(filename);
00453 
00454   char *path = strdup(filename + basepath_length);
00455   char *psep = strrchr(path, PATHSEPCHAR);
00456   if (psep != NULL) {
00457     psep[1] = '\0';
00458   } else {
00459     *path = '\0';
00460   }
00461 
00462   if (FillGraphicsSetDetails(graphics, ini, path)) {
00463     GraphicsSet *duplicate = NULL;
00464     for (GraphicsSet *c = _available_graphics_sets; c != NULL; c = c->next) {
00465       if (strcmp(c->name, graphics->name) == 0 || c->shortname == graphics->shortname) {
00466         duplicate = c;
00467         break;
00468       }
00469     }
00470     if (duplicate != NULL) {
00471       /* The more complete graphics set takes precedence over the version number. */
00472       if ((duplicate->found_grfs == graphics->found_grfs && duplicate->version >= graphics->version) ||
00473           duplicate->found_grfs > graphics->found_grfs) {
00474         DEBUG(grf, 1, "Not adding %s (%i) as base graphics set (duplicate)", graphics->name, graphics->version);
00475         delete graphics;
00476       } else {
00477         GraphicsSet **prev = &_available_graphics_sets;
00478         while (*prev != duplicate) prev = &(*prev)->next;
00479 
00480         *prev = graphics;
00481         graphics->next = duplicate->next;
00482         /* don't allow recursive delete of all remaining items */
00483         duplicate->next = NULL;
00484 
00485         DEBUG(grf, 1, "Removing %s (%i) as base graphics set (duplicate)", duplicate->name, duplicate->version);
00486         delete duplicate;
00487         ret = true;
00488       }
00489     } else {
00490       GraphicsSet **last = &_available_graphics_sets;
00491       while (*last != NULL) last = &(*last)->next;
00492 
00493       *last = graphics;
00494       ret = true;
00495     }
00496     if (ret) {
00497       DEBUG(grf, 1, "Adding %s (%i) as base graphics set", graphics->name, graphics->version);
00498     }
00499   } else {
00500     delete graphics;
00501   }
00502   free(path);
00503 
00504   delete ini;
00505   return ret;
00506 }
00507 
00508 
00509 
00511 void FindGraphicsSets()
00512 {
00513   DEBUG(grf, 1, "Scanning for Graphics sets");
00514   OBGFileScanner::DoScan();
00515 }
00516 
00522 bool SetGraphicsSet(const char *name)
00523 {
00524   if (StrEmpty(name)) {
00525     if (!DetermineGraphicsPack()) return false;
00526     CheckExternalFiles();
00527     return true;
00528   }
00529 
00530   for (const GraphicsSet *g = _available_graphics_sets; g != NULL; g = g->next) {
00531     if (strcmp(name, g->name) == 0) {
00532       _used_graphics_set = g;
00533       CheckExternalFiles();
00534       return true;
00535     }
00536   }
00537   return false;
00538 }
00539 
00546 char *GetGraphicsSetsList(char *p, const char *last)
00547 {
00548   p += seprintf(p, last, "List of graphics sets:\n");
00549   for (const GraphicsSet *g = _available_graphics_sets; g != NULL; g = g->next) {
00550     if (g->found_grfs <= 1) continue;
00551 
00552     p += seprintf(p, last, "%18s: %s", g->name, g->description);
00553     int difference = MAX_GFT - g->found_grfs;
00554     if (difference != 0) {
00555       p += seprintf(p, last, " (missing %i file%s)\n", difference, difference == 1 ? "" : "s");
00556     } else {
00557       p += seprintf(p, last, "\n");
00558     }
00559   }
00560   p += seprintf(p, last, "\n");
00561 
00562   return p;
00563 }
00564 
00565 #if defined(ENABLE_NETWORK)
00566 #include "network/network_content.h"
00567 
00574 bool HasGraphicsSet(const ContentInfo *ci, bool md5sum)
00575 {
00576   assert(ci->type == CONTENT_TYPE_BASE_GRAPHICS);
00577   for (const GraphicsSet *g = _available_graphics_sets; g != NULL; g = g->next) {
00578     if (g->found_grfs <= 1) continue;
00579 
00580     if (g->shortname != ci->unique_id) continue;
00581     if (!md5sum) return true;
00582 
00583     byte md5[16];
00584     memset(md5, 0, sizeof(md5));
00585     for (uint i = 0; i < MAX_GFT; i++) {
00586       for (uint j = 0; j < sizeof(md5); j++) {
00587         md5[j] ^= g->files[i].hash[j];
00588       }
00589     }
00590     if (memcmp(md5, ci->md5sum, sizeof(md5)) == 0) return true;
00591   }
00592 
00593   return false;
00594 }
00595 
00596 #endif /* ENABLE_NETWORK */
00597 
00601 int GetNumGraphicsSets()
00602 {
00603   int n = 0;
00604   for (const GraphicsSet *g = _available_graphics_sets; g != NULL; g = g->next) {
00605     if (g != _used_graphics_set && g->found_grfs <= 1) continue;
00606     n++;
00607   }
00608   return n;
00609 }
00610 
00614 int GetIndexOfCurrentGraphicsSet()
00615 {
00616   int n = 0;
00617   for (const GraphicsSet *g = _available_graphics_sets; g != NULL; g = g->next) {
00618     if (g == _used_graphics_set) return n;
00619     if (g->found_grfs <= 1) continue;
00620     n++;
00621   }
00622   return -1;
00623 }
00624 
00628 const char *GetGraphicsSetName(int index)
00629 {
00630   for (const GraphicsSet *g = _available_graphics_sets; g != NULL; g = g->next) {
00631     if (g != _used_graphics_set && g->found_grfs <= 1) continue;
00632     if (index == 0) return g->name;
00633     index--;
00634   }
00635   error("GetGraphicsSetName: index %d out of range", index);
00636 }

Generated on Wed Jul 15 20:35:58 2009 for OpenTTD by  doxygen 1.5.6