1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "gfx.h"

     4

#include "fileio.h"

     5

#include "newgrf.h"

     6

#include <ctype.h>

     7

     8

#define SPRITECACHE_ID 0xF00F0006

     9

#define SPRITE_CACHE_SIZE 1024*1024

    10

    11

    12

//#define WANT_SPRITESIZES

    13

#define WANT_NEW_LRU

    14

//#define WANT_LOCKED

    15

    16

    17

/* These are used in newgrf.c: */

    18

    19

int _skip_sprites = 0;

    20

int _replace_sprites_count[16];

    21

int _replace_sprites_offset[16];

    22

    23

static const char *_cur_grffile;

    24

static int _loading_stage;

    25

static int _skip_specials;

    26

uint16 _custom_sprites_base;

    27

static SpriteHdr _cur_sprite;

    28

    29

    30

static byte *_sprite_ptr[NUM_SPRITES];

    31

static uint16 _sprite_size[NUM_SPRITES];

    32

static uint32 _sprite_file_pos[NUM_SPRITES];

    33

    34

// This one is probably not needed.

    35

#if defined(WANT_LOCKED)

    36

static bool _sprite_locked[NUM_SPRITES];

    37

#endif

    38

    39

#if defined(WANT_NEW_LRU)

    40

static int16 _sprite_lru_new[NUM_SPRITES];

    41

#else

    42

static uint16 _sprite_lru[NUM_SPRITES];

    43

static uint16 _sprite_lru_cur[NUM_SPRITES];

    44

#endif

    45

    46

#ifdef WANT_SPRITESIZES

    47

static int8 _sprite_xoffs[NUM_SPRITES];

    48

static int8 _sprite_yoffs[NUM_SPRITES];

    49

static uint16 _sprite_xsize[NUM_SPRITES];

    50

static uint8 _sprite_ysize[NUM_SPRITES];

    51

#endif

    52

    53

static uint _sprite_lru_counter;

    54

static byte *_spritecache_ptr;

    55

static uint32 _spritecache_size;

    56

static int _compact_cache_counter;

    57

    58

typedef struct FileList {

    59

	const char * const basic[4];     // grf files that always have to be loaded

    60

	const char * const landscape[3]; // landscape specific grf files

    61

} FileList;

    62

    63

FileList files_dos = {

    64

	{	"TRG1.GRF",

    65

		"TRGI.GRF",

    66

		"signalsw.grf", //0x1320 - 0x1405 inclusive

    67

		NULL },

    68

	{	"TRGC.GRF",

    69

		"TRGH.GRF",

    70

		"TRGT.GRF" },

    71

};

    72

    73

FileList files_win = {

    74

	{	"TRG1R.GRF",

    75

		"TRGIR.GRF",

    76

		"signalsw.grf", //0x1320 - 0x1405 inclusive

    77

		NULL },

    78

	{	"TRGCR.GRF",

    79

		"TRGHR.GRF",

    80

		"TRGTR.GRF" },

    81

};

    82

    83

#include "table/landscape_sprite.h"

    84

    85

static const uint16 * const _landscape_spriteindexes[] = {

    86

	_landscape_spriteindexes_1,

    87

	_landscape_spriteindexes_2,

    88

	_landscape_spriteindexes_3,

    89

};

    90

    91

static const uint16 * const _slopes_spriteindexes[] = {

    92

	_slopes_spriteindexes_0,

    93

	_slopes_spriteindexes_1,

    94

	_slopes_spriteindexes_2,

    95

	_slopes_spriteindexes_3,

    96

};

    97

    98

static void CompactSpriteCache();

    99

   100

static void ReadSpriteHeaderSkipData(int num, int load_index)

   101

{

   102

	byte type;

   103

	int8 i;

   104

	int deaf = 0;

   105

   106

	if (_skip_sprites) {

   107

		if (_skip_sprites > 0)

   108

			_skip_sprites--;

   109

		deaf = 1;

   110

	}

   111

   112

	type = FioReadByte();

   113

	_cur_sprite.info = type;

   114

	if (type == 0xFF) {

   115

		/* We need to really skip only special sprites in the deaf

   116

		 * mode.  It won't hurt to proceed regular sprites as usual

   117

		 * because if no special sprite referencing to them is

   118

		 * processed, they themselves are never referenced and loaded

   119

		 * on their own. */

   120

		if (_skip_specials || deaf) {

   121

			FioSkipBytes(num);

   122

		} else {

   123

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   124

		}

   125

		return;

   126

	}

   127

   128

#ifdef WANT_SPRITESIZES

   129

	_cur_sprite.height = FioReadByte();

   130

	_cur_sprite.width = FioReadWord();

   131

	_cur_sprite.x_offs = FioReadWord();

   132

	_cur_sprite.y_offs = FioReadWord();

   133

#else

   134

	FioSkipBytes(7);

   135

#endif

   136

	num -= 8;

   137

	if (num == 0)

   138

		return;

   139

   140

	if (type & 2) {

   141

		FioSkipBytes(num);

   142

		return;

   143

	}

   144

   145

	while (num) {

   146

		i = FioReadByte();

   147

		if (i>=0) {

   148

			num -= i;

   149

			FioSkipBytes(i);

   150

		} else {

   151

			i = -(i >> 3);

   152

			num -= i;

   153

			FioReadByte();

   154

		}

   155

	}

   156

}

   157

   158

