1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "gfx.h"

     4

#include "fileio.h"

     5

#include "newgrf.h"

     6

#include <ctype.h>

     7

     8

#define SPRITECACHE_ID 0xF00F0006

     9

#define SPRITE_CACHE_SIZE 1024*1024

    10

    11

    12

//#define WANT_SPRITESIZES

    13

#define WANT_NEW_LRU

    14

//#define WANT_LOCKED

    15

    16

    17

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

    18

    19

int _skip_sprites = 0;

    20

int _replace_sprites_count[16];

    21

int _replace_sprites_offset[16];

    22

    23

static const char *_cur_grffile;

    24

static int _loading_stage;

    25

static int _skip_specials;

    26

uint16 _custom_sprites_base;

    27

static SpriteHdr _cur_sprite;

    28

    29

    30

static byte *_sprite_ptr[NUM_SPRITES];

    31

static uint16 _sprite_size[NUM_SPRITES];

    32

static uint32 _sprite_file_pos[NUM_SPRITES];

    33

    34

// This one is probably not needed.

    35

#if defined(WANT_LOCKED)

    36

static bool _sprite_locked[NUM_SPRITES];

    37

#endif

    38

    39

#if defined(WANT_NEW_LRU)

    40

static int16 _sprite_lru_new[NUM_SPRITES];

    41

#else

    42

static uint16 _sprite_lru[NUM_SPRITES];

    43

static uint16 _sprite_lru_cur[NUM_SPRITES];

    44

#endif

    45

    46

#ifdef WANT_SPRITESIZES

    47

static int8 _sprite_xoffs[NUM_SPRITES];

    48

static int8 _sprite_yoffs[NUM_SPRITES];

    49

static uint16 _sprite_xsize[NUM_SPRITES];

    50

static uint8 _sprite_ysize[NUM_SPRITES];

    51

#endif

    52

    53

static uint _sprite_lru_counter;

    54

static byte *_spritecache_ptr;

    55

static uint32 _spritecache_size;

    56

static int _compact_cache_counter;

    57

    58

    59

static const char * const _filename_list[] = {

    60

	"TRG1R.GRF",

    61

	"TRGIR.GRF",

    62

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

    63

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

    64

	NULL

    65

};

    66

    67

static const char * const _landscape_filenames[] = {

    68

	"TRGCR.GRF",

    69

	"TRGHR.GRF",

    70

	"TRGTR.GRF"

    71

};

    72

    73

    74

#include "table/landscape_sprite.h"

    75

    76

static const uint16 * const _landscape_spriteindexes[] = {

    77

	_landscape_spriteindexes_1,

    78

	_landscape_spriteindexes_2,

    79

	_landscape_spriteindexes_3,

    80

};

    81

    82

static const uint16 * const _slopes_spriteindexes[] = {

    83

	_slopes_spriteindexes_0,

    84

	_slopes_spriteindexes_1,

    85

	_slopes_spriteindexes_2,

    86

	_slopes_spriteindexes_3,

    87

};

    88

    89

static void CompactSpriteCache();

    90

    91

static void ReadSpriteHeaderSkipData(int num, int load_index)

    92

{

    93

	byte type;

    94

	int8 i;

    95

	int deaf = 0;

    96

    97

	if (_skip_sprites) {

    98

		if (_skip_sprites > 0)

    99

			_skip_sprites--;

   100

		deaf = 1;

   101

	}

   102

   103

	type = FioReadByte();

   104

	_cur_sprite.info = type;

   105

	if (type == 0xFF) {

   106

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

   107

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

   108

		 * because if no special sprite referencing to them is

   109

		 * processed, they themselves are never referenced and loaded

   110

		 * on their own. */

   111

		if (_skip_specials || deaf) {

   112

			FioSkipBytes(num);

   113

		} else {

   114

			DecodeSpecialSprite(_cur_grffile, num, load_index, _loading_stage);

   115

		}

   116

		return;

   117

	}

   118

   119

#ifdef WANT_SPRITESIZES

   120

	_cur_sprite.height = FioReadByte();

   121

	_cur_sprite.width = FioReadWord();

   122

	_cur_sprite.x_offs = FioReadWord();

   123

	_cur_sprite.y_offs = FioReadWord();

   124

#else

   125

	FioSkipBytes(7);

   126

#endif

   127

	num -= 8;

   128

	if (num == 0)

   129

		return;

   130

   131

	if (type & 2) {

   132

		FioSkipBytes(num);

   133

		return;

   134

	}

   135

   136

	while (num) {

   137

		i = FioReadByte();

   138

		if (i>=0) {

   139

			num -= i;

   140

			FioSkipBytes(i);

   141

		} else {

   142

			i = -(i >> 3);

   143

			num -= i;

   144

			FioReadByte();

   145

		}

   146

	}

   147

}

   148

   149

