OpenTTD Source 20261112-master-gbcbec5e63f
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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
6 */
7
9
10#include "stdafx.h"
11#include "newgrf.h"
12#include "newgrf_config.h"
13#include "3rdparty/md5/md5.h"
14#include "fontcache.h"
15#include "gfx_func.h"
16#include "spritecache.h"
17#include "transparency.h"
18#include "blitter/factory.hpp"
20#include "window_func.h"
21#include "palette_func.h"
22#include "base_media_func.h"
23#include "base_media_graphics.h"
24#include "base_media_sounds.h"
25
26#include "table/sprites.h"
27
28#include "safeguards.h"
29
31
33static constexpr std::span<const std::pair<SpriteID, SpriteID>> _landscape_spriteindexes[] = {
34 _landscape_spriteindexes_arctic,
35 _landscape_spriteindexes_tropic,
36 _landscape_spriteindexes_toyland,
37};
38
46static uint LoadGrfFile(const std::string &filename, SpriteID load_index, bool needs_palette_remap)
47{
48 SpriteID load_index_org = load_index;
49 SpriteID sprite_id = 0;
50
51 SpriteFile &file = OpenCachedSpriteFile(filename, Subdirectory::Baseset, needs_palette_remap);
52
53 Debug(Facility::Sprite, Severity::Warning, "Reading grf-file '{}'", filename);
54
55 uint8_t container_ver = file.GetContainerVersion();
56 if (container_ver == 0) UserError("Base grf '{}' is corrupt", filename);
58 if (container_ver >= 2) {
59 /* Read compression. */
60 uint8_t compression = file.ReadByte();
61 if (compression != 0) UserError("Unsupported compression format");
62 }
63
64 while (LoadNextSprite(load_index, file, sprite_id)) {
65 load_index++;
66 sprite_id++;
67 if (load_index >= MAX_SPRITES) {
68 UserError("Too many sprites. Recompile with higher MAX_SPRITES value or remove some custom GRF files.");
69 }
70 }
71 Debug(Facility::Sprite, Severity::Warning, "Currently {} sprites are loaded", load_index);
72
73 return load_index - load_index_org;
74}
75
82static void LoadGrfFileIndexed(const std::string &filename, std::span<const std::pair<SpriteID, SpriteID>> index_tbl, bool needs_palette_remap)
83{
84 uint sprite_id = 0;
85
86 SpriteFile &file = OpenCachedSpriteFile(filename, Subdirectory::Baseset, needs_palette_remap);
87
88 Debug(Facility::Sprite, Severity::Warning, "Reading indexed grf-file '{}'", filename);
89
90 uint8_t container_ver = file.GetContainerVersion();
91 if (container_ver == 0) UserError("Base grf '{}' is corrupt", filename);
93 if (container_ver >= 2) {
94 /* Read compression. */
95 uint8_t compression = file.ReadByte();
96 if (compression != 0) UserError("Unsupported compression format");
97 }
98
99 for (const auto &pair : index_tbl) {
100 for (SpriteID load_index = pair.first; load_index <= pair.second; ++load_index) {
101 [[maybe_unused]] bool b = LoadNextSprite(load_index, file, sprite_id);
102 assert(b);
103 sprite_id++;
104 }
105 }
106}
107
114{
115 if (BaseGraphics::GetUsedSet() == nullptr || BaseSounds::GetUsedSet() == nullptr) return;
116
117 const GraphicsSet *used_set = BaseGraphics::GetUsedSet();
118
119 Debug(Facility::Grf, Severity::Error, "Using the {} base graphics set", used_set->name);
120
121 std::string error_msg;
122 auto output_iterator = std::back_inserter(error_msg);
123 if (used_set->GetNumInvalid() != 0) {
124 /* Not all files were loaded successfully, see which ones */
125 fmt::format_to(output_iterator, "Trying to load graphics set '{}', but it is incomplete. The game will probably not run correctly until you properly install this set or select another one. See section 1.4 of README.md.\n\nThe following files are corrupted or missing:\n", used_set->name);
126 for (const auto &file : used_set->files) {
128 if (res != MD5File::ChecksumResult::Match) fmt::format_to(output_iterator, "\t{} is {} ({})\n", file.filename, res == MD5File::ChecksumResult::Mismatch ? "corrupt" : "missing", file.missing_warning);
129 }
130 fmt::format_to(output_iterator, "\n");
131 }
132
133 const SoundsSet *sounds_set = BaseSounds::GetUsedSet();
134 if (sounds_set->GetNumInvalid() != 0) {
135 fmt::format_to(output_iterator, "Trying to load sound set '{}', but it is incomplete. The game will probably not run correctly until you properly install this set or select another one. See section 1.4 of README.md.\n\nThe following files are corrupted or missing:\n", sounds_set->name);
136
137 static_assert(SoundsSet::NUM_FILES == 1);
138 /* No need to loop each file, as long as there is only a single
139 * sound file. */
140 fmt::format_to(output_iterator, "\t{} is {} ({})\n", sounds_set->files[0].filename, SoundsSet::CheckMD5(&sounds_set->files[0], Subdirectory::Baseset) == MD5File::ChecksumResult::Mismatch ? "corrupt" : "missing", sounds_set->files[0].missing_warning);
141 }
142
143 if (!error_msg.empty()) ShowInfoI(error_msg);
144}
145
150static std::unique_ptr<GRFConfig> GetDefaultExtraGRFConfig()
151{
152 auto gc = std::make_unique<GRFConfig>("OPENTTD.GRF");
153 gc->palette |= GRFP_GRF_DOS;
155 gc->flags.Reset(GRFConfigFlag::InitOnly);
156 return gc;
157}
158
163static std::unique_ptr<GRFConfig> GetBasesetExtraGRFConfig()
164{
165 auto gc = std::make_unique<GRFConfig>(BaseGraphics::GetUsedSet()->GetOrCreateExtraConfig());
166 if (gc->param.empty()) gc->SetParameterDefaults();
167 gc->flags.Reset(GRFConfigFlag::InitOnly);
168 return gc;
169}
170
172static void LoadSpriteTables()
173{
174 const GraphicsSet *used_set = BaseGraphics::GetUsedSet();
175
176 LoadGrfFile(used_set->files[to_underlying(GraphicsFileType::Base)].filename, 0, PaletteType::DOS != used_set->palette);
177
178 /*
179 * The second basic file always starts at the given location and does
180 * contain a different amount of sprites depending on the "type"; DOS
181 * has a few sprites less. However, we do not care about those missing
182 * sprites as they are not shown anyway (logos in intro game).
183 */
184 LoadGrfFile(used_set->files[to_underlying(GraphicsFileType::Logos)].filename, 4793, PaletteType::DOS != used_set->palette);
185
186 /*
187 * Load additional sprites for climates other than temperate.
188 * This overwrites some of the temperate sprites, such as foundations
189 * and the ground sprites.
190 */
191 if (_settings_game.game_creation.landscape != LandscapeType::Temperate) {
193 used_set->files[to_underlying(GraphicsFileType::Arctic) + to_underlying(_settings_game.game_creation.landscape) - 1].filename,
194 _landscape_spriteindexes[to_underlying(_settings_game.game_creation.landscape) - 1],
195 PaletteType::DOS != used_set->palette
196 );
197 }
198
199 /* Initialize the unicode to sprite mapping table */
201
202 /*
203 * Load the base and extra NewGRF with OTTD required graphics as first NewGRF.
204 * However, we do not want it to show up in the list of used NewGRFs,
205 * so we have to manually add it, and then remove it later.
206 */
207
208 auto default_extra = GetDefaultExtraGRFConfig();
209 auto baseset_extra = GetBasesetExtraGRFConfig();
210 std::string default_filename = default_extra->filename;
211
212 _grfconfig.insert(std::begin(_grfconfig), std::move(default_extra));
213 _grfconfig.insert(std::next(std::begin(_grfconfig)), std::move(baseset_extra));
214
216
217 uint total_extra_graphics = SPR_NEWGRFS_BASE - SPR_OPENTTD_BASE;
218 Debug(Facility::Sprite, Severity::Info, "Checking sprites from fallback grf");
220 Debug(Facility::Sprite, Severity::Error, "{} extra sprites, {} from baseset, {} from fallback", total_extra_graphics, total_extra_graphics - _missing_extra_graphics, _missing_extra_graphics);
221
222 /* The original baseset extra graphics intentionally make use of the fallback graphics.
223 * Let's say everything which provides less than 500 sprites misses the rest intentionally. */
224 if (500 + _missing_extra_graphics > total_extra_graphics) _missing_extra_graphics = 0;
225
226 /* Remove the default and baseset extra graphics from the config. */
227 _grfconfig.erase(std::begin(_grfconfig), std::next(std::begin(_grfconfig), 2));
228}
229
230
231static void RealChangeBlitter(std::string_view repl_blitter)
232{
233 std::string_view cur_blitter = BlitterFactory::GetCurrentBlitter()->GetName();
234 if (cur_blitter == repl_blitter) return;
235
236 Debug(Facility::Driver, Severity::Error, "Switching blitter from '{}' to '{}'... ", cur_blitter, repl_blitter);
237 Blitter *new_blitter = BlitterFactory::SelectBlitter(repl_blitter);
238 if (new_blitter == nullptr) NOT_REACHED();
239 Debug(Facility::Driver, Severity::Error, "Successfully switched to {}.", repl_blitter);
240
241 if (!VideoDriver::GetInstance()->AfterBlitterChange()) {
242 /* Failed to switch blitter, let's hope we can return to the old one. */
243 if (BlitterFactory::SelectBlitter(cur_blitter) == nullptr || !VideoDriver::GetInstance()->AfterBlitterChange()) UserError("Failed to reinitialize video driver. Specify a fixed blitter in the config");
244 }
245
246 /* Clear caches that might have sprites for another blitter. */
250 ReInitAllWindows(false);
251}
252
258{
259 /* Never switch if the blitter was specified by the user. */
260 if (!_blitter_autodetected) return false;
261
262 /* Null driver => dedicated server => do nothing. */
263 if (BlitterFactory::GetCurrentBlitter()->GetScreenDepth() == 0) return false;
264
265 /* Get preferred depth.
266 * - depth_wanted_by_base: Depth required by the baseset, i.e. the majority of the sprites.
267 * - depth_wanted_by_grf: Depth required by some NewGRF.
268 * Both can force using a 32bpp blitter. depth_wanted_by_base is used to select
269 * between multiple 32bpp blitters, which perform differently with 8bpp sprites.
270 */
271 uint depth_wanted_by_base = BaseGraphics::GetUsedSet()->blitter == BLT_32BPP ? 32 : 8;
272 uint depth_wanted_by_grf = _support8bpp != Support8bpp::None ? 8 : 32;
273 for (const auto &c : _grfconfig) {
274 if (c->status == GRFStatus::Disabled || c->status == GRFStatus::NotFound || c->flags.Test(GRFConfigFlag::InitOnly)) continue;
275 if (c->palette & GRFP_BLT_32BPP) depth_wanted_by_grf = 32;
276 }
277 /* We need a 32bpp blitter for font anti-alias. */
278 if (GetFontAAState()) depth_wanted_by_grf = 32;
279
280 /* Search the best blitter. */
281 static const struct {
282 const std::string_view name;
283 uint animation;
284 uint min_base_depth, max_base_depth, min_grf_depth, max_grf_depth;
285 } replacement_blitters[] = {
286 { "8bpp-optimized", 2, 8, 8, 8, 8 },
287 { "40bpp-anim", 2, 8, 32, 8, 32 },
288#ifdef WITH_SSE
289 { "32bpp-sse4", 0, 32, 32, 8, 32 },
290 { "32bpp-ssse3", 0, 32, 32, 8, 32 },
291 { "32bpp-sse2", 0, 32, 32, 8, 32 },
292 { "32bpp-sse4-anim", 1, 32, 32, 8, 32 },
293#endif
294 { "32bpp-optimized", 0, 8, 32, 8, 32 },
295#ifdef WITH_SSE
296 { "32bpp-sse2-anim", 1, 8, 32, 8, 32 },
297#endif
298 { "32bpp-anim", 1, 8, 32, 8, 32 },
299 };
300
301 const bool animation_wanted = _display_opt.Test(DisplayOption::FullAnimation);
302 std::string_view cur_blitter = BlitterFactory::GetCurrentBlitter()->GetName();
303
304 for (const auto &replacement_blitter : replacement_blitters) {
305 if (animation_wanted && (replacement_blitter.animation == 0)) continue;
306 if (!animation_wanted && (replacement_blitter.animation == 1)) continue;
307
308 if (!IsInsideMM(depth_wanted_by_base, replacement_blitter.min_base_depth, replacement_blitter.max_base_depth + 1)) continue;
309 if (!IsInsideMM(depth_wanted_by_grf, replacement_blitter.min_grf_depth, replacement_blitter.max_grf_depth + 1)) continue;
310
311 if (replacement_blitter.name == cur_blitter) {
312 return false;
313 }
314 if (BlitterFactory::GetBlitterFactory(replacement_blitter.name) == nullptr) continue;
315
316 /* Inform the video driver we want to switch blitter as soon as possible. */
317 VideoDriver::GetInstance()->QueueOnMainThread(std::bind(&RealChangeBlitter, replacement_blitter.name));
318 break;
319 }
320
321 return true;
322}
323
333
336{
337 Debug(Facility::Sprite, Severity::Warning, "Loading sprite set {}", _settings_game.game_creation.landscape);
338
342 GfxInitSpriteMem();
344 GfxInitPalettes();
345
347}
348
349/* instantiate here, because unique_ptr needs a complete type */
350GraphicsSet::GraphicsSet() = default;
351
352/* instantiate here, because unique_ptr needs a complete type */
353GraphicsSet::~GraphicsSet() = default;
354
355bool GraphicsSet::FillSetDetails(const IniFile &ini, const std::string &path, const std::string &full_filename)
356{
357 if (!this->BaseSet<GraphicsSet>::FillSetDetails(ini, path, full_filename, false)) return false;
358
359 const IniGroup *metadata = ini.GetGroup("metadata");
360 assert(metadata != nullptr); /* already checked by the inherited FillSetDetails. */
361 const IniItem *item;
362
363 item = this->GetMandatoryItem(full_filename, *metadata, "palette");
364 if (item == nullptr) return false;
365 this->palette = ((*item->value)[0] == 'D' || (*item->value)[0] == 'd') ? PaletteType::DOS : PaletteType::Windows;
366
367 /* Get optional blitter information. */
368 item = metadata->GetItem("blitter");
369 this->blitter = (item != nullptr && (*item->value)[0] == '3') ? BLT_32BPP : BLT_8BPP;
370
371 return true;
372}
373
379{
380 if (!this->extra_cfg) {
381 this->extra_cfg = std::make_unique<GRFConfig>(this->files[to_underlying(GraphicsFileType::Extra)].filename);
382
383 /* We know the palette of the base set, so if the base NewGRF is not
384 * setting one, use the palette of the base set and not the global
385 * one which might be the wrong palette for this base NewGRF.
386 * The value set here might be overridden via action14 later. */
387 switch (this->palette) {
388 case PaletteType::DOS: this->extra_cfg->palette |= GRFP_GRF_DOS; break;
389 case PaletteType::Windows: this->extra_cfg->palette |= GRFP_GRF_WINDOWS; break;
390 default: break;
391 }
393 }
394 return *this->extra_cfg;
395}
396
402{
403 const GRFConfig &cfg = this->GetOrCreateExtraConfig();
404 /* This check is more strict than the one for NewGRF Settings.
405 * There are no legacy basesets with parameters, but without Action14 */
406 return !cfg.param_info.empty();
407}
408
409void GraphicsSet::CopyCompatibleConfig(const GraphicsSet &src)
410{
411 const GRFConfig *src_cfg = src.GetExtraConfig();
412 if (src_cfg == nullptr || src_cfg->param.empty()) return;
413 GRFConfig &dest_cfg = this->GetOrCreateExtraConfig();
414 if (dest_cfg.IsCompatible(src_cfg->version)) return;
415 dest_cfg.CopyParams(*src_cfg);
416}
417
428{
429 size_t size = 0;
430 auto f = FioFOpenFile(file->filename, "rb", subdir, &size);
431 if (!f.has_value()) return MD5File::ChecksumResult::NoFile;
432
433 size_t max = GRFGetSizeOfDataSection(*f);
434
435 return file->CheckMD5(subdir, max);
436}
437
438
449{
450 size_t size;
451 auto f = FioFOpenFile(this->filename, "rb", subdir, &size);
452 if (!f.has_value()) return ChecksumResult::NoFile;
453
454 size = std::min(size, max_size);
455
456 Md5 checksum;
457 uint8_t buffer[1024];
458 MD5Hash digest;
459 size_t len;
460
461 while ((len = fread(buffer, 1, (size > sizeof(buffer)) ? sizeof(buffer) : size, *f)) != 0 && size != 0) {
462 size -= len;
463 checksum.Append(buffer, len);
464 }
465
466 checksum.Finish(digest);
467 return this->hash == digest ? ChecksumResult::Match : ChecksumResult::Mismatch;
468}
469
471static const std::string_view _graphics_file_names[] = { "base", "logos", "arctic", "tropical", "toyland", "extra" };
472
473/* Implementation */
474
476template <>
477/* static */ std::span<const std::string_view> BaseSet<GraphicsSet>::GetFilenames()
478{
480}
481
483template <>
485{
486 if (BaseMedia<GraphicsSet>::used_set != nullptr) return true;
487
488 const GraphicsSet *best = nullptr;
489
490 auto IsBetter = [&best] (const GraphicsSet *current) {
491 /* Nothing chosen yet. */
492 if (best == nullptr) return true;
493 /* Not being a fallback is better. */
494 if (best->fallback && !current->fallback) return true;
495 /* Having more valid files is better. */
496 if (best->valid_files < current->valid_files) return true;
497 /* Having (essentially) fewer valid files is worse. */
498 if (best->valid_files != current->valid_files) return false;
499 /* Having a later version of the same base set is better. */
500 if (best->shortname == current->shortname && best->version < current->version) return true;
501 /* The DOS palette is the better palette. */
502 return best->palette != PaletteType::DOS && current->palette == PaletteType::DOS;
503 };
504
505 for (const auto &c : BaseMedia<GraphicsSet>::available_sets) {
506 /* Skip unusable sets */
507 if (c->GetNumMissing() != 0) continue;
508
509 if (IsBetter(c.get())) best = c.get();
510 }
511
513 return BaseMedia<GraphicsSet>::used_set != nullptr;
514}
515
517template <>
518/* static */ std::string_view BaseMedia<GraphicsSet>::GetExtension()
519{
520 return ".obg"; // OpenTTD Base Graphics
521}
522
523template class BaseMedia<GraphicsSet>;
Generic function implementations for base data (graphics, sounds).
Generic functions for replacing base graphics data.
@ BLT_32BPP
Base set has both 8 bpp and 32 bpp sprites.
@ BLT_8BPP
Base set has 8 bpp sprites only.
@ Base
Base sprites for all climates.
@ Logos
Logos, landscape icons and original terrain generator sprites.
@ Arctic
Landscape replacement sprites for arctic.
@ Extra
Extra sprites that were not part of the original sprites.
Generic functions for replacing base sounds data.
Base for all base media (graphics, sounds).
static const GraphicsSet * GetUsedSet()
static std::vector< std::unique_ptr< Tbase_set > > available_sets
All available sets.
static const Tbase_set * used_set
The currently used set.
static bool DetermineBestSet()
Determine the graphics pack that has to be used.
static std::string_view GetExtension()
Get the extension that is used to identify this set.
static BlitterFactory * GetBlitterFactory(std::string_view name)
Get the blitter factory with the given name.
Definition factory.hpp:114
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
Definition factory.hpp:139
static Blitter * SelectBlitter(std::string_view name)
Find the requested blitter and return its class.
Definition factory.hpp:98
How all blitters should look like.
Definition base.hpp:28
virtual std::string_view GetName()=0
Get the name of the blitter, the same as the Factory-instance returns.
static void ClearFontCaches(FontSizes fontsizes)
Clear cached information for the specified font caches.
uint8_t ReadByte()
Read a byte from the file.
RandomAccessFile with some extra information specific for sprite files.
uint8_t GetContainerVersion() const
Get the version number of container type used by the file.
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.
virtual void ClearSystemSprites()
Clear all cached sprites.
static VideoDriver * GetInstance()
Get the currently active instance of the video driver.
#define Debug(facility, severity, format_string,...)
Output a line of debugging information.
Definition debug.h:36
@ Driver
Driver message facility.
Definition debug_type.h:29
@ Sprite
Sprite message facility.
Definition debug_type.h:34
@ Grf
Grf message facility.
Definition debug_type.h:30
@ Warning
Warning, wrong but okay if you don't know.
Definition debug_type.h:17
@ Info
Info, information you might care about.
Definition debug_type.h:19
@ Error
Error, but we are recovering.
Definition debug_type.h:16
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23).
Definition enum_type.hpp:21
Factory to 'query' all available blitters.
bool _blitter_autodetected
Was the blitter autodetected or specified by the user?
Definition driver.cpp:37
std::optional< FileHandle > FioFOpenFile(std::string_view filename, std::string_view mode, Subdirectory subdir, size_t *filesize)
Opens a OpenTTD file somewhere in a personal or global directory.
Definition fileio.cpp:248
Subdirectory
The different kinds of subdirectories OpenTTD uses.
Definition fileio_type.h:87
@ Baseset
Subdirectory for all base data (base sets, intro game).
Definition fileio_type.h:95
Functions to read fonts from files and cache them.
void InitializeUnicodeGlyphMap()
Initialize the glyph map.
void UpdateCursorSize()
Update cursor dimension.
Definition gfx.cpp:1617
Support8bpp _support8bpp
State of the support for 8bpp graphics.
Definition gfx.cpp:38
Functions related to the gfx engine.
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition gfx_type.h:17
@ None
No support for 8bpp by OS or hardware, force 32bpp blitters.
Definition gfx_type.h:428
constexpr FontSizes FONTSIZES_ALL
Mask of all possible font sizes.
Definition gfx_type.h:262
PaletteType
Palettes OpenTTD supports.
Definition gfx_type.h:398
@ DOS
Use the DOS palette.
Definition gfx_type.h:399
@ Windows
Use the Windows palette.
Definition gfx_type.h:400
static std::unique_ptr< GRFConfig > GetDefaultExtraGRFConfig()
Get GRFConfig for the default extra graphics.
Definition gfxinit.cpp:150
static std::unique_ptr< GRFConfig > GetBasesetExtraGRFConfig()
Get GRFConfig for the baseset extra graphics.
Definition gfxinit.cpp:163
static void LoadSpriteTables()
Actually load the sprite tables.
Definition gfxinit.cpp:172
static bool SwitchNewGRFBlitter()
Check blitter needed by NewGRF config and switch if needed.
Definition gfxinit.cpp:257
void CheckBlitter()
Check whether we still use the right blitter, or use another (better) one.
Definition gfxinit.cpp:325
static const std::string_view _graphics_file_names[]
Names corresponding to the GraphicsFileType.
Definition gfxinit.cpp:471
static constexpr std::span< const std::pair< SpriteID, SpriteID > > _landscape_spriteindexes[]
Offsets for loading the different "replacement" sprites in the files.
Definition gfxinit.cpp:33
static void LoadGrfFileIndexed(const std::string &filename, std::span< const std::pair< SpriteID, SpriteID > > index_tbl, bool needs_palette_remap)
Load an old fashioned GRF file to replace already loaded sprites.
Definition gfxinit.cpp:82
static uint LoadGrfFile(const std::string &filename, SpriteID load_index, bool needs_palette_remap)
Load an old fashioned GRF file.
Definition gfxinit.cpp:46
void CheckExternalFiles()
Checks whether the MD5 checksums of the files are correct.
Definition gfxinit.cpp:113
void GfxLoadSprites()
Initialise and load all the sprites.
Definition gfxinit.cpp:335
Offsets of sprites to replace for non-temperate landscapes.
@ Temperate
Base landscape.
constexpr bool IsInsideMM(const size_t x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
void LoadNewGRF(SpriteID load_index, uint num_baseset)
Load all the NewGRFs.
Definition newgrf.cpp:1760
Base for the NewGRF implementation.
GRFConfigList _grfconfig
First item in list of current GRF set up.
uint _missing_extra_graphics
Number of sprites provided by the fallback extra GRF, i.e. missing in the baseset.
bool FillGRFDetails(GRFConfig &config, bool is_static, Subdirectory subdir)
Find the GRFID of a given grf, and calculate its md5sum.
size_t GRFGetSizeOfDataSection(FileHandle &f)
Get the data section size of a GRF.
Functions to find and configure NewGRFs.
@ NotFound
GRF file was not found in the local cache.
@ Disabled
GRF file is disabled.
@ InitOnly
GRF file is processed up to GrfLoadingStage::Init.
@ GRFP_GRF_WINDOWS
The NewGRF says the Windows palette can be used.
@ GRFP_GRF_DOS
The NewGRF says the DOS palette can be used.
@ GRFP_BLT_32BPP
The NewGRF prefers a 32 bpp blitter.
@ FullAnimation
Perform palette animation.
Definition openttd.h:49
Functions related to palettes.
A number of safeguards to prevent using unsafe methods.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:61
void GfxClearSpriteCache()
Remove all encoded sprites from the sprite cache without discarding sprite location information.
uint GetSpriteCountForFile(const std::string &filename, SpriteID begin, SpriteID end)
Count the sprites which originate from a specific file in a range of SpriteIDs.
SpriteFile & OpenCachedSpriteFile(const std::string &filename, Subdirectory subdir, bool palette_remap)
Open/get the SpriteFile that is cached for use in the sprite cache.
bool LoadNextSprite(SpriteID load_index, SpriteFile &file, uint file_sprite_id)
Load a real or recolour sprite.
void ReadGRFSpriteOffsets(SpriteFile &file)
Parse the sprite section of GRFs.
Functions to cache sprites in memory.
This file contains all sprite-related enums and defines.
static constexpr uint32_t MAX_SPRITES
Masks needed for sprite operations.
Definition sprites.h:1742
static const SpriteID SPR_OPENTTD_BASE
Definition sprites.h:60
static const SpriteID SPR_NEWGRFS_BASE
From where can we start putting NewGRFs.
Definition sprites.h:381
Definition of base types and functions in a cross-platform compatible way.
std::array< MD5File, BaseSet< T >::NUM_FILES > files
All files part of this set.
uint valid_files
Number of the files that could be found and are valid.
const IniItem * GetMandatoryItem(std::string_view full_filename, const IniGroup &group, std::string_view name) const
static constexpr size_t NUM_FILES
static MD5File::ChecksumResult CheckMD5(const MD5File *file, Subdirectory subdir)
static std::span< const std::string_view > GetFilenames()
Get the internal names of the files in this set.
std::string name
The name of the base set.
bool fallback
This set is a fallback set, i.e. it should be used only as last resort.
bool FillSetDetails(const IniFile &ini, const std::string &path, const std::string &full_filename, bool allow_empty_filename=true)
Read the set information from a loaded ini.
std::vector< uint32_t > version
The version of this base set.
uint32_t shortname
Four letter short variant of the name.
int GetNumInvalid() const
Get the number of invalid files.
Information about GRF, used in the game and (part of it) in savegames.
std::vector< std::optional< GRFParameterInfo > > param_info
NOSAVE: extra information about the parameters.
uint32_t version
NOSAVE: Version a NewGRF can set so only the newest NewGRF is shown.
std::vector< uint32_t > param
GRF parameters.
bool IsCompatible(uint32_t old_version) const
Return whether this NewGRF can replace an older version of the same NewGRF.
void CopyParams(const GRFConfig &src)
Copy the parameter information from the src config.
All data of a graphics set.
bool IsConfigurable() const
Checks whether this set has configuration options.
Definition gfxinit.cpp:401
std::unique_ptr< GRFConfig > extra_cfg
Parameters for extra GRF.
PaletteType palette
Palette of this graphics set.
static MD5File::ChecksumResult CheckMD5(const MD5File *file, Subdirectory subdir)
Calculate and check the MD5 hash of the supplied GRF.
Definition gfxinit.cpp:427
BlitterType blitter
Blitter of this graphics set.
GRFConfig & GetOrCreateExtraConfig() const
Return configuration for the extra GRF, or lazily create it.
Definition gfxinit.cpp:378
Ini file that supports both loading and saving.
Definition ini_type.h:87
const IniItem * GetItem(std::string_view name) const
Get the item with the given name.
Definition ini_load.cpp:50
std::optional< std::string > value
The value of this item.
Definition ini_type.h:25
const IniGroup * GetGroup(std::string_view name) const
Get the group with the given name.
Definition ini_load.cpp:117
Structure holding filename and MD5 information about a single file.
ChecksumResult CheckMD5(Subdirectory subdir, size_t max_size) const
Calculate and check the MD5 hash of the supplied filename.
Definition gfxinit.cpp:448
ChecksumResult
The result of a checksum check.
@ NoFile
The file did not exist.
@ Mismatch
The file did exist, just the md5 checksum did not match.
@ Match
The file did exist and the md5 checksum did match.
MD5Hash hash
md5 sum of the file
std::string filename
filename
All data of a sounds set.
Functions related to transparency.
DisplayOptions _display_opt
What do we want to draw/do?
Base of all video drivers.
void ReInitAllWindows(bool zoom_changed)
Re-initialize all windows.
Definition window.cpp:3494
Window functions not directly related to making/drawing windows.