1

/* $Id$ */

     2

     3

#ifndef SPRITE_H

     4

#define SPRITE_H

     5

     6

     7

/* The following describes bunch of sprites to be drawn together in a single 3D

     8

 * bounding box. Used especially for various multi-sprite buildings (like

     9

 * depots or stations): */

    10

    11

typedef struct DrawTileSeqStruct {

    12

	int8 delta_x; // 0x80 is sequence terminator

    13

	int8 delta_y;

    14

	int8 delta_z;

    15

	byte width,height;

    16

	byte unk; // 'depth', just z-size; TODO: rename

    17

	uint32 image;

    18

} DrawTileSeqStruct;

    19

    20

typedef struct DrawTileSprites {

    21

	SpriteID ground_sprite;

    22

	const DrawTileSeqStruct* seq;

    23

} DrawTileSprites;

    24

    25

// Iterate through all DrawTileSeqStructs in DrawTileSprites.

    26

#define foreach_draw_tile_seq(idx, list) for (idx = list; ((byte) idx->delta_x) != 0x80; idx++)

    27

    28

    29

/* This is for custom sprites: */

    30

    31

    32

typedef struct SpriteGroup SpriteGroup;

    33

    34

typedef struct RealSpriteGroup {

    35

	// XXX: Would anyone ever need more than 16 spritesets? Maybe we should

    36

	// use even less, now we take whole 8kb for custom sprites table, oh my!

    37

	byte sprites_per_set; // means number of directions - 4 or 8

    38

    39

	// Loaded = in motion, loading = not moving

    40

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

    41

    42

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

    43

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

    44

	// of da stuff.

    45

    46

	byte loaded_count;

    47

	SpriteGroup *loaded[16]; // sprite ids

    48

	byte loading_count;

    49

	SpriteGroup *loading[16]; // sprite ids

    50

} RealSpriteGroup;

    51

    52

/* Shared by deterministic and random groups. */

    53

typedef enum VarSpriteGroupScope {

    54

	VSG_SCOPE_SELF,

    55

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

    56

	VSG_SCOPE_PARENT,

    57

} VarSpriteGroupScope;

    58

    59

typedef struct DeterministicSpriteGroupRanges DeterministicSpriteGroupRanges;

    60

    61

typedef enum DeterministicSpriteGroupOperation {

    62

	DSG_OP_NONE,

    63

	DSG_OP_DIV,

    64

	DSG_OP_MOD,

    65

} DeterministicSpriteGroupOperation;

    66

    67

typedef struct DeterministicSpriteGroupRange DeterministicSpriteGroupRange;

    68

    69

typedef struct DeterministicSpriteGroup {

    70

	// Take this variable:

    71

	VarSpriteGroupScope var_scope;

    72

	byte variable;

    73

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

    74

    75

	// Do this with it:

    76

	byte shift_num;

    77

	byte and_mask;

    78

    79

	// Then do this with it:

    80

	DeterministicSpriteGroupOperation operation;

    81

	byte add_val;

    82

	byte divmod_val;

    83

    84

	// And apply it to this:

    85

	byte num_ranges;

    86

	DeterministicSpriteGroupRange *ranges; // Dynamically allocated

    87

    88

	// Dynamically allocated, this is the sole owner

    89

	SpriteGroup *default_group;

    90

} DeterministicSpriteGroup;

    91

    92

typedef enum RandomizedSpriteGroupCompareMode {

    93

	RSG_CMP_ANY,

    94

	RSG_CMP_ALL,

    95

} RandomizedSpriteGroupCompareMode;

    96

    97

typedef struct RandomizedSpriteGroup {

    98

	// Take this object:

    99

	VarSpriteGroupScope var_scope;

   100

   101

	// Check for these triggers:

   102

	RandomizedSpriteGroupCompareMode cmp_mode;

   103

	byte triggers;

   104

   105

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

   106

	byte lowest_randbit;

   107

	byte num_groups; // must be power of 2

   108

   109

	// Take the group with appropriate index:

   110

	SpriteGroup **groups;

   111

} RandomizedSpriteGroup;

   112

   113

typedef struct CallbackResultSpriteGroup {

   114

	uint16 result;

   115

} CallbackResultSpriteGroup;

   116

   117

typedef struct ResultSpriteGroup {

   118

	uint16 result;

   119

	byte sprites;

   120

} ResultSpriteGroup;

   121

   122

typedef enum SpriteGroupType {

   123

	SGT_REAL,

   124

	SGT_DETERMINISTIC,

   125

	SGT_RANDOMIZED,

   126

	SGT_CALLBACK,

   127

	SGT_RESULT,

   128

} SpriteGroupType;

   129

   130

struct SpriteGroup {

   131

	SpriteGroupType type;

   132

	byte ref_count;

   133

   134

	union {

   135

		RealSpriteGroup real;

   136

		DeterministicSpriteGroup determ;

   137

		RandomizedSpriteGroup random;

   138

		CallbackResultSpriteGroup callback;

   139

		ResultSpriteGroup result;

   140

	} g;

   141

};

   142

   143

struct DeterministicSpriteGroupRange {

   144

	SpriteGroup *group;

   145

	byte low;

   146

	byte high;

   147

};

   148

   149

/* This takes value (probably of the variable specified in the group) and

   150

 * chooses corresponding SpriteGroup accordingly to the given

   151

 * DeterministicSpriteGroup. */

   152

SpriteGroup *EvalDeterministicSpriteGroup(const DeterministicSpriteGroup *dsg, int value);

   153

/* Get value of a common deterministic SpriteGroup variable. */

   154

int GetDeterministicSpriteValue(byte var);

   155

   156

/* This takes randomized bitmask (probably associated with

   157

 * vehicle/station/whatever) and chooses corresponding SpriteGroup

   158

 * accordingly to the given RandomizedSpriteGroup. */

   159

SpriteGroup *EvalRandomizedSpriteGroup(const RandomizedSpriteGroup *rsg, byte random_bits);

   160

/* Triggers given RandomizedSpriteGroup with given bitmask and returns and-mask

   161

 * of random bits to be reseeded, or zero if there were no triggers matched

   162

 * (then they are |ed to @waiting_triggers instead). */

   163

byte RandomizedSpriteGroupTriggeredBits(const RandomizedSpriteGroup *rsg, byte triggers, byte *waiting_triggers);

   164

   165

void UnloadSpriteGroup(SpriteGroup **group_ptr);

   166

   167

#endif /* SPRITE_H */