1

/* $Id$ */

     2

     3

/** @file base.hpp Base for all blitters. */

     4

     5

#ifndef BLITTER_BASE_HPP

     6

#define BLITTER_BASE_HPP

     7

     8

#include "../spritecache.h"

     9

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

    10

#include "../zoom_type.h"

    11

    12

enum BlitterMode {

    13

	BM_NORMAL,

    14

	BM_COLOUR_REMAP,

    15

	BM_TRANSPARENT,

    16

};

    17

    18

/**

    19

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

    20

 */

    21

class Blitter {

    22

public:

    23

	struct BlitterParams {

    24

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

    25

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

    26

    27

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

    28

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

    29

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

    30

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

    31

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

    32

    33

		void *dst;               ///< Destination buffer

    34

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

    35

	};

    36

    37

	enum PaletteAnimation {

    38

		PALETTE_ANIMATION_NONE,           ///< No palette animation

    39

		PALETTE_ANIMATION_VIDEO_BACKEND,  ///< Palette animation should be done by video backend (8bpp only!)

    40

		PALETTE_ANIMATION_BLITTER,        ///< The blitter takes care of the palette animation

    41

	};

    42

    43

	typedef void *AllocatorProc(size_t size);

    44

    45

	/**

    46

	 * Get the screen depth this blitter works for.

    47

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

    48

	 */

    49

	virtual uint8 GetScreenDepth() = 0;

    50

    51

	/**

    52

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

    53

	 */

    54

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

    55

    56

	/**

    57

	 * Draw a colortable to the screen. This is: the color of the screen is read

    58

	 *  and is looked-up in the palette to match a new color, which then is put

    59

	 *  on the screen again.

    60

	 * @param dst the destination pointer (video-buffer).

    61

	 * @param width the width of the buffer.

    62

	 * @param height the height of the buffer.

    63

	 * @param pal the palette to use.

    64

	 */

    65

	virtual void DrawColorMappingRect(void *dst, int width, int height, int pal) = 0;

    66

    67

	/**

    68

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

    69

	 */

    70

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

    71

    72

	/**

    73

	 * Move the destination pointer the requested amount x and y, keeping in mind

    74

	 *  any pitch and bpp of the renderer.

    75

	 * @param video The destination pointer (video-buffer) to scroll.

    76

	 * @param x How much you want to scroll to the right.

    77

	 * @param y How much you want to scroll to the bottom.

    78

	 * @return A new destination pointer moved the the requested place.

    79

	 */

    80

	virtual void *MoveTo(const void *video, int x, int y) = 0;

    81

    82

	/**

    83

	 * Draw a pixel with a given color on the video-buffer.

    84

	 * @param video The destination pointer (video-buffer).

    85

	 * @param x The x position within video-buffer.

    86

	 * @param y The y position within video-buffer.

    87

	 * @param color A 8bpp mapping color.

    88

	 */

    89

	virtual void SetPixel(void *video, int x, int y, uint8 color) = 0;

    90

    91

	/**

    92

	 * Draw a pixel with a given color on the video-buffer if there is currently a black pixel.

    93

	 * @param video The destination pointer (video-buffer).

    94

	 * @param x The x position within video-buffer.

    95

	 * @param y The y position within video-buffer.

    96

	 * @param color A 8bpp mapping color.

    97

	 */

    98

	virtual void SetPixelIfEmpty(void *video, int x, int y, uint8 color) = 0;

    99

   100

	/**

   101

	 * Make a single horizontal line in a single color on the video-buffer.

   102

	 * @param video The destination pointer (video-buffer).

   103

	 * @param width The lenght of the line.

   104

	 * @param color A 8bpp mapping color.

   105

	 */

   106

	virtual void DrawRect(void *video, int width, int height, uint8 color) = 0;

   107

   108

	/**

   109

	 * Draw a line with a given color.

   110

	 * @param video The destination pointer (video-buffer).

   111

	 * @param x The x coordinate from where the line starts.

   112

	 * @param y The y coordinate from where the line starts.

   113

	 * @param x2 The x coordinate to where the line goes.

   114

	 * @param y2 The y coordinate to where the lines goes.

   115

	 * @param screen_width The width of the screen you are drawing in (to avoid buffer-overflows).

   116

	 * @param screen_height The height of the screen you are drawing in (to avoid buffer-overflows).

   117

	 * @param color A 8bpp mapping color.

   118

	 */

