1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "gfx.h"

     4

#include "fileio.h"

     5

#include <ctype.h>

     6

     7

#define SPRITECACHE_ID 0xF00F0006

     8

#define SPRITE_CACHE_SIZE 1024*1024

     9

    10

    11

//#define WANT_SPRITESIZES

    12

#define WANT_NEW_LRU

    13

//#define WANT_LOCKED

    14

    15

    16

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

    17

    18

int _skip_sprites = 0;

    19

int _replace_sprites_count[16];

    20

int _replace_sprites_offset[16];

    21

    22

static const char *_cur_grffile;

    23

static int _skip_specials;

    24

static SpriteHdr _cur_sprite;

    25

    26

    27

static byte *_sprite_ptr[NUM_SPRITES];

    28

static uint16 _sprite_size[NUM_SPRITES];

    29

static uint32 _sprite_file_pos[NUM_SPRITES];

    30

    31

// This one is probably not needed.

    32

#if defined(WANT_LOCKED)

    33

static bool _sprite_locked[NUM_SPRITES];

    34

#endif

    35

    36

#if defined(WANT_NEW_LRU)

    37

static int16 _sprite_lru_new[NUM_SPRITES];

    38

#else

    39

static uint16 _sprite_lru[NUM_SPRITES];

    40

static uint16 _sprite_lru_cur[NUM_SPRITES];

    41

#endif

    42

    43

#ifdef WANT_SPRITESIZES

    44

static int8 _sprite_xoffs[NUM_SPRITES];

    45

static int8 _sprite_yoffs[NUM_SPRITES];

    46

static uint16 _sprite_xsize[NUM_SPRITES];

    47

static uint8 _sprite_ysize[NUM_SPRITES];

    48

#endif

    49

    50

static uint _sprite_lru_counter;

    51

static byte *_spritecache_ptr;

    52

static uint32 _spritecache_size;

    53

static int _compact_cache_counter;

    54

    55

    56

static const char * const _filename_list[] = {

    57

	"TRG1R.GRF",

    58

	"TRGIR.GRF",

    59

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

    60

//	"openttd.grf",	//0x1406 -

    61

	NULL

    62

};

    63

    64

static const char * const _landscape_filenames[] = {

    65

	"TRGCR.GRF",

    66

	"TRGHR.GRF",

    67

	"TRGTR.GRF"

    68

};

    69

    70

    71

#include "table/landscape_sprite.h"

    72

    73

static const uint16 * const _landscape_spriteindexes[] = {

    74

	_landscape_spriteindexes_1,

    75

	_landscape_spriteindexes_2,

    76

	_landscape_spriteindexes_3,

    77

};

    78

    79

static const uint16 * const _slopes_spriteindexes[] = {

    80

	_slopes_spriteindexes_0,

    81

	_slopes_spriteindexes_1,

    82

	_slopes_spriteindexes_2,

    83

	_slopes_spriteindexes_3,

    84

};

    85

    86

static void CompactSpriteCache();

    87

    88

void DecodeSpecialSprite(const char *filename, int num, int load_index);

    89

    90

static void ReadSpriteHeaderSkipData(int num, int load_index)

    91

{

    92

	byte type;

    93

	int8 i;

    94

	int deaf = 0;

    95

    96

	if (_skip_sprites) {

    97

		if (_skip_sprites > 0)

    98

			_skip_sprites--;

    99

		deaf = 1;

   100

	}

   101

   102

	type = FioReadByte();

   103

	_cur_sprite.info = type;

   104

	if (type == 0xFF) {

   105

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

   106

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

   107

		 * because if no special sprite referencing to them is

   108

		 * processed, they themselves are never referenced and loaded

   109

		 * on their own. */

   110

		if (_skip_specials || deaf) {

   111

			FioSkipBytes(num);

   112

		} else {

   113

			DecodeSpecialSprite(_cur_grffile, num, load_index);

   114

		}

   115

		return;

   116

	}

   117

   118

#ifdef WANT_SPRITESIZES

   119

	_cur_sprite.height = FioReadByte();

   120

	_cur_sprite.width = FioReadWord();

   121

	_cur_sprite.x_offs = FioReadWord();

   122

	_cur_sprite.y_offs = FioReadWord();

   123

#else

   124

	FioSkipBytes(7);

   125

#endif

   126

	num -= 8;

   127

	if (num == 0)

   128

		return;

   129

   130

	if (type & 2) {

   131

		FioSkipBytes(num);

   132

		return;

   133

	}

   134

   135

	while (num) {

   136

		i = FioReadByte();

   137

		if (i>=0) {

   138

			num -= i;

   139

			FioSkipBytes(i);

   140

		} else {

   141

			i = -(i >> 3);

   142

			num -= i;

   143

			FioReadByte();

   144

		}

   145

	}

   146

}

   147

   148