static void ReadSprite(int num, byte *dest)

   159

{

   160

	byte type;

   161

	byte *rel;

   162

	int8 i;

   163

	int j, dist;

   164

   165

	type = FioReadByte();

   166

	/* We've decoded special sprites when reading headers. */

   167

	if (type != 0xFF) {

   168

		/* read sprite hdr */

   169

		*dest++ = type;

   170

		for(j=0; j!=7; j++)

   171

			*dest++ = FioReadByte();

   172

		num -= 8;

   173

	}

   174

   175

	if (type & 2) {

   176

		while (num--)

   177

			*dest++ = FioReadByte();

   178

		return;

   179

	}

   180

   181

	while (num) {

   182

		i = FioReadByte();

   183

		if (i>=0) {

   184

			num -= i;

   185

			while (i--)

   186

				*dest++ = FioReadByte();

   187

		} else {

   188

			dist = -(((i&7)<<8)|FioReadByte());

   189

			i = -(i >> 3);

   190

			num -= i;

   191

   192

			rel = &dest[dist];

   193

			while (i--)

   194

				*dest++ = *rel++;

   195

		}

   196

	}

   197

}

   198

   199

   200

static bool LoadNextSprite(int load_index, byte file_index)

   201

{

   202

	uint16 size;

   203

	uint32 file_pos;

   204

   205

	if ((size = FioReadWord()) == 0)

   206

		return false;

   207

   208

	file_pos = FioGetPos() | (file_index << 24);

   209

   210

	ReadSpriteHeaderSkipData(size, load_index);

   211

   212

	if ((_replace_sprites_count[0] > 0) && (_cur_sprite.info != 0xFF)) {

   213

		int count = _replace_sprites_count[0];

   214

		int offset = _replace_sprites_offset[0];

   215

   216

		_replace_sprites_offset[0]++;

   217

		_replace_sprites_count[0]--;

   218

   219

		if ((offset + count) <= NUM_SPRITES) {

   220

			load_index = offset;

   221

		} else {

   222

			DEBUG(spritecache, 1) ("Sprites to be replaced are out of range: %x+%x",

   223

					count, offset);

   224

			_replace_sprites_offset[0] = 0;

   225

			_replace_sprites_count[0] = 0;

   226

		}

   227

   228

		if (_replace_sprites_count[0] == 0) {

   229

			int i;

   230

   231

			for (i = 0; i < 15; i++) {

   232

				_replace_sprites_count[i] = _replace_sprites_count[i + 1];

   233

				_replace_sprites_offset[i] = _replace_sprites_offset[i + 1];

   234

			}

   235

			_replace_sprites_count[i] = 0;

   236

			_replace_sprites_offset[i] = 0;

   237

		}

   238

	}

   239

   240

	_sprite_size[load_index] = size;

   241

	_sprite_file_pos[load_index] = file_pos;

   242

   243

#ifdef WANT_SPRITESIZES

   244

	_sprite_xsize[load_index] = _cur_sprite.width;

   245

	_sprite_ysize[load_index] = _cur_sprite.height;

   246

   247

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   248

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   249

#endif

   250

   251

	_sprite_ptr[load_index] = NULL;

   252

#if defined(WANT_LOCKED)

   253

	_sprite_locked[load_index] = false;

   254

#endif

   255

   256

#if defined(WANT_NEW_LRU)

   257

	_sprite_lru_new[load_index] = 0;

   258

#else

   259

	_sprite_lru[load_index] = 0xFFFF;

   260

	_sprite_lru_cur[load_index] = 0;

   261

#endif

   262

   263

	return true;

   264

}

   265

   266

static void SkipSprites(int count)

   267

