9626
|
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 |
/**
|
|
52 |
* Convert a sprite from the loader to our own format.
|
|
53 |
*/
|
|
54 |
virtual Sprite *Encode(SpriteLoader::Sprite *sprite, Blitter::AllocatorProc *allocator) = 0;
|
|
55 |
|
|
56 |
virtual ~Blitter() { }
|
|
57 |
};
|
|
58 |
|
|
59 |
/**
|
|
60 |
* The base factory, keeping track of all blitters.
|
|
61 |
*/
|
|
62 |
class BlitterFactoryBase {
|
|
63 |
private:
|
|
64 |
char *name;
|
|
65 |
typedef std::map<std::string, BlitterFactoryBase *> Blitters;
|
|
66 |
|
|
67 |
static Blitters &GetBlitters()
|
|
68 |
{
|
|
69 |
static Blitters &s_blitters = *new Blitters();
|
|
70 |
return s_blitters;
|
|
71 |
}
|
|
72 |
|
|
73 |
static Blitter **GetActiveBlitter()
|
|
74 |
{
|
|
75 |
static Blitter *s_blitter = NULL;
|
|
76 |
return &s_blitter;
|
|
77 |
}
|
|
78 |
|
|
79 |
protected:
|
|
80 |
/**
|
|
81 |
* Register a blitter internally, based on his name.
|
|
82 |
* @param name the name of the blitter.
|
|
83 |
* @note an assert() will be trigger if 2 blitters with the same name try to register.
|
|
84 |
*/
|
|
85 |
void RegisterBlitter(const char *name)
|
|
86 |
{
|
|
87 |
/* Don't register nameless Blitters */
|
|
88 |
if (name == NULL) return;
|
|
89 |
|
|
90 |
this->name = strdup(name);
|
|
91 |
std::pair<Blitters::iterator, bool> P = GetBlitters().insert(Blitters::value_type(name, this));
|
|
92 |
assert(P.second);
|
|
93 |
}
|
|
94 |
|
|
95 |
public:
|
|
96 |
BlitterFactoryBase() :
|
|
97 |
name(NULL)
|
|
98 |
{}
|
|
99 |
|
|
100 |
virtual ~BlitterFactoryBase() { if (this->name != NULL) GetBlitters().erase(this->name); free(this->name); }
|
|
101 |
|
|
102 |
/**
|
|
103 |
* Find the requested blitter and return his class.
|
|
104 |
* @param name the blitter to select.
|
|
105 |
* @post Sets the blitter so GetCurrentBlitter() returns it too.
|
|
106 |
*/
|
|
107 |
static Blitter *SelectBlitter(const char *name)
|
|
108 |
{
|
|
109 |
if (GetBlitters().size() == 0) return NULL;
|
|
110 |
|
|
111 |
Blitters::iterator it = GetBlitters().begin();
|
|
112 |
for (; it != GetBlitters().end(); it++) {
|
|
113 |
BlitterFactoryBase *b = (*it).second;
|
|
114 |
if (strcasecmp(name, b->name) == 0) {
|
|
115 |
Blitter *newb = b->CreateInstance();
|
|
116 |
*GetActiveBlitter() = newb;
|
|
117 |
return newb;
|
|
118 |
}
|
|
119 |
}
|
|
120 |
return NULL;
|
|
121 |
}
|
|
122 |
|
|
123 |
/**
|
|
124 |
* Get the current active blitter (always set by calling SelectBlitter).
|
|
125 |
*/
|
|
126 |
static Blitter *GetCurrentBlitter()
|
|
127 |
{
|
|
128 |
return *GetActiveBlitter();
|
|
129 |
}
|
|
130 |
|
|
131 |
|
|
132 |
static char *GetBlittersInfo(char *p, const char *last)
|
|
133 |
{
|
|
134 |
p += snprintf(p, last - p, "List of blitters:\n");
|
|
135 |
Blitters::iterator it = GetBlitters().begin();
|
|
136 |
for (; it != GetBlitters().end(); it++) {
|
|
137 |
BlitterFactoryBase *b = (*it).second;
|
|
138 |
p += snprintf(p, last - p, "%18s: %s\n", b->name, b->GetDescription());
|
|
139 |
}
|
|
140 |
p += snprintf(p, last - p, "\n");
|
|
141 |
|
|
142 |
return p;
|
|
143 |
}
|
|
144 |
|
|
145 |
/**
|
|
146 |
* Get a nice description of the blitter-class.
|
|
147 |
*/
|
|
148 |
virtual const char *GetDescription() = 0;
|
|
149 |
|
|
150 |
/**
|
|
151 |
* Create an instance of this Blitter-class.
|
|
152 |
*/
|
|
153 |
virtual Blitter *CreateInstance() = 0;
|
|
154 |
};
|
|
155 |
|
|
156 |
/**
|
|
157 |
* A template factory, so ->GetName() works correctly. This because else some compiler will complain.
|
|
158 |
*/
|
|
159 |
template <class T>
|
|
160 |
class BlitterFactory: public BlitterFactoryBase {
|
|
161 |
public:
|
|
162 |
BlitterFactory() { this->RegisterBlitter(((T *)this)->GetName()); }
|
|
163 |
|
|
164 |
/**
|
|
165 |
* Get the long, human readable, name for the Blitter-class.
|
|
166 |
*/
|
|
167 |
const char *GetName();
|
|
168 |
};
|
|
169 |
|
|
170 |
#endif /* BLITTER_HPP */
|