23 #include "table/strings.h"
29 uint _sprite_cache_size = 4;
43 static uint _spritecache_items = 0;
47 static inline SpriteCache *GetSpriteCache(uint index)
49 return &_spritecache[index];
52 static inline bool IsMapgenSpriteID(
SpriteID sprite)
59 if (index >= _spritecache_items) {
61 uint items =
Align(index + 1, 1024);
63 DEBUG(sprite, 4,
"Increasing sprite cache to %u items (" PRINTF_SIZE
" bytes)", items, items *
sizeof(*_spritecache));
65 _spritecache =
ReallocT(_spritecache, items);
68 memset(_spritecache + _spritecache_items, 0, (items - _spritecache_items) *
sizeof(*_spritecache));
69 _spritecache_items = items;
72 return GetSpriteCache(index);
81 static uint _sprite_lru_counter;
83 static uint _allocated_sprite_cache_size = 0;
84 static int _compact_cache_counter;
87 static void *AllocSprite(
size_t mem_req);
103 int size = (i == 0) ? 0x80 : i;
104 if (size > num)
return false;
120 if (
id >= _spritecache_items)
return false;
123 if (
id == 0)
return true;
124 return !(GetSpriteCache(
id)->file_pos == 0 && GetSpriteCache(
id)->file_slot == 0);
135 return GetSpriteCache(sprite)->
type;
145 if (!SpriteExists(sprite))
return 0;
146 return GetSpriteCache(sprite)->file_slot;
156 if (!SpriteExists(sprite))
return 0;
157 return GetSpriteCache(sprite)->id;
170 for (
SpriteID i = begin; i != end; i++) {
171 if (SpriteExists(i)) {
173 if (sc->file_slot == file_slot) count++;
189 return _spritecache_items;
197 if (sprite[src].width * scaled_1 > UINT16_MAX || sprite[src].height * scaled_1 > UINT16_MAX)
return false;
199 sprite[tgt].
width = sprite[src].
width * scaled_1;
205 sprite[tgt].
AllocateData(tgt, sprite[tgt].width * sprite[tgt].height);
208 for (
int y = 0; y < sprite[tgt].
height; y++) {
210 for (
int x = 0; x < sprite[tgt].width; x++) {
211 *dst = src_ln[x / scaled_1];
228 sprite[zoom].
AllocateData(zoom, sprite[zoom].height * sprite[zoom].width);
234 for (uint y = 0; y < sprite[zoom].
height; y++) {
236 assert(src_ln <= src_end);
237 for (uint x = 0; x < sprite[zoom].
width; x++) {
238 assert(src < src_ln);
239 if (src + 1 != src_ln && (src + 1)->a != 0) {
247 src = src_ln + sprite[zoom - 1].
width;
253 uint width = sprite->
width + pad_left + pad_right;
254 uint height = sprite->
height + pad_top + pad_bottom;
256 if (width > UINT16_MAX || height > UINT16_MAX)
return false;
266 for (uint y = 0; y < height; y++) {
267 if (y < pad_top || pad_bottom + y >= height) {
280 src += sprite->
width;
281 data += sprite->
width;
293 sprite->
width = width;
295 sprite->
x_offs -= pad_left;
296 sprite->
y_offs -= pad_top;
304 int min_xoffs = INT32_MAX;
305 int min_yoffs = INT32_MAX;
307 if (
HasBit(sprite_avail, zoom)) {
308 min_xoffs = std::min(min_xoffs,
ScaleByZoom(sprite[zoom].x_offs, zoom));
309 min_yoffs = std::min(min_yoffs,
ScaleByZoom(sprite[zoom].y_offs, zoom));
314 int max_width = INT32_MIN;
315 int max_height = INT32_MIN;
317 if (
HasBit(sprite_avail, zoom)) {
318 max_width = std::max(max_width,
ScaleByZoom(sprite[zoom].width + sprite[zoom].x_offs -
UnScaleByZoom(min_xoffs, zoom), zoom));
319 max_height = std::max(max_height,
ScaleByZoom(sprite[zoom].height + sprite[zoom].y_offs -
UnScaleByZoom(min_yoffs, zoom), zoom));
326 max_width =
Align(max_width, align);
327 max_height =
Align(max_height, align);
332 if (
HasBit(sprite_avail, zoom)) {
335 int pad_left = std::max(0, sprite[zoom].x_offs -
UnScaleByZoom(min_xoffs, zoom));
336 int pad_top = std::max(0, sprite[zoom].y_offs -
UnScaleByZoom(min_yoffs, zoom));
337 int pad_right = std::max(0,
UnScaleByZoom(max_width, zoom) - sprite[zoom].width - pad_left);
338 int pad_bottom = std::max(0,
UnScaleByZoom(max_height, zoom) - sprite[zoom].height - pad_top);
340 if (pad_left > 0 || pad_right > 0 || pad_top > 0 || pad_bottom > 0) {
341 if (!PadSingleSprite(&sprite[zoom], zoom, pad_left, pad_top, pad_right, pad_bottom))
return false;
354 if (!ResizeSpriteIn(sprite, first_avail,
ZOOM_LVL_NORMAL))
return false;
359 if (!PadSprites(sprite, sprite_avail, encoder))
return false;
363 if (
HasBit(sprite_avail, zoom)) {
372 if (!
HasBit(sprite_avail, zoom)) ResizeSpriteOut(sprite, zoom);
390 static const uint RECOLOUR_SPRITE_SIZE = 257;
391 byte *dest = (
byte *)AllocSprite(std::max(RECOLOUR_SPRITE_SIZE, num));
394 byte *dest_tmp =
AllocaM(
byte, std::max(RECOLOUR_SPRITE_SIZE, num));
397 if (num < RECOLOUR_SPRITE_SIZE) memset(dest_tmp, 0, RECOLOUR_SPRITE_SIZE);
401 for (uint i = 1; i < RECOLOUR_SPRITE_SIZE; i++) {
425 uint8 file_slot = sc->file_slot;
426 size_t file_pos = sc->file_pos;
429 assert(IsMapgenSpriteID(
id) == (sprite_type ==
ST_MAPGEN));
430 assert(sc->
type == sprite_type);
432 DEBUG(sprite, 9,
"Load sprite %d",
id);
435 uint8 sprite_avail = 0;
441 sprite_avail = sprite_loader.
LoadSprite(sprite, file_slot, file_pos, sprite_type,
true);
443 if (sprite_avail == 0) {
444 sprite_avail = sprite_loader.
LoadSprite(sprite, file_slot, file_pos, sprite_type,
false);
447 if (sprite_avail == 0) {
448 if (sprite_type ==
ST_MAPGEN)
return nullptr;
449 if (
id == SPR_IMG_QUERY)
usererror(
"Okay... something went horribly wrong. I couldn't load the fallback sprite. What should I do?");
472 byte *dest = s->
data;
481 if (!ResizeSprites(sprite, sprite_avail, file_slot, sc->id, encoder)) {
482 if (
id == SPR_IMG_QUERY)
usererror(
"Okay... something went horribly wrong. I couldn't resize the fallback sprite. What should I do?");
496 return encoder->
Encode(sprite, allocator);
521 if (container_version >= 2) {
529 uint32 id, prev_id = 0;
550 bool LoadNextSprite(
int load_index,
byte file_slot, uint file_sprite_id,
byte container_version)
556 if (num == 0)
return false;
560 void *data =
nullptr;
561 if (grf_type == 0xFF) {
570 }
else if (container_version >= 2 && grf_type == 0xFD) {
583 if (container_version >= 2)
return false;
592 bool is_mapgen = IsMapgenSpriteID(load_index);
595 if (type !=
ST_NORMAL)
usererror(
"Uhm, would you be so kind not to load a NewGRF that changes the type of the map generator sprites?");
600 sc->file_slot = file_slot;
601 sc->file_pos = file_pos;
604 sc->id = file_sprite_id;
618 scnew->file_slot = scold->file_slot;
619 scnew->file_pos = scold->file_pos;
620 scnew->ptr =
nullptr;
621 scnew->id = scold->id;
636 static_assert(
sizeof(
MemBlock) ==
sizeof(
size_t));
638 static_assert((
sizeof(
size_t) & (
sizeof(
size_t) - 1)) == 0);
645 static size_t GetSpriteCacheUsage()
650 for (s = _spritecache_ptr; s->size != 0; s = NextBlock(s)) {
658 void IncreaseSpriteLRU()
661 if (_sprite_lru_counter > 16384) {
664 DEBUG(sprite, 3,
"Fixing lru %u, inuse=" PRINTF_SIZE, _sprite_lru_counter, GetSpriteCacheUsage());
666 for (i = 0; i != _spritecache_items; i++) {
668 if (sc->ptr !=
nullptr) {
671 }
else if (sc->lru != -32768) {
676 _sprite_lru_counter = 0;
680 if (++_compact_cache_counter >= 740) {
682 _compact_cache_counter = 0;
694 DEBUG(sprite, 3,
"Compacting sprite cache, inuse=" PRINTF_SIZE, GetSpriteCacheUsage());
696 for (s = _spritecache_ptr; s->size != 0;) {
706 if (next->size == 0)
break;
709 for (i = 0; GetSpriteCache(i)->ptr != next->data; i++) {
710 assert(i != _spritecache_items);
713 GetSpriteCache(i)->ptr = s->data;
716 memmove(s, next, next->size);
740 GetSpriteCache(item)->ptr =
nullptr;
743 for (s = _spritecache_ptr; s->size != 0; s = NextBlock(s)) {
754 uint best = UINT_MAX;
757 DEBUG(sprite, 3,
"DeleteEntryFromSpriteCache, inuse=" PRINTF_SIZE, GetSpriteCacheUsage());
760 for (
SpriteID i = 0; i != _spritecache_items; i++) {
762 if (sc->
type !=
ST_RECOLOUR && sc->ptr !=
nullptr && sc->lru < cur_lru) {
770 if (best == UINT_MAX)
error(
"Out of sprite memory");
775 static void *AllocSprite(
size_t mem_req)
786 for (s = _spritecache_ptr; s->size != 0; s = NextBlock(s)) {
792 if (cur_size == mem_req ||
793 cur_size >= mem_req +
sizeof(
MemBlock)) {
798 if (cur_size != mem_req) {
799 NextBlock(s)->size = (cur_size - mem_req) |
S_FREE_MASK;
817 return MallocT<byte>(size);
831 static const char *
const sprite_types[] = {
844 byte warning_level = sc->
warned ? 6 : 0;
846 DEBUG(sprite, warning_level,
"Tried to load %s sprite #%d as a %s sprite. Probable cause: NewGRF interference", sprite_types[available], sprite, sprite_types[requested]);
850 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?");
855 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?");
876 assert(type !=
ST_MAPGEN || IsMapgenSpriteID(sprite));
879 if (!SpriteExists(sprite)) {
880 DEBUG(sprite, 1,
"Tried to load non-existing sprite #%d. Probable cause: Wrong/missing NewGRFs", sprite);
883 sprite = SPR_IMG_QUERY;
890 if (allocator ==
nullptr && encoder ==
nullptr) {
894 sc->lru = ++_sprite_lru_counter;
897 if (sc->ptr ==
nullptr) sc->ptr =
ReadSprite(sc, sprite, type, AllocSprite,
nullptr);
902 return ReadSprite(sc, sprite, type, allocator, encoder);
907 static void GfxInitSpriteCache()
911 uint target_size = (bpp > 0 ? _sprite_cache_size * bpp / 8 : 1) * 1024 * 1024;
914 static uint last_alloc_attempt = 0;
916 if (_spritecache_ptr ==
nullptr || (_allocated_sprite_cache_size != target_size && target_size != last_alloc_attempt)) {
917 delete[]
reinterpret_cast<byte *
>(_spritecache_ptr);
919 last_alloc_attempt = target_size;
920 _allocated_sprite_cache_size = target_size;
925 _spritecache_ptr =
reinterpret_cast<MemBlock *
>(
new byte[_allocated_sprite_cache_size + _allocated_sprite_cache_size / 2]);
926 }
catch (std::bad_alloc &) {
927 _spritecache_ptr =
nullptr;
930 if (_spritecache_ptr !=
nullptr) {
932 delete[]
reinterpret_cast<byte *
>(_spritecache_ptr);
933 _spritecache_ptr =
reinterpret_cast<MemBlock *
>(
new byte[_allocated_sprite_cache_size]);
934 }
else if (_allocated_sprite_cache_size < 2 * 1024 * 1024) {
935 usererror(
"Cannot allocate spritecache");
938 _allocated_sprite_cache_size >>= 1;
940 }
while (_spritecache_ptr ==
nullptr);
942 if (_allocated_sprite_cache_size != target_size) {
943 DEBUG(misc, 0,
"Not enough memory to allocate %d MiB of spritecache. Spritecache was reduced to %d MiB.", target_size / 1024 / 1024, _allocated_sprite_cache_size / 1024 / 1024);
945 ErrorMessageData msg(STR_CONFIG_ERROR_OUT_OF_MEMORY, STR_CONFIG_ERROR_SPRITECACHE_TOO_BIG);
946 msg.SetDParam(0, target_size);
947 msg.SetDParam(1, _allocated_sprite_cache_size);
955 NextBlock(_spritecache_ptr)->size = 0;
958 void GfxInitSpriteMem()
960 GfxInitSpriteCache();
964 _spritecache_items = 0;
965 _spritecache =
nullptr;
967 _compact_cache_counter = 0;
977 for (uint i = 0; i != _spritecache_items; i++) {