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

   273

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

   274

		int end = *index_tbl++;

   275

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

   276

			SkipSprites(end);

   277

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

   278

			do {

   279

				bool b = LoadNextSprite(start, file_index);

   280

				assert(b);

   281

			} while (++start <= end);

   282

		}

   283

	}

   284

}	

   285

   286

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

   287

   288

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

   289

{

   290

	FILE *f;

   291

	fread_t *proc;

   292

	uint32 hdr;

   293

   294

	if (!_cache_sprites)

   295

		return false;

   296

   297

	if (read) {

   298

		f = fopen(filename, "rb");

   299

		proc = fread;

   300

   301

		if (f == NULL)

   302

			return false;

   303

   304

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

   305

		if (hdr != SPRITECACHE_ID) {

   306

			fclose(f);

   307

			return false;

   308

		}

   309

	} else {

   310

		f = fopen(filename, "wb");

   311

		proc = (fread_t*) fwrite;

   312

   313

		if (f == NULL)

   314

			return false;

   315

   316

		hdr = SPRITECACHE_ID;

   317

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

   318

	}

   319

   320

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

   321

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

   322

   323

#if 0

   324

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

   325

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

   326

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

   327

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

   328

#endif

   329

   330

#if !defined(WANT_NEW_LRU)

   331

	if (read)

   332

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

   333

#endif

   334

   335

	fclose(f);

   336

	return true;

   337

}

   338

   339

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

   340

#define S_FREE_MASK 1

   341

#define S_HDRSIZE sizeof(uint32)

   342

   343

static uint32 GetSpriteCacheUsage()

   344

{

   345

	byte *s = _spritecache_ptr;

   346

	size_t cur_size, tot_size = 0;

   347

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

   348

		if ( cur_size & S_FREE_MASK ) {

   349

			cur_size--;

   350

		} else {

   351

			tot_size += cur_size;

   352

		}

   353

	}

   354

   355

	return tot_size;

   356

}

   357

   358

   359

void IncreaseSpriteLRU()

   360

{

   361

	int i;

   362

   363

	// Increase all LRU values

   364

#if defined(WANT_NEW_LRU)

   365

	if (_sprite_lru_counter > 16384) {

   366

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

   367

   368

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

   369

			if (_sprite_ptr[i] != NULL) {

   370

				if (_sprite_lru_new[i] >= 0) {

   371

					_sprite_lru_new[i] = -1;

   372

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

   373

					_sprite_lru_new[i]--;

   374

				}

   375

			}

   376

		_sprite_lru_counter = 0;

   377

	}

   378

#else

   379

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

   380

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

   381

			_sprite_lru[i]++;

   382

	// Reset the lru counter.

   383

	_sprite_lru_counter = 0;

   384

#endif

   385

   386

	// Compact sprite cache every now and then.

   387

	if (++_compact_cache_counter >= 740) {

   388

		CompactSpriteCache();

   389

		_compact_cache_counter = 0;

   390

	}

   391

}

   392

   393

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

   394

// That is accomplished by moving the cached data.

   395

static void CompactSpriteCache()

   396

{

   397

	byte *s, *t;

   398

	size_t size, sizeb, cur_size;

   399

	int i;

   400

   401

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

   402

   403

	s = _spritecache_ptr;

   404

   405

	while (true) {

   406

		size = S_DATA(s);

   407

   408

		// Only look for free blocks.

   409

		if (size & S_FREE_MASK) {

   410

			size -= S_FREE_MASK;

   411

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

   412

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

   413

   414

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

   415

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

   416

				break;

   417

   418

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

   419

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

   420

   421

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

   422

#if defined(WANT_LOCKED)

   423

			if (!_sprite_locked[i]) {

   424

#endif

   425

   426

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

   427

				_sprite_ptr[i] -= size;

   428

   429

				// Move the memory 

   430

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

   431

   432

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

   433

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

   434

				S_DATA(s) = sizeb;

   435

   436

				// Then coalesce the free ones that follow.

   437

				s += sizeb;

   438

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

   439

					size += cur_size - S_FREE_MASK;

   440

				S_DATA(s) = size + S_FREE_MASK;

   441

				continue;

   442

#if defined(WANT_LOCKED)

   443

			}

   444

#endif

   445

		}

   446

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

   447

		s += size;

   448

		if (size == 0)

   449

			break;

   450

	}

   451

}

   452

   453

static void DeleteEntryFromSpriteCache()

   454

{

   455

	int i;

   456

	int best = -1;

   457

	byte *s;

   458

	size_t cur_size, cur;

   459

	int cur_lru;

   460

   461

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

   462

   463

#if defined(WANT_NEW_LRU)

   464

	cur_lru = 0xffff;

   465

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

   466

		if (_sprite_ptr[i] != 0 &&

   467

				_sprite_lru_new[i] < cur_lru

   468

#if defined(WANT_LOCKED)

   469

				 && !_sprite_locked[i]) {

   470

#else

   471

				) {

   472

#endif

   473

			cur_lru = _sprite_lru_new[i];

   474

			best = i;

   475

		}

   476

	}

   477

#else

   478

	{

   479

	uint16 cur_lru = 0, cur_lru_cur = 0xffff;

   480

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

   481

		if (_sprite_ptr[i] == 0 ||

   482

#if defined(WANT_LOCKED)

   483

				_sprite_locked[i] ||

   484

#endif

   485

				_sprite_lru[i] < cur_lru)

   486

					continue;

   487

   488

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

   489

		if (_sprite_lru[i] != cur_lru) {

   490

			cur_lru = _sprite_lru[i];

   491

			best = i;

   492

   493

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

   494

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

   495

			cur_lru_cur = _sprite_lru_cur[i];

   496

			cur_lru = _sprite_lru[i];

   497

			best = i;

   498

		}

   499

	}

   500

	}

   501

#endif

   502

   503

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

   504

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

   505

	if (best == -1)

   506

		error("Out of sprite memory");

   507

   508

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

   509

	s = _sprite_ptr[best];

   510

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

   511

	S_DATA(s - S_HDRSIZE) += S_FREE_MASK;

   512

	_sprite_ptr[best] = NULL;

   513

   514

	// And coalesce adjacent free blocks

   515

	s = _spritecache_ptr;

   516

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

   517

		if ( cur_size & S_FREE_MASK ) {

   518

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

   519

				cur_size += cur - S_FREE_MASK;

   520

				S_DATA(s) = cur_size;

   521

			}

   522

			cur_size--;

   523

		}

   524

	}

   525

}

   526

   527

static byte *LoadSpriteToMem(int sprite)