VectorRendererSpec.h

Go to the documentation of this file.

/* 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.
 *
 */

#ifndef VECTOR_RENDERER_SPEC_H
#define VECTOR_RENDERER_SPEC_H

#include "graphics/VectorRenderer.h"

namespace Graphics {

template<typename PixelType>
class VectorRendererSpec : public VectorRenderer {
    typedef VectorRenderer Base;

public:
    VectorRendererSpec(PixelFormat format);

    void drawLine(int x1, int y1, int x2, int y2) override;
    void drawCircle(int x, int y, int r) override;
    void drawSquare(int x, int y, int w, int h) override;
    void drawRoundedSquare(int x, int y, int r, int w, int h) override;
    void drawTriangle(int x, int y, int base, int height, TriangleOrientation orient) override;
    void drawTab(int x, int y, int r, int w, int h) override;

    void drawBeveledSquare(int x, int y, int w, int h) override {
        bool useClippingVersions = !_clippingArea.contains(Common::Rect(x, y, x + w, y + h));
        if (useClippingVersions) {
            drawBevelSquareAlgClip(x, y, w, h, _bevel, _bevelColor, _fgColor);
        } else {
            drawBevelSquareAlg(x, y, w, h, _bevel, _bevelColor, _fgColor);
        }
    }
    void drawString(const Graphics::Font *font, const Common::String &text,
        const Common::Rect &area, Graphics::TextAlign alignH, GUI::ThemeEngine::TextAlignVertical alignV,
        int deltax, bool elipsis, const Common::Rect &textDrawableArea = Common::Rect(0, 0, 0, 0)) override;

    void setFgColor(uint8 r, uint8 g, uint8 b) override { _fgColor = _format.RGBToColor(r, g, b); }
    void setBgColor(uint8 r, uint8 g, uint8 b) override { _bgColor = _format.RGBToColor(r, g, b); }
    void setBevelColor(uint8 r, uint8 g, uint8 b) override { _bevelColor = _format.RGBToColor(r, g, b); }
    void setGradientColors(uint8 r1, uint8 g1, uint8 b1, uint8 r2, uint8 g2, uint8 b2) override;
    void setClippingRect(const Common::Rect &clippingArea) override { _clippingArea = clippingArea; }

    void copyFrame(OSystem *sys, const Common::Rect &r) override;
    void copyWholeFrame(OSystem *sys) override { copyFrame(sys, Common::Rect(0, 0, _activeSurface->w, _activeSurface->h)); }

    void fillSurface() override;
    void blitSurface(const Graphics::Surface *source, const Common::Rect &r) override;
    void blitSubSurface(const Graphics::Surface *source, const Common::Point &p) override;
    void blitKeyBitmap(const Graphics::Surface *source, const Common::Point &p) override;
    void blitAlphaBitmap(Graphics::TransparentSurface *source, const Common::Rect &r,
            GUI::ThemeEngine::AutoScaleMode autoscale = GUI::ThemeEngine::kAutoScaleNone,
            Graphics::DrawStep::VectorAlignment xAlign = Graphics::DrawStep::kVectorAlignManual,
            Graphics::DrawStep::VectorAlignment yAlign = Graphics::DrawStep::kVectorAlignManual,
            int alpha = 255) override;

    void applyScreenShading(GUI::ThemeEngine::ShadingStyle shadingStyle) override;

protected:

    Common::Rect _clippingArea;

    inline void putPixel(int x, int y, PixelType color) {
        PixelType *ptr = (PixelType *)_activeSurface->getBasePtr(x, y);
        *ptr = color;
    }

    inline void blendPixel(int x, int y, PixelType color, uint8 alpha) {
        blendPixelPtr((PixelType *)Base::_activeSurface->getBasePtr(x, y), color, alpha);
    }

    inline void blendPixelPtr(PixelType *ptr, PixelType color, uint8 alpha);
    inline void blendPixelPtrClip(PixelType *ptr, PixelType color, uint8 alpha, int x, int y);

    inline void blendPixelDestAlphaPtr(PixelType *ptr, PixelType color, uint8 alpha);


    virtual void drawLineAlg(int x1, int y1, int x2, int y2,
        uint dx, uint dy, PixelType color);

    virtual void drawLineAlgClip(int x1, int y1, int x2, int y2,
        uint dx, uint dy, PixelType color);

    virtual void drawCircleAlg(int x, int y, int r,
        PixelType color, FillMode fill_m);

