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

#include "newgrf_storage.h"

    11

    12

/**

    13

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

    14

 * @param i index of the register

    15

 * @pre i < 0x110

    16

 * @return the value of the register

    17

 */

    18

static inline uint32 GetRegister(uint i)

    19

{

    20

	extern TemporaryStorageArray<uint, 0x110> _temp_store;

    21

	return _temp_store.Get(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

    80

};

    81

    82

    83

struct DeterministicSpriteGroupAdjust {

    84

	DeterministicSpriteGroupAdjustOperation operation;

    85

	DeterministicSpriteGroupAdjustType type;

    86

	byte variable;

    87

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

    88

	byte shift_num;

    89

	uint32 and_mask;

    90

	uint32 add_val;

    91

	uint32 divmod_val;

    92

	const SpriteGroup *subroutine;

    93

};

    94

    95

    96

struct DeterministicSpriteGroupRange {

    97

	const SpriteGroup *group;

    98

	uint32 low;

    99

	uint32 high;

   100

};

   101

   102

   103

struct DeterministicSpriteGroup {

   104

	VarSpriteGroupScope var_scope;

   105

	DeterministicSpriteGroupSize size;

   106

	byte num_adjusts;

   107

	byte num_ranges;

   108

	DeterministicSpriteGroupAdjust *adjusts;

   109

	DeterministicSpriteGroupRange *ranges; // Dynamically allocated

   110

   111

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

   112

	const SpriteGroup *default_group;

   113

};

   114

   115

enum RandomizedSpriteGroupCompareMode {

   116

	RSG_CMP_ANY,

   117

	RSG_CMP_ALL,

   118

};

   119

   120

struct RandomizedSpriteGroup {

   121

	VarSpriteGroupScope var_scope;  ///< Take this object:

   122

   123

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

   124

	byte triggers;

   125

   126

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

   127

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

   128

   129

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

   130

};

   131

   132

   133

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

   134

 * CALLBACK_FAILED */

   135

struct CallbackResultSpriteGroup {

   136

	uint16 result;

   137

};

   138

   139

   140

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

   141

 * sprites in the set */

   142

struct ResultSpriteGroup {

   143

	SpriteID sprite;

   144

	byte num_sprites;

   145

};

   146

   147

struct TileLayoutSpriteGroup {

   148

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

   149

	struct DrawTileSprites *dts;

   150

};

   151

   152

struct IndustryProductionSpriteGroup {

   153

	uint8 version;

   154

	uint16 substract_input[3];

   155

	uint16 add_output[2];

   156

	uint8 again;

   157

};

   158

   159

/* List of different sprite group types */

   160

enum SpriteGroupType {

   161

	SGT_INVALID,

   162

	SGT_REAL,

   163

	SGT_DETERMINISTIC,

   164

	SGT_RANDOMIZED,

   165

	SGT_CALLBACK,

   166

	SGT_RESULT,

   167

	SGT_TILELAYOUT,

   168

	SGT_INDUSTRY_PRODUCTION,

   169

};

   170

   171

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

   172

struct SpriteGroup {

   173

	SpriteGroupType type;

   174

   175

	union {

   176

		RealSpriteGroup real;

   177

		DeterministicSpriteGroup determ;

   178

		RandomizedSpriteGroup random;

   179

		CallbackResultSpriteGroup callback;

   180

		ResultSpriteGroup result;

   181

		TileLayoutSpriteGroup layout;

   182

		IndustryProductionSpriteGroup indprod;

   183

	} g;

   184

};

   185

   186

   187

SpriteGroup *AllocateSpriteGroup();

   188

void InitializeSpriteGroupPool();

   189

   190

   191

struct ResolverObject {

   192

	CallbackID callback;

   193

	uint32 callback_param1;

   194

	uint32 callback_param2;

   195

   196

	byte trigger;

   197

	uint32 last_value;

   198

	uint32 reseed;

   199

	VarSpriteGroupScope scope;

   200

   201

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

   202

   205

	union {

   206

		struct {

   207

			const struct Vehicle *self;

   208

			const struct Vehicle *parent;

   209

			EngineID self_type;

   210

		} vehicle;

   211

		struct {

   212

			TileIndex tile;

   213

		} canal;

   214

		struct {

   215

			TileIndex tile;

   216

			const struct Station *st;

   217

			const struct StationSpec *statspec;

   218

			CargoID cargo_type;

   219

		} station;

   220

		struct {

   221

			TileIndex tile;

   222

			Town *town;

   223

			HouseID house_id;

   224

		} house;

   225

		struct {

   226

			TileIndex tile;

   227

			Industry *ind;

   228

			IndustryGfx gfx;

   229

		} industry;

   230

		struct {

   231

			TileIndex tile;

   232

			const IndustrySpec *spec;

   233

			uint itspec_index;

   234

		} industry_location;

   235

		struct {

   236

			const struct CargoSpec *cs;

   237

		} cargo;

   238

	} u;

   239

   240

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

   241

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

   242

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

   243

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

   244

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

   245

};

   246

   247

   248

/* Base sprite group resolver */

   249

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

   250

   251

   252

#endif /* NEWGRF_SPRITEGROUP_H */