VectorRenderer.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_H
#define VECTOR_RENDERER_H

#include "common/rect.h"
#include "common/scummsys.h"
#include "common/str.h"

#include "graphics/managed_surface.h"

#include "gui/ThemeEngine.h"

class OSystem;

namespace Graphics {
class VectorRenderer;
struct DrawStep;

typedef void (VectorRenderer::*DrawingFunctionCallback)(const Common::Rect &, const Graphics::DrawStep &);


struct DrawStep {
    DrawingFunctionCallback drawingCall; 
    Common::SharedPtr<Graphics::ManagedSurface> blitSrc;
    Graphics::AlphaType alphaType;

    struct Color {
        uint8 r, g, b;
        bool set;

        Color () : r(0), g(0), b(0), set(false) {}
    };
    Color fgColor; 
    Color bgColor; 
    Color gradColor1; 
    Color gradColor2; 
    Color bevelColor;

    bool autoWidth, autoHeight;
    int16 x, y, w, h; 
    Common::Rect padding;
    Common::Rect clip; 
    enum VectorAlignment {
        kVectorAlignManual,
        kVectorAlignLeft,
        kVectorAlignRight,
        kVectorAlignBottom,
        kVectorAlignTop,
        kVectorAlignCenter
    };

    VectorAlignment xAlign;
    VectorAlignment yAlign;

    uint8 shadow, stroke, factor, radius, bevel; 
    uint8 fillMode; 
    uint8 shadowFillMode; 
    uint32 extraData; 
    uint32 scale; 
    uint32 shadowIntensity; 
    GUI::ThemeEngine::AutoScaleMode autoscale; 
    DrawStep() {
        drawingCall = nullptr;
        alphaType = Graphics::ALPHA_OPAQUE;
        // fgColor, bgColor, gradColor1, gradColor2, bevelColor initialized by Color default constructor
        autoWidth = autoHeight = false;
        x = y = w = h = 0;
        // padding initialized by Common::Rect default constructor
        xAlign = yAlign = kVectorAlignManual;
        shadow = stroke = factor = radius = bevel = 0;
        fillMode = 0;
        shadowFillMode = 0;
        extraData = 0;
        scale = 0;
        shadowIntensity = 1 << 16;
        autoscale = GUI::ThemeEngine::kAutoScaleNone;
    }
};

VectorRenderer *createRenderer(int mode);

class VectorRenderer {
public:
    VectorRenderer() : _activeSurface(NULL), _fillMode(kFillDisabled), _shadowOffset(0), _shadowFillMode(kShadowExponential),
        _disableShadows(false), _strokeWidth(1), _gradientFactor(1), _bevel(0), _dynamicData(0) {

    }

    virtual ~VectorRenderer() {}

    enum FillMode {
        kFillDisabled = 0,
        kFillForeground = 1,
        kFillBackground = 2,
        kFillGradient = 3
    };

    enum TriangleOrientation {
        kTriangleAuto = 0,
        kTriangleUp,
        kTriangleDown,
        kTriangleLeft,
        kTriangleRight
    };

    enum ShadowFillMode {
        kShadowLinear = 0,
        kShadowExponential = 1
    };

    virtual void drawLine(int x1, int y1, int x2, int y2) = 0;

    virtual void drawCircle(int x, int y, int r) = 0;

    virtual void drawSquare(int x, int y, int w, int h) = 0;

    virtual void drawRoundedSquare(int x, int y, int r, int w, int h) = 0;

    virtual void drawTriangle(int x, int y, int base, int height, TriangleOrientation orient) = 0;

    virtual void drawBeveledSquare(int x, int y, int w, int h) = 0;

    virtual void drawTab(int x, int y, int r, int w, int h, int s) = 0;

    virtual void drawCross(int x, int y, int w, int h) {
        drawLine(x, y, x + w, y + w);
        drawLine(x + w, y, x, y + h);
    }

    virtual void setFgColor(uint8 r, uint8 g, uint8 b) = 0;

    virtual void setBgColor(uint8 r, uint8 g, uint8 b) = 0;

    virtual void setBevelColor(uint8 r, uint8 g, uint8 b) = 0;

    virtual void setGradientColors(uint8 r1, uint8 g1, uint8 b1, uint8 r2, uint8 g2, uint8 b2) = 0;

    virtual void setSurface(ManagedSurface *surface) {
        _activeSurface = surface;
    }

    virtual ManagedSurface *getActiveSurface() {
        return _activeSurface;
    }

    virtual void fillSurface() = 0;

    virtual void clearSurface() {
        byte *src = (byte *)_activeSurface->getPixels();
        memset(src, 0, _activeSurface->pitch * _activeSurface->h);
    }

    virtual void setFillMode(FillMode mode) {
        _fillMode = mode;
    }

    virtual void setShadowFillMode(ShadowFillMode mode) {
        _shadowFillMode = mode;
    }

    virtual void setStrokeWidth(int width) {
        _strokeWidth = width;
    }