static void ReadSprite(int num, byte *dest)

   149

{

   150

	byte type;

   151

	byte *rel;

   152

	int8 i;

   153

	int j, dist;

   154

   155

	type = FioReadByte();

   156

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

   157

	if (type != 0xFF) {

   158

		/* read sprite hdr */

   159

		*dest++ = type;

   160

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

   161

			*dest++ = FioReadByte();

   162

		num -= 8;

   163

	}

   164

   165

	if (type & 2) {

   166

		while (num--)

   167

			*dest++ = FioReadByte();

   168

		return;

   169

	}

   170

   171

	while (num) {

   172

		i = FioReadByte();

   173

		if (i>=0) {

   174

			num -= i;

   175

			while (i--)

   176

				*dest++ = FioReadByte();

   177

		} else {

   178

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

   179

			i = -(i >> 3);

   180

			num -= i;

   181

   182

			rel = &dest[dist];

   183

			while (i--)

   184

				*dest++ = *rel++;

   185

		}

   186

	}

   187

}

   188

   189

   190

static bool LoadNextSprite(int load_index, byte file_index)

   191

{

   192

	uint16 size;

   193

	uint32 file_pos;

   194

   195

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

   196

		return false;

   197

   198

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

   199

   200

	ReadSpriteHeaderSkipData(size, load_index);

   201

   202

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

   203

		int count = _replace_sprites_count[0];

   204

		int offset = _replace_sprites_offset[0];

   205

   206

		_replace_sprites_offset[0]++;

   207

		_replace_sprites_count[0]--;

   208

   209

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

   210

			load_index = offset;

   211

		} else {

   212

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

   213

					count, offset);

   214

			_replace_sprites_offset[0] = 0;

   215

			_replace_sprites_count[0] = 0;

   216

		}

   217

   218

		if (_replace_sprites_count[0] == 0) {

   219

			int i;

   220

   221

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

   222

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

   223

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

   224

			}

   225

			_replace_sprites_count[i] = 0;

   226

			_replace_sprites_offset[i] = 0;

   227

		}

   228

	}

   229

   230

	_sprite_size[load_index] = size;

   231

	_sprite_file_pos[load_index] = file_pos;

   232

   233

#ifdef WANT_SPRITESIZES

   234

	_sprite_xsize[load_index] = _cur_sprite.width;

   235

	_sprite_ysize[load_index] = _cur_sprite.height;

   236

   237

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   238

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   239

#endif

   240

   241

	_sprite_ptr[load_index] = NULL;

   242

#if defined(WANT_LOCKED)

   243

	_sprite_locked[load_index] = false;

   244

#endif

   245

   246

#if defined(WANT_NEW_LRU)

   247

	_sprite_lru_new[load_index] = 0;

   248

#else

   249

	_sprite_lru[load_index] = 0xFFFF;

   250

	_sprite_lru_cur[load_index] = 0;

   251

#endif

   252

   253

	return true;

   254

}

   255

   256

static void SkipSprites(int count)

   257

{

   258

	while(count>0)

   259

	{

   260

		uint16 size;

   261

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

   262

			return;

   263

   264

		ReadSpriteHeaderSkipData(size, NUM_SPRITES-1);

   265

		count--;

   266

	}

   267

}

   268

   269

// Checks, if trg1r.grf is the Windows version

   270

static bool CheckGrfFile()

   271

