1

/* $Id$ */

     2

     3

/** @file newgrf_spritegroup.h */

     4

     5

#ifndef NEWGRF_SPRITEGROUP_H

     6

#define NEWGRF_SPRITEGROUP_H

     7

     8

#include "town_type.h"

     9

#include "industry_type.h"

    10

#include "newgrf_storage.h"

    11

#include "core/bitmath_func.hpp"

    12

#include "gfx_type.h"

    13

    14

/**

    15

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

    16

 * @param i index of the register

    17

 * @pre i < 0x110

    18

 * @return the value of the register

    19

 */

    20

static inline uint32 GetRegister(uint i)

    21

{

    22

	extern TemporaryStorageArray<uint32, 0x110> _temp_store;

    23

	return _temp_store.Get(i);

    24

}

    25

    26

struct SpriteGroup;

    27

    28

    29

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

    30

 * groups. */

    31

struct RealSpriteGroup {

    32

	/* Loaded = in motion, loading = not moving

    33

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

    34

    35

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

    36

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

    37

	 * of da stuff. */

    38

    39

	byte num_loaded;       ///< Number of loaded groups

    40

	byte num_loading;      ///< Number of loading groups

    41

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

    42

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

    43

};

    44

    45

/* Shared by deterministic and random groups. */

    46

enum VarSpriteGroupScope {

    47

	VSG_SCOPE_SELF,

    48

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

    49

	VSG_SCOPE_PARENT,

    50

};

    51

    52

enum DeterministicSpriteGroupSize {

    53

	DSG_SIZE_BYTE,

    54

	DSG_SIZE_WORD,

    55

	DSG_SIZE_DWORD,

    56

};

    57

    58

enum DeterministicSpriteGroupAdjustType {

    59

	DSGA_TYPE_NONE,

    60

	DSGA_TYPE_DIV,

    61

	DSGA_TYPE_MOD,

    62

};

    63

    64

enum DeterministicSpriteGroupAdjustOperation {

    65

	DSGA_OP_ADD,  ///< a + b

    66

	DSGA_OP_SUB,  ///< a - b

    67

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

    68

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

    69

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

    70

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

    71

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

    72

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

    73

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

    74

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

    75

	DSGA_OP_MUL,  ///< a * b

    76

	DSGA_OP_AND,  ///< a & b

    77

	DSGA_OP_OR,   ///< a | b

    78

	DSGA_OP_XOR,  ///< a ^ b

    79

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

    80

	DSGA_OP_RST,  ///< return b

    81

	DSGA_OP_STOP, ///< store a into persistent storage, indexed by b, return a

    82

	DSGA_OP_ROR,  ///< rotate a b positions to the right

    83

	DSGA_OP_SCMP, ///< (signed) comparision (a < b -> 0, a == b = 1, a > b = 2)

    84

	DSGA_OP_UCMP, ///< (unsigned) comparision (a < b -> 0, a == b = 1, a > b = 2)

    85

};

    86

    87

    88

struct DeterministicSpriteGroupAdjust {

    89

	DeterministicSpriteGroupAdjustOperation operation;

    90

	DeterministicSpriteGroupAdjustType type;

    91

	byte variable;

    92

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

    93

	byte shift_num;

    94

	uint32 and_mask;

    95

	uint32 add_val;

    96

	uint32 divmod_val;

    97

	const SpriteGroup *subroutine;

    98

};

    99

   100

   101

struct DeterministicSpriteGroupRange {

   102

	const SpriteGroup *group;

   103

	uint32 low;

   104

	uint32 high;

   105

};

   106

   107

   108

struct DeterministicSpriteGroup {

   109

	VarSpriteGroupScope var_scope;

   110

	DeterministicSpriteGroupSize size;

   111

	byte num_adjusts;

   112

	byte num_ranges;

   113

	DeterministicSpriteGroupAdjust *adjusts;

   114

	DeterministicSpriteGroupRange *ranges; // Dynamically allocated

   115

   116

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

   117

	const SpriteGroup *default_group;

   118

};

   119

   120

enum RandomizedSpriteGroupCompareMode {

   121

	RSG_CMP_ANY,

   122

	RSG_CMP_ALL,

   123

};

   124

   125

struct RandomizedSpriteGroup {

   126

	VarSpriteGroupScope var_scope;  ///< Take this object:

   127

   128

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

   129

	byte triggers;

   130

   131

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

   132

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

   133

   134

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

   135

};

   136

   137

   138

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

   139

 * CALLBACK_FAILED */

   140

struct CallbackResultSpriteGroup {

   141

	uint16 result;

   142

};

   143

   144

   145

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

   146

 * sprites in the set */

   147

struct ResultSpriteGroup {

   148

	SpriteID sprite;

   149

	byte num_sprites;

   150

};

   151

   152

struct TileLayoutSpriteGroup {

   153

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

   154

	struct DrawTileSprites *dts;

   155

};

   156

   157

struct IndustryProductionSpriteGroup {

   158

	uint8 version;

   159

	uint16 substract_input[3];

   160

	uint16 add_output[2];

   161

	uint8 again;

   162

};

   163

   164

/* List of different sprite group types */

   165

enum SpriteGroupType {

   166

	SGT_INVALID,

   167

	SGT_REAL,

   168

	SGT_DETERMINISTIC,

   169

	SGT_RANDOMIZED,

   170

	SGT_CALLBACK,

   171

	SGT_RESULT,

   172

	SGT_TILELAYOUT,

   173

	SGT_INDUSTRY_PRODUCTION,

   174

};

   175

   176

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

   177

struct SpriteGroup {

   178

	SpriteGroupType type;

   179

   180

	union {

   181

		RealSpriteGroup real;

   182

		DeterministicSpriteGroup determ;

   183

		RandomizedSpriteGroup random;

   184

		CallbackResultSpriteGroup callback;

   185

		ResultSpriteGroup result;

   186

		TileLayoutSpriteGroup layout;

   187

		IndustryProductionSpriteGroup indprod;

   188

	} g;

   189

};

   190

   191

   192

SpriteGroup *AllocateSpriteGroup();

   193

void InitializeSpriteGroupPool();

   194

   195

   196

struct ResolverObject {

   197

	CallbackID callback;

   198

	uint32 callback_param1;

   199

	uint32 callback_param2;

   200

   201

	byte trigger;

   202

	uint32 last_value;

   203

	uint32 reseed;

   204

	VarSpriteGroupScope scope;

   205

   206

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

   207

   208

	BaseStorageArray *psa; ///< The persistent storage array of this resolved object.

   209

   210

	union {

   211

		struct {

   212

			const struct Vehicle *self;

   213

			const struct Vehicle *parent;

   214

			EngineID self_type;

   215

		} vehicle;

   216

		struct {

   217

			TileIndex tile;

   218

		} canal;

   219

		struct {

   220

			TileIndex tile;

   221

			const struct Station *st;

   222

			const struct StationSpec *statspec;

   223

			CargoID cargo_type;

   224

		} station;

   225

		struct {

   226

			TileIndex tile;

   227

			Town *town;

   228

			HouseID house_id;

   229

		} house;

   230

		struct {

   231

			TileIndex tile;

   232

			Industry *ind;

   233

			IndustryGfx gfx;

   234

			IndustryType type;

   235

		} industry;

   236

		struct {

   237

			const struct CargoSpec *cs;

   238

		} cargo;

   239

	} u;

   240

   241

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

   242

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

   243

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

   244

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

   245

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

   246

};

   247

   248

   249

/* Base sprite group resolver */

   250

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

   251

   252

   253

#endif /* NEWGRF_SPRITEGROUP_H */