OpenTTD
gfxinit.cpp
Go to the documentation of this file.
1 /* $Id: gfxinit.cpp 27732 2017-01-14 18:30:26Z frosch $ */
2 
3 /*
4  * This file is part of OpenTTD.
5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
8  */
9 
12 #include "stdafx.h"
13 #include "fios.h"
14 #include "newgrf.h"
15 #include "3rdparty/md5/md5.h"
16 #include "fontcache.h"
17 #include "gfx_func.h"
18 #include "transparency.h"
19 #include "blitter/factory.hpp"
20 #include "video/video_driver.hpp"
21 #include "window_func.h"
22 
23 /* The type of set we're replacing */
24 #define SET_TYPE "graphics"
25 #include "base_media_func.h"
26 
27 #include "table/sprites.h"
28 
29 #include "safeguards.h"
30 
33 
34 #include "table/landscape_sprite.h"
35 
37 static const SpriteID * const _landscape_spriteindexes[] = {
38  _landscape_spriteindexes_arctic,
39  _landscape_spriteindexes_tropic,
40  _landscape_spriteindexes_toyland,
41 };
42 
50 static uint LoadGrfFile(const char *filename, uint load_index, int file_index)
51 {
52  uint load_index_org = load_index;
53  uint sprite_id = 0;
54 
55  FioOpenFile(file_index, filename, BASESET_DIR);
56 
57  DEBUG(sprite, 2, "Reading grf-file '%s'", filename);
58 
59  byte container_ver = GetGRFContainerVersion();
60  if (container_ver == 0) usererror("Base grf '%s' is corrupt", filename);
61  ReadGRFSpriteOffsets(container_ver);
62  if (container_ver >= 2) {
63  /* Read compression. */
64  byte compression = FioReadByte();
65  if (compression != 0) usererror("Unsupported compression format");
66  }
67 
68  while (LoadNextSprite(load_index, file_index, sprite_id, container_ver)) {
69  load_index++;
70  sprite_id++;
71  if (load_index >= MAX_SPRITES) {
72  usererror("Too many sprites. Recompile with higher MAX_SPRITES value or remove some custom GRF files.");
73  }
74  }
75  DEBUG(sprite, 2, "Currently %i sprites are loaded", load_index);
76 
77  return load_index - load_index_org;
78 }
79 
87 static void LoadGrfFileIndexed(const char *filename, const SpriteID *index_tbl, int file_index)
88 {
89  uint start;
90  uint sprite_id = 0;
91 
92  FioOpenFile(file_index, filename, BASESET_DIR);
93 
94  DEBUG(sprite, 2, "Reading indexed grf-file '%s'", filename);
95 
96  byte container_ver = GetGRFContainerVersion();
97  if (container_ver == 0) usererror("Base grf '%s' is corrupt", filename);
98  ReadGRFSpriteOffsets(container_ver);
99  if (container_ver >= 2) {
100  /* Read compression. */
101  byte compression = FioReadByte();
102  if (compression != 0) usererror("Unsupported compression format");
103  }
104 
105  while ((start = *index_tbl++) != END) {
106  uint end = *index_tbl++;
107 
108  do {
109  bool b = LoadNextSprite(start, file_index, sprite_id, container_ver);
110  assert(b);
111  sprite_id++;
112  } while (++start <= end);
113  }
114 }
115 
122 {
123  if (BaseGraphics::GetUsedSet() == NULL || BaseSounds::GetUsedSet() == NULL) return;
124 
125  const GraphicsSet *used_set = BaseGraphics::GetUsedSet();
126 
127  DEBUG(grf, 1, "Using the %s base graphics set", used_set->name);
128 
129  static const size_t ERROR_MESSAGE_LENGTH = 256;
130  static const size_t MISSING_FILE_MESSAGE_LENGTH = 128;
131 
132  /* Allocate for a message for each missing file and for one error
133  * message per set.
134  */
135  char error_msg[MISSING_FILE_MESSAGE_LENGTH * (GraphicsSet::NUM_FILES + SoundsSet::NUM_FILES) + 2 * ERROR_MESSAGE_LENGTH];
136  error_msg[0] = '\0';
137  char *add_pos = error_msg;
138  const char *last = lastof(error_msg);
139 
140  if (used_set->GetNumInvalid() != 0) {
141  /* Not all files were loaded successfully, see which ones */
142  add_pos += seprintf(add_pos, last, "Trying to load graphics set '%s', but it is incomplete. The game will probably not run correctly until you properly install this set or select another one. See section 4.1 of readme.txt.\n\nThe following files are corrupted or missing:\n", used_set->name);
143  for (uint i = 0; i < GraphicsSet::NUM_FILES; i++) {
145  if (res != MD5File::CR_MATCH) add_pos += seprintf(add_pos, last, "\t%s is %s (%s)\n", used_set->files[i].filename, res == MD5File::CR_MISMATCH ? "corrupt" : "missing", used_set->files[i].missing_warning);
146  }
147  add_pos += seprintf(add_pos, last, "\n");
148  }
149 
150  const SoundsSet *sounds_set = BaseSounds::GetUsedSet();
151  if (sounds_set->GetNumInvalid() != 0) {
152  add_pos += seprintf(add_pos, last, "Trying to load sound set '%s', but it is incomplete. The game will probably not run correctly until you properly install this set or select another one. See section 4.1 of readme.txt.\n\nThe following files are corrupted or missing:\n", sounds_set->name);
153 
154  assert_compile(SoundsSet::NUM_FILES == 1);
155  /* No need to loop each file, as long as there is only a single
156  * sound file. */
157  add_pos += seprintf(add_pos, last, "\t%s is %s (%s)\n", sounds_set->files->filename, SoundsSet::CheckMD5(sounds_set->files, BASESET_DIR) == MD5File::CR_MISMATCH ? "corrupt" : "missing", sounds_set->files->missing_warning);
158  }
159 
160  if (add_pos != error_msg) ShowInfoF("%s", error_msg);
161 }
162 
164 static void LoadSpriteTables()
165 {
166  memset(_palette_remap_grf, 0, sizeof(_palette_remap_grf));
167  uint i = FIRST_GRF_SLOT;
168  const GraphicsSet *used_set = BaseGraphics::GetUsedSet();
169 
170  _palette_remap_grf[i] = (PAL_DOS != used_set->palette);
171  LoadGrfFile(used_set->files[GFT_BASE].filename, 0, i++);
172 
173  /*
174  * The second basic file always starts at the given location and does
175  * contain a different amount of sprites depending on the "type"; DOS
176  * has a few sprites less. However, we do not care about those missing
177  * sprites as they are not shown anyway (logos in intro game).
178  */
179  _palette_remap_grf[i] = (PAL_DOS != used_set->palette);
180  LoadGrfFile(used_set->files[GFT_LOGOS].filename, 4793, i++);
181 
182  /*
183  * Load additional sprites for climates other than temperate.
184  * This overwrites some of the temperate sprites, such as foundations
185  * and the ground sprites.
186  */
187  if (_settings_game.game_creation.landscape != LT_TEMPERATE) {
188  _palette_remap_grf[i] = (PAL_DOS != used_set->palette);
192  i++
193  );
194  }
195 
196  /* Initialize the unicode to sprite mapping table */
198 
199  /*
200  * Load the base and extra NewGRF with OTTD required graphics as first NewGRF.
201  * However, we do not want it to show up in the list of used NewGRFs,
202  * so we have to manually add it, and then remove it later.
203  */
204  GRFConfig *top = _grfconfig;
205 
206  /* Default extra graphics */
207  GRFConfig *master = new GRFConfig("OPENTTD.GRF");
208  master->palette |= GRFP_GRF_DOS;
209  FillGRFDetails(master, false, BASESET_DIR);
210  ClrBit(master->flags, GCF_INIT_ONLY);
211 
212  /* Baseset extra graphics */
213  GRFConfig *extra = new GRFConfig(used_set->files[GFT_EXTRA].filename);
214 
215  /* We know the palette of the base set, so if the base NewGRF is not
216  * setting one, use the palette of the base set and not the global
217  * one which might be the wrong palette for this base NewGRF.
218  * The value set here might be overridden via action14 later. */
219  switch (used_set->palette) {
220  case PAL_DOS: extra->palette |= GRFP_GRF_DOS; break;
221  case PAL_WINDOWS: extra->palette |= GRFP_GRF_WINDOWS; break;
222  default: break;
223  }
224  FillGRFDetails(extra, false, BASESET_DIR);
225  ClrBit(extra->flags, GCF_INIT_ONLY);
226 
227  extra->next = top;
228  master->next = extra;
229  _grfconfig = master;
230 
231  LoadNewGRF(SPR_NEWGRFS_BASE, i, 2);
232 
233  uint total_extra_graphics = SPR_NEWGRFS_BASE - SPR_OPENTTD_BASE;
234  _missing_extra_graphics = GetSpriteCountForSlot(i, SPR_OPENTTD_BASE, SPR_NEWGRFS_BASE);
235  DEBUG(sprite, 1, "%u extra sprites, %u from baseset, %u from fallback", total_extra_graphics, total_extra_graphics - _missing_extra_graphics, _missing_extra_graphics);
236 
237  /* The original baseset extra graphics intentionally make use of the fallback graphics.
238  * Let's say everything which provides less than 500 sprites misses the rest intentionally. */
239  if (500 + _missing_extra_graphics > total_extra_graphics) _missing_extra_graphics = 0;
240 
241  /* Free and remove the top element. */
242  delete extra;
243  delete master;
244  _grfconfig = top;
245 }
246 
247 
252 static bool SwitchNewGRFBlitter()
253 {
254  /* Never switch if the blitter was specified by the user. */
255  if (!_blitter_autodetected) return false;
256 
257  /* Null driver => dedicated server => do nothing. */
258  if (BlitterFactory::GetCurrentBlitter()->GetScreenDepth() == 0) return false;
259 
260  /* Get preferred depth.
261  * - depth_wanted_by_base: Depth required by the baseset, i.e. the majority of the sprites.
262  * - depth_wanted_by_grf: Depth required by some NewGRF.
263  * Both can force using a 32bpp blitter. depth_wanted_by_base is used to select
264  * between multiple 32bpp blitters, which perform differently with 8bpp sprites.
265  */
266  uint depth_wanted_by_base = BaseGraphics::GetUsedSet()->blitter == BLT_32BPP ? 32 : 8;
267  uint depth_wanted_by_grf = _support8bpp == S8BPP_NONE ? 32 : 8;
268  for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
269  if (c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND || HasBit(c->flags, GCF_INIT_ONLY)) continue;
270  if (c->palette & GRFP_BLT_32BPP) depth_wanted_by_grf = 32;
271  }
272 
273  /* Search the best blitter. */
274  static const struct {
275  const char *name;
276  uint animation;
277  uint min_base_depth, max_base_depth, min_grf_depth, max_grf_depth;
278  } replacement_blitters[] = {
279 #ifdef WITH_SSE
280  { "32bpp-sse4", 0, 32, 32, 8, 32 },
281  { "32bpp-ssse3", 0, 32, 32, 8, 32 },
282  { "32bpp-sse2", 0, 32, 32, 8, 32 },
283  { "32bpp-sse4-anim", 1, 32, 32, 8, 32 },
284 #endif
285  { "8bpp-optimized", 2, 8, 8, 8, 8 },
286  { "32bpp-optimized", 0, 8, 32, 8, 32 },
287  { "32bpp-anim", 1, 8, 32, 8, 32 },
288  };
289 
290  const bool animation_wanted = HasBit(_display_opt, DO_FULL_ANIMATION);
291  const char *cur_blitter = BlitterFactory::GetCurrentBlitter()->GetName();
292 
293  for (uint i = 0; i < lengthof(replacement_blitters); i++) {
294  if (animation_wanted && (replacement_blitters[i].animation == 0)) continue;
295  if (!animation_wanted && (replacement_blitters[i].animation == 1)) continue;
296 
297  if (!IsInsideMM(depth_wanted_by_base, replacement_blitters[i].min_base_depth, replacement_blitters[i].max_base_depth + 1)) continue;
298  if (!IsInsideMM(depth_wanted_by_grf, replacement_blitters[i].min_grf_depth, replacement_blitters[i].max_grf_depth + 1)) continue;
299  const char *repl_blitter = replacement_blitters[i].name;
300 
301  if (strcmp(repl_blitter, cur_blitter) == 0) return false;
302  if (BlitterFactory::GetBlitterFactory(repl_blitter) == NULL) continue;
303 
304  DEBUG(misc, 1, "Switching blitter from '%s' to '%s'... ", cur_blitter, repl_blitter);
305  Blitter *new_blitter = BlitterFactory::SelectBlitter(repl_blitter);
306  if (new_blitter == NULL) NOT_REACHED();
307  DEBUG(misc, 1, "Successfully switched to %s.", repl_blitter);
308  break;
309  }
310 
311  if (!VideoDriver::GetInstance()->AfterBlitterChange()) {
312  /* Failed to switch blitter, let's hope we can return to the old one. */
313  if (BlitterFactory::SelectBlitter(cur_blitter) == NULL || !VideoDriver::GetInstance()->AfterBlitterChange()) usererror("Failed to reinitialize video driver. Specify a fixed blitter in the config");
314  }
315 
316  return true;
317 }
318 
321 {
322  if (!SwitchNewGRFBlitter()) return;
323 
324  ClearFontCache();
327 }
328 
331 {
332  DEBUG(sprite, 2, "Loading sprite set %d", _settings_game.game_creation.landscape);
333 
335  ClearFontCache();
336  GfxInitSpriteMem();
338  GfxInitPalettes();
339 
341 }
342 
343 bool GraphicsSet::FillSetDetails(IniFile *ini, const char *path, const char *full_filename)
344 {
345  bool ret = this->BaseSet<GraphicsSet, MAX_GFT, true>::FillSetDetails(ini, path, full_filename, false);
346  if (ret) {
347  IniGroup *metadata = ini->GetGroup("metadata");
348  IniItem *item;
349 
350  fetch_metadata("palette");
351  this->palette = (*item->value == 'D' || *item->value == 'd') ? PAL_DOS : PAL_WINDOWS;
352 
353  /* Get optional blitter information. */
354  item = metadata->GetItem("blitter", false);
355  this->blitter = (item != NULL && *item->value == '3') ? BLT_32BPP : BLT_8BPP;
356  }
357  return ret;
358 }
359 
370 {
371  size_t size = 0;
372  FILE *f = FioFOpenFile(file->filename, "rb", subdir, &size);
373  if (f == NULL) return MD5File::CR_NO_FILE;
374 
375  size_t max = GRFGetSizeOfDataSection(f);
376 
377  FioFCloseFile(f);
378 
379  return file->CheckMD5(subdir, max);
380 }
381 
382 
393 {
394  size_t size;
395  FILE *f = FioFOpenFile(this->filename, "rb", subdir, &size);
396 
397  if (f == NULL) return CR_NO_FILE;
398 
399  size = min(size, max_size);
400 
401  Md5 checksum;
402  uint8 buffer[1024];
403  uint8 digest[16];
404  size_t len;
405 
406  while ((len = fread(buffer, 1, (size > sizeof(buffer)) ? sizeof(buffer) : size, f)) != 0 && size != 0) {
407  size -= len;
408  checksum.Append(buffer, len);
409  }
410 
411  FioFCloseFile(f);
412 
413  checksum.Finish(digest);
414  return memcmp(this->hash, digest, sizeof(this->hash)) == 0 ? CR_MATCH : CR_MISMATCH;
415 }
416 
418 static const char * const _graphics_file_names[] = { "base", "logos", "arctic", "tropical", "toyland", "extra" };
419 
421 template <class T, size_t Tnum_files, bool Tsearch_in_tars>
423 
424 template <class Tbase_set>
426 {
427  if (BaseMedia<Tbase_set>::used_set != NULL) return true;
428 
429  const Tbase_set *best = NULL;
430  for (const Tbase_set *c = BaseMedia<Tbase_set>::available_sets; c != NULL; c = c->next) {
431  /* Skip unusable sets */
432  if (c->GetNumMissing() != 0) continue;
433 
434  if (best == NULL ||
435  (best->fallback && !c->fallback) ||
436  best->valid_files < c->valid_files ||
437  (best->valid_files == c->valid_files && (
438  (best->shortname == c->shortname && best->version < c->version) ||
439  (best->palette != PAL_DOS && c->palette == PAL_DOS)))) {
440  best = c;
441  }
442  }
443 
445  return BaseMedia<Tbase_set>::used_set != NULL;
446 }
447 
448 template <class Tbase_set>
449 /* static */ const char *BaseMedia<Tbase_set>::GetExtension()
450 {
451  return ".obg"; // OpenTTD Base Graphics
452 }
453