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

int _skip_sprites = 0;

    17

    18

static const char *_cur_grffile;

    19

static int _skip_specials;

    20

static SpriteHdr _cur_sprite;

    21

    22

static byte *_sprite_ptr[NUM_SPRITES];

    23

static uint16 _sprite_size[NUM_SPRITES];

    24

static uint32 _sprite_file_pos[NUM_SPRITES];

    25

    26

// This one is probably not needed.

    27

#if defined(WANT_LOCKED)

    28

static bool _sprite_locked[NUM_SPRITES];

    29

#endif

    30

    31

#if defined(WANT_NEW_LRU)

    32

static int16 _sprite_lru_new[NUM_SPRITES];

    33

#else

    34

static uint16 _sprite_lru[NUM_SPRITES];

    35

static uint16 _sprite_lru_cur[NUM_SPRITES];

    36

#endif

    37

    38

#ifdef WANT_SPRITESIZES

    39

static int8 _sprite_xoffs[NUM_SPRITES];

    40

static int8 _sprite_yoffs[NUM_SPRITES];

    41

static uint16 _sprite_xsize[NUM_SPRITES];

    42

static uint8 _sprite_ysize[NUM_SPRITES];

    43

#endif

    44

    45

static uint _sprite_lru_counter;

    46

static byte *_spritecache_ptr;

    47

static uint32 _spritecache_size;

    48

static int _compact_cache_counter;

    49

    50

    51

static const char * const _filename_list[] = {

    52

	"TRG1R.GRF",

    53

	"TRGIR.GRF",

    54

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

    55

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

    56

	NULL

    57

};

    58

    59

static const char * const _landscape_filenames[] = {

    60

	"TRGCR.GRF",

    61

	"TRGHR.GRF",

    62

	"TRGTR.GRF"

    63

};

    64

    65

    66

#include "table/landscape_sprite.h"

    67

    68

static const uint16 * const _landscape_spriteindexes[] = {

    69

	_landscape_spriteindexes_1,

    70

	_landscape_spriteindexes_2,

    71

	_landscape_spriteindexes_3,

    72

};

    73

    74

static const uint16 * const _slopes_spriteindexes[] = {

    75

	_slopes_spriteindexes_0,

    76

	_slopes_spriteindexes_1,

    77

	_slopes_spriteindexes_2,

    78

	_slopes_spriteindexes_3,

    79

};

    80

    81

static void CompactSpriteCache();

    82

    83

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

    84

    85

static void ReadSpriteHeaderSkipData(int num, int load_index)

    86

{

    87

	byte type;

    88

	int8 i;

    89

	int deaf = 0;

    90

    91

	if (_skip_sprites) {

    92

		if (_skip_sprites > 0)

    93

			_skip_sprites--;

    94

		deaf = 1;

    95

	}

    96

    97

	type = FioReadByte();

    98

	if (type == 0xFF) {

    99

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

   100

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

   101

		 * because if no special sprite referencing to them is

   102

		 * processed, they themselves are never referenced and loaded

   103

		 * on their own. */

   104

		if (_skip_specials || deaf) {

   105

			FioSkipBytes(num);

   106

		} else {

   107

			DecodeSpecialSprite(_cur_grffile, num, load_index);

   108

		}

   109

		return;

   110

	}

   111

   112

	_cur_sprite.info = type;

   113

#ifdef WANT_SPRITESIZES

   114

	_cur_sprite.height = FioReadByte();

   115

	_cur_sprite.width = FioReadWord();

   116

	_cur_sprite.x_offs = FioReadWord();

   117

	_cur_sprite.y_offs = FioReadWord();

   118

#else

   119

	FioSkipBytes(7);

   120

#endif

   121

	num -= 8;

   122

	if (num == 0)

   123

		return;

   124

   125

	if (type & 2) {

   126

		FioSkipBytes(num);

   127

		return;

   128

	}

   129

   130

	while (num) {

   131

		i = FioReadByte();

   132

		if (i>=0) {

   133

			num -= i;

   134

			FioSkipBytes(i);

   135

		} else {

   136

			i = -(i >> 3);

   137

			num -= i;

   138

			FioReadByte();

   139

		}

   140

	}

   141

}

   142

   143

static void ReadSprite(int num, byte *dest)

   144

{

   145

	byte type;

   146

	byte *rel;

   147

	int8 i;

   148

	int j, dist;

   149

   150

	type = FioReadByte();

   151

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

   152

	if (type != 0xFF) {

   153

		/* read sprite hdr */

   154

		*dest++ = type;

   155

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

   156

			*dest++ = FioReadByte();

   157

		num -= 8;

   158

	}

   159

   160

	if (type & 2) {

   161

		while (num--)

   162

			*dest++ = FioReadByte();

   163

		return;

   164

	}

   165

   166

	while (num) {

   167

		i = FioReadByte();

   168

		if (i>=0) {

   169

			num -= i;

   170

			while (i--)

   171

				*dest++ = FioReadByte();

   172

		} else {

   173

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

   174

			i = -(i >> 3);

   175

			num -= i;

   176

   177

			rel = &dest[dist];

   178

			while (i--)

   179

				*dest++ = *rel++;

   180

		}

   181

	}

   182

}

   183

   184

   185

