openttd-mini: comparison spritecache.c

equal deleted inserted replaced

-:ec2b02ea4c88
+:dbeaaaf8b2bb
 static const char * const _filename_list[] = {
 	"TRG1R.GRF",
 	"TRGIR.GRF",
 	"signalsw.grf", //0x1320 - 0x1405 inclusive
 //	"openttd.grf",	//0x1406 -
 	NULL
 };
 static const char * const _landscape_filenames[] = {
 	"TRGCR.GRF",
 	if (_skip_sprites) {
 		if (_skip_sprites > 0)
 			_skip_sprites--;
 		deaf = 1;
 	}
 	type = FioReadByte();
 	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
 		} else {
 			DecodeSpecialSprite(_cur_grffile, num, load_index);
 		}
 		return;
 	}
 	_cur_sprite.info = type;
 #ifdef WANT_SPRITESIZES
 	_cur_sprite.height = FioReadByte();
 	_cur_sprite.width = FioReadWord();
 	_cur_sprite.x_offs = FioReadWord();
 {
 	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;
 				*dest++ = FioReadByte();
 		} else {
 			dist = -(((i&7)<<8)|FioReadByte());
 			i = -(i >> 3);
 			num -= i;
 			rel = &dest[dist];
 			while (i--)
 				*dest++ = *rel++;
 		}
 	}
 	_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;
 				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)
 {
 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.
 #endif
 				// Offset the sprite pointer by the size of the free block
 				_sprite_ptr[i] -= size;
 				// Move the memory
 				memcpy_overlapping(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;
 #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;
 			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.
 			_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)
 	MAP(4120, 4125, _fence_map)
 	return s;
 }
 #endif
 byte *GetSpritePtr(uint sprite)
 {
 	byte *p;
 	assert(sprite < NUM_SPRITES);
 	// 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] = {
 static void LoadSpriteTables()
 {
 	int i,j;
-	/* load initial sprites */
+	/*
+	 * 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.
+	 */
+	// 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; _filename_list[i] != NULL; i++) {
 			load_index += LoadGrfFile(_filename_list[i], load_index, (byte)i);
 		}
 		LoadGrfIndexed("openttd.grf", _openttd_grf_indexes, i++);
-		{
+		if (_sprite_page_to_load != 0)
-			int l;
+			LoadGrfIndexed(_landscape_filenames[_sprite_page_to_load-1], _landscape_spriteindexes[_sprite_page_to_load-1], i++);
-			if ((l=_sprite_page_to_load) != 0)
-				LoadGrfIndexed(_landscape_filenames[l-1], _landscape_spriteindexes[l-1], i++);
-		}
 		LoadGrfIndexed("trkfoundw.grf", _slopes_spriteindexes[_opt.landscape], i++);
 		load_index = SPR_CANALS_BASE;
 		load_index += LoadGrfFile("canalsw.grf", load_index, i++);
-		/* XXX: Only for debugging. Will be more generic. */
+		load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT + 1;
-		load_index = SPR_OPENTTD_BASE + OPENTTD_SPRITES_COUNT+1;
 		for(j=0; j!=lengthof(_newgrf_files) && _newgrf_files[j]; j++)
 			load_index += LoadGrfFile(_newgrf_files[j], load_index, i++);
-//		load_index += LoadGrfFile("arcticseto.grf", load_index, i++);
+		// If needed, save the cache to file
-//		load_index += LoadGrfFile("tempsetpo.grf", load_index, i++);
-//		load_index += LoadGrfFile("newshipso.grf", load_index, i++);
-		//load_index += LoadGrfFile("brseto.grf", load_index, i++);
 		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; _filename_list[i] != NULL; i++)
 			FioOpenFile(i,_filename_list[i]);
-		FioOpenFile(i, "openttd.grf");
+		FioOpenFile(i++, "openttd.grf");
-		FioOpenFile(i+1, "canalsw.grf");
 		if (_sprite_page_to_load != 0)
-			FioOpenFile(i+2, _landscape_filenames[_sprite_page_to_load-1]);
+			FioOpenFile(i++, _landscape_filenames[_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 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
 	sd->xsize = _sprite_xsize[sprite];
 	sd->ysize = _sprite_ysize[sprite];
 */
 	return sd;
 }

changeset 184	dbeaaaf8b2bb
parent 182	1641047f1d9f
child 361	95307fb1c3f8