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 _loading_stage;

    24

static int _skip_specials;

    25

uint16 _custom_sprites_base;

    26

static SpriteHdr _cur_sprite;

    27

    28

    29

static byte *_sprite_ptr[NUM_SPRITES];

    30

static uint16 _sprite_size[NUM_SPRITES];

    31

static uint32 _sprite_file_pos[NUM_SPRITES];

    32

    33

// This one is probably not needed.

    34

#if defined(WANT_LOCKED)

    35

static bool _sprite_locked[NUM_SPRITES];

    36

#endif

    37

    38

#if defined(WANT_NEW_LRU)

    39

static int16 _sprite_lru_new[NUM_SPRITES];

    40

#else

    41

static uint16 _sprite_lru[NUM_SPRITES];

    42

static uint16 _sprite_lru_cur[NUM_SPRITES];

    43

#endif

    44

    45

#ifdef WANT_SPRITESIZES

    46

static int8 _sprite_xoffs[NUM_SPRITES];

    47

static int8 _sprite_yoffs[NUM_SPRITES];

    48

static uint16 _sprite_xsize[NUM_SPRITES];

    49

static uint8 _sprite_ysize[NUM_SPRITES];

    50

#endif

    51

    52

static uint _sprite_lru_counter;

    53

static byte *_spritecache_ptr;

    54

static uint32 _spritecache_size;

    55

static int _compact_cache_counter;

    56

    57

    58

static const char * const _filename_list[] = {

    59

	"TRG1R.GRF",

    60

	"TRGIR.GRF",

    61

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

    62

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

    63

	NULL

    64

};

    65

    66

static const char * const _landscape_filenames[] = {

    67

	"TRGCR.GRF",

    68

	"TRGHR.GRF",

    69

	"TRGTR.GRF"

    70

};

    71

    72

    73

#include "table/landscape_sprite.h"

    74

    75

static const uint16 * const _landscape_spriteindexes[] = {

    76

	_landscape_spriteindexes_1,

    77

	_landscape_spriteindexes_2,

    78

	_landscape_spriteindexes_3,

    79

};

    80

    81

static const uint16 * const _slopes_spriteindexes[] = {

    82

	_slopes_spriteindexes_0,

    83

	_slopes_spriteindexes_1,

    84

	_slopes_spriteindexes_2,

    85

	_slopes_spriteindexes_3,

    86

};

    87

    88

static void CompactSpriteCache();

    89

    90

void InitNewGRFFile(const char *filename, int sprite_offset);

    91

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

    92

    93

static void ReadSpriteHeaderSkipData(int num, int load_index)

    94

{

    95

	byte type;

    96

	int8 i;

    97

	int deaf = 0;

    98

    99

	if (_skip_sprites) {

   100

		if (_skip_sprites > 0)

   101

			_skip_sprites--;

   102

		deaf = 1;

   103

	}

   104

   105

	type = FioReadByte();

   106

	_cur_sprite.info = type;

   107

	if (type == 0xFF) {

   108

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

   109

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

   110

		 * because if no special sprite referencing to them is

   111

		 * processed, they themselves are never referenced and loaded

   112

		 * on their own. */

   113

		if (_skip_specials || deaf) {

   114

			FioSkipBytes(num);

   115

		} else {

   116

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   117

		}

   118

		return;

   119

	}

   120

   121

#ifdef WANT_SPRITESIZES

   122

	_cur_sprite.height = FioReadByte();

   123

	_cur_sprite.width = FioReadWord();

   124

	_cur_sprite.x_offs = FioReadWord();

   125

	_cur_sprite.y_offs = FioReadWord();

   126

#else

   127

	FioSkipBytes(7);

   128

#endif

   129

	num -= 8;

   130

	if (num == 0)

   131

		return;

   132

   133

	if (type & 2) {

   134

		FioSkipBytes(num);

   135

		return;

   136

	}

   137

   138

	while (num) {

   139

		i = FioReadByte();

   140

		if (i>=0) {

   141

			num -= i;

   142

			FioSkipBytes(i);

   143

		} else {

   144

			i = -(i >> 3);

   145

			num -= i;

   146

			FioReadByte();

   147

		}

   148

	}

   149

}

   150

   151

static void ReadSprite(int num, byte *dest)

   152

