OpenTTD-patches/spritecache.c
dominik 6e99d2c0e8 (svn r1038) Feature: OpenTTD runs with the grf files of the DOS version
Please read the Readme for further information. There are some minor graphical glitches when you use the DOS files. E.g. the autorail button is a bit screwed up.
2004-12-12 20:36:24 +00:00

950 lines
22 KiB
C
Raw Blame History

#include "stdafx.h"
#include "ttd.h"
#include "gfx.h"
#include "fileio.h"
#include "newgrf.h"
#include <ctype.h>
#define SPRITECACHE_ID 0xF00F0006
#define SPRITE_CACHE_SIZE 1024*1024
//#define WANT_SPRITESIZES
#define WANT_NEW_LRU
//#define WANT_LOCKED
/* These are used in newgrf.c: */
int _skip_sprites = 0;
int _replace_sprites_count[16];
int _replace_sprites_offset[16];
static const char *_cur_grffile;
static int _loading_stage;
static int _skip_specials;
uint16 _custom_sprites_base;
static SpriteHdr _cur_sprite;
static byte *_sprite_ptr[NUM_SPRITES];
static uint16 _sprite_size[NUM_SPRITES];
static uint32 _sprite_file_pos[NUM_SPRITES];
// This one is probably not needed.
#if defined(WANT_LOCKED)
static bool _sprite_locked[NUM_SPRITES];
#endif
#if defined(WANT_NEW_LRU)
static int16 _sprite_lru_new[NUM_SPRITES];
#else
static uint16 _sprite_lru[NUM_SPRITES];
static uint16 _sprite_lru_cur[NUM_SPRITES];
#endif
#ifdef WANT_SPRITESIZES
static int8 _sprite_xoffs[NUM_SPRITES];
static int8 _sprite_yoffs[NUM_SPRITES];
static uint16 _sprite_xsize[NUM_SPRITES];
static uint8 _sprite_ysize[NUM_SPRITES];
#endif
static uint _sprite_lru_counter;
static byte *_spritecache_ptr;
static uint32 _spritecache_size;
static int _compact_cache_counter;
typedef struct FileList {
const char * const basic[4]; // grf files that always have to be loaded
const char * const landscape[3]; // landscape specific grf files
} FileList;
FileList files_dos = {
{ "TRG1.GRF",
"TRGI.GRF",
"signalsw.grf", //0x1320 - 0x1405 inclusive
NULL },
{ "TRGC.GRF",
"TRGH.GRF",
"TRGT.GRF" },
};
FileList files_win = {
{ "TRG1R.GRF",
"TRGIR.GRF",
"signalsw.grf", //0x1320 - 0x1405 inclusive
NULL },
{ "TRGCR.GRF",
"TRGHR.GRF",
"TRGTR.GRF" },
};
#include "table/landscape_sprite.h"
static const uint16 * const _landscape_spriteindexes[] = {
_landscape_spriteindexes_1,
_landscape_spriteindexes_2,
_landscape_spriteindexes_3,
};
static const uint16 * const _slopes_spriteindexes[] = {
_slopes_spriteindexes_0,
_slopes_spriteindexes_1,
_slopes_spriteindexes_2,
_slopes_spriteindexes_3,
};
static void CompactSpriteCache();
static void ReadSpriteHeaderSkipData(int num, int load_index)
{
byte type;
int8 i;
int deaf = 0;
if (_skip_sprites) {
if (_skip_sprites > 0)
_skip_sprites--;
deaf = 1;
}
type = FioReadByte();
_cur_sprite.info = type;
if (type == 0xFF) {
/* We need to really skip only special sprites in the deaf
* mode. It won't hurt to proceed regular sprites as usual
* because if no special sprite referencing to them is
* processed, they themselves are never referenced and loaded
* on their own. */
if (_skip_specials || deaf) {
FioSkipBytes(num);
} else {
DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);
}
return;
}
#ifdef WANT_SPRITESIZES
_cur_sprite.height = FioReadByte();
_cur_sprite.width = FioReadWord();
_cur_sprite.x_offs = FioReadWord();
_cur_sprite.y_offs = FioReadWord();
#else
FioSkipBytes(7);
#endif
num -= 8;
if (num == 0)
return;
if (type & 2) {
FioSkipBytes(num);
return;
}
while (num) {
i = FioReadByte();
if (i>=0) {
num -= i;
FioSkipBytes(i);
} else {
i = -(i >> 3);
num -= i;
FioReadByte();
}
}
}
static void ReadSprite(int num, byte *dest)
{
byte type;
byte *rel;
int8 i;
int j, dist;
type = FioReadByte();
/* We've decoded special sprites when reading headers. */
if (type != 0xFF) {
/* read sprite hdr */
*dest++ = type;
for(j=0; j!=7; j++)
*dest++ = FioReadByte();
num -= 8;
}
if (type & 2) {
while (num--)
*dest++ = FioReadByte();
return;
}
while (num) {
i = FioReadByte();
if (i>=0) {
num -= i;
while (i--)
*dest++ = FioReadByte();
} else {
dist = -(((i&7)<<8)|FioReadByte());
i = -(i >> 3);
num -= i;
rel = &dest[dist];
while (i--)
*dest++ = *rel++;
}
}
}
static bool LoadNextSprite(int load_index, byte file_index)
{
uint16 size;
uint32 file_pos;
if ((size = FioReadWord()) == 0)
return false;
file_pos = FioGetPos() | (file_index << 24);
ReadSpriteHeaderSkipData(size, load_index);
if ((_replace_sprites_count[0] > 0) && (_cur_sprite.info != 0xFF)) {
int count = _replace_sprites_count[0];
int offset = _replace_sprites_offset[0];
_replace_sprites_offset[0]++;
_replace_sprites_count[0]--;
if ((offset + count) <= NUM_SPRITES) {
load_index = offset;
} else {
DEBUG(spritecache, 1) ("Sprites to be replaced are out of range: %x+%x",
count, offset);
_replace_sprites_offset[0] = 0;
_replace_sprites_count[0] = 0;
}
if (_replace_sprites_count[0] == 0) {
int i;
for (i = 0; i < 15; i++) {
_replace_sprites_count[i] = _replace_sprites_count[i + 1];
_replace_sprites_offset[i] = _replace_sprites_offset[i + 1];
}
_replace_sprites_count[i] = 0;
_replace_sprites_offset[i] = 0;
}
}
_sprite_size[load_index] = size;
_sprite_file_pos[load_index] = file_pos;
#ifdef WANT_SPRITESIZES
_sprite_xsize[load_index] = _cur_sprite.width;
_sprite_ysize[load_index] = _cur_sprite.height;
_sprite_xoffs[load_index] = _cur_sprite.x_offs;
_sprite_yoffs[load_index] = _cur_sprite.y_offs;
#endif
_sprite_ptr[load_index] = NULL;
#if defined(WANT_LOCKED)
_sprite_locked[load_index] = false;
#endif
#if defined(WANT_NEW_LRU)
_sprite_lru_new[load_index] = 0;
#else
_sprite_lru[load_index] = 0xFFFF;
_sprite_lru_cur[load_index] = 0;
#endif
return true;
}
static void SkipSprites(int count)
{
while(count>0)
{
uint16 size;
if ( (size = FioReadWord()) == 0)
return;
ReadSpriteHeaderSkipData(size, NUM_SPRITES-1);
count--;
}
}
static int LoadGrfFile(const char *filename, int load_index, int file_index)
{
int load_index_org = load_index;
FioOpenFile(file_index, filename);
/* Thou shalt use LoadNewGrfFile() if thou loadeth a GRF file that
* might contain some special sprites. */
_skip_specials = 1;
_skip_sprites = 0;
DEBUG(spritecache, 2) ("Reading grf-file ``%s''", filename);
while (LoadNextSprite(load_index, file_index)) {
load_index++;
if (load_index >= NUM_SPRITES) {
error("Too many sprites. Recompile with higher NUM_SPRITES value or remove some custom GRF files.");
}
}
return load_index - load_index_org;
}
static int LoadNewGrfFile(const char *filename, int load_index, int file_index)
{
int i;
FioOpenFile(file_index, filename);
_cur_grffile = filename;
_skip_specials = 0;
_skip_sprites = 0;
DEBUG(spritecache, 2) ("Reading newgrf-file ``%s'' [offset: %u]",
filename, load_index);
/* Skip the first sprite; we don't care about how many sprites this
* does contain; newest TTDPatches and George's longvehicles don't
* neither, apparently. */
{
int length;
byte type;
length = FioReadWord();
type = FioReadByte();
if ((length == 4) && (type == 0xFF)) {
FioReadDword();
} else {
error("Custom .grf has invalid format.");
}
}
for (i = 0; LoadNextSprite(load_index + i, file_index); i++) {
if (load_index + i >= NUM_SPRITES)
error("Too many sprites (%x). Recompile with higher NUM_SPRITES value or remove some custom GRF files.",
load_index + i);
}
/* Clean up. */
_skip_sprites = 0;
memset(_replace_sprites_count, 0, 16 * sizeof(*_replace_sprites_count));
memset(_replace_sprites_offset, 0, 16 * sizeof(*_replace_sprites_offset));
return i;
}
static void LoadGrfIndexed(const char *filename, const uint16 *index_tbl, int file_index)
{
int start;
FioOpenFile(file_index, filename);
_skip_specials = 1;
_skip_sprites = 0;
DEBUG(spritecache, 2) ("Reading indexed grf-file ``%s''", filename);
for(;(start=*index_tbl++) != 0xffff;) {
int end = *index_tbl++;
if(start==0xfffe) { // skip sprites (amount in second var)
SkipSprites(end);
} else { // load sprites and use indexes from start to end
do {
bool b = LoadNextSprite(start, file_index);
assert(b);
} while (++start <= end);
}
}
}
typedef size_t CDECL fread_t(void*,size_t,size_t,FILE*);
static bool HandleCachedSpriteHeaders(const char *filename, bool read)
{
FILE *f;
fread_t *proc;
uint32 hdr;
if (!_cache_sprites)
return false;
if (read) {
f = fopen(filename, "rb");
proc = fread;
if (f == NULL)
return false;
proc(&hdr, sizeof(hdr), 1, f);
if (hdr != SPRITECACHE_ID) {
fclose(f);
return false;
}
} else {
f = fopen(filename, "wb");
proc = (fread_t*) fwrite;
if (f == NULL)
return false;
hdr = SPRITECACHE_ID;
proc(&hdr, sizeof(hdr), 1, f);
}
proc(_sprite_size, 1, sizeof(_sprite_size), f);
proc(_sprite_file_pos, 1, sizeof(_sprite_file_pos), f);
#if 0
proc(_sprite_xsize, 1, sizeof(_sprite_xsize), f);
proc(_sprite_ysize, 1, sizeof(_sprite_ysize), f);
proc(_sprite_xoffs, 1, sizeof(_sprite_xoffs), f);
proc(_sprite_yoffs, 1, sizeof(_sprite_yoffs), f);
#endif
#if !defined(WANT_NEW_LRU)
if (read)
memset(_sprite_lru, 0xFF, sizeof(_sprite_lru));
#endif
fclose(f);
return true;
}
#define S_DATA(x) (*(uint32*)(x))
#define S_FREE_MASK 1
#define S_HDRSIZE sizeof(uint32)
static uint32 GetSpriteCacheUsage()
{
byte *s = _spritecache_ptr;
size_t cur_size, tot_size = 0;
for(; (cur_size=S_DATA(s)) != 0; s+=cur_size) {
if ( cur_size & S_FREE_MASK ) {
cur_size--;
} else {
tot_size += cur_size;
}
}
return tot_size;
}
void IncreaseSpriteLRU()
{
int i;
// Increase all LRU values
#if defined(WANT_NEW_LRU)
if (_sprite_lru_counter > 16384) {
DEBUG(spritecache, 2) ("fixing lru %d, inuse=%d", _sprite_lru_counter, GetSpriteCacheUsage());
for(i=0; i!=NUM_SPRITES; i++)
if (_sprite_ptr[i] != NULL) {
if (_sprite_lru_new[i] >= 0) {
_sprite_lru_new[i] = -1;
} else if (_sprite_lru_new[i] != -32768) {
_sprite_lru_new[i]--;
}
}
_sprite_lru_counter = 0;
}
#else
for(i=0; i!=NUM_SPRITES; i++)
if (_sprite_ptr[i] != NULL && _sprite_lru[i] != 65535)
_sprite_lru[i]++;
// Reset the lru counter.
_sprite_lru_counter = 0;
#endif
// Compact sprite cache every now and then.
if (++_compact_cache_counter >= 740) {
CompactSpriteCache();
_compact_cache_counter = 0;
}
}
// Called when holes in the sprite cache should be removed.
// That is accomplished by moving the cached data.
static void CompactSpriteCache()
{
byte *s, *t;
size_t size, sizeb, cur_size;
int i;
DEBUG(spritecache, 2) ("compacting sprite cache, inuse=%d", GetSpriteCacheUsage());
s = _spritecache_ptr;
while (true) {
size = S_DATA(s);
// Only look for free blocks.
if (size & S_FREE_MASK) {
size -= S_FREE_MASK;
// Since free blocks are automatically coalesced, this should hold true.
assert(!(S_DATA(s+size) & S_FREE_MASK));
// If the next block is the sentinel block, we can safely return
if ( (sizeb=S_DATA(s + size)) == 0)
break;
// Locate the sprite number belonging to the next pointer.
for(i=0,t=s+size+S_HDRSIZE; _sprite_ptr[i] != t; i++) {assert(i < NUM_SPRITES);}
// If it's locked, we must not move it.
#if defined(WANT_LOCKED)
if (!_sprite_locked[i]) {
#endif
// Offset the sprite pointer by the size of the free block
_sprite_ptr[i] -= size;
// Move the memory
memmove(s + S_HDRSIZE, s + S_HDRSIZE + size, sizeb - S_HDRSIZE);
// What we just did had the effect of swapping the allocated block with the free block, so we need to update
// the block pointers. First update the allocated one. It is in use.
S_DATA(s) = sizeb;
// Then coalesce the free ones that follow.
s += sizeb;
while ((cur_size = S_DATA(s+size)) & S_FREE_MASK)
size += cur_size - S_FREE_MASK;
S_DATA(s) = size + S_FREE_MASK;
continue;
#if defined(WANT_LOCKED)
}
#endif
}
// Continue with next block until the sentinel is reached.
s += size;
if (size == 0)
break;
}
}
static void DeleteEntryFromSpriteCache()
{
int i;
int best = -1;
byte *s;
size_t cur_size, cur;
int cur_lru;
DEBUG(spritecache, 2) ("DeleteEntryFromSpriteCache, inuse=%d", GetSpriteCacheUsage());
#if defined(WANT_NEW_LRU)
cur_lru = 0xffff;
for(i=0; i!=NUM_SPRITES; i++) {
if (_sprite_ptr[i] != 0 &&
_sprite_lru_new[i] < cur_lru
#if defined(WANT_LOCKED)
&& !_sprite_locked[i]) {
#else
) {
#endif
cur_lru = _sprite_lru_new[i];
best = i;
}
}
#else
{
uint16 cur_lru = 0, cur_lru_cur = 0xffff;
for(i=0; i!=NUM_SPRITES; i++) {
if (_sprite_ptr[i] == 0 ||
#if defined(WANT_LOCKED)
_sprite_locked[i] ||
#endif
_sprite_lru[i] < cur_lru)
continue;
// Found a sprite with a higher LRU value, then remember it.
if (_sprite_lru[i] != cur_lru) {
cur_lru = _sprite_lru[i];
best = i;
// Else if both sprites were very recently referenced, compare by the cur value instead.
} else if (cur_lru == 0 && _sprite_lru_cur[i] <= cur_lru_cur) {
cur_lru_cur = _sprite_lru_cur[i];
cur_lru = _sprite_lru[i];
best = i;
}
}
}
#endif
// Display an error message and die, in case we found no sprite at all.
// This shouldn't really happen, unless all sprites are locked.
if (best == -1)
error("Out of sprite memory");
// Mark the block as free (the block must be in use)
s = _sprite_ptr[best];
assert(!(S_DATA(s - S_HDRSIZE) & S_FREE_MASK));
S_DATA(s - S_HDRSIZE) += S_FREE_MASK;
_sprite_ptr[best] = NULL;
// And coalesce adjacent free blocks
s = _spritecache_ptr;
for(; (cur_size=S_DATA(s)) != 0; s+=cur_size) {
if ( cur_size & S_FREE_MASK ) {
while ((cur=S_DATA(s+cur_size-S_FREE_MASK)) & S_FREE_MASK) {
cur_size += cur - S_FREE_MASK;
S_DATA(s) = cur_size;
}
cur_size--;
}
}
}
static byte *LoadSpriteToMem(int sprite)
{
byte *s;
size_t mem_req, cur_size;
DEBUG(spritecache, 9) ("load sprite %d", sprite);
restart:
// Number of needed bytes
mem_req = _sprite_size[sprite] + S_HDRSIZE;
// Align this to an uint32 boundary. This also makes sure that the 2 least bit are not used,
// so we could use those for other things.
mem_req = (mem_req + sizeof(uint32) - 1) & ~(sizeof(uint32) - 1);
s = _spritecache_ptr;
for(;;) {
for(;;) {
cur_size = S_DATA(s);
if (! (cur_size & S_FREE_MASK) ) break;
cur_size -= S_FREE_MASK;
// Now s points at a free block.
// The block is exactly the size we need?
if (cur_size != mem_req) {
// No.. is it too small?
if (cur_size < mem_req + S_HDRSIZE)
break;
// Block was big enough, and we need to inject a free block too.
S_DATA(s + mem_req) = cur_size - mem_req + S_FREE_MASK;
}
// Set size and in use
S_DATA(s) = mem_req;
_sprite_ptr[sprite] = (s += S_HDRSIZE);
FioSeekToFile(_sprite_file_pos[sprite]);
ReadSprite(_sprite_size[sprite], s);
// Patch the height to compensate for a TTD bug?
if (sprite == 142) { s[1] = 10; }
// Return sprite ptr
return s;
}
// Reached sentinel, but no block found yet. Need to delete some old entries.
if (cur_size == 0) {
DeleteEntryFromSpriteCache();
goto restart;
}
s += cur_size;
}
}
#if defined(NEW_ROTATION)
#define X15(x) else if (s >= x && s < (x+15)) { s = _rotate_tile_sprite[s - x] + x; }
#define X19(x) else if (s >= x && s < (x+19)) { s = _rotate_tile_sprite[s - x] + x; }
#define MAP(from,to,map) else if (s >= from && s <= to) { s = map[s - from] + from; }
static uint RotateSprite(uint s)
{
static const byte _rotate_tile_sprite[19] = { 0,2,4,6,8,10,12,14,1,3,5,7,9,11,13,17,18,16,15 };
static const byte _coast_map[9] = {0, 4, 3, 1, 2, 6, 8, 5, 7};
static const byte _fence_map[6] = {1, 0, 5, 4, 3, 2};
if (0);
X19(752)
X15(990-1)
X19(3924)
X19(3943)
X19(3962)
X19(3981)
X19(4000)
X19(4023)
X19(4042)
MAP(4061,4069,_coast_map)
X19(4126)
X19(4145)
X19(4164)
X19(4183)
X19(4202)
X19(4221)
X19(4240)
X19(4259)
X19(4259)
X19(4278)
MAP(4090, 4095, _fence_map)
MAP(4096, 4101, _fence_map)
MAP(4102, 4107, _fence_map)
MAP(4108, 4113, _fence_map)
MAP(4114, 4119, _fence_map)
MAP(4120, 4125, _fence_map)
return s;
}
#endif
byte *GetSpritePtr(uint sprite)
{
byte *p;
assert(sprite < NUM_SPRITES);
#if defined(NEW_ROTATION)
sprite = RotateSprite(sprite);
#endif
// Update LRU
#if defined(WANT_NEW_LRU)
_sprite_lru_new[sprite] = ++_sprite_lru_counter;
#else
_sprite_lru_cur[sprite] = ++_sprite_lru_counter;
_sprite_lru[sprite] = 0;
#endif
// Check if the sprite is loaded already?
p = _sprite_ptr[sprite];
if (p == NULL)
p = LoadSpriteToMem(sprite); // No, need to load it.
return p;
}
byte _sprite_page_to_load = 0xFF;
static const char * const _cached_filenames[4] = {
"cached_sprites.xxx",
"cached_sprites.xx1",
"cached_sprites.xx2",
"cached_sprites.xx3",
};
#define OPENTTD_SPRITES_COUNT 93
static const uint16 _openttd_grf_indexes[] = {
SPR_OPENTTD_BASE+0, SPR_OPENTTD_BASE+7, // icons etc
134, 134, // euro symbol medium size
582, 582, // euro symbol large size
358, 358, // euro symbol tiny
SPR_OPENTTD_BASE+11, SPR_OPENTTD_BASE+57, // more icons
648, 648, // nordic char: <20>
616, 616, // nordic char: <20>
666, 666, // nordic char: <20>
634, 634, // nordic char: <20>
SPR_OPENTTD_BASE+62, SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT, // more icons
0xffff,
};
/* Checks, if either the Windows files exist (TRG1R.GRF) or the DOS files (TRG1.GRF).
* _use_dos_palette is set accordingly
* WARNING! This is case-sensitive, therefore the file has to be uppercase for correct
* detection. If neither are found, Windows palette is assumed. */
static void CheckGrfFile()
{
FILE *f;
byte *s;
s = str_fmt("%s%s", _path.data_dir, files_win.basic[0]);
f = fopen(s, "r");
if (f != NULL) {
_use_dos_palette = false;
return;
}
s = str_fmt("%s%s", _path.data_dir, files_dos.basic[0]);
f = fopen(s, "r");
if (f != NULL) {
_use_dos_palette = true;
return;
}
}
static void LoadSpriteTables()
{
int i,j;
FileList *files; // list of grf files to be loaded. Either Windows files or DOS files
_loading_stage = 1;
/*
* Note for developers:
* Keep in mind that when you add a LoadGrfIndexed in the 'if'-section below
* that you should also add the corresponding FioOpenFile to the 'else'-section
* below.
*
* TODO:
* I think we can live entirely without Indexed GRFs, but I have to
* invest that further. --octo
*/
// Check if we have the DOS or Windows version of the GRF files
CheckGrfFile();
files = _use_dos_palette?(&files_dos):(&files_win);
// Try to load the sprites from cache
if (!HandleCachedSpriteHeaders(_cached_filenames[_opt.landscape], true)) {
// We do not have the sprites in cache yet, or cache is disabled
// So just load all files from disk..
int load_index = 0;
for(i=0; files->basic[i] != NULL; i++) {
load_index += LoadGrfFile(files->basic[i], load_index, (byte)i);
}
LoadGrfIndexed("openttd.grf", _openttd_grf_indexes, i++);
if (_sprite_page_to_load != 0)
LoadGrfIndexed(files->landscape[_sprite_page_to_load-1], _landscape_spriteindexes[_sprite_page_to_load-1], i++);
LoadGrfIndexed("trkfoundw.grf", _slopes_spriteindexes[_opt.landscape], i++);
load_index = SPR_CANALS_BASE;
load_index += LoadGrfFile("canalsw.grf", load_index, i++);
load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT + 1;
/* Load newgrf sprites */
_custom_sprites_base = load_index;
_loading_stage = 0;
for (j = 0; j != lengthof(_newgrf_files) && _newgrf_files[j]; j++) {
InitNewGRFFile(_newgrf_files[j], load_index);
load_index += LoadNewGrfFile(_newgrf_files[j], load_index, i++);
}
_loading_stage = 1;
load_index = _custom_sprites_base;
for (j = 0; j != lengthof(_newgrf_files) && _newgrf_files[j]; j++)
load_index += LoadNewGrfFile(_newgrf_files[j], load_index, i++);
// If needed, save the cache to file
HandleCachedSpriteHeaders(_cached_filenames[_opt.landscape], false);
} else {
// We have sprites cached. We just loaded the cached files
// now we only have to open a file-pointer to all the original grf-files
// This is very important. Not all sprites are in the cache. So sometimes
// the game needs to load the sprite from disk. When the file is not
// open it can not read. So all files that are in the 'if'-section
// above should also be in this 'else'-section.
//
// NOTE: the order of the files must be identical as in the section above!!
for(i = 0; files->basic[i] != NULL; i++)
FioOpenFile(i,files->basic[i]);
FioOpenFile(i++, "openttd.grf");
if (_sprite_page_to_load != 0)
FioOpenFile(i++, files->landscape[_sprite_page_to_load-1]);
FioOpenFile(i++, "trkfoundw.grf");
FioOpenFile(i++, "canalsw.grf");
// FIXME: if a user changes his newgrf's, the cached-sprites gets
// invalid. We should have some kind of check for this.
// The best solution for this is to delete the cached-sprites.. but how
// do we detect it?
for(j=0; j!=lengthof(_newgrf_files) && _newgrf_files[j]; j++)
FioOpenFile(i++, _newgrf_files[j]);
}
_compact_cache_counter = 0;
}
void GfxInitSpriteMem(byte *ptr, uint32 size)
{
// initialize sprite cache heap
_spritecache_ptr = ptr;
_spritecache_size = size;
// Sentinel block (identified by size=0)
S_DATA(ptr + size - S_HDRSIZE) = 0;
// A big free block
S_DATA(ptr) = size - S_HDRSIZE + S_FREE_MASK;
memset(_sprite_ptr, 0, sizeof(_sprite_ptr));
}
void GfxLoadSprites() {
static byte *_sprite_mem;
// Need to reload the sprites only if the landscape changed
if (_sprite_page_to_load != _opt.landscape) {
_sprite_page_to_load = _opt.landscape;
// Sprite cache
DEBUG(spritecache, 1) ("Loading sprite set %d.", _sprite_page_to_load);
// Reuse existing memory?
if (_sprite_mem == NULL) _sprite_mem = malloc(SPRITE_CACHE_SIZE);
GfxInitSpriteMem(_sprite_mem, SPRITE_CACHE_SIZE);
LoadSpriteTables();
GfxInitPalettes();
}
}
const SpriteDimension *GetSpriteDimension(uint sprite)
{
static SpriteDimension sd_static;
SpriteDimension *sd;
#ifndef WANT_SPRITESIZES
byte *p;
p = _sprite_ptr[sprite];
if (p == NULL)
p = GetSpritePtr(sprite);
/* decode sprite header */
sd = &sd_static;
sd->xoffs = (int16)READ_LE_UINT16(&((SpriteHdr*)p)->x_offs);
sd->yoffs = (int16)READ_LE_UINT16(&((SpriteHdr*)p)->y_offs);
sd->xsize = READ_LE_UINT16(&((SpriteHdr*)p)->width);
sd->ysize = ((SpriteHdr*)p)->height;
#else
sd = &sd_static;
sd->xoffs = _sprite_xoffs[sprite];
sd->yoffs = _sprite_yoffs[sprite];
sd->xsize = _sprite_xsize[sprite];
sd->ysize = _sprite_ysize[sprite];
#endif
/* sd->xoffs = _sprite_xoffs[sprite];
sd->yoffs = _sprite_yoffs[sprite];
sd->xsize = _sprite_xsize[sprite];
sd->ysize = _sprite_ysize[sprite];
*/
return sd;
}