{

   272

	byte check;

   273

	FioSeekToFile(38); // Byte 38 has the value 0x21 in Windows version, 0x07 in DOS

   274

	check = FioReadWord();

   275

	FioSeekToFile(0);

   276

	return (check==0x21);

   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

	_cur_grffile = filename;

   292

   293

 	if(file_index==0 && !_ignore_wrong_grf)

   294

 		if(!CheckGrfFile())

   295

 			error("Wrong version of grf files!\nThe Windows 95 edition of Transport Tycoon Deluxe is required to play OTTD!\n(you can disable this message by starting with the \"-i\" switch.");

   296

   297

	while (LoadNextSprite(load_index, file_index)) {

   298

		load_index++;

   299

		if (load_index >= NUM_SPRITES) {

   300

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

   301

		}

   302

	}

   303

   350

	/* Clean up. */

   351

	_skip_sprites = 0;

   352

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

   353

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

   354

   356

}

   357

   358

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

   359

{

   360

	int start;

   361

   362

	FioOpenFile(file_index, filename);

   363

	_cur_grffile = filename;

   368

   369

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

   370

		int end = *index_tbl++;

   371

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

   372

			SkipSprites(end);

   373

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

   374

			do {

   375

				bool b = LoadNextSprite(start, file_index);

   376

				assert(b);

   377

			} while (++start <= end);

   378

		}

   379

	}

   380

}

   381

   382

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

   383

   384

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

   385

{

   386

	FILE *f;

   387

	fread_t *proc;

   388

	uint32 hdr;

   389

   390

	if (!_cache_sprites)

   391

		return false;

   392

   393

	if (read) {

   394

		f = fopen(filename, "rb");

   395

		proc = fread;

   396

   397

		if (f == NULL)

   398

			return false;

   399

   400

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

   401

		if (hdr != SPRITECACHE_ID) {

   402

			fclose(f);

   403

			return false;

   404

		}

   405

	} else {

   406

		f = fopen(filename, "wb");

   407

		proc = (fread_t*) fwrite;

   408

   409

		if (f == NULL)

   410

			return false;

   411

   412

		hdr = SPRITECACHE_ID;

   413

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

   414

	}

   415

   416

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

   417

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

   418

   419

#if 0

   420

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

   421

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

   422

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

   423

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

   424

#endif

   425

   426

#if !defined(WANT_NEW_LRU)

   427

	if (read)

   428

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

   429

#endif

   430

   431

	fclose(f);

   432

	return true;

   433

}

   434

   435

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

   436

#define S_FREE_MASK 1

   437

#define S_HDRSIZE sizeof(uint32)

   438

   439

static uint32 GetSpriteCacheUsage()

   440

{

   441

	byte *s = _spritecache_ptr;

   442

	size_t cur_size, tot_size = 0;

   443

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

   444

		if ( cur_size & S_FREE_MASK ) {

   445

			cur_size--;

   446

		} else {

   447

			tot_size += cur_size;

   448

		}

   449

	}

   450

   451

	return tot_size;

   452

}

   453

   454

   455

void IncreaseSpriteLRU()

   456

{

   457

	int i;

   458

   459

	// Increase all LRU values

   460

#if defined(WANT_NEW_LRU)

   461

	if (_sprite_lru_counter > 16384) {

   462

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

   463

   464

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

   465

			if (_sprite_ptr[i] != NULL) {

   466

				if (_sprite_lru_new[i] >= 0) {

   467

					_sprite_lru_new[i] = -1;

   468

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

   469

					_sprite_lru_new[i]--;

   470

				}

   471

			}

   472

		_sprite_lru_counter = 0;

   473

	}

   474

#else

   475

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

   476

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

   477

			_sprite_lru[i]++;

   478

	// Reset the lru counter.

   479

	_sprite_lru_counter = 0;

   480

#endif

   481

   482

	// Compact sprite cache every now and then.

   483

	if (++_compact_cache_counter >= 740) {

   484

		CompactSpriteCache();

   485

		_compact_cache_counter = 0;

   486

	}

   487

}

   488

   489

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

   490

// That is accomplished by moving the cached data.

   491

static void CompactSpriteCache()

   492

{

   493

	byte *s, *t;

   494

	size_t size, sizeb, cur_size;

   495

	int i;

   496

   497

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

   498

   499

	s = _spritecache_ptr;

   500

   501

	while (true) {

   502

		size = S_DATA(s);

   503

   504

		// Only look for free blocks.

   505

		if (size & S_FREE_MASK) {

   506

			size -= S_FREE_MASK;

   507

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

   508

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

   509

   510

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

   511

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

   512

				break;

   513

   514

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

   515

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

   516