bitmap.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 BAGEL_BOFLIB_GFX_BMP_H
#define BAGEL_BOFLIB_GFX_BMP_H

#include "graphics/managed_surface.h"
#include "bagel/boflib/palette.h"
#include "bagel/boflib/cache.h"
#include "bagel/boflib/error.h"
#include "bagel/boflib/object.h"
#include "bagel/boflib/point.h"
#include "bagel/boflib/rect.h"
#include "bagel/boflib/size.h"
#include "bagel/boflib/stdinc.h"

namespace Bagel {
namespace SpaceBar {

// Color constants
//
enum {
    NOT_TRANSPARENT = -1,
    COLOR_WHITE     = 255,
    COLOR_BLACK     = 0
};

#define CBMP_FADE_SPEED 10
#define CBMP_FADE_SIZE 4

#define CBMP_CURT_SPEED 8 // Must be a power of 2

#define CBMP_LINE_SPEED 32 // Should be a power of 4

// forward declare CBofWindow
class CBofWindow;

class CBofBitmap : public CBofError, public CBofObject, public CCache {
protected:
    bool alloc() override;

    void free() override;

    //
    // data members
    //
    static bool _bUseBackdrop;

    char _szFileName[MAX_FNAME];

    Graphics::ManagedSurface _bitmap;

    byte *_pBits = nullptr;

    CBofPalette *_pPalette = nullptr;

    int _nScanDX = 0;
    int _nDX = 0;
    int _nDY = 0;
    bool _bTopDown = false;

    bool _bOwnPalette = false;
    bool _bReadOnly = false;
    bool _bInitialized = false;

public:
    CBofBitmap();

    CBofBitmap(int dx, int dy, CBofPalette *pPalette, bool bOwnPalette = false, byte *pPrivateBuff = nullptr);

    CBofBitmap(const char *pszFileName, CBofPalette *pPalette = nullptr, bool bOwnPalette = false);

    virtual ~CBofBitmap();

    ErrorCode buildBitmap(CBofPalette *pPalette);

    ErrorCode loadBitmap(const char *pszFileName, CBofPalette *pPalette);

    void releaseBitmap();

    //
    // Palette routines
    //

    void setPalette(CBofPalette *pPalette, bool bOwnPalette = false);

    CBofPalette *getPalette() {
        return _pPalette;
    }

    void setIsOwnPalette(bool own) {
        _bOwnPalette = own;
    }

    //
    // Misc routines
    //

    byte *getPixelAddress(int x, int y);
    byte *getPixelAddress(CBofPoint *pPoint) {
        return getPixelAddress(pPoint->x, pPoint->y);
    }

    CBofSize getSize() {
        return CBofSize(_nDX, _nDY);
    }

    CBofRect getRect() {
        return CBofRect(0, 0, _nDX - 1, _nDY - 1);
    }

    void setReadOnly(bool bReadOnly) {
        _bReadOnly = bReadOnly;
    }

    bool getReadOnly() {
        return _bReadOnly;
    }

    bool isTopDown() {
        return _bTopDown;
    }

    int width() {
        return _nDX;
    }

    int widthBytes() {
        return _nScanDX;
    }

    int height() {
        return _nDY;
    }

    operator Graphics::ManagedSurface &() {
        return _bitmap;
    }

    Graphics::ManagedSurface getSurface();

    const char *getFileName();

    //
    // Drawing routines
    //
    ErrorCode paint(CBofWindow *pWnd, int x, int y, CBofRect *pSrcRect = nullptr, int nMaskColor = NOT_TRANSPARENT);

    ErrorCode paint(CBofWindow *pWnd, CBofRect *pDstRect = nullptr, CBofRect *pSrcRect = nullptr, int nMaskColor = NOT_TRANSPARENT);

    ErrorCode paintMaskBackdrop(CBofWindow *pWnd, CBofRect *pDstRect = nullptr, CBofRect *pSrcRect = nullptr, int nMaskColor = NOT_TRANSPARENT);

    ErrorCode paint(CBofBitmap *pBmp, int x, int y, CBofRect *pSrcRect = nullptr, int nMaskColor = NOT_TRANSPARENT);

    ErrorCode paint(CBofBitmap *pBmp, CBofRect *pDstRect = nullptr, CBofRect *pSrcRect = nullptr, int nMaskColor = NOT_TRANSPARENT);

    //
    // Special Paint routines Optimized for specific tasks
    //

    // Stretches 4 pixel wide
    ErrorCode paintStretch4(CBofBitmap *pBmp, CBofRect *pDstRect, CBofRect *pSrcRect);

    ErrorCode paintStretchOpt(CBofBitmap *pBmp, CBofRect *pDstRect, CBofRect *pSrcRect, int nOptSize);

    ErrorCode paint1To1(CBofBitmap *pBmp);

    ErrorCode captureScreen(CBofWindow *pWnd, CBofRect *pSrcRect, CBofRect *pDstRect = nullptr);

    ErrorCode fadeIn(CBofWindow *pWnd, int x = 0, int y = 0, int nMaskColor = NOT_TRANSPARENT, int nBlockSize = CBMP_FADE_SIZE, int nSpeed = CBMP_FADE_SPEED);

    ErrorCode curtain(CBofWindow *pWnd, int nSpeed = CBMP_CURT_SPEED, int nMaskColor = NOT_TRANSPARENT);
    ErrorCode fadeLines(CBofWindow *pWnd, int nSpeed = CBMP_LINE_SPEED, int nMaskColor = NOT_TRANSPARENT);

    byte readPixel(int x, int y);

    void writePixel(int x, int y, byte iColor);

    void circle(int x, int y, uint16 nRadius, byte iColor);

    void line(int nSrcX, int nSrcY, int nDstX, int nDstY, byte iColor);

    void line(CBofPoint *pSrc, CBofPoint *pDest, byte iColor);

    void drawRect(CBofRect *cRect, byte iColor);

    void fillRect(CBofRect *cRect, byte iColor);

    ErrorCode scrollRight(int nPixels, CBofRect *pRect = nullptr);


    ErrorCode scrollLeft(int nPixels, CBofRect *pRect = nullptr) {
        return scrollRight(-nPixels, pRect);
    }

    ErrorCode scrollUp(int nPixels);

    static void setUseBackdrop(bool b) {
        _bUseBackdrop = b;
    }
    static bool getUseBackdrop() {
        return _bUseBackdrop;
    }
};

//
// Misc graphics routines
//

extern CBofBitmap *loadBitmap(const char *pszFileName, CBofPalette *pPalette = nullptr, bool bSharedPal = false);

extern ErrorCode paintBitmap(CBofWindow *pWindow, const char *pszFileName, CBofRect *pDstRect = nullptr,
                             CBofRect *pSrcRect = nullptr, CBofPalette *pPalette = nullptr, int nMaskColor = NOT_TRANSPARENT);

} // namespace SpaceBar
} // namespace Bagel

#endif