1

/* $Id$ */

     2

     5

#ifndef NEWGRF_SPRITEGROUP_H

     6

#define NEWGRF_SPRITEGROUP_H

     7

     8

#include "town.h"

     9

    10

struct SpriteGroup;

    11

    12

    13

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

    14

 * groups. */

    15

struct RealSpriteGroup {

    18

    22

    23

	byte num_loaded;       ///< Number of loaded groups

    24

	byte num_loading;      ///< Number of loading groups

    25

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

    26

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

    27

};

    28

    29

/* Shared by deterministic and random groups. */

    30

enum VarSpriteGroupScope {

    31

	VSG_SCOPE_SELF,

    33

	VSG_SCOPE_PARENT,

    34

};

    35

    36

enum DeterministicSpriteGroupSize {

    37

	DSG_SIZE_BYTE,

    38

	DSG_SIZE_WORD,

    39

	DSG_SIZE_DWORD,

    40

};

    41

    42

enum DeterministicSpriteGroupAdjustType {

    43

	DSGA_TYPE_NONE,

    44

	DSGA_TYPE_DIV,

    45

	DSGA_TYPE_MOD,

    46

};

    47

    48

enum DeterministicSpriteGroupAdjustOperation {

    63

};

    64

    65

    66

struct DeterministicSpriteGroupAdjust {

    67

	DeterministicSpriteGroupAdjustOperation operation;

    68

	DeterministicSpriteGroupAdjustType type;

    69

	byte variable;

    70

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

    71

	byte shift_num;

    72

	uint32 and_mask;

    73

	uint32 add_val;

    74

	uint32 divmod_val;

    75

	const SpriteGroup *subroutine;

    76

};

    77

    78

    79

struct DeterministicSpriteGroupRange {

    80

	const SpriteGroup *group;

    81

	uint32 low;

    82

	uint32 high;

    83

};

    84

    85

    86

struct DeterministicSpriteGroup {

    87

	VarSpriteGroupScope var_scope;

    88

	DeterministicSpriteGroupSize size;

    89

	byte num_adjusts;

    90

	byte num_ranges;

    91

	DeterministicSpriteGroupAdjust *adjusts;

    92

	DeterministicSpriteGroupRange *ranges; // Dynamically allocated

    93

    95

	const SpriteGroup *default_group;

    96

};

    97

    98

enum RandomizedSpriteGroupCompareMode {

    99

	RSG_CMP_ANY,

   100

	RSG_CMP_ALL,

   101

};

   102

   103

struct RandomizedSpriteGroup {

   105

   107

	byte triggers;

   108

   111

   113

};

   114

   115

   116

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

   117

 * CALLBACK_FAILED */

   118

struct CallbackResultSpriteGroup {

   119

	uint16 result;

   120

};

   121

   122

   123

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

   124

 * sprites in the set */

   125

struct ResultSpriteGroup {

   126

	SpriteID sprite;

   127

	byte num_sprites;

   128

};

   129

   130

struct TileLayoutSpriteGroup {

   132

	struct DrawTileSprites *dts;

   133

};

   134

   135

/* List of different sprite group types */

   136

enum SpriteGroupType {

   137

	SGT_INVALID,

   138

	SGT_REAL,

   139

	SGT_DETERMINISTIC,

   140

	SGT_RANDOMIZED,

   141

	SGT_CALLBACK,

   142

	SGT_RESULT,

   143

	SGT_TILELAYOUT,

   144

};

   145

   146

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

   147

struct SpriteGroup {

   148

	SpriteGroupType type;

   149

   150

	union {

   151

		RealSpriteGroup real;

   152

		DeterministicSpriteGroup determ;

   153

		RandomizedSpriteGroup random;

   154

		CallbackResultSpriteGroup callback;

   155

		ResultSpriteGroup result;

   156

		TileLayoutSpriteGroup layout;

   157

	} g;

   158

};

   159

   160

   161

SpriteGroup *AllocateSpriteGroup();

   162

void InitializeSpriteGroupPool();

   163

   164

   165

struct ResolverObject {

   166

	uint16 callback;

   167

	uint32 callback_param1;

   168

	uint32 callback_param2;

   169

   170

	byte trigger;

   171

	uint32 last_value;

   172

	uint32 reseed;

   173

	VarSpriteGroupScope scope;

   174

   175

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

   176

   177

	union {

   178

		struct {

   179

			const struct Vehicle *self;

   180

			const struct Vehicle *parent;

   181

			EngineID self_type;

   182

		} vehicle;

   183

		struct {

   184

			TileIndex tile;

   185

			const struct Station *st;

   186

			const struct StationSpec *statspec;

   187

			CargoID cargo_type;

   188

		} station;

   189

		struct {

   190

			TileIndex tile;

   191

			Town *town;

   192

			HouseID house_id;

   193

		} house;

   197

	} u;

   198

   199

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

   200

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

   201

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

   202

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

   203

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

   204

};

   205

   206

   207

/* Base sprite group resolver */

   208

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

   209

   210

   211

#endif /* NEWGRF_SPRITEGROUP_H */