static void ReadSprite(int num, byte *dest)

   150

{

   151

	byte type;

   152

	byte *rel;

   153

	int8 i;

   154

	int j, dist;

   155

   156

	type = FioReadByte();

   157

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

   158

	if (type != 0xFF) {

   159

		/* read sprite hdr */

   160

		*dest++ = type;

   161

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

   162

			*dest++ = FioReadByte();

   163

		num -= 8;

   164

	}

   165

   166

	if (type & 2) {

   167

		while (num--)

   168

			*dest++ = FioReadByte();

   169

		return;

   170

	}

   171

   172

	while (num) {

   173

		i = FioReadByte();

   174

		if (i>=0) {

   175

			num -= i;

   176

			while (i--)

   177

				*dest++ = FioReadByte();

   178

		} else {

   179

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

   180

			i = -(i >> 3);

   181

			num -= i;

   182

   183

			rel = &dest[dist];

   184

			while (i--)

   185

				*dest++ = *rel++;

   186

		}

   187

	}

   188

}

   189

   190

   191

static bool LoadNextSprite(int load_index, byte file_index)

   192

{

   193

	uint16 size;

   194

	uint32 file_pos;

   195

   196

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

   197

		return false;

   198

   199

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

   200

   201

	ReadSpriteHeaderSkipData(size, load_index);

   202

   203

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

   204

		int count = _replace_sprites_count[0];

   205

		int offset = _replace_sprites_offset[0];

   206

   207

		_replace_sprites_offset[0]++;

   208

		_replace_sprites_count[0]--;

   209

   210

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

   211

			load_index = offset;

   212

		} else {

   213

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

   214

					count, offset);

   215

			_replace_sprites_offset[0] = 0;

   216

			_replace_sprites_count[0] = 0;

   217

		}

   218

   219

		if (_replace_sprites_count[0] == 0) {

   220

			int i;

   221

   222

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

   223

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

   224

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

   225

			}

   226

			_replace_sprites_count[i] = 0;

   227

			_replace_sprites_offset[i] = 0;

   228

		}

   229

	}

   230

   231

	_sprite_size[load_index] = size;

   232

	_sprite_file_pos[load_index] = file_pos;

   233

   234

#ifdef WANT_SPRITESIZES

   235

	_sprite_xsize[load_index] = _cur_sprite.width;

   236

	_sprite_ysize[load_index] = _cur_sprite.height;

   237

   238

	_sprite_xoffs[load_index] = _cur_sprite.x_offs;

   239

	_sprite_yoffs[load_index] = _cur_sprite.y_offs;

   240

#endif

   241

   242

	_sprite_ptr[load_index] = NULL;

   243

#if defined(WANT_LOCKED)

   244

	_sprite_locked[load_index] = false;

   245

#endif

   246

   247

#if defined(WANT_NEW_LRU)

   248

	_sprite_lru_new[load_index] = 0;

   249

#else

   250

	_sprite_lru[load_index] = 0xFFFF;

   251

	_sprite_lru_cur[load_index] = 0;

   252

#endif

   253

   254

	return true;

   255

}

   256

   257

static void SkipSprites(int count)

   258

{

   259

	while(count>0)

   260

	{

   261

		uint16 size;

   262

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

   263

			return;

   264

   265

		ReadSpriteHeaderSkipData(size, NUM_SPRITES-1);

   266

		count--;

   267

	}

   268

}

   269

   270

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

   271

static bool CheckGrfFile()

   272

{

   273

	byte check;

   274

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

   275

	check = FioReadWord();

   276

	FioSeekToFile(0);

   277

	return (check==0x21);

   278

}

   279

   280

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

   281

{

   282

	int load_index_org = load_index;

   283

   284

	FioOpenFile(file_index, filename);

   285

   286

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

   287

	 * might contain some special sprites. */

   288

	_skip_specials = 1;

   289

	_skip_sprites = 0;

   290

   291

	DEBUG(spritecache, 2) ("Reading grf-file ``%s''", 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

   304

	return load_index - load_index_org;

   305

}

   306

   307

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

   308

{

   309

	int i;

   310

   311

	FioOpenFile(file_index, filename);

   312

	_cur_grffile = filename;

   313

	_skip_specials = 0;

   314

	_skip_sprites = 0;

   315

   316

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

   317

			filename, load_index);

   318

   319

	/* Skip the first sprite; we don't care about how many sprites this

   320

	 * does contain; newest TTDPatches and George's longvehicles don't

   321

	 * neither, apparently. */

   322

	{

   323

		int length;

   324

		byte type;

   325

   326

		length = FioReadWord();

   327

		type = FioReadByte();

   328

   329

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

   330

			FioReadDword();

   331

		} else {

   332

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

   333

		}

   334

	}

   335

   336

	for (i = 0; LoadNextSprite(load_index + i, file_index); i++) {

   337

		if (load_index + i >= NUM_SPRITES)

   338

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

   339

			      load_index + i);

   340

	}

   341

   342

	/* Clean up. */

   343

	_skip_sprites = 0;

   344

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

   345

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

   346

   347

	return i;

   348

}

   349

   350

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

   351

