1

/* $Id$ */

     2

     3

#ifndef NEWGRF_SPRITEGROUP_H

     4

#define NEWGRF_SPRITEGROUP_H

     5

     7

     8

struct SpriteGroup;

     9

    10

    11

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

    12

 * groups. */

    13

struct RealSpriteGroup {

    14

	// Loaded = in motion, loading = not moving

    15

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

    16

    17

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

    18

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

    19

	// of da stuff.

    20

    21

	byte num_loaded;       ///< Number of loaded groups

    22

	byte num_loading;      ///< Number of loading groups

    23

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

    24

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

    25

};

    26

    27

/* Shared by deterministic and random groups. */

    28

enum VarSpriteGroupScope {

    29

	VSG_SCOPE_SELF,

    30

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

    31

	VSG_SCOPE_PARENT,

    32

};

    33

    34

enum DeterministicSpriteGroupSize {

    35

	DSG_SIZE_BYTE,

    36

	DSG_SIZE_WORD,

    37

	DSG_SIZE_DWORD,

    38

};

    39

    40

enum DeterministicSpriteGroupAdjustType {

    41

	DSGA_TYPE_NONE,

    42

	DSGA_TYPE_DIV,

    43

	DSGA_TYPE_MOD,

    44

};

    45

    46

enum DeterministicSpriteGroupAdjustOperation {

    47

	DSGA_OP_ADD,  // a + b

    48

	DSGA_OP_SUB,  // a - b

    49

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

    50

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

    51

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

    52

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

    53

	DSGA_OP_SDIV, // (signed) a / b

    54

	DSGA_OP_SMOD, // (signed) a % b

    55

	DSGA_OP_UDIV, // (unsigned) a / b

    56

	DSGA_OP_UMOD, // (unsigned) a & b

    57

	DSGA_OP_MUL,  // a * b

    58

	DSGA_OP_AND,  // a & b

    59

	DSGA_OP_OR,   // a | b

    60

	DSGA_OP_XOR,  // a ^ b

    61

};

    62

    63

    64

struct DeterministicSpriteGroupAdjust {

    65

	DeterministicSpriteGroupAdjustOperation operation;

    66

	DeterministicSpriteGroupAdjustType type;

    67

	byte variable;

    68

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

    69

	byte shift_num;

    70

	uint32 and_mask;

    71

	uint32 add_val;

    72

	uint32 divmod_val;

    73

	const SpriteGroup *subroutine;

    74

};

    75

    76

    77

struct DeterministicSpriteGroupRange {

    78

	const SpriteGroup *group;

    79

	uint32 low;

    80

	uint32 high;

    81

};

    82

    83

    84

struct DeterministicSpriteGroup {

    85

	VarSpriteGroupScope var_scope;

    86

	DeterministicSpriteGroupSize size;

    87

	byte num_adjusts;

    88

	byte num_ranges;

    89

	DeterministicSpriteGroupAdjust *adjusts;

    90

	DeterministicSpriteGroupRange *ranges; // Dynamically allocated

    91

    92

	// Dynamically allocated, this is the sole owner

    93

	const SpriteGroup *default_group;

    94

};

    95

    96

enum RandomizedSpriteGroupCompareMode {

    97

	RSG_CMP_ANY,

    98

	RSG_CMP_ALL,

    99

};

   100

   101

struct RandomizedSpriteGroup {

   102

	// Take this object:

   103

	VarSpriteGroupScope var_scope;

   104

   105

	// Check for these triggers:

   106

	RandomizedSpriteGroupCompareMode cmp_mode;

   107

	byte triggers;

   108

   109

	// Look for this in the per-object randomized bitmask:

   110

	byte lowest_randbit;

   111

	byte num_groups; // must be power of 2

   112

   113

	// Take the group with appropriate index:

   114

	const SpriteGroup **groups;

   115

};

   116

   117

   118

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

   119

 * CALLBACK_FAILED */

   120

struct CallbackResultSpriteGroup {

   121

	uint16 result;

   122

};

   123

   124

   125

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

   126

 * sprites in the set */

   127

struct ResultSpriteGroup {

   128

	SpriteID sprite;

   129

	byte num_sprites;

   130

};

   131

   137

/* List of different sprite group types */

   138

enum SpriteGroupType {

   139

	SGT_INVALID,

   140

	SGT_REAL,

   141

	SGT_DETERMINISTIC,

   142

	SGT_RANDOMIZED,

   143

	SGT_CALLBACK,

   144

	SGT_RESULT,

   146

};

   147

   148

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

   149

struct SpriteGroup {

   150

	SpriteGroupType type;

   151

   152

	union {

   153

		RealSpriteGroup real;

   154

		DeterministicSpriteGroup determ;

   155

		RandomizedSpriteGroup random;

   156

		CallbackResultSpriteGroup callback;

   157

		ResultSpriteGroup result;

   159

	} g;

   160

};

   161

   162

   163

SpriteGroup *AllocateSpriteGroup();

   164

void InitializeSpriteGroupPool();

   165

   166

   167

struct ResolverObject {

   168

	uint16 callback;

   169

	uint32 callback_param1;

   170

	uint32 callback_param2;

   171

   172

	byte trigger;

   173

	uint32 last_value;

   174

	uint32 reseed;

   175

	VarSpriteGroupScope scope;

   176

   177

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

   178

   179

	union {

   180

		struct {

   181

			const struct Vehicle *self;

   182

			const struct Vehicle *parent;

   183

			EngineID self_type;

   184

		} vehicle;

   185

		struct {

   186

			TileIndex tile;

   187

			const struct Station *st;

   188

			const struct StationSpec *statspec;

   189

			CargoID cargo_type;

   190

		} station;

   196

	} u;

   197

   198

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

   199

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

   200

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

   201

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

   202

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

   203

};

   204

   205

   206

/* Base sprite group resolver */

   207

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

   208

   209

   210

#endif /* NEWGRF_SPRITEGROUP_H */