1

/* $Id$ */

     2

     3

/** @file newgrf_spritegroup.h */

     4

     5

#ifndef NEWGRF_SPRITEGROUP_H

     6

#define NEWGRF_SPRITEGROUP_H

     7

     8

#include "town.h"

     9

#include "industry.h"

    10

    11

/**

    12

 * Gets the value of a so-called newgrf "register".

    13

 * @param i index of the register

    14

 * @pre i < 0x110

    15

 * @return the value of the register

    16

 */

    17

static inline uint32 GetRegister(uint i)

    18

{

    19

	assert(i < 0x110);

    20

	extern uint32 _temp_store[0x110];

    21

	return _temp_store[i];

    22

}

    23

    24

struct SpriteGroup;

    25

    26

    27

/* 'Real' sprite groups contain a list of other result or callback sprite

    28

 * groups. */

    29

struct RealSpriteGroup {

    30

	/* Loaded = in motion, loading = not moving

    31

	 * Each group contains several spritesets, for various loading stages */

    32

    33

	/* XXX: For stations the meaning is different - loaded is for stations

    34

	 * with small amount of cargo whilst loading is for stations with a lot

    35

	 * of da stuff. */

    36

    37

	byte num_loaded;       ///< Number of loaded groups

    38

	byte num_loading;      ///< Number of loading groups

    39

	const SpriteGroup **loaded;  ///< List of loaded groups (can be SpriteIDs or Callback results)

    40

	const SpriteGroup **loading; ///< List of loading groups (can be SpriteIDs or Callback results)

    41

};

    42

    43

/* Shared by deterministic and random groups. */

    44

enum VarSpriteGroupScope {

    45

	VSG_SCOPE_SELF,

    46

	/* Engine of consists for vehicles, city for stations. */

    47

	VSG_SCOPE_PARENT,

    48

};

    49

    50

enum DeterministicSpriteGroupSize {

    51

	DSG_SIZE_BYTE,

    52

	DSG_SIZE_WORD,

    53

	DSG_SIZE_DWORD,

    54

};

    55

    56

enum DeterministicSpriteGroupAdjustType {

    57

	DSGA_TYPE_NONE,

    58

	DSGA_TYPE_DIV,

    59

	DSGA_TYPE_MOD,

    60

};

    61

    62

enum DeterministicSpriteGroupAdjustOperation {

    63

	DSGA_OP_ADD,  ///< a + b

    64

	DSGA_OP_SUB,  ///< a - b

    65

	DSGA_OP_SMIN, ///< (signed) min(a, b)

    66

	DSGA_OP_SMAX, ///< (signed) max(a, b)

    67

	DSGA_OP_UMIN, ///< (unsigned) min(a, b)

    68

	DSGA_OP_UMAX, ///< (unsigned) max(a, b)

    69

	DSGA_OP_SDIV, ///< (signed) a / b

    70

	DSGA_OP_SMOD, ///< (signed) a % b

    71

	DSGA_OP_UDIV, ///< (unsigned) a / b

    72

	DSGA_OP_UMOD, ///< (unsigned) a & b

    73

	DSGA_OP_MUL,  ///< a * b

    74

	DSGA_OP_AND,  ///< a & b

    75

	DSGA_OP_OR,   ///< a | b

    76

	DSGA_OP_XOR,  ///< a ^ b

    77

	DSGA_OP_STO,  ///< store a into temporary storage, indexed by b. return a

    78

	DSGA_OP_RST,  ///< return b

    79

};

    80

    81

    82

struct DeterministicSpriteGroupAdjust {

    83

	DeterministicSpriteGroupAdjustOperation operation;

    84

	DeterministicSpriteGroupAdjustType type;

    85

	byte variable;

    86

	byte parameter; ///< Used for variables between 0x60 and 0x7F inclusive.

    87

	byte shift_num;

    88

	uint32 and_mask;

    89

	uint32 add_val;

    90

	uint32 divmod_val;

    91

	const SpriteGroup *subroutine;

    92

};

    93

    94

    95

struct DeterministicSpriteGroupRange {

    96

	const SpriteGroup *group;

    97

	uint32 low;

    98

	uint32 high;

    99

};

   100

   101

   102

struct DeterministicSpriteGroup {

   103

	VarSpriteGroupScope var_scope;

   104

	DeterministicSpriteGroupSize size;

   105

	byte num_adjusts;

   106

	byte num_ranges;

   107

	DeterministicSpriteGroupAdjust *adjusts;

   108

	DeterministicSpriteGroupRange *ranges; // Dynamically allocated

   109

   110

	/* Dynamically allocated, this is the sole owner */

   111

	const SpriteGroup *default_group;

