31static std::vector<SpriteCache> _spritecache;
32static size_t _spritecache_bytes_used = 0;
33static uint32_t _sprite_lru_counter;
34static std::vector<std::unique_ptr<SpriteFile>> _sprite_files;
36static inline SpriteCache *GetSpriteCache(uint index)
38 return &_spritecache[index];
43 if (index >= _spritecache.size()) {
45 uint items =
Align(index + 1, 1024);
49 _spritecache.resize(items);
52 return GetSpriteCache(index);
62 for (
auto &f : _sprite_files) {
63 if (f->GetFilename() == filename) {
89 if (file ==
nullptr) {
90 file = _sprite_files.insert(std::end(_sprite_files), std::make_unique<SpriteFile>(filename, subdir, palette_remap))->get();
112 int size = (i == 0) ? 0x80 : i;
113 if (size > num)
return false;
129 if (
id >= _spritecache.size())
return false;
132 if (
id == 0)
return true;
133 return !(GetSpriteCache(
id)->file_pos == 0 && GetSpriteCache(
id)->file ==
nullptr);
144 return GetSpriteCache(sprite)->type;
154 if (!SpriteExists(sprite))
return nullptr;
155 return GetSpriteCache(sprite)->file;
165 if (!SpriteExists(sprite))
return 0;
166 return GetSpriteCache(sprite)->id;
179 if (file ==
nullptr)
return 0;
182 for (
SpriteID i = begin; i != end; i++) {
183 if (SpriteExists(i)) {
185 if (sc->
file == file) {
204 return static_cast<SpriteID>(_spritecache.size());
210 const auto &src_sprite = sprite[src];
211 auto &dest_sprite = sprite[tgt];
214 if (src_sprite.width * scaled_1 > UINT16_MAX || src_sprite.height * scaled_1 > UINT16_MAX)
return false;
216 dest_sprite.width = src_sprite.width * scaled_1;
217 dest_sprite.height = src_sprite.height * scaled_1;
218 dest_sprite.x_offs = src_sprite.x_offs * scaled_1;
219 dest_sprite.y_offs = src_sprite.y_offs * scaled_1;
220 dest_sprite.colours = src_sprite.colours;
222 dest_sprite.AllocateData(tgt,
static_cast<size_t>(dest_sprite.width) * dest_sprite.height);
225 for (
int y = 0; y < dest_sprite.height; y++) {
227 for (
int x = 0; x < dest_sprite.width; x++) {
228 *dst = src_ln[x / scaled_1];
238 const auto &root_sprite = sprite.Root();
239 const auto &src_sprite = sprite[zoom - 1];
240 auto &dest_sprite = sprite[zoom];
244 dest_sprite.height =
UnScaleByZoom(root_sprite.height, zoom);
245 dest_sprite.x_offs =
UnScaleByZoom(root_sprite.x_offs, zoom);
246 dest_sprite.y_offs =
UnScaleByZoom(root_sprite.y_offs, zoom);
247 dest_sprite.colours = root_sprite.colours;
249 dest_sprite.AllocateData(zoom,
static_cast<size_t>(dest_sprite.height) * dest_sprite.width);
255 for (uint y = 0; y < dest_sprite.height; y++) {
257 assert(src_ln <= src_end);
258 for (uint x = 0; x < dest_sprite.width; x++) {
259 assert(src < src_ln);
260 if (src + 1 != src_ln && (src + 1)->a != 0) {
268 src = src_ln + src_sprite.width;
274 uint width = sprite->
width + pad_left + pad_right;
275 uint height = sprite->
height + pad_top + pad_bottom;
277 if (width > UINT16_MAX || height > UINT16_MAX)
return false;
280 size_t sprite_size =
static_cast<size_t>(sprite->
width) * sprite->
height;
281 std::vector<SpriteLoader::CommonPixel> src_data(sprite->
data, sprite->
data + sprite_size);
282 sprite->
AllocateData(zoom,
static_cast<size_t>(width) * height);
287 for (uint y = 0; y < height; y++) {
288 if (y < pad_top || pad_bottom + y >= height) {
300 std::copy_n(src, sprite->
width, data);
301 src += sprite->
width;
302 data += sprite->
width;
313 sprite->
width = width;
315 sprite->
x_offs -= pad_left;
316 sprite->
y_offs -= pad_top;
324 int min_xoffs = INT32_MAX;
325 int min_yoffs = INT32_MAX;
327 min_xoffs = std::min(min_xoffs,
ScaleByZoom(sprite[zoom].x_offs, zoom));
328 min_yoffs = std::min(min_yoffs,
ScaleByZoom(sprite[zoom].y_offs, zoom));
332 int max_width = INT32_MIN;
333 int max_height = INT32_MIN;
335 max_width = std::max(max_width,
ScaleByZoom(sprite[zoom].width + sprite[zoom].x_offs -
UnScaleByZoom(min_xoffs, zoom), zoom));
336 max_height = std::max(max_height,
ScaleByZoom(sprite[zoom].height + sprite[zoom].y_offs -
UnScaleByZoom(min_yoffs, zoom), zoom));
342 max_width =
Align(max_width, align);
343 max_height =
Align(max_height, align);
348 auto &cur_sprite = sprite[zoom];
351 int pad_left = std::max(0, cur_sprite.x_offs -
UnScaleByZoom(min_xoffs, zoom));
352 int pad_top = std::max(0, cur_sprite.y_offs -
UnScaleByZoom(min_yoffs, zoom));
353 int pad_right = std::max(0,
UnScaleByZoom(max_width, zoom) - cur_sprite.width - pad_left);
354 int pad_bottom = std::max(0,
UnScaleByZoom(max_height, zoom) - cur_sprite.height - pad_top);
356 if (pad_left > 0 || pad_right > 0 || pad_top > 0 || pad_bottom > 0) {
357 if (!PadSingleSprite(&cur_sprite, zoom, pad_left, pad_top, pad_right, pad_bottom))
return false;
369 if (!sprite_avail.
Test(zoom))
continue;
379 if (!PadSprites(sprite, sprite_avail, encoder))
return false;
383 if (sprite_avail.
Test(zoom)) {
385 [[maybe_unused]]
const auto &root_sprite = sprite[
ZoomLevel::Min];
386 [[maybe_unused]]
const auto &dest_sprite = sprite[zoom];
387 assert(dest_sprite.width ==
UnScaleByZoom(root_sprite.width, zoom));
388 assert(dest_sprite.height ==
UnScaleByZoom(root_sprite.height, zoom));
389 assert(dest_sprite.x_offs ==
UnScaleByZoom(root_sprite.x_offs, zoom));
390 assert(dest_sprite.y_offs ==
UnScaleByZoom(root_sprite.y_offs, zoom));
393 ResizeSpriteOut(sprite, zoom);
400 ResizeSpriteIn(sprite, zoom, zoom - 1);
421 static const uint RECOLOUR_SPRITE_SIZE = 257;
422 uint8_t *dest = allocator.
Allocate<uint8_t>(std::max(RECOLOUR_SPRITE_SIZE, num));
424 file.
SeekTo(file_pos, SEEK_SET);
426 uint8_t *dest_tmp =
new uint8_t[std::max(RECOLOUR_SPRITE_SIZE, num)];
429 if (num < RECOLOUR_SPRITE_SIZE) std::fill_n(dest_tmp, RECOLOUR_SPRITE_SIZE, 0);
433 for (uint i = 1; i < RECOLOUR_SPRITE_SIZE; i++) {
434 dest[i] = _palmap_w2d[dest_tmp[
_palmap_d2w[i - 1] + 1]];
459 size_t file_pos = sc->file_pos;
463 assert(sc->
type == sprite_type);
475 sprite_avail = sprite_loader.
LoadSprite(sprite, file, file_pos, sprite_type,
true, sc->
control_flags, avail_8bpp, avail_32bpp);
477 if (sprite_avail.
None()) {
478 sprite_avail = sprite_loader.
LoadSprite(sprite, file, file_pos, sprite_type,
false, sc->
control_flags, avail_8bpp, avail_32bpp);
482 sprite_avail = make_indexed.
LoadSprite(sprite, file, file_pos, sprite_type,
true, sc->
control_flags, sprite_avail, avail_32bpp);
486 if (sprite_avail.
None()) {
488 if (
id ==
SPR_IMG_QUERY) UserError(
"Okay... something went horribly wrong. I couldn't load the fallback sprite. What should I do?");
502 const auto &root_sprite = sprite.Root();
503 uint num = root_sprite.
width * root_sprite.height;
506 s->
width = root_sprite.width;
507 s->
height = root_sprite.height;
508 s->
x_offs = root_sprite.x_offs;
509 s->
y_offs = root_sprite.y_offs;
512 uint8_t *dest =
reinterpret_cast<uint8_t *
>(s->
data);
521 if (!ResizeSprites(sprite, sprite_avail, encoder)) {
522 if (
id ==
SPR_IMG_QUERY) UserError(
"Okay... something went horribly wrong. I couldn't resize the fallback sprite. What should I do?");
531 return encoder->
Encode(sprite_type, sprite, allocator);
563 size_t old_pos = file.
GetPos();
564 file.
SeekTo(data_offset, SEEK_CUR);
574 offset.file_pos = file.
GetPos() - 4;
575 offset.control_flags.
Reset();
585 if (colour.
Any() && zoom == 0) {
589 if (colour.
Any() && zoom == 2) {
599 file.
SeekTo(old_pos, SEEK_SET);
613 size_t file_pos = file.
GetPos();
617 if (num == 0)
return false;
622 if (grf_type == 0xFF) {
641 file_pos = iter->second.file_pos;
642 control_flags = iter->second.control_flags;
657 UserError(
"Tried to load too many sprites (#{}; max {})", load_index,
MAX_SPRITES);
660 bool is_mapgen = IsMapgenSpriteID(load_index);
663 if (type !=
SpriteType::Normal) UserError(
"Uhm, would you be so kind not to load a NewGRF that changes the type of the map generator sprites?");
669 sc->file_pos = file_pos;
672 sc->id = file_sprite_id;
687 scnew->file_pos = scold->file_pos;
688 scnew->ClearSpriteData();
689 scnew->id = scold->id;
703 const size_t initial_in_use = _spritecache_bytes_used;
710 auto operator<=>(
const SpriteInfo &other)
const noexcept
712 return this->lru <=> other.lru;
716 std::vector<SpriteInfo> candidates;
717 size_t candidate_bytes = 0;
719 auto push = [&](SpriteInfo info) {
720 candidates.push_back(info);
721 std::push_heap(candidates.begin(), candidates.end());
722 candidate_bytes += info.size;
726 candidate_bytes -= candidates.front().size;
727 std::pop_heap(candidates.begin(), candidates.end());
728 candidates.pop_back();
732 for (; i !=
static_cast<SpriteID>(_spritecache.size()) && candidate_bytes < to_remove; i++) {
734 if (sc->ptr !=
nullptr) {
735 push({ sc->lru, i, sc->
length });
736 if (candidate_bytes >= to_remove)
break;
741 for (; i !=
static_cast<SpriteID>(_spritecache.size()); i++) {
743 if (sc->ptr !=
nullptr && sc->lru <= candidates.front().lru) {
744 push({ sc->lru, i, sc->
length });
745 while (!candidates.empty() && candidate_bytes - candidates.front().size >= to_remove) {
751 for (
const auto &it : candidates) {
752 GetSpriteCache(it.id)->ClearSpriteData();
756 candidates.size(), candidate_bytes, initial_in_use, _spritecache_bytes_used, to_remove);
759void IncreaseSpriteLRU()
763 if (_spritecache_bytes_used > target_size) {
767 if (_sprite_lru_counter >= 0xC0000000) {
771 if (sc.ptr !=
nullptr) {
772 if (sc.lru > 0x80000000) {
773 sc.lru -= 0x80000000;
779 _sprite_lru_counter -= 0x80000000;
783void SpriteCache::ClearSpriteData()
785 _spritecache_bytes_used -= this->
length;
791 this->data = std::make_unique<std::byte[]>(size);
793 return this->data.get();
809 static const std::string_view sprite_types[] = {
824 Debug(
Facility::Sprite, warning_level,
"Tried to load {} sprite #{} as a {} sprite. Probable cause: NewGRF interference", sprite_types[
static_cast<uint8_t
>(available)], sprite, sprite_types[
static_cast<uint8_t
>(requested)]);
828 if (sprite ==
SPR_IMG_QUERY) UserError(
"Uhm, would you be so kind not to load a NewGRF that makes the 'query' sprite a non-normal sprite?");
833 if (sprite ==
PALETTE_TO_DARK_BLUE) UserError(
"Uhm, would you be so kind not to load a NewGRF that makes the 'PALETTE_TO_DARK_BLUE' sprite a non-remap sprite?");
857 if (!SpriteExists(sprite)) {
868 if (allocator ==
nullptr) {
869 assert(encoder ==
nullptr);
873 sc->lru = ++_sprite_lru_counter;
876 if (sc->ptr ==
nullptr) {
881 ReadSprite(sc, sprite, type, cache_allocator,
nullptr);
883 sc->ptr = std::move(cache_allocator.data);
884 sc->
length =
static_cast<uint32_t
>(cache_allocator.size);
885 _spritecache_bytes_used += sc->
length;
888 return static_cast<void *
>(sc->ptr.get());
890 assert(encoder !=
nullptr);
892 return ReadSprite(sc, sprite, type, *allocator, encoder);
896void GfxInitSpriteMem()
899 _spritecache.clear();
900 _spritecache.shrink_to_fit();
902 _sprite_files.clear();
903 _spritecache_bytes_used = 0;
914 if (sc.ptr !=
nullptr) sc.ClearSpriteData();
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr bool None() const
Test if none of the values are set.
constexpr Timpl & Reset()
Reset all bits.
constexpr Timpl & Set()
Set all bits.
constexpr bool Any(const Timpl &other) const
Test if any of the given values are set.
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
virtual uint8_t GetScreenDepth()=0
Get the screen depth this blitter works for.
Iterate a range of enum values.
void ReadBlock(void *ptr, size_t size)
Read a block.
size_t GetPos() const
Get position in the file.
void SeekTo(size_t pos, int mode)
Seek in the current file.
uint8_t ReadByte()
Read a byte from the file.
uint32_t ReadDword()
Read a double word (32 bits) from the file (in low endian format).
void SkipBytes(size_t n)
Skip n bytes ahead in the file.
uint16_t ReadWord()
Read a word (16 bits) from the file (in low endian format).
Interface for something that can allocate memory for a sprite.
T * Allocate(size_t size)
Allocate memory for a sprite.
Interface for something that can encode a sprite.
virtual bool Is32BppSupported()=0
Can the sprite encoder make use of RGBA sprites?
virtual uint GetSpriteAlignment()
Get the value which the height and width on a sprite have to be aligned by.
virtual Sprite * Encode(SpriteType sprite_type, const SpriteLoader::SpriteCollection &sprite, SpriteAllocator &allocator)=0
Convert a sprite from the loader to our own format.
RandomAccessFile with some extra information specific for sprite files.
bool NeedsPaletteRemap() const
Whether a palette remap is needed when loading sprites from this file.
uint8_t GetContainerVersion() const
Get the version number of container type used by the file.
void SeekToBegin()
Seek to the begin of the content, i.e.
Sprite loader for graphics coming from a (New)GRF.
ZoomLevels LoadSprite(SpriteLoader::SpriteCollection &sprite, SpriteFile &file, size_t file_pos, SpriteType sprite_type, bool load_32bpp, SpriteCacheCtrlFlags control_flags, ZoomLevels &avail_8bpp, ZoomLevels &avail_32bpp) override
Load a sprite from the disk and return a sprite struct which is the same for all loaders.
Sprite loader for converting graphics coming from another source.
ZoomLevels LoadSprite(SpriteLoader::SpriteCollection &sprite, SpriteFile &file, size_t file_pos, SpriteType sprite_type, bool load_32bpp, SpriteCacheCtrlFlags control_flags, ZoomLevels &avail_8bpp, ZoomLevels &avail_32bpp) override
Load a sprite from the disk and return a sprite struct which is the same for all loaders.
SpriteCollMap< Sprite > SpriteCollection
Type defining a collection of sprites, one for each zoom level.
SpriteAllocator that allocates memory via a unique_ptr array.
void * AllocatePtr(size_t size) override
Allocate memory for a sprite.
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.
@ Sprite
Sprite message facility.
Severity
Debug message severity levels.
@ Critical
Critical, user should know about this.
@ Debug2
Debug #2 - Low level debug messages.
@ Info
Info, information you might care about.
@ Error
Error, but we are recovering.
@ Trace3
Trace information #3.
Error reporting related functions.
Factory to 'query' all available blitters.
Subdirectory
The different kinds of subdirectories OpenTTD uses.
ZoomLevel _font_zoom
Sprite font Zoom level (not clamped).
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
SpriteType
Types of sprites that might be loaded.
@ Recolour
Recolour sprite.
@ Font
A sprite used for fonts.
@ MapGen
Special sprite for the map generator.
@ Invalid
Pseudosprite or other unusable sprite, used only internally.
@ Normal
The most basic (normal) sprite.
Base for reading sprites from (New)GRFs.
Base for converting sprites from another source from 32bpp RGBA to indexed 8bpp.
constexpr T Align(const T x, uint n)
Return the smallest multiple of n equal or greater than x.
static auto operator<=>(const GUIBadgeClasses::Element &a, const GUIBadgeClasses::Element &b) noexcept
Compare two GUIBadgeClasses::Elements.
Translation tables from one GRF to another GRF.
static const uint8_t _palmap_d2w[]
Converting from the DOS palette to the Windows palette.
A number of safeguards to prevent using unsafe methods.
ClientSettings _settings_client
The current settings for this game.
Types related to global configuration settings.
static void DeleteEntriesFromSpriteCache(size_t to_remove)
Delete entries from the sprite cache to remove the requested number of bytes.
static std::map< uint32_t, GrfSpriteOffset > _grf_sprite_offsets
Map from sprite numbers to position in the GRF file.
SpriteType GetSpriteType(SpriteID sprite)
Get the sprite type of a given sprite.
void GfxClearSpriteCache()
Remove all encoded sprites from the sprite cache without discarding sprite location information.
static SpriteFile * GetCachedSpriteFileByName(const std::string &filename)
Get the cached SpriteFile given the name of the file.
uint GetSpriteCountForFile(const std::string &filename, SpriteID begin, SpriteID end)
Count the sprites which originate from a specific file in a range of SpriteIDs.
static void * ReadSprite(const SpriteCache *sc, SpriteID id, SpriteType sprite_type, SpriteAllocator &allocator, SpriteEncoder *encoder)
Read a sprite from disk.
void GfxClearFontSpriteCache()
Remove all encoded font sprites from the sprite cache without discarding sprite location information.
SpriteID GetMaxSpriteID()
Get a reasonable (upper bound) estimate of the maximum SpriteID used in OpenTTD; there will be no spr...
SpriteFile & OpenCachedSpriteFile(const std::string &filename, Subdirectory subdir, bool palette_remap)
Open/get the SpriteFile that is cached for use in the sprite cache.
uint _sprite_cache_size
Default of 4MB spritecache.
void * GetRawSprite(SpriteID sprite, SpriteType type, SpriteAllocator *allocator, SpriteEncoder *encoder)
Reads a sprite (from disk or sprite cache).
std::span< const std::unique_ptr< SpriteFile > > GetCachedSpriteFiles()
Get the list of cached SpriteFiles.
bool LoadNextSprite(SpriteID load_index, SpriteFile &file, uint file_sprite_id)
Load a real or recolour sprite.
SpriteFile * GetOriginFile(SpriteID sprite)
Get the SpriteFile of a given sprite.
size_t GetGRFSpriteOffset(uint32_t id)
Get the file offset for a specific sprite in the sprite section of a GRF.
static void * ReadRecolourSprite(SpriteFile &file, size_t file_pos, uint num, SpriteAllocator &allocator)
Load a recolour sprite into memory.
bool SkipSpriteData(SpriteFile &file, uint8_t type, uint16_t num)
Skip the given amount of sprite graphics data.
uint32_t GetSpriteLocalID(SpriteID sprite)
Get the GRF-local sprite id of a given sprite.
void ReadGRFSpriteOffsets(SpriteFile &file)
Parse the sprite section of GRFs.
static void * HandleInvalidSpriteRequest(SpriteID sprite, SpriteType requested, SpriteCache *sc, SpriteAllocator *allocator, SpriteEncoder *encoder)
Handles the case when a sprite of different type is requested than is present in the SpriteCache.
Functions to cache sprites in memory.
Internal functions to cache sprites in memory.
@ AllowZoomMin1x32bpp
Allow use of sprite min zoom setting at 1x in 32bpp mode.
@ AllowZoomMin2x32bpp
Allow use of sprite min zoom setting at 2x in 32bpp mode.
@ AllowZoomMin1xPal
Allow use of sprite min zoom setting at 1x in palette mode.
@ AllowZoomMin2xPal
Allow use of sprite min zoom setting at 2x in palette mode.
EnumBitSet< SpriteCacheCtrlFlag, uint8_t > SpriteCacheCtrlFlags
Bitset of SpriteCacheCtrlFlag elements.
@ Palette
Sprite has palette data.
EnumBitSet< SpriteComponent, uint8_t, SpriteComponent::End > SpriteComponents
Bitset of SpriteComponent elements.
This file contains all sprite-related enums and defines.
static constexpr uint32_t MAX_SPRITES
Masks needed for sprite operations.
static const PaletteID PALETTE_TO_DARK_BLUE
static const SpriteID SPR_IMG_QUERY
Definition of base types and functions in a cross-platform compatible way.
uint32_t length
Length of sprite data.
bool warned
True iff the user has been warned about incorrect use of this sprite.
SpriteCacheCtrlFlags control_flags
Control flags, see SpriteCacheCtrlFlags.
SpriteType type
In some cases a single sprite is misused by two NewGRFs. Once as real sprite and once as recolour spr...
SpriteFile * file
The file the sprite in this entry can be found in.
Definition of a common pixel in OpenTTD's realm.
Structure for passing information from the sprite loader to the blitter.
static SpriteCollMap< ReusableBuffer< SpriteLoader::CommonPixel > > buffer
Allocated memory to pass sprite data around.
void AllocateData(ZoomLevel zoom, size_t size)
Allocate the sprite data of this sprite.
uint16_t width
Width of the sprite.
int16_t x_offs
The x-offset of where the sprite will be drawn.
SpriteLoader::CommonPixel * data
The sprite itself.
uint16_t height
Height of the sprite.
int16_t y_offs
The y-offset of where the sprite will be drawn.
Data structure describing a sprite.
uint16_t width
Width of the sprite.
uint16_t height
Height of the sprite.
int16_t y_offs
Number of pixels to shift the sprite downwards.
std::byte data[]
Sprite data.
int16_t x_offs
Number of pixels to shift the sprite to the right.
Base of all video drivers.
Functions related to zooming.
int ScaleByZoom(int value, ZoomLevel zoom)
Scale by zoom level, usually shift left (when zoom > ZoomLevel::Min) When shifting right,...
int AdjustByZoom(int value, int zoom)
Adjust by zoom level; zoom < 0 shifts right, zoom >= 0 shifts left.
int UnScaleByZoom(int value, ZoomLevel zoom)
Scale by zoom level, usually shift right (when zoom > ZoomLevel::Min) When shifting right,...
EnumBitSet< ZoomLevel, uint8_t > ZoomLevels
Bitset of ZoomLevel elements.
ZoomLevel
All zoom levels we know.
@ Normal
The normal zoom level.