static bool LoadNextSprite(int load_index, byte file_index)

   186

{

   187

	uint16 size;

   188

   189

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

   190

		return false;

   191

   192

	_sprite_size[load_index] = size;

   193

	_sprite_file_pos[load_index] = FioGetPos() | (file_index << 24);

   194

   195

	ReadSpriteHeaderSkipData(size, load_index);

   196

   197

#ifdef WANT_SPRITESIZES

   198

	_sprite_xsize[load_index] = _cur_sprite.width;

   199

	_sprite_ysize[load_index] = _cur_sprite.height;

   200

   201

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   202

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   203

#endif

   204

   205

	_sprite_ptr[load_index] = NULL;

   206

#if defined(WANT_LOCKED)

   207

	_sprite_locked[load_index] = false;

   208

#endif

   209

   210

#if defined(WANT_NEW_LRU)

   211

	_sprite_lru_new[load_index] = 0;

   212

#else	

   213

	_sprite_lru[load_index] = 0xFFFF;

   214

	_sprite_lru_cur[load_index] = 0;

   215

#endif

   216

   217

	return true;

   218

}

   219

   220

static void SkipSprites(int count)

   221

{

   222

	while(count>0)

   223

	{

   224

		uint16 size;

   225

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

   226

			return;

   227

   228

		ReadSpriteHeaderSkipData(size, NUM_SPRITES-1);

   229

		count--;

   230

	}

   231

}

   232

   233

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

   234

static bool CheckGrfFile()

   235

{

   236

	byte check;

   237

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

   238

	check = FioReadWord();

   239

	FioSeekToFile(0);

   240

	return (check==0x21);

   241

}

   242

   243

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

   244

{

   245

	int load_index_org = load_index;

   246

   247

	FioOpenFile(file_index, filename);

   248

	_cur_grffile = filename;

   249

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

   250

   251

 	if(file_index==0 && !_ignore_wrong_grf)

   252

 		if(!CheckGrfFile())

   253

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

   254

   255

	while (LoadNextSprite(load_index, file_index)) {

   256

		load_index++;

   257

		if (load_index >= NUM_SPRITES) {

   258

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

   259

		}

   260

	}

   261

   262

	_skip_sprites = 0; // clean up

   263

   264

	return load_index - load_index_org;

   265

}

   266

   267

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

   268

{

   269

	int start;

   270

   271

	FioOpenFile(file_index, filename);

   272

	_cur_grffile = filename;

   273

   274

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

   275

		int end = *index_tbl++;

   276

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

   277

			SkipSprites(end);

   278

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

   279

			do {

   280

				bool b = LoadNextSprite(start, file_index);

   281

				assert(b);

   282

			} while (++start <= end);

   283

		}

   284

	}

   285

}	

   286

   287

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

   288

   289

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

   290

{

   291

	FILE *f;

   292

	fread_t *proc;

   293

	uint32 hdr;

   294

   295

	if (!_cache_sprites)

   296

		return false;

   297

   298

	if (read) {

   299

		f = fopen(filename, "rb");

   300

		proc = fread;

   301

   302

		if (f == NULL)

   303

			return false;

   304

   305

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

   306

		if (hdr != SPRITECACHE_ID) {

   307

			fclose(f);

   308

			return false;

   309

		}

   310

	} else {

   311

		f = fopen(filename, "wb");

   312

		proc = (fread_t*) fwrite;

   313

   314

		if (f == NULL)

   315

			return false;

   316

   317

		hdr = SPRITECACHE_ID;

   318

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

   319

	}

   320

   321

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

   322

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

   323

   324

#if 0

   325

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

   326

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

   327

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

   328

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

   329

#endif

   330

   331

#if !defined(WANT_NEW_LRU)

   332

	if (read)

   333

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

   334

#endif

   335

   336

	fclose(f);

   337

	return true;

   338

}

   339

   340

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

   341

#define S_FREE_MASK 1

   342

#define S_HDRSIZE sizeof(uint32)

   343

   344

static uint32 GetSpriteCacheUsage()

   345

{

   346

	byte *s = _spritecache_ptr;

   347

	size_t cur_size, tot_size = 0;

   348

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

   349

		if ( cur_size & S_FREE_MASK ) {

   350

			cur_size--;

   351

		} else {

   352

			tot_size += cur_size;

   353

		}

   354

	}

   355

   356

	return tot_size;

   357

}

   358

   359

   360

void IncreaseSpriteLRU()

   361