   112

};

   113

   114

enum RandomizedSpriteGroupCompareMode {

   115

	RSG_CMP_ANY,

   116

	RSG_CMP_ALL,

   117

};

   118

   119

struct RandomizedSpriteGroup {

   120

	VarSpriteGroupScope var_scope;  ///< Take this object:

   121

   122

	RandomizedSpriteGroupCompareMode cmp_mode; ///< Check for these triggers:

   123

	byte triggers;

   124

   125

	byte lowest_randbit; ///< Look for this in the per-object randomized bitmask:

   126

	byte num_groups; ///< must be power of 2

   127

   128

	const SpriteGroup **groups; ///< Take the group with appropriate index:

   129

};

   130

   131

   132

/* This contains a callback result. A failed callback has a value of

   133

 * CALLBACK_FAILED */

   134

struct CallbackResultSpriteGroup {

   135

	uint16 result;

   136

};

   137

   138

   139

/* A result sprite group returns the first SpriteID and the number of

   140

 * sprites in the set */

   141

struct ResultSpriteGroup {

   142

	SpriteID sprite;

   143

	byte num_sprites;

   144

};

   145

   146

struct TileLayoutSpriteGroup {

   147

	byte num_sprites; ///< Number of sprites in the spriteset, used for loading stages

   148

	struct DrawTileSprites *dts;

   149

};

   150

   151

struct IndustryProductionSpriteGroup {

   152

	uint8 version;

   153

	uint16 substract_input[3];

   154

	uint16 add_output[2];

   155

	uint8 again;

   156

};

   157

   158

/* List of different sprite group types */

   159

enum SpriteGroupType {

   160

	SGT_INVALID,

   161

	SGT_REAL,

   162

	SGT_DETERMINISTIC,

   163

	SGT_RANDOMIZED,

   164

	SGT_CALLBACK,

   165

	SGT_RESULT,

   166

	SGT_TILELAYOUT,

   167

	SGT_INDUSTRY_PRODUCTION,

   168

};

   169

   170

/* Common wrapper for all the different sprite group types */

   171

struct SpriteGroup {

   172

	SpriteGroupType type;

   173

   174

	union {

   175

		RealSpriteGroup real;

   176

		DeterministicSpriteGroup determ;

   177

		RandomizedSpriteGroup random;

   178

		CallbackResultSpriteGroup callback;

   179

		ResultSpriteGroup result;

   180

		TileLayoutSpriteGroup layout;

   181

		IndustryProductionSpriteGroup indprod;

   182

	} g;

   183

};

   184

   185

   186

SpriteGroup *AllocateSpriteGroup();

   187

void InitializeSpriteGroupPool();

   188

   189

   190

struct ResolverObject {

   192

	uint32 callback_param1;

   193

	uint32 callback_param2;

   194

   195

	byte trigger;

   196

	uint32 last_value;

   197

	uint32 reseed;

   198

	VarSpriteGroupScope scope;

   199

   200

	bool info_view; ///< Indicates if the item is being drawn in an info window

   201

   202

	union {

   203

		struct {

   204

			const struct Vehicle *self;

   205

			const struct Vehicle *parent;

   206

			EngineID self_type;

   207

		} vehicle;

   208

		struct {

   209

			TileIndex tile;

   210

		} canal;

   211

		struct {

   212

			TileIndex tile;

   213

			const struct Station *st;

   214

			const struct StationSpec *statspec;

   215

			CargoID cargo_type;

   216

		} station;

   217

		struct {

   218

			TileIndex tile;

   219

			Town *town;

   220

			HouseID house_id;

   221

		} house;

   222

		struct {

   223

			TileIndex tile;

   224

			Industry *ind;

   225

			IndustryGfx gfx;

   226

		} industry;

   227

		struct {

   228

			TileIndex tile;

   229

			const IndustrySpec *spec;

   230

			uint itspec_index;

   231

		} industry_location;

   232

		struct {

   233

			const struct CargoSpec *cs;

   234

		} cargo;

   235

	} u;

   236

   237

	uint32 (*GetRandomBits)(const struct ResolverObject*);

   238

	uint32 (*GetTriggers)(const struct ResolverObject*);

   239

	void (*SetTriggers)(const struct ResolverObject*, int);

   240

	uint32 (*GetVariable)(const struct ResolverObject*, byte, byte, bool*);

   241

	const SpriteGroup *(*ResolveReal)(const struct ResolverObject*, const SpriteGroup*);

   242

};

   243

   244

   245

/* Base sprite group resolver */

   246

const SpriteGroup *Resolve(const SpriteGroup *group, ResolverObject *object);

   247

   248

   249

#endif /* NEWGRF_SPRITEGROUP_H */