image.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 ULTIMA4_GFX_IMAGE_H
#define ULTIMA4_GFX_IMAGE_H

#include "ultima/ultima4/core/types.h"
#include "ultima/ultima4/gfx/textcolor.h"
#include "graphics/managed_surface.h"

namespace Ultima {
namespace Ultima4 {

typedef Graphics::ManagedSurface *BackendSurface;

#define DARK_GRAY_HALO RGBA(14,15,16,255)

struct RGBA {
    RGBA(int red, int green, int blue, int alpha) : r(red), g(green), b(blue), a(alpha) {}
    RGBA() : r(0), g(0), b(0), a(255) {}
    uint r, g, b, a;

    operator uint32() const {
        return r | (g << 8) | (b << 16) | (0xff << 24);
    }
};
bool operator==(const RGBA &lhs, const RGBA &rhs);

class Image;

struct SubImage : public Common::Rect {
    Common::String _name;
    Common::String _srcImageName;
};

#define IM_OPAQUE (uint) 255
#define IM_TRANSPARENT 0

class Image {
private:
    Graphics::ManagedSurface *_surface;
    DisposeAfterUse::Flag _disposeAfterUse;
    bool _paletted;
    RGBA _backgroundColor;
    Image();                    /* use create method to construct images */

    // disallow assignments, copy construction
    Image(const Image &);
    const Image &operator=(const Image &);

    Graphics::ManagedSurface *getSurface(Image *d) const;

    uint getColor(byte r, byte g, byte b, byte a);
public:
    static Image *create(int w, int h);

    static Image *create(int w, int h, const Graphics::PixelFormat &format);

    static Image *createScreenImage();

    static Image *duplicate(Image *image, const Graphics::PixelFormat &format);

    ~Image();

    void createInternal(int w, int h, const Graphics::PixelFormat &format);

    /* palette handling */
    void setPalette(const byte *colors, unsigned n_colors);

    void setPaletteFromImage(const Image *src);
    bool getTransparentIndex(uint &index) const;
    void performTransparencyHack(uint colorValue, uint numFrames, uint currentFrameIndex, uint haloWidth, uint haloOpacityIncrementByPixelDistance);
    void setTransparentIndex(uint index);

    bool setFontColor(ColorFG fg, ColorBG bg);

    bool setFontColorFG(ColorFG fg);

    bool setFontColorBG(ColorBG bg);

    RGBA getPaletteColor(int index);       // returns the color of the specified palette index

    bool setPaletteIndex(uint index, uint8 r, uint8 g, uint8 b);

    RGBA setColor(uint8 r, uint8 g, uint8 b, uint8 a = IM_OPAQUE);


    /* alpha handling */
    bool isAlphaOn() const;
    void alphaOn();
    void alphaOff();


    /* Will clear the image to the background color, and set the internal backgroundColor variable */
    void initializeToBackgroundColor(RGBA backgroundColor = DARK_GRAY_HALO);
    /* Will make the pixels that match the background color disappear, with a blur halo */
    void makeBackgroundColorTransparent(int haloSize = 0,  int shadowOpacity = 255);


    //void finalizeAlphaSurface(RGBA * key = nullptr);

    /* writing to image */

    void putPixel(int x, int y, int r, int g, int b, int a); //TODO Consider using &

    void putPixelIndex(int x, int y, uint index);

    void fillRect(int x, int y, int w, int h, int r, int g, int b, int a = IM_OPAQUE);

    void blitFrom(const Graphics::Surface &src);

    /* reading from image */
    void getPixel(int x, int y, uint &r, uint &g, uint &b, uint &a) const;

    void getPixelIndex(int x, int y, uint &index) const;

    /* image drawing methods */
    void draw(int x, int y) const {
        drawOn(nullptr, x, y);
    }

    void drawSubRect(int x, int y, int rx, int ry, int rw, int rh) const {
        drawSubRectOn(nullptr, x, y, rx, ry, rw, rh);
    }

    void drawSubRectInverted(int x, int y, int rx, int ry, int rw, int rh) const {
        drawSubRectInvertedOn(nullptr, x, y, rx, ry, rw, rh);
    }

    /* image drawing methods for drawing onto another image instead of the screen */
    void drawOn(Image *d, int x, int y) const;

    void drawSubRectOn(Image *d, int x, int y, int rx, int ry, int rw, int rh) const;

    void drawSubRectInvertedOn(Image *d, int x, int y, int rx, int ry, int rw, int rh) const;

    int width() const {
        return _surface->w;
    }
    int height() const {
        return _surface->h;
    }
    Graphics::PixelFormat format() const {
        return _surface->format;
    }
    bool isIndexed() const {
        return _paletted;
    }
    BackendSurface getSurface() {
        return _surface;
    }

    void drawHighlighted();

    void dump();
};

} // End of namespace Ultima4
} // End of namespace Ultima

#endif