    virtual void drawCircleAlgClip(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 drawRoundedSquareAlgClip(int x1, int y1, int r, int w, int h,
        PixelType color, FillMode fill_m);

    virtual void drawBorderRoundedSquareAlg(int x1, int y1, int r, int w, int h,
        PixelType color, FillMode fill_m, uint8 alpha_t, uint8 alpha_r, uint8 alpha_b, uint8 alpha_l);

    virtual void drawBorderRoundedSquareAlgClip(int x1, int y1, int r, int w, int h,
        PixelType color, FillMode fill_m, uint8 alpha_t, uint8 alpha_r, uint8 alpha_b, uint8 alpha_l);

    virtual void drawInteriorRoundedSquareAlg(int x1, int y1, int r, int w, int h,
        PixelType color, FillMode fill_m);

    virtual void drawInteriorRoundedSquareAlgClip(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 drawSquareAlgClip(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 drawTriangleVertAlgClip(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);

    virtual void drawBevelSquareAlgClip(int x, int y, int w, int h,
        int bevel, PixelType top_color, PixelType bottom_color);

    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 drawTabAlgClip(int x, int y, int w, int h, int r,
        PixelType color, VectorRenderer::FillMode fill_m,
        int baseLeft = 0, int baseRight = 0);

    virtual void drawTabShadow(int x, int y, int w, int h, int r);

    virtual void drawTabShadowClip(int x, int y, int w, int h, int r);

    virtual void drawBevelTabAlg(int x, int y, int w, int h,
        int bevel, PixelType topColor, PixelType bottomColor,
        int baseLeft = 0, int baseRight = 0);

    virtual void drawBevelTabAlgClip(int x, int y, int w, int h,
        int bevel, PixelType topColor, PixelType bottomColor,
        int baseLeft = 0, int baseRight = 0);

    virtual void drawSquareShadow(int x, int y, int w, int h, int offset);
    virtual void drawSquareShadowClip(int x, int y, int w, int h, int offset);
    virtual void drawRoundedSquareShadow(int x, int y, int r, int w, int h, int offset);
    virtual void drawRoundedSquareShadowClip(int x, int y, int r, int w, int h, int offset);

    inline PixelType calcGradient(uint32 pos, uint32 max);

    void precalcGradient(int h);
    void gradientFill(PixelType *first, int width, int x, int y);
    void gradientFillClip(PixelType *first, int width, int x, int y, int realX, int realY);

    inline void blendFill(PixelType *first, PixelType *last, PixelType color, uint8 alpha) {
        while (first != last)
            blendPixelPtr(first++, color, alpha);
    }

    inline void blendFillClip(PixelType *first, PixelType *last, PixelType color, uint8 alpha, int realX, int realY) {
        if (_clippingArea.top <= realY && realY < _clippingArea.bottom) {
            while (first != last) {
                if (_clippingArea.left <= realX && realX < _clippingArea.right)
                    blendPixelPtr(first++, color, alpha);
                else
                    ++first;
                ++realX;
            }
        }
    }

    void darkenFill(PixelType *first, PixelType *last);
    void darkenFillClip(PixelType *first, PixelType *last, int x, int y);

    const PixelFormat _format;
    const PixelType _redMask, _greenMask, _blueMask, _alphaMask;

    PixelType _fgColor; 
    PixelType _bgColor; 
    PixelType _gradientStart; 
    PixelType _gradientEnd; 
    int _gradientBytes[3]; 
    Common::Array<PixelType> _gradCache;
    Common::Array<int> _gradIndexes;

    PixelType _bevelColor;
    PixelType _bitmapAlphaColor;
};


#ifndef DISABLE_FANCY_THEMES

template<typename PixelType>
class VectorRendererAA : public VectorRendererSpec<PixelType> {
    typedef VectorRendererSpec<PixelType> Base;
public:
    VectorRendererAA(PixelFormat format) : VectorRendererSpec<PixelType>(format) {
    }

protected:
    virtual void drawLineAlg(int x1, int y1, int x2, int y2, uint dx, uint dy, PixelType color);

    virtual void drawCircleAlg(int x, int y, int r, PixelType color, VectorRenderer::FillMode fill_m);

    virtual void drawRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color, VectorRenderer::FillMode fill_m);

    virtual void drawBorderRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color, VectorRenderer::FillMode fill_m, uint8 alpha_t, uint8 alpha_l, uint8 alpha_r, uint8 alpha_b);

    virtual void drawInteriorRoundedSquareAlg(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 offset) {
        Base::drawRoundedSquareShadow(x, y, r, w, h, offset);
    }

    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);
};
#endif

}
#endif