    virtual void setShadowOffset(int offset) {
        if (offset >= 0)
            _shadowOffset = offset;
    }

    virtual void setBevel(int amount) {
        if (amount >= 0)
            _bevel = amount;
    }

    virtual void setGradientFactor(int factor) {
        if (factor > 0)
            _gradientFactor = factor;
    }

    virtual void setShadowIntensity(uint32 shadowIntensity) {
        if (shadowIntensity > 0)
            _shadowIntensity = shadowIntensity;
        else
            warning("setShadowIntensity(): zero intensity");
    }

    virtual void setClippingRect(const Common::Rect &clippingArea) = 0;

    void stepGetPositions(const DrawStep &step, const Common::Rect &area, uint16 &in_x, uint16 &in_y, uint16 &in_w, uint16 &in_h);

    int stepGetRadius(const DrawStep &step, const Common::Rect &area);

    Common::Rect applyStepClippingRect(const Common::Rect &area, const Common::Rect &clip, const DrawStep &step);

    void drawCallback_CIRCLE(const Common::Rect &area, const DrawStep &step) {
        uint16 x, y, w, h, radius;

        radius = stepGetRadius(step, area);
        stepGetPositions(step, area, x, y, w, h);

        drawCircle(x + radius, y + radius, radius);
    }

    void drawCallback_SQUARE(const Common::Rect &area, const DrawStep &step) {
        uint16 x, y, w, h;
        stepGetPositions(step, area, x, y, w, h);
        drawSquare(x, y, w, h);
    }

    void drawCallback_LINE(const Common::Rect &area, const DrawStep &step) {
        uint16 x, y, w, h;
        stepGetPositions(step, area, x, y, w, h);
        drawLine(x, y, x + w, y + h);
    }

    void drawCallback_ROUNDSQ(const Common::Rect &area, const DrawStep &step) {
        uint16 x, y, w, h;
        stepGetPositions(step, area, x, y, w, h);
        drawRoundedSquare(x, y, stepGetRadius(step, area), w, h);
    }

    void drawCallback_FILLSURFACE(const Common::Rect &area, const DrawStep &step) {
        fillSurface();
    }

    void drawCallback_TRIANGLE(const Common::Rect &area, const DrawStep &step) {
        uint16 x, y, w, h;
        stepGetPositions(step, area, x, y, w, h);
        drawTriangle(x, y, w, h, (TriangleOrientation)step.extraData);
    }

    void drawCallback_BEVELSQ(const Common::Rect &area, const DrawStep &step) {
        uint16 x, y, w, h;
        stepGetPositions(step, area, x, y, w, h);
        drawBeveledSquare(x, y, w, h);
    }

    void drawCallback_TAB(const Common::Rect &area, const DrawStep &step) {
        uint16 x, y, w, h;
        stepGetPositions(step, area, x, y, w, h);
        drawTab(x, y, stepGetRadius(step, area), w, h, step.shadow);
    }

    void drawCallback_BITMAP(const Common::Rect &area, const DrawStep &step) {
        uint16 x, y, w, h;
        stepGetPositions(step, area, x, y, w, h);
        blitManagedSurface(step.blitSrc.get(), Common::Point(x, y), step.alphaType);
    }

    void drawCallback_CROSS(const Common::Rect &area, const DrawStep &step) {
        uint16 x, y, w, h;
        stepGetPositions(step, area, x, y, w, h);
        drawCross(x, y, w, h);
    }

    void drawCallback_VOID(const Common::Rect &area, const DrawStep &step) {}

    virtual void drawStep(const Common::Rect &area, const Common::Rect &clip, const DrawStep &step, uint32 extra = 0);

    virtual void copyFrame(OSystem *sys, const Common::Rect &r) = 0;

    virtual void copyWholeFrame(OSystem *sys) = 0;

    virtual void blitSurface(const Graphics::ManagedSurface *source, const Common::Rect &r) = 0;

    virtual void blitManagedSurface(const Graphics::ManagedSurface *source, const Common::Point &p, Graphics::AlphaType alphaType) = 0;

    virtual void drawString(const Graphics::Font *font, const Common::U32String &text,
                            const Common::Rect &area, Graphics::TextAlign alignH,
                            GUI::ThemeEngine::TextAlignVertical alignV, int deltax, bool useEllipsis, const Common::Rect &textDrawableArea) = 0;

    virtual void disableShadows() { _disableShadows = true; }
    virtual void enableShadows() { _disableShadows = false; }

    virtual void applyScreenShading(GUI::ThemeEngine::ShadingStyle) = 0;

protected:
    ManagedSurface *_activeSurface; 
    FillMode _fillMode; 
    ShadowFillMode _shadowFillMode;

    int _shadowOffset; 
    int _bevel; 
    bool _disableShadows; 
    int _strokeWidth; 
    uint32 _dynamicData; 
    int _gradientFactor; 
    uint32 _shadowIntensity; 
};
} // End of namespace Graphics

#endif