{

   153

	byte type;

   154

	byte *rel;

   155

	int8 i;

   156

	int j, dist;

   157

   158

	type = FioReadByte();

   159

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

   160

	if (type != 0xFF) {

   161

		/* read sprite hdr */

   162

		*dest++ = type;

   163

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

   164

			*dest++ = FioReadByte();

   165

		num -= 8;

   166

	}

   167

   168

	if (type & 2) {

   169

		while (num--)

   170

			*dest++ = FioReadByte();

   171

		return;

   172

	}

   173

   174

	while (num) {

   175

		i = FioReadByte();

   176

		if (i>=0) {

   177

			num -= i;

   178

			while (i--)

   179

				*dest++ = FioReadByte();

   180

		} else {

   181

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

   182

			i = -(i >> 3);

   183

			num -= i;

   184

   185

			rel = &dest[dist];

   186

			while (i--)

   187

				*dest++ = *rel++;

   188

		}

   189

	}

   190

}

   191

   192

   193

static bool LoadNextSprite(int load_index, byte file_index)

   194

{

   195

	uint16 size;

   196

	uint32 file_pos;

   197

   198

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

   199

		return false;

   200

   201

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

   202

   203

	ReadSpriteHeaderSkipData(size, load_index);

   204

   205

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

   206

		int count = _replace_sprites_count[0];

   207

		int offset = _replace_sprites_offset[0];

   208

   209

		_replace_sprites_offset[0]++;

   210

		_replace_sprites_count[0]--;

   211

   212

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

   213

			load_index = offset;

   214

		} else {

   215

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

   216

					count, offset);

   217

			_replace_sprites_offset[0] = 0;

   218

			_replace_sprites_count[0] = 0;

   219

		}

   220

   221

		if (_replace_sprites_count[0] == 0) {

   222

			int i;

   223

   224

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

   225

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

   226

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

   227

			}

   228

			_replace_sprites_count[i] = 0;

   229

			_replace_sprites_offset[i] = 0;

   230

		}

   231

	}

   232

   233

	_sprite_size[load_index] = size;

   234

	_sprite_file_pos[load_index] = file_pos;

   235

   236

#ifdef WANT_SPRITESIZES

   237

	_sprite_xsize[load_index] = _cur_sprite.width;

   238

	_sprite_ysize[load_index] = _cur_sprite.height;

   239

   240

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   241

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   242

#endif

   243

   244

	_sprite_ptr[load_index] = NULL;

   245

#if defined(WANT_LOCKED)

   246

	_sprite_locked[load_index] = false;

   247

#endif

   248

   249

#if defined(WANT_NEW_LRU)

   250

	_sprite_lru_new[load_index] = 0;

   251

#else

   252

	_sprite_lru[load_index] = 0xFFFF;

   253

	_sprite_lru_cur[load_index] = 0;

   254

#endif

   255

   256

	return true;

   257

}

   258

   259

static void SkipSprites(int count)

   260

{

   261

	while(count>0)

   262

	{

   263

		uint16 size;

   264

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

   265

			return;

   266

   267

		ReadSpriteHeaderSkipData(size, NUM_SPRITES-1);

   268

		count--;

   269

	}

   270

}

   271

   272

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

   273

static bool CheckGrfFile()

   274

{

   275

	byte check;

   276

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

   277

	check = FioReadWord();

   278

	FioSeekToFile(0);

   279

	return (check==0x21);

   280

}

   281

   282

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

   283

{

   284

	int load_index_org = load_index;

   285

   286

	FioOpenFile(file_index, filename);

   287

   288

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

   289

	 * might contain some special sprites. */

   290

	_skip_specials = 1;

   291

	_skip_sprites = 0;

   292

   293

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

   294

   295

 	if(file_index==0 && !_ignore_wrong_grf)

   296

 		if(!CheckGrfFile())

   297

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

   298

   299

	while (LoadNextSprite(load_index, file_index)) {

   300

		load_index++;

   301

		if (load_index >= NUM_SPRITES) {

   302

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

   303

		}

   304

	}

   305

   306

	return load_index - load_index_org;

   307

}

   308

   309

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

   310

