1

/* $Id$ */

     2

     3

/** @file blitter.hpp */

     4

     5

#ifndef BLITTER_HPP

     6

#define BLITTER_HPP

     7

     8

#include "../spriteloader/spriteloader.hpp"

     9

#include "../spritecache.h"

    10

#include <string>

    11

#include <map>

    12

    13

enum BlitterMode {

    14

	BM_NORMAL,

    15

	BM_COLOUR_REMAP,

    16

	BM_TRANSPARENT,

    17

};

    18

    19

/**

    20

 * How all blitters should look like. Extend this class to make your own.

    21

 */

    22

class Blitter {

    23

public:

    24

	struct BlitterParams {

    25

		const void *sprite;      ///< Pointer to the sprite how ever the encoder stored it

    26

		const byte *remap;       ///< XXX -- Temporary storage for remap array

    27

    28

		int skip_left, skip_top; ///< How much pixels of the source to skip on the left and top (based on zoom of dst)

    29

		int width, height;       ///< The width and height in pixels that needs to be drawn to dst

    30

		int sprite_width;        ///< Real width of the sprite

    31

		int sprite_height;       ///< Real height of the sprite

    32

		int left, top;           ///< The offset in the 'dst' in pixels to start drawing

    33

    34

		void *dst;               ///< Destination buffer

    35

		int pitch;               ///< The pitch of the destination buffer

    36

	};

    37

    38

	typedef void *AllocatorProc(size_t size);

    39

    40

	/**

    41

	 * Get the screen depth this blitter works for.

    42

	 *  This is either: 8, 16, 24 or 32.

    43

	 */

    44

	virtual uint8 GetScreenDepth() = 0;

    45

    46

	/**

    47

	 * Draw an image to the screen, given an amount of params defined above.

    48

	 */

    49

	virtual void Draw(Blitter::BlitterParams *bp, BlitterMode mode, ZoomLevel zoom) = 0;

    50

    51

	/**

    63

	 * Convert a sprite from the loader to our own format.

    64

	 */

    65

	virtual Sprite *Encode(SpriteLoader::Sprite *sprite, Blitter::AllocatorProc *allocator) = 0;

    66

    67

	/**

    68

	 * Get the renderer this class depends on.

    69

	 */

    70

	virtual const char *GetRenderer() = 0;

    71

    72

	virtual ~Blitter() { }

    73

};

    74

    75

/**

    76

 * The base factory, keeping track of all blitters.

    77

 */

    78

class BlitterFactoryBase {

    79

private:

    80

	char *name;

    81

	typedef std::map<std::string, BlitterFactoryBase *> Blitters;

    82

    83

	static Blitters &GetBlitters()

    84

	{

    85

		static Blitters &s_blitters = *new Blitters();

    86

		return s_blitters;

    87

	}

    88

    89

	static Blitter **GetActiveBlitter()

    90

	{

    91

		static Blitter *s_blitter = NULL;

    92

		return &s_blitter;

    93

	}

    94

    95

protected:

    96

	/**

    97

	 * Register a blitter internally, based on his name.

    98

	 * @param name the name of the blitter.

    99

	 * @note an assert() will be trigger if 2 blitters with the same name try to register.

   100

	 */

   101

	void RegisterBlitter(const char *name)

   102

	{

   103

		/* Don't register nameless Blitters */

   104

		if (name == NULL) return;

   105

   106

		this->name = strdup(name);

   107

		std::pair<Blitters::iterator, bool> P = GetBlitters().insert(Blitters::value_type(name, this));

   108

		assert(P.second);

   109

	}

   110

   111

public:

   112

	BlitterFactoryBase() :

   113

		name(NULL)

   114

	{}

   115

   116

	virtual ~BlitterFactoryBase() { if (this->name != NULL) GetBlitters().erase(this->name); free(this->name); }

   117

   118

	/**

   119

	 * Find the requested blitter and return his class.

   120

	 * @param name the blitter to select.

   121

	 * @post Sets the blitter so GetCurrentBlitter() returns it too.

   122

	 */

   123

	static Blitter *SelectBlitter(const char *name)

   124

	{

   125

		if (GetBlitters().size() == 0) return NULL;

   126

   127

		Blitters::iterator it = GetBlitters().begin();

   128

		for (; it != GetBlitters().end(); it++) {

   129

			BlitterFactoryBase *b = (*it).second;

   130

			if (strcasecmp(name, b->name) == 0) {

   131

				Blitter *newb = b->CreateInstance();

   132

				*GetActiveBlitter() = newb;

   133

				return newb;

   134

			}

   135

		}

   136

		return NULL;

   137

	}

   138

   139

	/**

   140

	 * Get the current active blitter (always set by calling SelectBlitter).

   141

	 */

   142

	static Blitter *GetCurrentBlitter()

   143

	{

   144

		return *GetActiveBlitter();

   145

	}

   146

   147

   148

	static char *GetBlittersInfo(char *p, const char *last)

   149

	{

   150

		p += snprintf(p, last - p, "List of blitters:\n");

   151

		Blitters::iterator it = GetBlitters().begin();

   152

		for (; it != GetBlitters().end(); it++) {

   153

			BlitterFactoryBase *b = (*it).second;

   154

			p += snprintf(p, last - p, "%18s: %s\n", b->name, b->GetDescription());

   155

		}

   156

		p += snprintf(p, last - p, "\n");

   157

   158

		return p;

   159

	}

   160

   161

	/**

   162

	 * Get a nice description of the blitter-class.

   163

	 */

   164

	virtual const char *GetDescription() = 0;

   165

   166

	/**

   167

	 * Create an instance of this Blitter-class.

   168

	 */

   169

	virtual Blitter *CreateInstance() = 0;

   170

};

   171

   172

/**

   173

 * A template factory, so ->GetName() works correctly. This because else some compiler will complain.

   174

 */

   175

template <class T>

   176

class BlitterFactory: public BlitterFactoryBase {

   177

public:

   178

	BlitterFactory() { this->RegisterBlitter(((T *)this)->GetName()); }

   179

   180

	/**

   181

	 * Get the long, human readable, name for the Blitter-class.

   182

	 */

   183

	const char *GetName();

   184

};

   185

   186

#endif /* BLITTER_HPP */