{

   268

	while(count>0)

   269

	{

   270

		uint16 size;

   271

		if ( (size = FioReadWord()) == 0)

   272

			return;

   273

   274

		ReadSpriteHeaderSkipData(size, NUM_SPRITES-1);

   275

		count--;

   276

	}

   277

}

   278

   279

static int LoadGrfFile(const char *filename, int load_index, int file_index)

   280

{

   281

	int load_index_org = load_index;

   282

   283

	FioOpenFile(file_index, filename);

   284

   285

	/* Thou shalt use LoadNewGrfFile() if thou loadeth a GRF file that

   286

	 * might contain some special sprites. */

   287

	_skip_specials = 1;

   288

	_skip_sprites = 0;

   289

   290

	DEBUG(spritecache, 2) ("Reading grf-file ``%s''", filename);

   291

   292

	while (LoadNextSprite(load_index, file_index)) {

   293

		load_index++;

   294

		if (load_index >= NUM_SPRITES) {

   295

			error("Too many sprites. Recompile with higher NUM_SPRITES value or remove some custom GRF files.");

   296

		}

   297

	}

   298

   299

	return load_index - load_index_org;

   300

}

   301

   302

static int LoadNewGrfFile(const char *filename, int load_index, int file_index)

   303

{

   304

	int i;

   305

   306

	FioOpenFile(file_index, filename);

   307

	_cur_grffile = filename;

   308

	_skip_specials = 0;

   309

	_skip_sprites = 0;

   310

   311

	DEBUG(spritecache, 2) ("Reading newgrf-file ``%s'' [offset: %u]",

   312

			filename, load_index);

   313

   314

	/* Skip the first sprite; we don't care about how many sprites this

   315

	 * does contain; newest TTDPatches and George's longvehicles don't

   316

	 * neither, apparently. */

   317

	{

   318

		int length;

   319

		byte type;

   320

   321

		length = FioReadWord();

   322

		type = FioReadByte();

   323

   324

		if ((length == 4) && (type == 0xFF)) {

   325

			FioReadDword();

   326

		} else {

   327

			error("Custom .grf has invalid format.");

   328

		}

   329

	}

   330

   331

	for (i = 0; LoadNextSprite(load_index + i, file_index); i++) {

   332

		if (load_index + i >= NUM_SPRITES)

   333

			error("Too many sprites (%x). Recompile with higher NUM_SPRITES value or remove some custom GRF files.",

   334

			      load_index + i);

   335

	}

   336

   337

	/* Clean up. */

   338

	_skip_sprites = 0;

   339

	memset(_replace_sprites_count, 0, 16 * sizeof(*_replace_sprites_count));

   340

	memset(_replace_sprites_offset, 0, 16 * sizeof(*_replace_sprites_offset));

   341

   342

	return i;

   343

}

   344

   345

static void LoadGrfIndexed(const char *filename, const uint16 *index_tbl, int file_index)

   346

{

   347

	int start;

   348

   349

	FioOpenFile(file_index, filename);

   350

	_skip_specials = 1;

   351

	_skip_sprites = 0;

   352

   353

	DEBUG(spritecache, 2) ("Reading indexed grf-file ``%s''", filename);

   354

   355

	for(;(start=*index_tbl++) != 0xffff;) {

   356

		int end = *index_tbl++;

   357

		if(start==0xfffe) { // skip sprites (amount in second var)

   358

			SkipSprites(end);

   359

		} else { // load sprites and use indexes from start to end

   360

			do {

   361

				bool b = LoadNextSprite(start, file_index);

   362

				assert(b);

   363

			} while (++start <= end);

   364

		}

   365

	}

   366

}

   367

   368

typedef size_t CDECL fread_t(void*,size_t,size_t,FILE*);

   369

   370

static bool HandleCachedSpriteHeaders(const char *filename, bool read)

   371