{

   311

	/* XXX: Is it better to fervently follow the num_sprites information or

   312

	 * be tolerant and comply with more/less sprites too? --pasky */

   313

	int num_sprites = 0;

   314

	int i;

   315

   316

	FioOpenFile(file_index, filename);

   317

	_cur_grffile = filename;

   318

	_skip_specials = 0;

   319

	_skip_sprites = 0;

   320

   321

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

   322

			filename, load_index);

   323

   324

	{

   325

		int length;

   326

		byte type;

   327

   328

		length = FioReadWord();

   329

		type = FioReadByte();

   330

   331

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

   332

			num_sprites = FioReadDword();

   333

		} else {

   334

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

   335

		}

   336

   337

		/* Ignore last sprite, it's only used to mark end-of-file */

   338

		num_sprites--;

   339

		load_index++;

   340

	}

   341

   342

	if ((load_index + num_sprites) > NUM_SPRITES)

   343

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

   344

		      load_index + num_sprites);

   345

   346

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

   347

		if (!LoadNextSprite(load_index + i, file_index))

   348

			error("NEWGRF: Header was talking abount %d sprites, but only %d found..",

   349

			      num_sprites, i);

   350

	}

   351

   352

	/* Clean up. */

   353

	_skip_sprites = 0;

   354

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

   355

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

   356

   357

	return num_sprites;

   358

}

   359

   360

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

   361

{

   362

	int start;

   363

   364

	FioOpenFile(file_index, filename);

   365

	_skip_specials = 1;

   366

	_skip_sprites = 0;

   367

   368

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

   369

   370

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

   371

		int end = *index_tbl++;

   372

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

   373

			SkipSprites(end);

   374

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

   375

			do {

   376

				bool b = LoadNextSprite(start, file_index);

   377

				assert(b);

   378

			} while (++start <= end);

   379

		}

   380

	}

   381

}

   382

   383

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

   384

   385

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

   386

{

   387

	FILE *f;

   388

	fread_t *proc;

   389

	uint32 hdr;

   390

   391

	if (!_cache_sprites)

   392

		return false;

   393

   394

	if (read) {

   395

		f = fopen(filename, "rb");

   396

		proc = fread;

   397

   398

		if (f == NULL)

   399

			return false;

   400

   401

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

   402

		if (hdr != SPRITECACHE_ID) {

   403

			fclose(f);

   404

			return false;

   405

		}

   406

	} else {

   407

		f = fopen(filename, "wb");

   408

		proc = (fread_t*) fwrite;

   409

   410

		if (f == NULL)

   411

			return false;

   412

   413

		hdr = SPRITECACHE_ID;

   414

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

   415

	}

   416

   417

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

   418

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

   419

   420

#if 0

   421

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

   422

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

   423

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

   424

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

   425

#endif

   426

   427

#if !defined(WANT_NEW_LRU)

   428

	if (read)

   429

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

   430

#endif

   431

   432

	fclose(f);

   433

	return true;

   434

}

   435

   436

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

   437

#define S_FREE_MASK 1

   438

#define S_HDRSIZE sizeof(uint32)

   439

   440

static uint32 GetSpriteCacheUsage()

   441

{

   442

	byte *s = _spritecache_ptr;

   443

	size_t cur_size, tot_size = 0;

   444

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

   445

		if ( cur_size & S_FREE_MASK ) {

   446

			cur_size--;

   447

		} else {

   448

			tot_size += cur_size;

   449

		}

   450

	}

   451

   452

	return tot_size;

   453

}

   454

   455

   456

void IncreaseSpriteLRU()

   457

{

   458

	int i;

   459

   460

	// Increase all LRU values

   461

#if defined(WANT_NEW_LRU)

   462

	if (_sprite_lru_counter > 16384) {

   463

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

   464

   465

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

   466

			if (_sprite_ptr[i] != NULL) {

   467

				if (_sprite_lru_new[i] >= 0) {

   468

					_sprite_lru_new[i] = -1;

   469

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

   470

					_sprite_lru_new[i]--;

   471

				}

   472

			}

   473

		_sprite_lru_counter = 0;

   474

	}

   475

#else

   476

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

   477

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

   478

			_sprite_lru[i]++;

   479

	// Reset the lru counter.

   480

	_sprite_lru_counter = 0;

   481

#endif

   482

   483

	// Compact sprite cache every now and then.

   484

	if (++_compact_cache_counter >= 740) {

   485

		CompactSpriteCache();

   486

		_compact_cache_counter = 0;

   487

	}

   488

}

   489

   490

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

   491

// That is accomplished by moving the cached data.

   492

static void CompactSpriteCache()

   493

{

   494

	byte *s, *t;

   495

	size_t size, sizeb, cur_size;

   496

	int i;

   497

   498

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

   499

   500

	s = _spritecache_ptr;

   501

   502

	while (true) {

   503

		size = S_DATA(s);

   504

   505

		// Only look for free blocks.

   506

		if (size & S_FREE_MASK) {

   507

			size -= S_FREE_MASK;

   508

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

   509

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

   510

   511

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

   512

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

   513

				break;

   514

   515

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