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

	if (type == 0xFF) {

   104

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

   105

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

   106

		 * because if no special sprite referencing to them is

   107

		 * processed, they themselves are never referenced and loaded

   108

		 * on their own. */

   109

		if (_skip_specials || deaf) {

   110

			FioSkipBytes(num);

   111

		} else {

   112

			DecodeSpecialSprite(_cur_grffile, num, load_index);

   113

		}

   114

		return;

   115

	}

   116

   117

	_cur_sprite.info = type;

   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;

   285

	_skip_specials = !strncmp(filename, "TRG", 3);

   286

   287

 	if(file_index==0 && !_ignore_wrong_grf)

   288

 		if(!CheckGrfFile())

   289

 			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.");

   290

   291

	while (LoadNextSprite(load_index, file_index)) {

   292

		load_index++;

   293

		if (load_index >= NUM_SPRITES) {

   294

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

   295

		}

   296

	}

   297

   298

	/* Clean up. */

   299

	_skip_sprites = 0;

   300

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

   301

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

   302

   303

	return load_index - load_index_org;

   304

}

   305

   306

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

   307

{

   308

	int start;

   309

   310

	FioOpenFile(file_index, filename);

   311

	_cur_grffile = filename;

   312

   313

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

   314

		int end = *index_tbl++;

   315

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

   316

			SkipSprites(end);

   317

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

   318

			do {

   319

				bool b = LoadNextSprite(start, file_index);

   320

				assert(b);

   321

			} while (++start <= end);

   322

		}

   323

	}

   324

}

   325

   326

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

   327

   328

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

   329

{

   330

	FILE *f;

   331

	fread_t *proc;

   332

	uint32 hdr;

   333

   334

	if (!_cache_sprites)

   335

		return false;

   336

   337

	if (read) {

   338

		f = fopen(filename, "rb");

   339

		proc = fread;

   340

   341

		if (f == NULL)

   342

			return false;

   343

   344

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

   345

		if (hdr != SPRITECACHE_ID) {

   346

			fclose(f);

   347

			return false;

   348

		}

   349

	} else {

   350

		f = fopen(filename, "wb");

   351

		proc = (fread_t*) fwrite;

   352

   353

		if (f == NULL)

   354

			return false;

   355

   356

		hdr = SPRITECACHE_ID;

   357

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

   358

	}

   359

   360

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

   361

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

   362

   363

#if 0

   364

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

   365

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

   366

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

   367

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

   368

#endif

   369

   370

#if !defined(WANT_NEW_LRU)

   371

	if (read)

   372

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

   373

#endif

   374

   375

	fclose(f);

   376

	return true;

   377

}

   378

   379

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

   380

#define S_FREE_MASK 1

   381

#define S_HDRSIZE sizeof(uint32)

   382

   383

static uint32 GetSpriteCacheUsage()

   384

{

   385

	byte *s = _spritecache_ptr;

   386

	size_t cur_size, tot_size = 0;

   387

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

   388

		if ( cur_size & S_FREE_MASK ) {

   389

			cur_size--;

   390

		} else {

   391

			tot_size += cur_size;

   392

		}

   393

	}

   394

   395

	return tot_size;

   396

}

   397

   398

   399

void IncreaseSpriteLRU()

   400

{

   401

	int i;

   402

   403

	// Increase all LRU values

   404

#if defined(WANT_NEW_LRU)

   405

	if (_sprite_lru_counter > 16384) {

   406

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

   407

   408

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

   409

			if (_sprite_ptr[i] != NULL) {

   410

				if (_sprite_lru_new[i] >= 0) {

   411

					_sprite_lru_new[i] = -1;

   412

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

   413

					_sprite_lru_new[i]--;

   414

				}

   415

			}

   416

		_sprite_lru_counter = 0;

   417

	}

   418

#else

   419

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

   420

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

   421

			_sprite_lru[i]++;

   422

	// Reset the lru counter.

   423

	_sprite_lru_counter = 0;

   424

#endif

   425

   426

	// Compact sprite cache every now and then.

   427

	if (++_compact_cache_counter >= 740) {

   428

		CompactSpriteCache();

   429

		_compact_cache_counter = 0;

   430

	}

   431

}

   432

   433

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

   434

// That is accomplished by moving the cached data.

   435

static void CompactSpriteCache()

   436

{

   437

	byte *s, *t;

   438

	size_t size, sizeb, cur_size;

   439

	int i;

   440

   441

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

   442

   443

	s = _spritecache_ptr;

   444

   445

	while (true) {

   446

		size = S_DATA(s);

   447

   448

		// Only look for free blocks.

   449

		if (size & S_FREE_MASK) {

   450

			size -= S_FREE_MASK;

   451

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

   452

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

   453

   454

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

   455

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

   456

				break;

   457

   458

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

   459

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

   460

   461

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

   462

#if defined(WANT_LOCKED)

   463

			if (!_sprite_locked[i]) {

   464

#endif

   465

   466

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

   467

				_sprite_ptr[i] -= size;

   468

   469

				// Move the memory

   470

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

   471

   472

				// What we just did had the effect of swapping the allocated block with the free block, so we need to update

   473

				//  the block pointers. First update the allocated one. It is in use.

   474

				S_DATA(s) = sizeb;

   475

   476

				// Then coalesce the free ones that follow.

   477

				s += sizeb;

   478

				while ((cur_size = S_DATA(s+size)) & S_FREE_MASK)

   479

					size += cur_size - S_FREE_MASK;

   480

				S_DATA(s) = size + S_FREE_MASK;

   481

				continue;

   482

#if defined(WANT_LOCKED)

   483

			}

   484

#endif

   485

		}

   486

		// Continue with next block until the sentinel is reached.

   487

		s += size;

   488

		if (size == 0)

   489

			break;

   490

	}

   491

}

   492

   493

static void DeleteEntryFromSpriteCache()

   494

{

   495

	int i;

   496

	int best = -1;

   497

	byte *s;

   498

	size_t cur_size, cur;

   499

	int cur_lru;

   500

   501

	DEBUG(spritecache, 2) ("DeleteEntryFromSpriteCache, inuse=%d", GetSpriteCacheUsage());

   502

   503

#if defined(WANT_NEW_LRU)

   504

	cur_lru = 0xffff;

   505

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

   506

		if (_sprite_ptr[i] != 0 &&

   507

				_sprite_lru_new[i] < cur_lru

   508

#if defined(WANT_LOCKED)

   509

				 && !_sprite_locked[i]) {

   510

#else

   511

				) {

   512

#endif

   513

			cur_lru = _sprite_lru_new[i];

   514

			best = i;

   515

		}

   516

	}

   517

#else

   518

	{

   519

	uint16 cur_lru = 0, cur_lru_cur = 0xffff;

   520

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