1

#ifndef SPRITE_H

     2

#define SPRITE_H

     3

     4

     5

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

     6

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

     7

 * depots or stations): */

     8

     9

typedef struct DrawTileSeqStruct {

    10

	int8 delta_x; // 0x80 is sequence terminator

    11

	int8 delta_y;

    12

	int8 delta_z;

    13

	byte width,height;

    14

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

    15

	uint32 image;

    16

} DrawTileSeqStruct;

    17

    18

typedef struct DrawTileSprites {

    19

	SpriteID ground_sprite;

    20

	DrawTileSeqStruct const *seq;

    21

} DrawTileSprites;

    22

    23

// Iterate through all DrawTileSeqStructs in DrawTileSprites.

    24

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

    25

    26

    27

/* This is for custom sprites: */

    28

    29

    30

typedef struct SpriteGroup SpriteGroup;

    31

    32

typedef struct RealSpriteGroup {

    33

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

    34

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

    35

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

    36

    37

	// Loaded = in motion, loading = not moving

    38

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

    39

    40

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

    41

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

    42

	// of da stuff.

    43

    44

	byte loaded_count;

    45

	uint16 loaded[16]; // sprite ids

    46

	byte loading_count;

    47

	uint16 loading[16]; // sprite ids

    48

} RealSpriteGroup;

    49

    50

/* Shared by deterministic and random groups. */

    51

typedef enum VarSpriteGroupScope {

    52

	VSG_SCOPE_SELF,

    53

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

    54

	VSG_SCOPE_PARENT,

    55

} VarSpriteGroupScope;

    56

    57

typedef struct DeterministicSpriteGroupRanges DeterministicSpriteGroupRanges;

    58

    59

typedef enum DeterministicSpriteGroupOperation {

    60

	DSG_OP_NONE,

    61

	DSG_OP_DIV,

    62

	DSG_OP_MOD,

    63

} DeterministicSpriteGroupOperation;

    64

    65

typedef struct DeterministicSpriteGroupRange DeterministicSpriteGroupRange;

    66

    67

typedef struct DeterministicSpriteGroup {

    68

	// Take this variable:

    69

	VarSpriteGroupScope var_scope;

    70

	byte variable;

    71

    72

	// Do this with it:

    73

	byte shift_num;

    74

	byte and_mask;

    75

    76

	// Then do this with it:

    77

	DeterministicSpriteGroupOperation operation;

    78

	byte add_val;

    79

	byte divmod_val;

    80

    81

	// And apply it to this:

    82

	byte num_ranges;

    83

	DeterministicSpriteGroupRange *ranges; // Dynamically allocated

    84

    85

	// Dynamically allocated, this is the sole owner

    86

	SpriteGroup *default_group;

    87

} DeterministicSpriteGroup;

    88

    89

typedef enum RandomizedSpriteGroupCompareMode {

    90

	RSG_CMP_ANY,

    91

	RSG_CMP_ALL,

    92

} RandomizedSpriteGroupCompareMode;

    93

    94

typedef struct RandomizedSpriteGroup {

    95

	// Take this object:

    96

	VarSpriteGroupScope var_scope;

    97

    98

	// Check for these triggers:

    99

	RandomizedSpriteGroupCompareMode cmp_mode;

   100

	byte triggers;

   101

   102

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

   103

	byte lowest_randbit;

   104

	byte num_groups; // must be power of 2

   105

   106

	// Take the group with appropriate index:

   107

	SpriteGroup *groups;

   108

} RandomizedSpriteGroup;

   109

   114

typedef enum SpriteGroupType {

   115

	SGT_REAL,

   116

	SGT_DETERMINISTIC,

   117

	SGT_RANDOMIZED,

   119

} SpriteGroupType;

   120

   121

struct SpriteGroup {

   122

	SpriteGroupType type;

   123

   124

	union {

   125

		RealSpriteGroup real;

   126

		DeterministicSpriteGroup determ;

   127

		RandomizedSpriteGroup random;

   129

	} g;

   130

};

   131

   132

struct DeterministicSpriteGroupRange {

   133

	SpriteGroup group;

   134

	byte low;

   135

	byte high;

   136

};

   137

   138

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

   139

 * chooses corresponding SpriteGroup accordingly to the given

   140

 * DeterministicSpriteGroup. */

   141

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

   142

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

   143

int GetDeterministicSpriteValue(byte var);

   144

   145

/* This takes randomized bitmask (probably associated with

   146

 * vehicle/station/whatever) and chooses corresponding SpriteGroup

   147

 * accordingly to the given RandomizedSpriteGroup. */

   148

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

   149

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

   150

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

   151

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

   152

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

   153

   154

#endif