   119

	virtual void DrawLine(void *video, int x, int y, int x2, int y2, int screen_width, int screen_height, uint8 color) = 0;

   120

   121

	/**

   122

	 * Copy from a buffer to the screen.

   123

	 * @param video The destionation pointer (video-buffer).

   124

	 * @param src The buffer from which the data will be read.

   125

	 * @param width The width of the buffer.

   126

	 * @param height The height of the buffer.

   127

	 * @note You can not do anything with the content of the buffer, as the blitter can store non-pixel data in it too!

   128

	 */

   129

	virtual void CopyFromBuffer(void *video, const void *src, int width, int height) = 0;

   130

   131

	/**

   132

	 * Copy from the screen to a buffer.

   133

	 * @param video The destination pointer (video-buffer).

   134

	 * @param dst The buffer in which the data will be stored.

   135

	 * @param width The width of the buffer.

   136

	 * @param height The height of the buffer.

   137

	 * @note You can not do anything with the content of the buffer, as the blitter can store non-pixel data in it too!

   138

	 */

   139

	virtual void CopyToBuffer(const void *video, void *dst, int width, int height) = 0;

   140

   141

	/**

   142

	 * Copy from the screen to a buffer in a palette format for 8bpp and RGBA format for 32bpp.

   143

	 * @param video The destination pointer (video-buffer).

   144

	 * @param dst The buffer in which the data will be stored.

   145

	 * @param width The width of the buffer.

   146

	 * @param height The height of the buffer.

   147

	 * @param dst_pitch The pitch (byte per line) of the destination buffer.

   148

	 */

   149

	virtual void CopyImageToBuffer(const void *video, void *dst, int width, int height, int dst_pitch) = 0;

   150

   151

	/**

   152

	 * Scroll the videobuffer some 'x' and 'y' value.

   153

	 * @param video The buffer to scroll into.

   154

	 * @param left The left value of the screen to scroll.

   155

	 * @param top The top value of the screen to scroll.

   156

	 * @param width The width of the screen to scroll.

   157

	 * @param height The height of the screen to scroll.

   158

	 * @param scroll_x How much to scroll in X.

   159

	 * @param scroll_y How much to scroll in Y.

   160

	 */

   161

	virtual void ScrollBuffer(void *video, int &left, int &top, int &width, int &height, int scroll_x, int scroll_y) = 0;

   162

   163

	/**

   164

	 * Calculate how much memory there is needed for an image of this size in the video-buffer.

   165

	 * @param width The width of the buffer-to-be.

   166

	 * @param height The height of the buffer-to-be.

   167

	 * @return The size needed for the buffer.

   168

	 */

   169

	virtual int BufferSize(int width, int height) = 0;

   170

   171

	/**

   172

	 * Called when the 8bpp palette is changed; you should redraw all pixels on the screen that

   173

	 *  are equal to the 8bpp palette indexes 'start' to 'start + count'.

   174

	 * @param start The start index in the 8bpp palette.

   175

	 * @param count The amount of indexes that are (possible) changed.

   176

	 */

   177

	virtual void PaletteAnimate(uint start, uint count) = 0;

   178

   179

	/**

   180

	 * Check if the blitter uses palette animation at all.

   181

	 * @return True if it uses palette animation.

   182

	 */

   183

	virtual Blitter::PaletteAnimation UsePaletteAnimation() = 0;

   184

   185

	/**

   186

	 * Get the name of the blitter, the same as the Factory-instance returns.

   187

	 */

   188

	virtual const char *GetName() = 0;

   189

   190

	/**

   191

	 * Get how many bytes are needed to store a pixel.

   192

	 */

   193

	virtual int GetBytesPerPixel() = 0;

   194

   195

	virtual ~Blitter() { }

   196

};

   197

   198

#endif /* BLITTER_BASE_HPP */