managed_surface.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 GRAPHICS_MANAGED_SURFACE_H
#define GRAPHICS_MANAGED_SURFACE_H
 
#include "graphics/pixelformat.h"
#include "graphics/surface.h"
#include "graphics/transform_struct.h"
#include "common/types.h"
#include "graphics/blit.h"
 
#define MS_RGB(R,G,B)       (uint32)(((R) << 24) | ((G) << 16) | ((B) << 8) | 0xff)
#define MS_ARGB(A,R,G,B)    (uint32)(((R) << 24) | ((G) << 16) | ((B) << 8) | (A))
 
namespace Graphics {
 
class Palette;
 
class ManagedSurface {
private:
    Surface _innerSurface;
 
    DisposeAfterUse::Flag _disposeAfterUse;
 
    ManagedSurface *_owner;
 
    Common::Point _offsetFromOwner;
 
    uint _transparentColor;
    bool _transparentColorSet;
 
    Palette *_palette;
protected:
    void simpleBlitFromInner(const Surface &src, const Common::Rect &srcRect,
        const Common::Point &destPos, const Palette *srcPalette,
        bool transparentColorSet, uint transparentColor,
        byte flip, bool alpha, byte aMod);
 
    void maskBlitFromInner(const Surface &src, const Surface &mask,
        const Common::Rect &srcRect, const Common::Point &destPos,
        const Palette *srcPalette, byte flip, bool alpha, byte aMod);
 
    void blitFromInner(const Surface &src, const Common::Rect &srcRect,
        const Common::Rect &destRect, const Palette *srcPalette);
 
    void transBlitFromInner(const Surface &src, const Common::Rect &srcRect,
        const Common::Rect &destRect, uint32 transColor, bool flipped, uint32 srcAlpha,
        const Palette *srcPalette, const Palette *dstPalette);
 
    void blendBlitFromInner(const Surface &src, const Common::Rect &srcRect,
        const Common::Rect &destRect, const int flipping, const uint colorMod,
        const TSpriteBlendMode blend, const AlphaType alphaType);
 
    uint32 convertTransparentColor(const ManagedSurface &surf, const PixelFormat &dstFmt) const;
 
public:
    bool clip(Common::Rect& srcBounds, Common::Rect& destBounds, uint src_w = 0, uint src_h = 0, byte flip = FLIP_NONE) const {
        return _innerSurface.clip(srcBounds, destBounds, src_w, src_h, flip);
    }
 
public:
    int16 &w;           
    int16 &h;           
    int32 &pitch;       
    PixelFormat &format; 
public:
    ManagedSurface();
 
    WARN_DEPRECATED("Use copyFrom(), a move constructor or supply bounds")
    ManagedSurface(const ManagedSurface &surf);
 
    ManagedSurface(ManagedSurface &&surf);
 
    ManagedSurface(int width, int height);
 
    ManagedSurface(int width, int height, const Graphics::PixelFormat &pixelFormat);
 
    ManagedSurface(ManagedSurface &surf, const Common::Rect &bounds);
 
    virtual ~ManagedSurface();
 
    operator const Surface &() const { return _innerSurface; }
 
    const Surface &rawSurface() const { return _innerSurface; }
    Surface *surfacePtr() { return &_innerSurface; }
 
    WARN_DEPRECATED("Use copyFrom() or a move constructor instead")
    ManagedSurface &operator=(const ManagedSurface &surf);
 
    ManagedSurface &operator=(ManagedSurface &&surf);
 
    bool empty() const { return w == 0 || h == 0 || _innerSurface.getPixels() == nullptr; }
 
    DisposeAfterUse::Flag disposeAfterUse() const { return _disposeAfterUse; }
 
    inline uint32 getPixel(int x, int y) const {
        return _innerSurface.getPixel(x, y);
    }
 
    inline void setPixel(int x, int y, uint32 pixel) {
        return _innerSurface.setPixel(x, y, pixel);
    }
 
    inline const void *getBasePtr(int x, int y) const {
        return _innerSurface.getBasePtr(x, y);
    }
 