{

   352

	int start;

   353

   354

	FioOpenFile(file_index, filename);

   355

	_skip_specials = 1;

   356

	_skip_sprites = 0;

   357

   358

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

   359

   360

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

   361

		int end = *index_tbl++;

   362

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

   363

			SkipSprites(end);

   364

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

   365

			do {

   366

				bool b = LoadNextSprite(start, file_index);

   367

				assert(b);

   368

			} while (++start <= end);

   369

		}

   370

	}

   371

}

   372

   373

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

   374

   375

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

   376

{

   377

	FILE *f;

   378

	fread_t *proc;

   379

	uint32 hdr;

   380

   381

	if (!_cache_sprites)

   382

		return false;

   383

   384

	if (read) {

   385

		f = fopen(filename, "rb");

   386

		proc = fread;

   387

   388

		if (f == NULL)

   389

			return false;

   390

   391

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

   392

		if (hdr != SPRITECACHE_ID) {

   393

			fclose(f);

   394

			return false;

   395

		}

   396

	} else {

   397

		f = fopen(filename, "wb");

   398

		proc = (fread_t*) fwrite;

   399

   400

		if (f == NULL)

   401

			return false;

   402

   403

		hdr = SPRITECACHE_ID;

   404

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

   405

	}

   406

   407

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

   408

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

   409

   410

#if 0

   411

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

   412

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

   413

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

   414

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

   415

#endif

   416

   417

#if !defined(WANT_NEW_LRU)

   418

	if (read)

   419

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

   420

#endif

   421

   422

	fclose(f);

   423

	return true;

   424

}

   425

   426

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

   427

#define S_FREE_MASK 1

   428

#define S_HDRSIZE sizeof(uint32)

   429

   430

static uint32 GetSpriteCacheUsage()

   431

{

   432

	byte *s = _spritecache_ptr;

   433

	size_t cur_size, tot_size = 0;

   434

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

   435

		if ( cur_size & S_FREE_MASK ) {

   436

			cur_size--;

   437

		} else {

   438

			tot_size += cur_size;

   439

		}

   440

	}

   441

   442

	return tot_size;

   443

}

   444

   445

   446

void IncreaseSpriteLRU()

   447

{

   448

	int i;

   449

   450

	// Increase all LRU values

   451

#if defined(WANT_NEW_LRU)

   452

	if (_sprite_lru_counter > 16384) {

   453

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

   454

   455

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

   456

			if (_sprite_ptr[i] != NULL) {

   457

				if (_sprite_lru_new[i] >= 0) {

   458

					_sprite_lru_new[i] = -1;

   459

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

   460

					_sprite_lru_new[i]--;

   461

				}

   462

			}

   463

		_sprite_lru_counter = 0;

   464

	}

   465

#else

   466

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

   467

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

   468

			_sprite_lru[i]++;

   469

	// Reset the lru counter.

   470

	_sprite_lru_counter = 0;

   471

#endif

   472

   473

	// Compact sprite cache every now and then.

   474

	if (++_compact_cache_counter >= 740) {

   475

		CompactSpriteCache();

   476

		_compact_cache_counter = 0;

   477

	}

   478

}

   479

   480

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

   481

// That is accomplished by moving the cached data.

   482

static void CompactSpriteCache()

   483

{

   484

	byte *s, *t;

   485

	size_t size, sizeb, cur_size;

   486

	int i;

   487

   488

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

   489

   490

	s = _spritecache_ptr;

   491

   492

	while (true) {

   493

		size = S_DATA(s);

   494

   495

		// Only look for free blocks.

   496

		if (size & S_FREE_MASK) {

   497

			size -= S_FREE_MASK;

   498

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

   499

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

   500

   501

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

   502

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

   503

				break;

   504

   505

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

   506

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

   507

   508

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

   509

#if defined(WANT_LOCKED)

   510

			if (!_sprite_locked[i]) {

   511

#endif

   512

   513

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

   514

				_sprite_ptr[i] -= size;

   515