OpenTTD
gfxinit.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of OpenTTD.
3  * 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.
4  * 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.
5  * 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/>.
6  */
7 
10 #include "stdafx.h"
11 #include "fios.h"
12 #include "newgrf.h"
13 #include "3rdparty/md5/md5.h"
14 #include "fontcache.h"
15 #include "gfx_func.h"
16 #include "transparency.h"
17 #include "blitter/factory.hpp"
18 #include "video/video_driver.hpp"
19 #include "window_func.h"
20 
21 /* The type of set we're replacing */
22 #define SET_TYPE "graphics"
23 #include "base_media_func.h"
24 
25 #include "table/sprites.h"
26 
27 #include "safeguards.h"
28 
31 
32 #include "table/landscape_sprite.h"
33 
35 static const SpriteID * const _landscape_spriteindexes[] = {
36  _landscape_spriteindexes_arctic,
37  _landscape_spriteindexes_tropic,
38  _landscape_spriteindexes_toyland,
39 };
40 
48 static uint LoadGrfFile(const char *filename, uint load_index, int file_index)
49 {
50  uint load_index_org = load_index;
51  uint sprite_id = 0;
52 
53  FioOpenFile(file_index, filename, BASESET_DIR);
54 
55  DEBUG(sprite, 2, "Reading grf-file '%s'", filename);
56 
57  byte container_ver = GetGRFContainerVersion();
58  if (container_ver == 0) usererror("Base grf '%s' is corrupt", filename);
59  ReadGRFSpriteOffsets(container_ver);
60  if (container_ver >= 2) {
61  /* Read compression. */
62  byte compression = FioReadByte();
63  if (compression != 0) usererror("Unsupported compression format");
64  }
65 
66  while (LoadNextSprite(load_index, file_index, sprite_id, container_ver)) {
67  load_index++;
68  sprite_id++;
69  if (load_index >= MAX_SPRITES) {
70  usererror("Too many sprites. Recompile with higher MAX_SPRITES value or remove some custom GRF files.");
71  }
72  }
73  DEBUG(sprite, 2, "Currently %i sprites are loaded", load_index);
74 
75  return load_index - load_index_org;
76 }
77 
85 static void LoadGrfFileIndexed(const char *filename, const SpriteID *index_tbl, int file_index)
86 {
87  uint start;
88  uint sprite_id = 0;
89 
90  FioOpenFile(file_index, filename, BASESET_DIR);
91 
92  DEBUG(sprite, 2, "Reading indexed grf-file '%s'", filename);
93 
94  byte container_ver = GetGRFContainerVersion();
95  if (container_ver == 0) usererror("Base grf '%s' is corrupt", filename);
96  ReadGRFSpriteOffsets(container_ver);
97  if (container_ver >= 2) {
98  /* Read compression. */
99  byte compression = FioReadByte();
100  if (compression != 0) usererror("Unsupported compression format");
101  }
102 
103  while ((start = *index_tbl++) != END) {
104  uint end = *index_tbl++;
105 
106  do {
107  bool b = LoadNextSprite(start, file_index, sprite_id, container_ver);
108  assert(b);
109  sprite_id++;
110  } while (++start <= end);
111  }
112 }
113 
120 {
121  if (BaseGraphics::GetUsedSet() == nullptr || BaseSounds::GetUsedSet() == nullptr) return;
122 
123  const GraphicsSet *used_set = BaseGraphics::GetUsedSet();
124 
125  DEBUG(grf, 1, "Using the %s base graphics set", used_set->name);
126 
127  static const size_t ERROR_MESSAGE_LENGTH = 256;
128  static const size_t MISSING_FILE_MESSAGE_LENGTH = 128;
129 
130  /* Allocate for a message for each missing file and for one error
131  * message per set.
132  */
133  char error_msg[MISSING_FILE_MESSAGE_LENGTH * (GraphicsSet::NUM_FILES + SoundsSet::NUM_FILES) + 2 * ERROR_MESSAGE_LENGTH];
134  error_msg[0] = '\0';
135  char *add_pos = error_msg;
136  const char *last = lastof(error_msg);
137 
138  if (used_set->GetNumInvalid() != 0) {
139  /* Not all files were loaded successfully, see which ones */
140  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.md.\n\nThe following files are corrupted or missing:\n", used_set->name);
141  for (uint i = 0; i < GraphicsSet::NUM_FILES; i++) {
143  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);
144  }
145  add_pos += seprintf(add_pos, last, "\n");
146  }
147 
148  const SoundsSet *sounds_set = BaseSounds::GetUsedSet();
149  if (sounds_set->GetNumInvalid() != 0) {
150  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.md.\n\nThe following files are corrupted or missing:\n", sounds_set->name);
151 
152  assert_compile(SoundsSet::NUM_FILES == 1);
153  /* No need to loop each file, as long as there is only a single
154  * sound file. */
155  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);
156  }
157 
158  if (add_pos != error_msg) ShowInfoF("%s", error_msg);
159 }
160 
162 static void LoadSpriteTables()
163 {
164  memset(_palette_remap_grf, 0, sizeof(_palette_remap_grf));
165  uint i = FIRST_GRF_SLOT;
166  const GraphicsSet *used_set = BaseGraphics::GetUsedSet();
167 
168  _palette_remap_grf[i] = (PAL_DOS != used_set->palette);
169  LoadGrfFile(used_set->files[GFT_BASE].filename, 0, i++);
170 
171  /*
172  * The second basic file always starts at the given location and does
173  * contain a different amount of sprites depending on the "type"; DOS
174  * has a few sprites less. However, we do not care about those missing
175  * sprites as they are not shown anyway (logos in intro game).
176  */
177  _palette_remap_grf[i] = (PAL_DOS != used_set->palette);
178  LoadGrfFile(used_set->files[GFT_LOGOS].filename, 4793, i++);
179 
180  /*
181  * Load additional sprites for climates other than temperate.
182  * This overwrites some of the temperate sprites, such as foundations
183  * and the ground sprites.
184  */
185  if (_settings_game.game_creation.landscape != LT_TEMPERATE) {
186  _palette_remap_grf[i] = (PAL_DOS != used_set->palette);
190  i++
191  );
192  }
193 
194  /* Initialize the unicode to sprite mapping table */
196 
197  /*
198  * Load the base and extra NewGRF with OTTD required graphics as first NewGRF.
199  * However, we do not want it to show up in the list of used NewGRFs,
200  * so we have to manually add it, and then remove it later.
201  */
202  GRFConfig *top = _grfconfig;
203 
204  /* Default extra graphics */
205  GRFConfig *master = new GRFConfig("OPENTTD.GRF");
206  master->palette |= GRFP_GRF_DOS;
207  FillGRFDetails(master, false, BASESET_DIR);
208  ClrBit(master->flags, GCF_INIT_ONLY);
209 
210  /* Baseset extra graphics */
211  GRFConfig *extra = new GRFConfig(used_set->files[GFT_EXTRA].filename);
212 
213  /* We know the palette of the base set, so if the base NewGRF is not
214  * setting one, use the palette of the base set and not the global
215  * one which might be the wrong palette for this base NewGRF.
216  * The value set here might be overridden via action14 later. */
217  switch (used_set->palette) {
218  case PAL_DOS: extra->palette |= GRFP_GRF_DOS; break;
219  case PAL_WINDOWS: extra->palette |= GRFP_GRF_WINDOWS; break;
220  default: break;
221  }
222  FillGRFDetails(extra, false, BASESET_DIR);
223  ClrBit(extra->flags, GCF_INIT_ONLY);
224 
225  extra->next = top;
226  master->next = extra;
227  _grfconfig = master;
228 
229  LoadNewGRF(SPR_NEWGRFS_BASE, i, 2);
230 
231  uint total_extra_graphics = SPR_NEWGRFS_BASE - SPR_OPENTTD_BASE;
232  _missing_extra_graphics = GetSpriteCountForSlot(i, SPR_OPENTTD_BASE, SPR_NEWGRFS_BASE);
233  DEBUG(sprite, 1, "%u extra sprites, %u from baseset, %u from fallback", total_extra_graphics, total_extra_graphics - _missing_extra_graphics, _missing_extra_graphics);
234 
235  /* The original baseset extra graphics intentionally make use of the fallback graphics.
236  * Let's say everything which provides less than 500 sprites misses the rest intentionally. */
237  if (500 + _missing_extra_graphics > total_extra_graphics) _missing_extra_graphics = 0;
238 
239  /* Free and remove the top element. */
240  delete extra;
241  delete master;
242  _grfconfig = top;
243 }
244 
245 
250 static bool SwitchNewGRFBlitter()
251 {
252  /* Never switch if the blitter was specified by the user. */
253  if (!_blitter_autodetected) return false;
254 
255  /* Null driver => dedicated server => do nothing. */
256  if (BlitterFactory::GetCurrentBlitter()->GetScreenDepth() == 0) return false;
257 
258  /* Get preferred depth.
259  * - depth_wanted_by_base: Depth required by the baseset, i.e. the majority of the sprites.
260  * - depth_wanted_by_grf: Depth required by some NewGRF.
261  * Both can force using a 32bpp blitter. depth_wanted_by_base is used to select
262  * between multiple 32bpp blitters, which perform differently with 8bpp sprites.
263  */
264  uint depth_wanted_by_base = BaseGraphics::GetUsedSet()->blitter == BLT_32BPP ? 32 : 8;
265  uint depth_wanted_by_grf = _support8bpp == S8BPP_NONE ? 32 : 8;
266  for (GRFConfig *c = _grfconfig; c != nullptr; c = c->next) {
267  if (c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND || HasBit(c->flags, GCF_INIT_ONLY)) continue;
268  if (c->palette & GRFP_BLT_32BPP) depth_wanted_by_grf = 32;
269  }
270 
271  /* Search the best blitter. */
272  static const struct {
273  const char *name;
274  uint animation;
275  uint min_base_depth, max_base_depth, min_grf_depth, max_grf_depth;
276  } replacement_blitters[] = {
277 #ifdef WITH_SSE
278  { "32bpp-sse4", 0, 32, 32, 8, 32 },
279  { "32bpp-ssse3", 0, 32, 32, 8, 32 },
280  { "32bpp-sse2", 0, 32, 32, 8, 32 },
281  { "32bpp-sse4-anim", 1, 32, 32, 8, 32 },
282 #endif
283  { "8bpp-optimized", 2, 8, 8, 8, 8 },
284  { "32bpp-optimized", 0, 8, 32, 8, 32 },
285 #ifdef WITH_SSE
286  { "32bpp-sse2-anim", 1, 8, 32, 8, 32 },
287 #endif
288  { "32bpp-anim", 1, 8, 32, 8, 32 },
289  };
290 
291  const bool animation_wanted = HasBit(_display_opt, DO_FULL_ANIMATION);
292  const char *cur_blitter = BlitterFactory::GetCurrentBlitter()->GetName();
293 
295 
296  for (uint i = 0; i < lengthof(replacement_blitters); i++) {
297  if (animation_wanted && (replacement_blitters[i].animation == 0)) continue;
298  if (!animation_wanted && (replacement_blitters[i].animation == 1)) continue;
299 
300  if (!IsInsideMM(depth_wanted_by_base, replacement_blitters[i].min_base_depth, replacement_blitters[i].max_base_depth + 1)) continue;
301  if (!IsInsideMM(depth_wanted_by_grf, replacement_blitters[i].min_grf_depth, replacement_blitters[i].max_grf_depth + 1)) continue;
302  const char *repl_blitter = replacement_blitters[i].name;
303 
304  if (strcmp(repl_blitter, cur_blitter) == 0) {
306  return false;
307  }
308  if (BlitterFactory::GetBlitterFactory(repl_blitter) == nullptr) continue;
309 
310  DEBUG(misc, 1, "Switching blitter from '%s' to '%s'... ", cur_blitter, repl_blitter);
311  Blitter *new_blitter = BlitterFactory::SelectBlitter(repl_blitter);
312  if (new_blitter == nullptr) NOT_REACHED();
313  DEBUG(misc, 1, "Successfully switched to %s.", repl_blitter);
314  break;
315  }
316 
317  if (!VideoDriver::GetInstance()->AfterBlitterChange()) {
318  /* Failed to switch blitter, let's hope we can return to the old one. */
319  if (BlitterFactory::SelectBlitter(cur_blitter) == nullptr || !VideoDriver::GetInstance()->AfterBlitterChange()) usererror("Failed to reinitialize video driver. Specify a fixed blitter in the config");
320  }
321 
323 
324  return true;
325 }
326 
329 {
330  if (!SwitchNewGRFBlitter()) return;
331 
332  ClearFontCache();
335 }
336 
339 {
340  DEBUG(sprite, 2, "Loading sprite set %d", _settings_game.game_creation.landscape);
341 
343  ClearFontCache();
344  GfxInitSpriteMem();
346  GfxInitPalettes();
347 
349 }
350 
351 bool GraphicsSet::FillSetDetails(IniFile *ini, const char *path, const char *full_filename)
352 {
353  bool ret = this->BaseSet<GraphicsSet, MAX_GFT, true>::FillSetDetails(ini, path, full_filename, false);
354  if (ret) {
355  IniGroup *metadata = ini->GetGroup("metadata");
356  IniItem *item;
357 
358  fetch_metadata("palette");
359  this->palette = (*item->value == 'D' || *item->value == 'd') ? PAL_DOS : PAL_WINDOWS;
360 
361  /* Get optional blitter information. */
362  item = metadata->GetItem("blitter", false);
363  this->blitter = (item != nullptr && *item->value == '3') ? BLT_32BPP : BLT_8BPP;
364  }
365  return ret;
366 }
367 
378 {
379  size_t size = 0;
380  FILE *f = FioFOpenFile(file->filename, "rb", subdir, &size);
381  if (f == nullptr) return MD5File::CR_NO_FILE;
382 
383  size_t max = GRFGetSizeOfDataSection(f);
384 
385  FioFCloseFile(f);
386 
387  return file->CheckMD5(subdir, max);
388 }
389 
390 
401 {
402  size_t size;
403  FILE *f = FioFOpenFile(this->filename, "rb", subdir, &size);
404 
405  if (f == nullptr) return CR_NO_FILE;
406 
407  size = min(size, max_size);
408 
409  Md5 checksum;
410  uint8 buffer[1024];
411  uint8 digest[16];
412  size_t len;
413 
414  while ((len = fread(buffer, 1, (size > sizeof(buffer)) ? sizeof(buffer) : size, f)) != 0 && size != 0) {
415  size -= len;
416  checksum.Append(buffer, len);
417  }
418 
419  FioFCloseFile(f);
420 
421  checksum.Finish(digest);
422  return memcmp(this->hash, digest, sizeof(this->hash)) == 0 ? CR_MATCH : CR_MISMATCH;
423 }
424 
426 static const char * const _graphics_file_names[] = { "base", "logos", "arctic", "tropical", "toyland", "extra" };
427 
429 template <class T, size_t Tnum_files, bool Tsearch_in_tars>
431 
432 template <class Tbase_set>
434 {
435  if (BaseMedia<Tbase_set>::used_set != nullptr) return true;
436 
437  const Tbase_set *best = nullptr;
438  for (const Tbase_set *c = BaseMedia<Tbase_set>::available_sets; c != nullptr; c = c->next) {
439  /* Skip unusable sets */
440  if (c->GetNumMissing() != 0) continue;
441 
442  if (best == nullptr ||
443  (best->fallback && !c->fallback) ||
444  best->valid_files < c->valid_files ||
445  (best->valid_files == c->valid_files && (
446  (best->shortname == c->shortname && best->version < c->version) ||
447  (best->palette != PAL_DOS && c->palette == PAL_DOS)))) {
448  best = c;
449  }
450  }
451 
453  return BaseMedia<Tbase_set>::used_set != nullptr;
454 }
455 
456 template <class Tbase_set>
457 /* static */ const char *BaseMedia<Tbase_set>::GetExtension()
458 {
459  return ".obg"; // OpenTTD Base Graphics
460 }
461 
First slot usable for (New)GRFs used during the game.
Definition: fios.h:97
A group within an ini file.
Definition: ini_type.h:36
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:79
Base of all video drivers.
bool _blitter_autodetected
Was the blitter autodetected or specified by the user?
Definition: driver.cpp:29
GRFConfig * _grfconfig
First item in list of current GRF set up.
byte landscape
the landscape we&#39;re currently in
Subdirectory
The different kinds of subdirectories OpenTTD uses.
Definition: fileio_type.h:108
Generic function implementations for base data (graphics, sounds).
size_t GRFGetSizeOfDataSection(FILE *f)
Get the data section size of a GRF.
void FioFCloseFile(FILE *f)
Close a file in a safe way.
Definition: fileio.cpp:332
GRF file is processed up to GLS_INIT.
Definition: newgrf_config.h:27
byte _display_opt
What do we want to draw/do?
virtual void ReleaseBlitterLock()
Release any lock(s) required to be held when changing blitters.
int CDECL seprintf(char *str, const char *last, const char *format,...)
Safer implementation of snprintf; same as snprintf except:
Definition: string.cpp:407
Structure holding filename and MD5 information about a single file.
int GetNumInvalid() const
Get the number of invalid files.
The file did not exist.
static const char * GetExtension()
Get the extension that is used to identify this set.
Definition: gfxinit.cpp:457
The NewGRF prefers a 32 bpp blitter.
Definition: newgrf_config.h:76
uint _missing_extra_graphics
Number of sprites provided by the fallback extra GRF, i.e. missing in the baseset.
static bool SwitchNewGRFBlitter()
Check blitter needed by NewGRF config and switch if needed.
Definition: gfxinit.cpp:250
void CheckExternalFiles()
Checks whether the MD5 checksums of the files are correct.
Definition: gfxinit.cpp:119
Use the Windows palette.
Definition: gfx_type.h:290
static void LoadSpriteTables()
Actually load the sprite tables.
Definition: gfxinit.cpp:162
Base set has both 8 bpp and 32 bpp sprites.
PaletteType palette
Palette of this graphics set.
Maximum number of slots.
Definition: fios.h:99
Use the DOS palette.
Definition: gfx_type.h:289
Maximum number of sprites that can be loaded at a given time.
Definition: sprites.h:1536
#define lastof(x)
Get the last element of an fixed size array.
Definition: depend.cpp:48
IniGroup * GetGroup(const char *name, size_t len=0, bool create_new=true)
Get the group with the given name.
Definition: ini_load.cpp:154
GRF file was not found in the local cache.
Definition: newgrf_config.h:36
MD5File files[NUM_FILES]
All files part of this set.
How all blitters should look like.
Definition: base.hpp:28
Base set has 8 bpp sprites only.
void LoadNewGRF(uint load_index, uint file_index, uint num_baseset)
Load all the NewGRFs.
Definition: newgrf.cpp:9748
Subdirectory for all base data (base sets, intro game)
Definition: fileio_type.h:116
static T max(const T a, const T b)
Returns the maximum of two values.
Definition: math_func.hpp:24
byte FioReadByte()
Read a byte from the file.
Definition: fileio.cpp:131
static void InitializeUnicodeGlyphMap()
Initialize the glyph map.
Definition: fontcache.h:179
virtual const char * GetName()=0
Get the name of the blitter, the same as the Factory-instance returns.
static const char *const _graphics_file_names[]
Names corresponding to the GraphicsFileType.
Definition: gfxinit.cpp:426
GRF file is disabled.
Definition: newgrf_config.h:35
struct GRFConfig * next
NOSAVE: Next item in the linked list.
Base sprites for all climates.
The file did exist, just the md5 checksum did not match.
A single "line" in an ini file.
Definition: ini_type.h:23
const char * missing_warning
warning when this file is missing
Landscape replacement sprites for arctic.
void CDECL ShowInfoF(const char *str,...)
Shows some information on the console/a popup box depending on the OS.
Definition: openttd.cpp:134
bool FillGRFDetails(GRFConfig *config, bool is_static, Subdirectory subdir)
Find the GRFID of a given grf, and calculate its md5sum.
Functions to read fonts from files and cache them.
static bool IsInsideMM(const T x, const size_t min, const size_t max)
Checks if a value is in an interval.
Definition: math_func.hpp:264
void ReadGRFSpriteOffsets(byte container_version)
Parse the sprite section of GRFs.
const char * filename
filename
Information about GRF, used in the game and (part of it) in savegames.
static Blitter * SelectBlitter(const char *name)
Find the requested blitter and return his class.
Definition: factory.hpp:94
const char * name
The name of the base set.
Functions related to the gfx engine.
static uint LoadGrfFile(const char *filename, uint load_index, int file_index)
Load an old fashioned GRF file.
Definition: gfxinit.cpp:48
FILE * FioFOpenFile(const char *filename, const char *mode, Subdirectory subdir, size_t *filesize)
Opens a OpenTTD file somewhere in a personal or global directory.
Definition: fileio.cpp:463
Definition of base types and functions in a cross-platform compatible way.
Extra sprites that were not part of the original sprites.
void CDECL usererror(const char *s,...)
Error handling for fatal user errors.
Definition: openttd.cpp:92
A number of safeguards to prevent using unsafe methods.
Offsets of sprites to replace for non-temperate landscapes.
uint8 flags
NOSAVE: GCF_Flags, bitset.
char * value
The value of this item.
Definition: ini_type.h:26
virtual void AcquireBlitterLock()
Acquire any lock(s) required to be held when changing blitters.
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:40
void GfxClearSpriteCache()
Remove all encoded sprites from the sprite cache without discarding sprite location information...
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
Definition: factory.hpp:145
#define fetch_metadata(name)
Try to read a single piece of metadata and return false if it doesn&#39;t exist.
static T min(const T a, const T b)
Returns the minimum of two values.
Definition: math_func.hpp:40
BlitterType blitter
Blitter of this graphics set.
Base for all base media (graphics, sounds)
ChecksumResult CheckMD5(Subdirectory subdir, size_t max_size) const
Calculate and check the MD5 hash of the supplied filename.
Definition: gfxinit.cpp:400
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:35
void FioOpenFile(int slot, const char *filename, Subdirectory subdir)
Open a slotted file.
Definition: fileio.cpp:248
The NewGRF says the Windows palette can be used.
Definition: newgrf_config.h:71
No support for 8bpp by OS or hardware, force 32bpp blitters.
Definition: gfx_type.h:316
void ReInitAllWindows()
Re-initialize all windows.
Definition: window.cpp:3451
Ini file that supports both loading and saving.
Definition: ini_type.h:86
static T ClrBit(T &x, const uint8 y)
Clears a bit in a variable.
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
void UpdateCursorSize()
Update cursor dimension.
Definition: gfx.cpp:1531
Declarations for savegames operations.
The file did exist and the md5 checksum did match.
uint8 palette
GRFPalette, bitset.
static VideoDriver * GetInstance()
Get the currently active instance of the video driver.
Functions related to transparency.
bool FillSetDetails(IniFile *ini, const char *path, const char *full_filename, bool allow_empty_filename=true)
Read the set information from a loaded ini.
All data of a sounds set.
#define INSTANTIATE_BASE_MEDIA_METHODS(repl_type, set_type)
Force instantiation of methods so we don&#39;t get linker errors.
All data of a graphics set.
ChecksumResult
The result of a checksum check.
IniItem * GetItem(const char *name, bool create)
Get the item with the given name, and if it doesn&#39;t exist and create is true it creates a new item...
Definition: ini_load.cpp:103
bool LoadNextSprite(int load_index, byte file_slot, uint file_sprite_id, byte container_version)
Load a real or recolour sprite.
static const SpriteID SPR_OPENTTD_BASE
Extra graphic spritenumbers.
Definition: sprites.h:56
static void LoadGrfFileIndexed(const char *filename, const SpriteID *index_tbl, int file_index)
Load an old fashioned GRF file to replace already loaded sprites.
Definition: gfxinit.cpp:85
Information about a single base set.
uint GetSpriteCountForSlot(uint file_slot, SpriteID begin, SpriteID end)
Count the sprites which originate from a specific file slot in a range of SpriteIDs.
The NewGRF says the DOS palette can be used.
Definition: newgrf_config.h:70
byte GetGRFContainerVersion()
Get the container version of the currently opened GRF file.
Definition: newgrf.cpp:9315
Perform palette animation.
Definition: openttd.h:44
static const SpriteID *const _landscape_spriteindexes[]
Offsets for loading the different "replacement" sprites in the files.
Definition: gfxinit.cpp:35
static BlitterFactory * GetBlitterFactory(const char *name)
Get the blitter factory with the given name.
Definition: factory.hpp:112
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Logos, landscape icons and original terrain generator sprites.
static MD5File::ChecksumResult CheckMD5(const MD5File *file, Subdirectory subdir)
Calculate and check the MD5 hash of the supplied file.
GameCreationSettings game_creation
settings used during the creation of a game (map)
Window functions not directly related to making/drawing windows.
bool _palette_remap_grf[MAX_FILE_SLOTS]
Whether the given NewGRFs must get a palette remap from windows to DOS or not.
Definition: gfxinit.cpp:30
void CheckBlitter()
Check whether we still use the right blitter, or use another (better) one.
Definition: gfxinit.cpp:328
This file contains all sprite-related enums and defines.
Factory to &#39;query&#39; all available blitters.
static const GraphicsSet * GetUsedSet()
Return the used set.
static bool DetermineBestSet()
Determine the graphics pack that has to be used.
Definition: gfxinit.cpp:433
static MD5File::ChecksumResult CheckMD5(const MD5File *file, Subdirectory subdir)
Calculate and check the MD5 hash of the supplied GRF.
Definition: gfxinit.cpp:377
static const size_t NUM_FILES
Number of files in this set.
void GfxLoadSprites()
Initialise and load all the sprites.
Definition: gfxinit.cpp:338
Base for the NewGRF implementation.