    inline void *getBasePtr(int x, int y) {
        return _innerSurface.getBasePtr(x, y);
    }
 
    inline void *getPixels() { return _innerSurface.getPixels(); }
    inline const void *getPixels() const { return _innerSurface.getPixels(); }
 
    virtual void setPixels(void *newPixels);
 
    virtual void create(int16 width, int16 height);
 
    virtual void create(int16 width, int16 height, const PixelFormat &pixelFormat);
 
    virtual void create(ManagedSurface &surf, const Common::Rect &bounds);
 
    virtual void free();
 
    virtual void clearDirtyRects() {}
 
    virtual void addDirtyRect(const Common::Rect &r);
 
    const Common::Point getOffsetFromOwner() const { return _offsetFromOwner; }
 
    const Common::Rect getBounds() const {
        return Common::Rect(0, 0, this->w, this->h);
    }
 
    void simpleBlitFrom(const Surface &src,
        byte flip = FLIP_NONE, bool alpha = false, byte aMod = 0xff,
        const Palette *srcPalette = nullptr);
 
    void simpleBlitFrom(const Surface &src, const Common::Point &destPos,
        byte flip = FLIP_NONE, bool alpha = false, byte aMod = 0xff,
        const Palette *srcPalette = nullptr);
 
    void simpleBlitFrom(const Surface &src, const Common::Rect &srcRect,
        const Common::Point &destPos,
        byte flip = FLIP_NONE, bool alpha = false, byte aMod = 0xff,
        const Palette *srcPalette = nullptr);
 
    void simpleBlitFrom(const ManagedSurface &src,
        byte flip = FLIP_NONE, bool alpha = false, byte aMod = 0xff);
 
    void simpleBlitFrom(const ManagedSurface &src, const Common::Point &destPos,
        byte flip = FLIP_NONE, bool alpha = false, byte aMod = 0xff);
 
    void simpleBlitFrom(const ManagedSurface &src, const Common::Rect &srcRect,
        const Common::Point &destPos,
        byte flip = FLIP_NONE, bool alpha = false, byte aMod = 0xff);
 
    void maskBlitFrom(const Surface &src, const Surface &mask,
        byte flip = FLIP_NONE, bool alpha = false, byte aMod = 0xff,
        const Palette *srcPalette = nullptr);
 
    void maskBlitFrom(const Surface &src, const Surface &mask, const Common::Point &destPos,
        byte flip = FLIP_NONE, bool alpha = false, byte aMod = 0xff,
        const Palette *srcPalette = nullptr);
 
    void maskBlitFrom(const Surface &src, const Surface &mask, const Common::Rect &srcRect,
        const Common::Point &destPos,
        byte flip = FLIP_NONE, bool alpha = false, byte aMod = 0xff,
        const Palette *srcPalette = nullptr);
 
    void maskBlitFrom(const ManagedSurface &src, const ManagedSurface &mask,
        byte flip = FLIP_NONE, bool alpha = false, byte aMod = 0xff);
 
    void maskBlitFrom(const ManagedSurface &src, const ManagedSurface &mask, const Common::Point &destPos,
        byte flip = FLIP_NONE, bool alpha = false, byte aMod = 0xff);
 
    void maskBlitFrom(const ManagedSurface &src, const ManagedSurface &mask,
        const Common::Rect &srcRect, const Common::Point &destPos,
        byte flip = FLIP_NONE, bool alpha = false, byte aMod = 0xff);
 
    void blitFrom(const Surface &src, const Palette *srcPalette = nullptr);
 
    void blitFrom(const Surface &src, const Common::Point &destPos, const Palette *srcPalette = nullptr);
 
    void blitFrom(const Surface &src, const Common::Rect &srcRect,
        const Common::Point &destPos, const Palette *srcPalette = nullptr);
 
    void blitFrom(const Surface &src, const Common::Rect &srcRect,
        const Common::Rect &destRect, const Palette *srcPalette = nullptr);
 