{

   372

	FILE *f;

   373

	fread_t *proc;

   374

	uint32 hdr;

   375

   376

	if (!_cache_sprites)

   377

		return false;

   378

   379

	if (read) {

   380

		f = fopen(filename, "rb");

   381

		proc = fread;

   382

   383

		if (f == NULL)

   384

			return false;

   385

   386

		proc(&hdr, sizeof(hdr), 1, f);

   387

		if (hdr != SPRITECACHE_ID) {

   388

			fclose(f);

   389

			return false;

   390

		}

   391

	} else {

   392

		f = fopen(filename, "wb");

   393

		proc = (fread_t*) fwrite;

   394

   395

		if (f == NULL)

   396

			return false;

   397

   398

		hdr = SPRITECACHE_ID;

   399

		proc(&hdr, sizeof(hdr), 1, f);

   400

	}

   401

   402

	proc(_sprite_size, 1, sizeof(_sprite_size), f);

   403

	proc(_sprite_file_pos, 1, sizeof(_sprite_file_pos), f);

   404

   405

#if 0

   406

	proc(_sprite_xsize, 1, sizeof(_sprite_xsize), f);

   407

	proc(_sprite_ysize, 1, sizeof(_sprite_ysize), f);

   408

	proc(_sprite_xoffs, 1, sizeof(_sprite_xoffs), f);

   409

	proc(_sprite_yoffs, 1, sizeof(_sprite_yoffs), f);

   410

#endif

   411

   412

#if !defined(WANT_NEW_LRU)

   413

	if (read)

   414

		memset(_sprite_lru, 0xFF, sizeof(_sprite_lru));

   415

#endif

   416

   417

	fclose(f);

   418

	return true;

   419

}

   420

   421

#define S_DATA(x) (*(uint32*)(x))

   422

#define S_FREE_MASK 1

   423

#define S_HDRSIZE sizeof(uint32)

   424

   425

static uint32 GetSpriteCacheUsage()

   426

{

   427

	byte *s = _spritecache_ptr;

   428

	size_t cur_size, tot_size = 0;

   429

	for(; (cur_size=S_DATA(s)) != 0; s+=cur_size) {

   430

		if ( cur_size & S_FREE_MASK ) {

   431

			cur_size--;

   432

		} else {

   433

			tot_size += cur_size;

   434

		}

   435

	}

   436

   437

	return tot_size;

   438

}

   439

   440

   441

void IncreaseSpriteLRU()

   442

{

   443

	int i;

   444

   445

	// Increase all LRU values

   446

#if defined(WANT_NEW_LRU)

   447

	if (_sprite_lru_counter > 16384) {

   448

		DEBUG(spritecache, 2) ("fixing lru %d, inuse=%d", _sprite_lru_counter, GetSpriteCacheUsage());

   449

   450

		for(i=0; i!=NUM_SPRITES; i++)

   451

			if (_sprite_ptr[i] != NULL) {

   452

				if (_sprite_lru_new[i] >= 0) {

   453

					_sprite_lru_new[i] = -1;

   454

				} else if (_sprite_lru_new[i] != -32768) {

   455

					_sprite_lru_new[i]--;

   456

				}

   457

			}

   458

		_sprite_lru_counter = 0;

   459

	}

   460

#else

   461

	for(i=0; i!=NUM_SPRITES; i++)

   462

		if (_sprite_ptr[i] != NULL && _sprite_lru[i] != 65535)

   463

			_sprite_lru[i]++;

   464

	// Reset the lru counter.

   465

	_sprite_lru_counter = 0;

   466

#endif

   467

   468

	// Compact sprite cache every now and then.

   469

	if (++_compact_cache_counter >= 740) {

   470

		CompactSpriteCache();

   471

		_compact_cache_counter = 0;

   472

	}

   473

}

   474

   475

// Called when holes in the sprite cache should be removed.

   476

// That is accomplished by moving the cached data.

   477

static void CompactSpriteCache()

   478

{

   479

	byte *s, *t;

   480

	size_t size, sizeb, cur_size;

   481

	int i;

   482

   483

	DEBUG(spritecache, 2) ("compacting sprite cache, inuse=%d", GetSpriteCacheUsage());

   484

   485

	s = _spritecache_ptr;

   486

   487

	while (true) {

   488

		size = S_DATA(s);

   489

   490

		// Only look for free blocks.

   491

		if (size & S_FREE_MASK) {

   492

			size -= S_FREE_MASK;

   493

			// Since free blocks are automatically coalesced, this should hold true.

   494

			assert(!(S_DATA(s+size) & S_FREE_MASK));

   495

   496

			// If the next block is the sentinel block, we can safely return

   497

			if ( (sizeb=S_DATA(s + size)) == 0)

   498

				break;

   499

   500

			// Locate the sprite number belonging to the next pointer.

   501

			for(i=0,t=s+size+S_HDRSIZE; _sprite_ptr[i] != t; i++) {assert(i < NUM_SPRITES);}

   502

   503

			// If it's locked, we must not move it.

   504

#if defined(WANT_LOCKED)

   505

			if (!_sprite_locked[i]) {

   506

#endif

   507

   508

				// Offset the sprite pointer by the size of the free block

   509

				_sprite_ptr[i] -= size;

   510

   511

				// Move the memory

   512

				memmove(s + S_HDRSIZE, s + S_HDRSIZE + size, sizeb - S_HDRSIZE);

   513