VectorRendererSpec.h

/* 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 */
 
#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, int s) 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::U32String &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::ManagedSurface *source, const Common::Rect &r) override;
    void blitManagedSurface(const Graphics::ManagedSurface *source, const Common::Point &p, Graphics::AlphaType alphaType) 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 drawTriangleHorzAlg(int x, int y, int w, int h,
        bool inverted, PixelType color, FillMode fill_m);
 
    virtual void drawTriangleHorzAlgClip(int x, int y, int w, int h,
        bool inverted, PixelType color, FillMode fill_m);
 
    virtual void drawTriangleFastH(int x, int y, int size,
        bool inverted, 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 drawTriangleFastV(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, int baseRight, bool vFlip);
 
    virtual void drawTabAlgClip(int x, int y, int w, int h, int r,
        PixelType color, VectorRenderer::FillMode fill_m,
        int baseLeft, int baseRight, bool vFlip);
 
    virtual void drawTabShadow(int x, int y, int w, int h, int r, int offset, uint32 shadowIntensity, bool vFlip);
 
    virtual void drawTabShadowClip(int x, int y, int w, int h, int r, int offset, uint32 shadowIntensity, bool vFlip);
 
    virtual void drawBevelTabAlg(int x, int y, int w, int h,
        int bevel, PixelType topColor, PixelType bottomColor,
        int baseLeft, int baseRight, bool vFlip);
 
    virtual void drawBevelTabAlgClip(int x, int y, int w, int h,
        int bevel, PixelType topColor, PixelType bottomColor,
        int baseLeft, int baseRight, bool vFlip);
 
    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, uint32 shadowIntensity);
    virtual void drawRoundedSquareShadowClip(int x, int y, int r, int w, int h, int offset, uint32 shadowIntensity);
 
    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;
};
 
 
#ifndef DISABLE_FANCY_THEMES
template<typename PixelType>
class VectorRendererAA : public VectorRendererSpec<PixelType> {
    typedef VectorRendererSpec<PixelType> Base;
public:
    VectorRendererAA(PixelFormat format) : VectorRendererSpec<PixelType>(format) {
    }
 
protected:
    void drawLineAlg(int x1, int y1, int x2, int y2, uint dx, uint dy, PixelType color) override;
 
    void drawCircleAlg(int x, int y, int r, PixelType color, VectorRenderer::FillMode fill_m) override;
 
    void drawRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color, VectorRenderer::FillMode fill_m) override;
 
    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) override;
 
    void drawInteriorRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color, VectorRenderer::FillMode fill_m) override;
 
    void drawRoundedSquareShadow(int x, int y, int r, int w, int h, int offset, uint32 shadowIntensity) override {
        Base::drawRoundedSquareShadow(x, y, r, w, h, offset, shadowIntensity);
    }
 
    void drawTabAlg(int x, int y, int w, int h, int r,
        PixelType color, VectorRenderer::FillMode fill_m,
        int baseLeft, int baseRight, bool vFlip) override;
};
#endif
}
#endif