1

/* $Id$ */

     2

     3

/** @file newgrf_spritegroup.h */

     4

     5

#ifndef NEWGRF_SPRITEGROUP_H

     6

#define NEWGRF_SPRITEGROUP_H

     7

     8

#include "town.h"

    10

    11

struct SpriteGroup;

    12

    13

    14

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

    15

 * groups. */

    16

struct RealSpriteGroup {

    17

	/* Loaded = in motion, loading = not moving

    18

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

    19

    20

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

    21

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

    22

	 * of da stuff. */

    23

    24

	byte num_loaded;       ///< Number of loaded groups

    25

	byte num_loading;      ///< Number of loading groups

    26

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

    27

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

    28

};

    29

    30

/* Shared by deterministic and random groups. */

    31

enum VarSpriteGroupScope {

    32

	VSG_SCOPE_SELF,

    33

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

    34

	VSG_SCOPE_PARENT,

    35

};

    36

    37

enum DeterministicSpriteGroupSize {

    38

	DSG_SIZE_BYTE,

    39

	DSG_SIZE_WORD,

    40

	DSG_SIZE_DWORD,

    41

};

    42

    43

enum DeterministicSpriteGroupAdjustType {

    44

	DSGA_TYPE_NONE,

    45

	DSGA_TYPE_DIV,

    46

	DSGA_TYPE_MOD,

    47

};

    48

    49

enum DeterministicSpriteGroupAdjustOperation {

    50

	DSGA_OP_ADD,  ///< a + b

    51

	DSGA_OP_SUB,  ///< a - b

    52

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

    53

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

    54

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

    55

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

    56

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

    57

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

    58

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

    59

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

    60

	DSGA_OP_MUL,  ///< a * b

    61

	DSGA_OP_AND,  ///< a & b

    62

	DSGA_OP_OR,   ///< a | b

    63

	DSGA_OP_XOR,  ///< a ^ b

    64

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

    65

	DSGA_OP_RST,  ///< return b

    66

};

    67

    68

    69

struct DeterministicSpriteGroupAdjust {

    70

	DeterministicSpriteGroupAdjustOperation operation;

    71

	DeterministicSpriteGroupAdjustType type;

    72

	byte variable;

    73

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

    74

	byte shift_num;

    75

	uint32 and_mask;

    76

	uint32 add_val;

    77

	uint32 divmod_val;

    78

	const SpriteGroup *subroutine;

    79

};

    80

    81

    82

struct DeterministicSpriteGroupRange {

    83

	const SpriteGroup *group;

    84

	uint32 low;

    85

	uint32 high;

    86

};

    87

    88

    89

struct DeterministicSpriteGroup {

    90

	VarSpriteGroupScope var_scope;

    91

	DeterministicSpriteGroupSize size;

    92

	byte num_adjusts;

    93

	byte num_ranges;

    94

	DeterministicSpriteGroupAdjust *adjusts;

    95

	DeterministicSpriteGroupRange *ranges; // Dynamically allocated

    96

    97

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

    98

	const SpriteGroup *default_group;

    99

};

   100

   101

enum RandomizedSpriteGroupCompareMode {

   102

	RSG_CMP_ANY,

   103

	RSG_CMP_ALL,

   104

};

   105

   106

struct RandomizedSpriteGroup {

   107

	VarSpriteGroupScope var_scope;  ///< Take this object:

   108

   109

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

   110

	byte triggers;

   111

   112

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

   113

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

   114

   115

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

   116

};

   117

   118

   119

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

   120

 * CALLBACK_FAILED */

   121

struct CallbackResultSpriteGroup {

   122

	uint16 result;

   123

};

   124

   125

   126

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

   127

 * sprites in the set */

   128

struct ResultSpriteGroup {

   129

	SpriteID sprite;

   130

	byte num_sprites;

   131

};

   132

   133

struct TileLayoutSpriteGroup {

   134

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

   135

	struct DrawTileSprites *dts;

   136

};

   137

   138

/* List of different sprite group types */

   139

enum SpriteGroupType {

   140

	SGT_INVALID,

   141

	SGT_REAL,

   142

	SGT_DETERMINISTIC,

   143

	SGT_RANDOMIZED,

   144

	SGT_CALLBACK,

   145

	SGT_RESULT,

   146

	SGT_TILELAYOUT,

   147

};

   148

   149

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

   150

struct SpriteGroup {

   151

	SpriteGroupType type;

   152

   153

	union {

   154

		RealSpriteGroup real;

   155

		DeterministicSpriteGroup determ;

   156

		RandomizedSpriteGroup random;

   157

		CallbackResultSpriteGroup callback;

   158

		ResultSpriteGroup result;

   159

		TileLayoutSpriteGroup layout;

   160

	} g;

   161

};

   162

   163

   164

SpriteGroup *AllocateSpriteGroup();

   165

void InitializeSpriteGroupPool();

   166

   167

   168

struct ResolverObject {

   169

	uint16 callback;

   170

	uint32 callback_param1;

   171

	uint32 callback_param2;

   172

   173

	byte trigger;

   174

	uint32 last_value;

   175

	uint32 reseed;

   176

	VarSpriteGroupScope scope;

   177

   178

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

   179

   180

	union {

   181

		struct {

   182

			const struct Vehicle *self;

   183

			const struct Vehicle *parent;

   184

			EngineID self_type;

   185

		} vehicle;

   186

		struct {

   187

			TileIndex tile;

   188

		} canal;

   189

		struct {

   190

			TileIndex tile;

   191

			const struct Station *st;

   192

			const struct StationSpec *statspec;

   193

			CargoID cargo_type;

   194

		} station;

   195

		struct {

   196

			TileIndex tile;

   197

			Town *town;

   198

			HouseID house_id;

   199

		} house;

   200

		struct {

   205

			const struct CargoSpec *cs;

   206

		} cargo;

   207

	} u;

   208

   209

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

   210

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

   211

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

   212

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

   213

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

   214

};

   215

   216

   217

/* Base sprite group resolver */

   218

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

   219

   220

   221

#endif /* NEWGRF_SPRITEGROUP_H */