From b53220d2cc97afa1ecc1a3b499a8571a5e8885e4 Mon Sep 17 00:00:00 2001 From: Vicent Marti Date: Sun, 31 Aug 2008 13:51:48 +0000 Subject: Split VectorRenderer interface from custom vector renderers. svn-id: r34226 --- graphics/VectorRendererSpec.h | 310 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 310 insertions(+) create mode 100644 graphics/VectorRendererSpec.h (limited to 'graphics/VectorRendererSpec.h') diff --git a/graphics/VectorRendererSpec.h b/graphics/VectorRendererSpec.h new file mode 100644 index 0000000000..4d30e5a75a --- /dev/null +++ b/graphics/VectorRendererSpec.h @@ -0,0 +1,310 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef VECTOR_RENDERER_SPEC_H +#define VECTOR_RENDERER_SPEC_H + +#include "graphics/VectorRenderer.h" + +namespace Graphics { + +/** + * VectorRendererSpec: Specialized Vector Renderer Class + * + * This templated class implements the basic subset of vector operations for + * all platforms by allowing the user to provide the actual Pixel Type and + * pixel information structs. + * + * This class takes two template parameters: + * + * @param PixelType Defines a type which may hold the color value of a single + * pixel, such as "byte" or "uint16" for 8 and 16 BPP respectively. + * + * @param PixelFormat Defines the type of the PixelFormat struct which contains all + * the actual information of the pixels being used, as declared in "graphics/colormasks.h" + * + * TODO: Expand documentation. + * + * @see VectorRenderer + */ +template +class VectorRendererSpec : public VectorRenderer { + typedef VectorRenderer Base; + +public: + VectorRendererSpec() { + _bitmapAlphaColor = RGBToColor(255, 0, 255); + } + + void drawLine(int x1, int y1, int x2, int y2); + void drawCircle(int x, int y, int r); + void drawSquare(int x, int y, int w, int h); + void drawRoundedSquare(int x, int y, int r, int w, int h); + void drawTriangle(int x, int y, int base, int height, TriangleOrientation orient); + void drawTab(int x, int y, int r, int w, int h); + void drawBeveledSquare(int x, int y, int w, int h, int bevel) { + drawBevelSquareAlg(x, y, w, h, bevel, _bevelColor, _fgColor, Base::_fillMode != kFillDisabled); + } + void drawString(const Graphics::Font *font, const Common::String &text, + const Common::Rect &area, GUI::Theme::TextAlign alignH, + GUI::Theme::TextAlignVertical alignV, int deltax, bool elipsis); + + void setFgColor(uint8 r, uint8 g, uint8 b) { _fgColor = RGBToColor(r, g, b); } + void setBgColor(uint8 r, uint8 g, uint8 b) { _bgColor = RGBToColor(r, g, b); } + void setBevelColor(uint8 r, uint8 g, uint8 b) { _bevelColor = RGBToColor(r, g, b); } + void setGradientColors(uint8 r1, uint8 g1, uint8 b1, uint8 r2, uint8 g2, uint8 b2); + + virtual void copyFrame(OSystem *sys, const Common::Rect &r); + virtual void copyWholeFrame(OSystem *sys) { copyFrame(sys, Common::Rect(0, 0, _activeSurface->w, _activeSurface->h)); } + + virtual void fillSurface(); + virtual void blitSurface(const Graphics::Surface *source, const Common::Rect &r); + virtual void blitSubSurface(const Graphics::Surface *source, const Common::Rect &r); + virtual void blitAlphaBitmap(const Graphics::Surface *source, const Common::Rect &r); + + virtual void applyScreenShading(GUI::Theme::ShadingStyle shadingStyle); + +protected: + + /** + * Draws a single pixel on the surface with the given coordinates and + * the given color. + * + * @param x Horizontal coordinate of the pixel. + * @param y Vertical coordinate of the pixel. + * @param color Color of the pixel + */ + virtual inline void putPixel(int x, int y, PixelType color) { + PixelType *ptr = (PixelType *)_activeSurface->getBasePtr(x, y); + *ptr = color; + } + + /** + * Blends a single pixel on the surface with the given coordinates, color + * and Alpha intensity. + * + * @param x Horizontal coordinate of the pixel. + * @param y Vertical coordinate of the pixel. + * @param color Color of the pixel + * @param alpha Alpha intensity of the pixel (0-255) + */ + virtual inline void blendPixel(int x, int y, PixelType color, uint8 alpha) { + if (alpha == 255) + putPixel(x, y, color); + else if (alpha > 0) + blendPixelPtr((PixelType*)Base::_activeSurface->getBasePtr(x, y), color, alpha); + } + + /** + * Blends a single pixel on the surface in the given pixel pointer, using supplied color + * and Alpha intensity. + * + * This is implemented to prevent blendPixel() to calculate the surface pointer on each call. + * Optimized drawing algorithms should call this function when possible. + * + * @see blendPixel + * @param ptr Pointer to the pixel to blend on top of + * @param color Color of the pixel + * @param alpha Alpha intensity of the pixel (0-255) + */ + virtual inline void blendPixelPtr(PixelType *ptr, PixelType color, uint8 alpha); + + /** + * PRIMITIVE DRAWING ALGORITHMS + * + * Generic algorithms for drawing all kinds of aliased primitive shapes. + * These may be overloaded in inheriting classes to implement platform-specific + * optimizations or improve looks. + * + * @see VectorRendererAA + * @see VectorRendererAA::drawLineAlg + * @see VectorRendererAA::drawCircleAlg + */ + virtual void drawLineAlg(int x1, int y1, int x2, int y2, + int dx, int dy, PixelType color); + + virtual void drawCircleAlg(int x, int y, int r, + PixelType color, FillMode fill_m); + + virtual void drawRoundedSquareAlg(int x1, int y1, int r, int w, int h, + PixelType color, FillMode fill_m); + + virtual void drawSquareAlg(int x, int y, int w, int h, + PixelType color, FillMode fill_m); + + virtual void drawTriangleVertAlg(int x, int y, int w, int h, + bool inverted, PixelType color, FillMode fill_m); + + virtual void drawTriangleFast(int x, int y, int size, + bool inverted, PixelType color, FillMode fill_m); + + virtual void drawBevelSquareAlg(int x, int y, int w, int h, + int bevel, PixelType top_color, PixelType bottom_color, bool fill); + + virtual void drawTabAlg(int x, int y, int w, int h, int r, + PixelType color, VectorRenderer::FillMode fill_m, + int baseLeft = 0, int baseRight = 0); + + virtual void drawBevelTabAlg(int x, int y, int w, int h, + int bevel, PixelType topColor, PixelType bottomColor, + int baseLeft = 0, int baseRight = 0); + + /** + * SHADOW DRAWING ALGORITHMS + * + * Optimized versions of the primitive drawing algorithms with alpha blending + * for shadow drawing. + * There functions may be overloaded in inheriting classes to improve performance + * in the slowest platforms where pixel alpha blending just doesn't cut it. + * + * @param blur Intensity/size of the shadow. + */ + virtual void drawSquareShadow(int x, int y, int w, int h, int blur); + virtual void drawRoundedSquareShadow(int x, int y, int r, int w, int h, int blur); + virtual void drawRoundedSquareFakeBevel(int x, int y, int r, int w, int h, int amount); + + /** + * Calculates the color gradient on a given point. + * This function assumes that the gradient start/end colors have been set + * beforehand from the API function call. + * + * @param pos Progress of the gradient. + * @param max Maximum amount of the progress. + * @return Composite color of the gradient at the given "progress" amount. + */ + virtual inline PixelType calcGradient(uint32 pos, uint32 max); + + /** + * Fills several pixels in a row with a given color and the specifed alpha blending. + * + * @see blendPixelPtr + * @see blendPixel + * @param first Pointer to the first pixel to fill. + * @param last Pointer to the last pixel to fill. + * @param color Color of the pixel + * @param alpha Alpha intensity of the pixel (0-255) + */ + virtual inline void blendFill(PixelType *first, PixelType *last, PixelType color, uint8 alpha) { + while (first != last) blendPixelPtr(first++, color, alpha); + } + + /** + * Fills several pixels in a row with a given color. + * + * This is a replacement function for Common::set_to, using an unrolled + * loop to maximize performance on most architectures. + * This function may (and should) be overloaded in any child renderers + * for portable platforms with platform-specific assembly code. + * + * This fill operation is extensively used throughout the renderer, so this + * counts as one of the main bottlenecks. Please replace it with assembly + * when possible! + * + * @param first Pointer to the first pixel to fill. + * @param last Pointer to the last pixel to fill. + * @param color Color of the pixel + */ + virtual inline void colorFill(PixelType *first, PixelType *last, PixelType color); + + /** + * Copies several pixes in a row from a surface to another one. + * Used for surface blitting. + * See colorFill() for optimization guidelines. + * + * @param src Source surface. + * @param dst Destination surface. + * @param count Amount of pixels to copy over. + */ + virtual inline void colorCopy(PixelType *src, PixelType *dst, int count); + + virtual void areaConvolution(const Common::Rect &area, const int filter[3][3], int filterDiv, int offset); + + PixelType _fgColor; /** Foreground color currently being used to draw on the renderer */ + PixelType _bgColor; /** Background color currently being used to draw on the renderer */ + + PixelType _gradientStart; /** Start color for the fill gradient */ + PixelType _gradientEnd; /** End color for the fill gradient */ + + PixelType _bevelColor; + PixelType _bitmapAlphaColor; +}; + + +/** + * VectorRendererAA: Anti-Aliased Vector Renderer Class + * + * This templated class inherits all the functionality of the VectorRendererSpec + * class but uses better looking yet slightly slower AA algorithms for drawing + * most primivitves. May be used in faster platforms. + * + * TODO: Expand documentation. + * + * @see VectorRenderer + * @see VectorRendererSpec + */ +template +class VectorRendererAA : public VectorRendererSpec { + typedef VectorRendererSpec Base; +protected: + /** + * "Wu's Line Antialiasing Algorithm" as published by Xiaolin Wu, July 1991 + * Based on the implementation found in Michael Abrash's Graphics Programming Black Book. + * + * Generic line drawing algorithm for the Antialiased renderer. Optimized with no + * floating point operations, assumes no special cases. + * + * @see VectorRenderer::drawLineAlg() + */ + virtual void drawLineAlg(int x1, int y1, int x2, int y2, int dx, int dy, PixelType color); + + /** + * "Wu's Circle Antialiasing Algorithm" as published by Xiaolin Wu, July 1991 + * Based on the theoretical concept of the algorithm. + * + * Implementation of Wu's algorithm for circles using fixed point arithmetics. + * Could be quite fast. + * + * @see VectorRenderer::drawCircleAlg() + */ + virtual void drawCircleAlg(int x, int y, int r, PixelType color, VectorRenderer::FillMode fill_m); + + /** + * "Wu's Circle Antialiasing Algorithm" as published by Xiaolin Wu, July 1991, + * modified with corner displacement to allow drawing of squares with rounded + * corners. + * + * @see VectorRenderer::drawRoundedAlg() + */ + virtual void drawRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color, VectorRenderer::FillMode fill_m); + + virtual void drawRoundedSquareShadow(int x, int y, int r, int w, int h, int blur) { + Base::drawRoundedSquareShadow(x, y, r, w, h, blur); +// VectorRenderer::applyConvolutionMatrix(VectorRenderer::kConvolutionHardBlur, +// Common::Rect(x, y, x + w + blur * 2, y + h + blur * 2)); + } +}; + +} +#endif \ No newline at end of file -- cgit v1.2.3