{

   362

	int i;

   363

   364

	// Increase all LRU values

   365

#if defined(WANT_NEW_LRU)

   366

	if (_sprite_lru_counter > 16384) {

   367

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

   368

   369

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

   370

			if (_sprite_ptr[i] != NULL) {

   371

				if (_sprite_lru_new[i] >= 0) {

   372

					_sprite_lru_new[i] = -1;

   373

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

   374

					_sprite_lru_new[i]--;

   375

				}

   376

			}

   377

		_sprite_lru_counter = 0;

   378

	}

   379

#else

   380

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

   381

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

   382

			_sprite_lru[i]++;

   383

	// Reset the lru counter.

   384

	_sprite_lru_counter = 0;

   385

#endif

   386

   387

	// Compact sprite cache every now and then.

   388

	if (++_compact_cache_counter >= 740) {

   389

		CompactSpriteCache();

   390

		_compact_cache_counter = 0;

   391

	}

   392

}

   393

   394

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

   395

// That is accomplished by moving the cached data.

   396

static void CompactSpriteCache()

   397

{

   398

	byte *s, *t;

   399

	size_t size, sizeb, cur_size;

   400

	int i;

   401

   402

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

   403

   404

	s = _spritecache_ptr;

   405

   406

	while (true) {

   407

		size = S_DATA(s);

   408

   409

		// Only look for free blocks.

   410

		if (size & S_FREE_MASK) {

   411

			size -= S_FREE_MASK;

   412

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

   413

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

   414

   415

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

   416

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

   417

				break;

   418

   419

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

   420

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

   421

   422

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

   423

#if defined(WANT_LOCKED)

   424

			if (!_sprite_locked[i]) {

   425

#endif

   426

   427

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

   428

				_sprite_ptr[i] -= size;

   429

   430

				// Move the memory 

   431

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

   432

   433

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

   434

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

   435

				S_DATA(s) = sizeb;

   436

   437

				// Then coalesce the free ones that follow.

   438

				s += sizeb;

   439

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

   440

					size += cur_size - S_FREE_MASK;

   441

				S_DATA(s) = size + S_FREE_MASK;

   442

				continue;

   443

#if defined(WANT_LOCKED)

   444

			}

   445

#endif

   446

		}

   447

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

   448

		s += size;

   449

		if (size == 0)

   450

			break;

   451

	}

   452

}

   453

   454

static void DeleteEntryFromSpriteCache()

   455

{

   456

	int i;

   457

	int best = -1;

   458

	byte *s;

   459

	size_t cur_size, cur;

   460

	int cur_lru;

   461

   462

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

   463

   464

#if defined(WANT_NEW_LRU)

   465

	cur_lru = 0xffff;

   466

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

   467

		if (_sprite_ptr[i] != 0 &&

   468

				_sprite_lru_new[i] < cur_lru

   469

#if defined(WANT_LOCKED)

   470

				 && !_sprite_locked[i]) {

   471

#else

   472

				) {

   473

#endif

   474

			cur_lru = _sprite_lru_new[i];

   475

			best = i;

   476

		}

   477

	}

   478

#else

   479

	{

   480

	uint16 cur_lru = 0, cur_lru_cur = 0xffff;

   481

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

   482

		if (_sprite_ptr[i] == 0 ||

   483

#if defined(WANT_LOCKED)

   484

				_sprite_locked[i] ||

   485

#endif

   486

				_sprite_lru[i] < cur_lru)

   487

					continue;

   488

   489

		// Found a sprite with a higher LRU value, then remember it.

   490

		if (_sprite_lru[i] != cur_lru) {

   491

			cur_lru = _sprite_lru[i];

   492

			best = i;

   493

   494

		// Else if both sprites were very recently referenced, compare by the cur value instead.

   495

		} else if (cur_lru == 0 && _sprite_lru_cur[i] <= cur_lru_cur) {

   496

			cur_lru_cur = _sprite_lru_cur[i];

   497

			cur_lru = _sprite_lru[i];

   498

			best = i;

   499

		}

   500

	}

   501

	}

   502

#endif

   503

   504

	// Display an error message and die, in case we found no sprite at all.

   505

	// This shouldn't really happen, unless all sprites are locked.

   506

	if (best == -1)

   507

		error("Out of sprite memory");

   508

   509

	// Mark the block as free (the block must be in use)

   510

	s = _sprite_ptr[best];

   511

	assert(!(S_DATA(s - S_HDRSIZE) & S_FREE_MASK));

   512

	S_DATA(s - S_HDRSIZE) += S_FREE_MASK;

   513

	_sprite_ptr[best] = NULL;

   514

   515

	// And coalesce adjacent free blocks

   516

	s = _spritecache_ptr;

   517

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

   518

		if ( cur_size & S_FREE_MASK ) {

   519

			while ((cur=S_DATA(s+cur_size-S_FREE_MASK)) & S_FREE_MASK) {

   520

				cur_size += cur - S_FREE_MASK;

   521

				S_DATA(s) = cur_size;

   522

			}

   523

			cur_size--;

   524

		}

   525

	}

   526

}

   527