OpenTTD Source: src/gfxinit.cpp Source File

OpenTTD Source 13.1

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