    void blitFrom(const ManagedSurface &src, const Common::Rect &srcRect,
        const Common::Rect &destRect);
 
    void blitFrom(const ManagedSurface &src);
 
    void blitFrom(const ManagedSurface &src, const Common::Point &destPos);
 
    void blitFrom(const ManagedSurface &src, const Common::Rect &srcRect,
        const Common::Point &destPos);
 
    void transBlitFrom(const Surface &src, uint32 transColor = 0, bool flipped = false,
        uint32 srcAlpha = 0xff, const Palette *srcPalette = nullptr);
 
    void transBlitFrom(const Surface &src, const Common::Point &destPos,
        uint32 transColor = 0, bool flipped = false, uint32 srcAlpha = 0xff, const Palette *srcPalette = nullptr);
 
    void transBlitFrom(const Surface &src, const Common::Rect &srcRect, const Common::Point &destPos,
        uint32 transColor = 0, bool flipped = false, uint32 srcAlpha = 0xff, const Palette *srcPalette = nullptr);
 
    void transBlitFrom(const Surface &src, const Common::Rect &srcRect, const Common::Rect &destRect, const Palette *srcPalette);
 
    void transBlitFrom(const Surface &src, const Common::Rect &srcRect, const Common::Rect &destRect,
        uint32 transColor = 0, bool flipped = false, uint32 srcAlpha = 0xff,
        const Palette *srcPalette = nullptr);
 
    void transBlitFrom(const ManagedSurface &src, uint32 transColor = 0, bool flipped = false,
        uint32 srcAlpha = 0xff);
 
    void transBlitFrom(const ManagedSurface &src, const Common::Point &destPos,
        uint32 transColor = 0, bool flipped = false, uint32 srcAlpha = 0xff);
 
    void transBlitFrom(const ManagedSurface &src, const Common::Rect &srcRect, const Common::Point &destPos,
        uint32 transColor = 0, bool flipped = false, uint32 srcAlpha = 0xff);
 
    void transBlitFrom(const ManagedSurface &src, const Common::Rect &srcRect, const Common::Rect &destRect,
        uint32 transColor = 0, bool flipped = false, uint32 srcAlpha = 0xff);
 
    void rawBlitFrom(const ManagedSurface &src, const Common::Rect &srcRect,
            const Common::Point &destPos) {
        blitFromInner(src._innerSurface, srcRect, Common::Rect(destPos.x, destPos.y, destPos.x + srcRect.width(),
            destPos.y + srcRect.height()), src._palette);
    }
    
    static inline bool isBlendBlitPixelFormatSupported(const PixelFormat &src, const PixelFormat &dst) {
        return BlendBlit::getSupportedPixelFormat() == src && BlendBlit::getSupportedPixelFormat() == dst;
    }
 
    void blendBlitFrom(const Surface &src,
        const int flipping = FLIP_NONE,
        const uint colorMod = MS_ARGB(255, 255, 255, 255),
        const TSpriteBlendMode blend = BLEND_NORMAL,
        const AlphaType alphaType = ALPHA_FULL);
 
    void blendBlitFrom(const Surface &src, const Common::Point &destPos,
        const int flipping = FLIP_NONE,
        const uint colorMod = MS_ARGB(255, 255, 255, 255),
        const TSpriteBlendMode blend = BLEND_NORMAL,
        const AlphaType alphaType = ALPHA_FULL);
 
    void blendBlitFrom(const Surface &src, const Common::Rect &srcRect,
        const Common::Point &destPos,
        const int flipping = FLIP_NONE,
        const uint colorMod = MS_ARGB(255, 255, 255, 255),
        const TSpriteBlendMode blend = BLEND_NORMAL,
        const AlphaType alphaType = ALPHA_FULL);
 
    void blendBlitFrom(const Surface &src, const Common::Rect &srcRect,
        const Common::Rect &destRect,
        const int flipping = FLIP_NONE,
        const uint colorMod = MS_ARGB(255, 255, 255, 255),
        const TSpriteBlendMode blend = BLEND_NORMAL,
        const AlphaType alphaType = ALPHA_FULL);
 
