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

	DrawTileSeqStruct const *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

	uint16 loaded[16]; // sprite ids

    48

	byte loading_count;

    49

	uint16 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

    74

	// Do this with it:

    75

	byte shift_num;

    76

	byte and_mask;

    77

    78

	// Then do this with it:

    79

	DeterministicSpriteGroupOperation operation;

    80

	byte add_val;

    81

	byte divmod_val;

    82

    83

	// And apply it to this:

    84

	byte num_ranges;

    85

	DeterministicSpriteGroupRange *ranges; // Dynamically allocated

    86

    87

	// Dynamically allocated, this is the sole owner

    88

	SpriteGroup *default_group;

    89

} DeterministicSpriteGroup;

    90

    91

typedef enum RandomizedSpriteGroupCompareMode {

    92

	RSG_CMP_ANY,

    93

	RSG_CMP_ALL,

    94

} RandomizedSpriteGroupCompareMode;

    95

    96

typedef struct RandomizedSpriteGroup {

    97

	// Take this object:

    98

	VarSpriteGroupScope var_scope;

    99

   100

	// Check for these triggers:

   101

	RandomizedSpriteGroupCompareMode cmp_mode;

   102

	byte triggers;

   103

   104

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

   105

	byte lowest_randbit;

   106

	byte num_groups; // must be power of 2

   107

   108

	// Take the group with appropriate index:

   109

	SpriteGroup *groups;

   110

} RandomizedSpriteGroup;

   111

   112

typedef struct CallbackResultSpriteGroup {

   113

	uint16 result;

   114

} CallbackResultSpriteGroup;

   115

   116

typedef enum SpriteGroupType {

   117

	SGT_REAL,

   118

	SGT_DETERMINISTIC,

   119

	SGT_RANDOMIZED,

   120

	SGT_CALLBACK,

   121

} SpriteGroupType;

   122

   123

struct SpriteGroup {

   124

	SpriteGroupType type;

   125

   126

	union {

   127

		RealSpriteGroup real;

   128

		DeterministicSpriteGroup determ;

   129

		RandomizedSpriteGroup random;

   130

		CallbackResultSpriteGroup callback;

   131

	} g;

   132

};

   133

   134

struct DeterministicSpriteGroupRange {

   135

	SpriteGroup group;

   136

	byte low;

   137

	byte high;

   138

};

   139

   140

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

   141

 * chooses corresponding SpriteGroup accordingly to the given

   142

 * DeterministicSpriteGroup. */

   143

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

   144

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

   145

int GetDeterministicSpriteValue(byte var);

   146

   147

/* This takes randomized bitmask (probably associated with

   148

 * vehicle/station/whatever) and chooses corresponding SpriteGroup

   149

 * accordingly to the given RandomizedSpriteGroup. */

   150

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

   151

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

   152

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

   153

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

   154

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

   155

   156

#endif