1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
/* $Id$ */
/** @file base.hpp Base for all blitters. */
#ifndef BLITTER_BASE_HPP
#define BLITTER_BASE_HPP
#include "../spritecache.h"
#include "../spriteloader/spriteloader.hpp"
#include "../zoom_type.h"
enum BlitterMode {
BM_NORMAL,
BM_COLOUR_REMAP,
BM_TRANSPARENT,
};
/**
* How all blitters should look like. Extend this class to make your own.
*/
class Blitter {
public:
struct BlitterParams {
const void *sprite; ///< Pointer to the sprite how ever the encoder stored it
const byte *remap; ///< XXX -- Temporary storage for remap array
int skip_left, skip_top; ///< How much pixels of the source to skip on the left and top (based on zoom of dst)
int width, height; ///< The width and height in pixels that needs to be drawn to dst
int sprite_width; ///< Real width of the sprite
int sprite_height; ///< Real height of the sprite
int left, top; ///< The offset in the 'dst' in pixels to start drawing
void *dst; ///< Destination buffer
int pitch; ///< The pitch of the destination buffer
};
enum PaletteAnimation {
PALETTE_ANIMATION_NONE, ///< No palette animation
PALETTE_ANIMATION_VIDEO_BACKEND, ///< Palette animation should be done by video backend (8bpp only!)
PALETTE_ANIMATION_BLITTER, ///< The blitter takes care of the palette animation
};
typedef void *AllocatorProc(size_t size);
/**
* Get the screen depth this blitter works for.
* This is either: 8, 16, 24 or 32.
*/
virtual uint8 GetScreenDepth() = 0;
/**
* Draw an image to the screen, given an amount of params defined above.
*/
virtual void Draw(Blitter::BlitterParams *bp, BlitterMode mode, ZoomLevel zoom) = 0;
/**
* Draw a colortable to the screen. This is: the color of the screen is read
* and is looked-up in the palette to match a new color, which then is put
* on the screen again.
* @param dst the destination pointer (video-buffer).
* @param width the width of the buffer.
* @param height the height of the buffer.
* @param pal the palette to use.
*/
virtual void DrawColorMappingRect(void *dst, int width, int height, int pal) = 0;
/**
* Convert a sprite from the loader to our own format.
*/
virtual Sprite *Encode(SpriteLoader::Sprite *sprite, Blitter::AllocatorProc *allocator) = 0;
/**
* Move the destination pointer the requested amount x and y, keeping in mind
* any pitch and bpp of the renderer.
* @param video The destination pointer (video-buffer) to scroll.
* @param x How much you want to scroll to the right.
* @param y How much you want to scroll to the bottom.
* @return A new destination pointer moved the the requested place.
*/
virtual void *MoveTo(const void *video, int x, int y) = 0;
/**
* Draw a pixel with a given color on the video-buffer.
* @param video The destination pointer (video-buffer).
* @param x The x position within video-buffer.
* @param y The y position within video-buffer.
* @param color A 8bpp mapping color.
*/
virtual void SetPixel(void *video, int x, int y, uint8 color) = 0;
/**
* Draw a pixel with a given color on the video-buffer if there is currently a black pixel.
* @param video The destination pointer (video-buffer).
* @param x The x position within video-buffer.
* @param y The y position within video-buffer.
* @param color A 8bpp mapping color.
*/
virtual void SetPixelIfEmpty(void *video, int x, int y, uint8 color) = 0;
/**
* Make a single horizontal line in a single color on the video-buffer.
* @param video The destination pointer (video-buffer).
* @param width The lenght of the line.
* @param color A 8bpp mapping color.
*/
virtual void DrawRect(void *video, int width, int height, uint8 color) = 0;
/**
* Draw a line with a given color.
* @param video The destination pointer (video-buffer).
* @param x The x coordinate from where the line starts.
* @param y The y coordinate from where the line starts.
* @param x2 The x coordinate to where the line goes.
* @param y2 The y coordinate to where the lines goes.
* @param screen_width The width of the screen you are drawing in (to avoid buffer-overflows).
* @param screen_height The height of the screen you are drawing in (to avoid buffer-overflows).
* @param color A 8bpp mapping color.
*/
virtual void DrawLine(void *video, int x, int y, int x2, int y2, int screen_width, int screen_height, uint8 color) = 0;
/**
* Copy from a buffer to the screen.
* @param video The destionation pointer (video-buffer).
* @param src The buffer from which the data will be read.
* @param width The width of the buffer.
* @param height The height of the buffer.
* @note You can not do anything with the content of the buffer, as the blitter can store non-pixel data in it too!
*/
virtual void CopyFromBuffer(void *video, const void *src, int width, int height) = 0;
/**
* Copy from the screen to a buffer.
* @param video The destination pointer (video-buffer).
* @param dst The buffer in which the data will be stored.
* @param width The width of the buffer.
* @param height The height of the buffer.
* @note You can not do anything with the content of the buffer, as the blitter can store non-pixel data in it too!
*/
virtual void CopyToBuffer(const void *video, void *dst, int width, int height) = 0;
/**
* Copy from the screen to a buffer in a palette format for 8bpp and RGBA format for 32bpp.
* @param video The destination pointer (video-buffer).
* @param dst The buffer in which the data will be stored.
* @param width The width of the buffer.
* @param height The height of the buffer.
* @param dst_pitch The pitch (byte per line) of the destination buffer.
*/
virtual void CopyImageToBuffer(const void *video, void *dst, int width, int height, int dst_pitch) = 0;
/**
* Scroll the videobuffer some 'x' and 'y' value.
* @param video The buffer to scroll into.
* @param left The left value of the screen to scroll.
* @param top The top value of the screen to scroll.
* @param width The width of the screen to scroll.
* @param height The height of the screen to scroll.
* @param scroll_x How much to scroll in X.
* @param scroll_y How much to scroll in Y.
*/
virtual void ScrollBuffer(void *video, int &left, int &top, int &width, int &height, int scroll_x, int scroll_y) = 0;
/**
* Calculate how much memory there is needed for an image of this size in the video-buffer.
* @param width The width of the buffer-to-be.
* @param height The height of the buffer-to-be.
* @return The size needed for the buffer.
*/
virtual int BufferSize(int width, int height) = 0;
/**
* Called when the 8bpp palette is changed; you should redraw all pixels on the screen that
* are equal to the 8bpp palette indexes 'start' to 'start + count'.
* @param start The start index in the 8bpp palette.
* @param count The amount of indexes that are (possible) changed.
*/
virtual void PaletteAnimate(uint start, uint count) = 0;
/**
* Check if the blitter uses palette animation at all.
* @return True if it uses palette animation.
*/
virtual Blitter::PaletteAnimation UsePaletteAnimation() = 0;
/**
* Get the naem of the blitter, the same as the Factory-instance returns.
*/
virtual const char *GetName() = 0;
virtual ~Blitter() { }
};
#endif /* BLITTER_BASE_HPP */
|