    void blendBlitFrom(const ManagedSurface &src,
        const int flipping = FLIP_NONE,
        const uint colorMod = MS_ARGB(255, 255, 255, 255),
        const TSpriteBlendMode blend = BLEND_NORMAL,
        const AlphaType alphaType = ALPHA_FULL);
 
    void blendBlitFrom(const ManagedSurface &src, const Common::Point &destPos,
        const int flipping = FLIP_NONE,
        const uint colorMod = MS_ARGB(255, 255, 255, 255),
        const TSpriteBlendMode blend = BLEND_NORMAL,
        const AlphaType alphaType = ALPHA_FULL);
 
    void blendBlitFrom(const ManagedSurface &src, const Common::Rect &srcRect,
        const Common::Point &destPos,
        const int flipping = FLIP_NONE,
        const uint colorMod = MS_ARGB(255, 255, 255, 255),
        const TSpriteBlendMode blend = BLEND_NORMAL,
        const AlphaType alphaType = ALPHA_FULL);
 
    void blendBlitFrom(const ManagedSurface &src, const Common::Rect &srcRect,
        const Common::Rect &destRect,
        const int flipping = FLIP_NONE,
        const uint colorMod = MS_ARGB(255, 255, 255, 255),
        const TSpriteBlendMode blend = BLEND_NORMAL,
        const AlphaType alphaType = ALPHA_FULL);
 
    Common::Rect blendBlitTo(ManagedSurface &target,
                             const int posX = 0, const int posY = 0,
                             const int flipping = FLIP_NONE,
                             const Common::Rect *srcRect = nullptr,
                             const uint colorMod = MS_ARGB(255, 255, 255, 255),
                             const int width = -1, const int height = -1,
                             const TSpriteBlendMode blend = BLEND_NORMAL,
                             const AlphaType alphaType = ALPHA_FULL);
    Common::Rect blendBlitTo(Surface &target,
                             const int posX = 0, const int posY = 0,
                             const int flipping = FLIP_NONE,
                             const Common::Rect *srcRect = nullptr,
                             const uint colorMod = MS_ARGB(255, 255, 255, 255),
                             const int width = -1, const int height = -1,
                             const TSpriteBlendMode blend = BLEND_NORMAL,
                             const AlphaType alphaType = ALPHA_FULL);
 
    void blendFillRect(const Common::Rect r, const uint colorMod, const TSpriteBlendMode blend);
 
    void clear(uint32 color = 0);
 
    void markAllDirty();
 
    void copyRectToSurface(const void *buffer, int srcPitch, int destX, int destY, int width, int height) {
        _innerSurface.copyRectToSurface(buffer, srcPitch, destX, destY, width, height);
        addDirtyRect(Common::Rect(destX, destY, destX + width, destY + height));
    }
 
    void copyRectToSurface(const Graphics::Surface &srcSurface, int destX, int destY, const Common::Rect &subRect) {
        _innerSurface.copyRectToSurface(srcSurface, destX, destY, subRect);
        addDirtyRect(Common::Rect(destX, destY, destX + subRect.width(), destY + subRect.height()));
    }
 
    void copyRectToSurfaceWithKey(const void *buffer, int srcPitch, int destX, int destY, int width, int height, uint32 key) {
        _innerSurface.copyRectToSurfaceWithKey(buffer, srcPitch, destX, destY, width, height, key);
        addDirtyRect(Common::Rect(destX, destY, destX + width, destY + height));
    }
 
    void copyRectToSurfaceWithKey(const Graphics::Surface &srcSurface, int destX, int destY, const Common::Rect &subRect, uint32 key) {
        _innerSurface.copyRectToSurfaceWithKey(srcSurface, destX, destY, subRect, key);
        addDirtyRect(Common::Rect(destX, destY, destX + subRect.width(), destY + subRect.height()));
    }
 
    void copyFrom(const ManagedSurface &surf);
 
    void copyFrom(const Surface &surf);
 
    void convertFrom(const ManagedSurface &surf, const PixelFormat &fmt);
 
    void convertFrom(const Surface &surf, const PixelFormat &fmt);
 
    ManagedSurface *scale(int16 newWidth, int16 newHeight, bool filtering = false, byte flip = 0) const;
 
    ManagedSurface *rotoscale(const TransformStruct &transform, bool filtering = false) const;
 
    void drawLine(int x0, int y0, int x1, int y1, uint32 color) {
        _innerSurface.drawLine(x0, y0, x1, y1, color);
        addDirtyRect(Common::Rect(MIN(x0, x1), MIN(y0, y1), MAX(x0, x1 + 1), MAX(y0, y1 + 1)));
    }
 
    void drawThickLine(int x0, int y0, int x1, int y1, int penX, int penY, uint32 color) {
        _innerSurface.drawThickLine(x0, y0, x1, y1, penX, penY, color);
        addDirtyRect(Common::Rect(MIN(x0, x1 + penX), MIN(y0, y1 + penY), MAX(x0, x1 + penX), MAX(y0, y1 + penY)));
    }
 
    void drawRoundRect(const Common::Rect &rect, int arc, uint32 color, bool filled) {
        _innerSurface.drawRoundRect(rect, arc, color, filled);
        addDirtyRect(rect);
    }
 
    void drawPolygonScan(const int *polyX, const int *polyY, int npoints, const Common::Rect &bbox, uint32 color) {
        _innerSurface.drawPolygonScan(polyX, polyY, npoints, bbox, color);
        addDirtyRect(bbox);
    }
 
    void drawEllipse(int x0, int y0, int x1, int y1, uint32 color, bool filled) {
        _innerSurface.drawEllipse(x0, y0, x1, y1, color, filled);
        addDirtyRect(Common::Rect(MIN(x0, x1), MIN(y0, y1), MAX(x0, x1 + 1), MAX(y0, y1 + 1)));
    }
 
    void hLine(int x, int y, int x2, uint32 color) {
        _innerSurface.hLine(x, y, x2, color);
        addDirtyRect(Common::Rect(x, y, x2 + 1, y + 1));
    }
 
    void vLine(int x, int y, int y2, uint32 color) {
        _innerSurface.vLine(x, y, y2, color);
        addDirtyRect(Common::Rect(x, y, x + 1, y2 + 1));
    }
 
    void fillRect(const Common::Rect &r, uint32 color) {
        _innerSurface.fillRect(r, color);
        addDirtyRect(r);
    }
 
    void frameRect(const Common::Rect &r, uint32 color) {
        _innerSurface.frameRect(r, color);
        addDirtyRect(r);
    }
 
    AlphaType detectAlpha() const {
        return _innerSurface.detectAlpha();
    }
 
    Surface getSubArea(const Common::Rect &area) {
        addDirtyRect(area);
        return _innerSurface.getSubArea(area);
    }
 
    const Surface getSubArea(const Common::Rect &area) const {
        return _innerSurface.getSubArea(area);
    }
 
    void convertToInPlace(const PixelFormat &dstFormat);
 
    void convertToInPlace(const PixelFormat &dstFormat, const byte *palette, uint16 paletteCount) {
        _innerSurface.convertToInPlace(dstFormat, palette, paletteCount);
    }
 
    uint getTransparentColor() const { return _transparentColor; }
 
    void setTransparentColor(uint32 color) {
        _transparentColor = color;
        _transparentColorSet = true;
    }
 
    void clearTransparentColor() {
        _transparentColorSet = false;
    }
 
    bool hasTransparentColor() const {
        return _transparentColorSet;
    }
 
    void clearPalette();
 
    bool hasPalette() const;
 
    void grabPalette(byte *colors, uint start, uint num) const;
    const Graphics::Palette *grabPalette() const {
        return _palette;
    }
 
    void setPalette(const byte *colors, uint start, uint num);
};
} // End of namespace Graphics
 
#endif