atari-graphics.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 BACKENDS_GRAPHICS_ATARI_H
#define BACKENDS_GRAPHICS_ATARI_H

#include "backends/graphics/graphics.h"
#include "common/events.h"

#include <mint/osbind.h>
#include <mint/ostruct.h>
#include <unordered_set>

#include "common/rect.h"
#include "graphics/surface.h"

template<>
struct std::hash<Common::Rect>
{
    std::size_t operator()(Common::Rect const& rect) const noexcept
    {
        return 31 * (31 * (31 * rect.left + rect.top) + rect.right) + rect.bottom;
    }
};


class AtariGraphicsManager : public GraphicsManager, Common::EventObserver {
public:
    AtariGraphicsManager();
    virtual ~AtariGraphicsManager();

    bool hasFeature(OSystem::Feature f) const override;
    void setFeatureState(OSystem::Feature f, bool enable) override;
    bool getFeatureState(OSystem::Feature f) const override;

    const OSystem::GraphicsMode *getSupportedGraphicsModes() const override {
        static const OSystem::GraphicsMode graphicsModes[] = {
            { "direct", "Direct rendering", (int)GraphicsMode::DirectRendering },
            { "single", "Single buffering", (int)GraphicsMode::SingleBuffering },
            { "triple", "Triple buffering", (int)GraphicsMode::TripleBuffering },
            { nullptr, nullptr, 0 }
        };
        return graphicsModes;
    }
    int getDefaultGraphicsMode() const override { return (int)GraphicsMode::TripleBuffering; }
    bool setGraphicsMode(int mode, uint flags = OSystem::kGfxModeNoFlags) override;
    int getGraphicsMode() const override { return (int)_currentState.mode; }

    void initSize(uint width, uint height, const Graphics::PixelFormat *format = NULL) override;

    int getScreenChangeID() const override { return 0; }

    void beginGFXTransaction() override;
    OSystem::TransactionError endGFXTransaction() override;

    int16 getHeight() const override { return _currentState.height; }
    int16 getWidth() const override { return _currentState.width; }
    void setPalette(const byte *colors, uint start, uint num) override;
    void grabPalette(byte *colors, uint start, uint num) const override;
    void copyRectToScreen(const void *buf, int pitch, int x, int y, int w, int h) override;
    Graphics::Surface *lockScreen() override;
    void unlockScreen() override;
    void fillScreen(uint32 col) override;
    void fillScreen(const Common::Rect &r, uint32 col) override;
    void updateScreen() override;
    void setShakePos(int shakeXOffset, int shakeYOffset) override;
    void setFocusRectangle(const Common::Rect& rect) override {}
    void clearFocusRectangle() override {}

    void showOverlay(bool inGUI) override;
    void hideOverlay() override;
    bool isOverlayVisible() const override { return _overlayVisible; }
    Graphics::PixelFormat getOverlayFormat() const override;
    void clearOverlay() override;
    void grabOverlay(Graphics::Surface &surface) const override;
    void copyRectToOverlay(const void *buf, int pitch, int x, int y, int w, int h) override;
    int16 getOverlayHeight() const override { return 480; }
    int16 getOverlayWidth() const override { return _vgaMonitor ? 640 : 640*1.2; }

    bool showMouse(bool visible) override;
    void warpMouse(int x, int y) override;
    void setMouseCursor(const void *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor,
                        bool dontScale = false, const Graphics::PixelFormat *format = NULL, const byte *mask = NULL) override;
    void setCursorPalette(const byte *colors, uint start, uint num) override;

    Common::Point getMousePosition() const { return _cursor.getPosition(); }
    void updateMousePosition(int deltaX, int deltaY);

    bool notifyEvent(const Common::Event &event) override;
    Common::Keymap *getKeymap() const;

protected:
    typedef void* (*AtariMemAlloc)(size_t bytes);
    typedef void (*AtariMemFree)(void *ptr);

    void allocateSurfaces();
    void freeSurfaces();

    enum class GraphicsMode : int {
        DirectRendering = 0,
        SingleBuffering = 1,
        TripleBuffering = 3
    };

    struct GraphicsState {
        GraphicsState(GraphicsMode mode_)
            : mode(mode_)
            , width(0)
            , height(0) {
        }

        GraphicsMode mode;
        int width;
        int height;
        Graphics::PixelFormat format;
    };
    GraphicsState _pendingState{ (GraphicsMode)getDefaultGraphicsMode() };

private:
    using DirtyRects = std::unordered_set<Common::Rect>;

    enum CustomEventAction {
        kActionToggleAspectRatioCorrection = 100,
    };

    enum SteTtRezValue {
        kRezValueSTLow  = 0,    // 320x200@4bpp, ST palette
        kRezValueSTMid  = 1,    // 640x200@2bpp, ST palette
        kRezValueSTHigh = 2,    // 640x400@1bpp, ST palette
        kRezValueTTLow  = 7,    // 320x480@8bpp, TT palette
        kRezValueTTMid  = 4,    // 640x480@4bpp, TT palette
        kRezValueTTHigh = 6     // 1280x960@1bpp, TT palette
    };

    int16 getMaximumScreenHeight() const { return 480; }
    int16 getMaximumScreenWidth() const { return _tt ? 320 : (_vgaMonitor ? 640 : 640*1.2); }

    template <bool directRendering>
    bool updateScreenInternal(const Graphics::Surface &srcSurface);

    void copyRectToScreenInternal(const void *buf, int pitch, int x, int y, int w, int h,
                                  const Graphics::PixelFormat &format, bool directRendering, bool tripleBuffer);

    int getBitsPerPixel(const Graphics::PixelFormat &format) const;

    bool isOverlayDirectRendering() const;

    virtual AtariMemAlloc getStRamAllocFunc() const {
        return [](size_t bytes) { return (void*)Mxalloc(bytes, MX_STRAM); };
    }
    virtual AtariMemFree getStRamFreeFunc() const {
        return [](void *ptr) { Mfree(ptr); };
    }

    virtual void copyRectToSurface(Graphics::Surface &dstSurface, int dstBitsPerPixel, const Graphics::Surface &srcSurface,
                                   int destX, int destY,
                                   const Common::Rect &subRect) const {
        dstSurface.copyRectToSurface(srcSurface, destX, destY, subRect);
    }

    virtual void drawMaskedSprite(Graphics::Surface &dstSurface, int dstBitsPerPixel,
                                  const Graphics::Surface &srcSurface, const Graphics::Surface &srcMask,
                                  int destX, int destY,
                                  const Common::Rect &subRect) = 0;

    virtual Common::Rect alignRect(int x, int y, int w, int h) const = 0;

    Common::Rect alignRect(const Common::Rect &rect) const {
        return alignRect(rect.left, rect.top, rect.width(), rect.height());
    }

    void cursorPositionChanged() {
        if (_overlayVisible) {
            _screen[OVERLAY_BUFFER]->cursorPositionChanged = true;
        } else {
            _screen[FRONT_BUFFER]->cursorPositionChanged
                = _screen[BACK_BUFFER1]->cursorPositionChanged
                = _screen[BACK_BUFFER2]->cursorPositionChanged
                = true;
        }
    }

    void cursorSurfaceChanged() {
        if (_overlayVisible) {
            _screen[OVERLAY_BUFFER]->cursorSurfaceChanged = true;
        } else {
            _screen[FRONT_BUFFER]->cursorSurfaceChanged
                = _screen[BACK_BUFFER1]->cursorSurfaceChanged
                = _screen[BACK_BUFFER2]->cursorSurfaceChanged
                = true;
        }
    }

    void cursorVisibilityChanged() {
        if (_overlayVisible) {
            _screen[OVERLAY_BUFFER]->cursorVisibilityChanged = true;
        } else {
            _screen[FRONT_BUFFER]->cursorVisibilityChanged
                = _screen[BACK_BUFFER1]->cursorVisibilityChanged
                = _screen[BACK_BUFFER2]->cursorVisibilityChanged
                = true;
        }
    }

    int getOverlayPaletteSize() const {
#ifndef DISABLE_FANCY_THEMES
        return _tt ? 16 : 256;
#else
        return 16;
#endif
    }

    bool _vgaMonitor = true;
    bool _tt = false;
    bool _aspectRatioCorrection = false;
    bool _oldAspectRatioCorrection = false;
    bool _checkUnalignedPitch = false;

    GraphicsState _currentState{ (GraphicsMode)getDefaultGraphicsMode() };

    enum PendingScreenChange {
        kPendingScreenChangeNone    = 0,
        kPendingScreenChangeMode    = 1<<0,
        kPendingScreenChangeScreen  = 1<<1,
        kPendingScreenChangePalette = 1<<2
    };
    int _pendingScreenChange = kPendingScreenChangeNone;

    enum {
        FRONT_BUFFER,
        BACK_BUFFER1,
        BACK_BUFFER2,
        OVERLAY_BUFFER,
        BUFFER_COUNT
    };

    class Palette {
    public:
        void clear() {
            memset(data, 0, sizeof(data));
        }

        uint16 *const tt = reinterpret_cast<uint16*>(data);
        _RGB *const falcon = reinterpret_cast<_RGB*>(data);

    private:
        byte data[256*4] = {};
    };

    struct Screen {
        Screen(AtariGraphicsManager *manager, int width, int height, const Graphics::PixelFormat &format, const Palette *palette);
        ~Screen();

        void reset(int width, int height, int bitsPerPixel);
        // must be called before any rectangle drawing
        void addDirtyRect(const Graphics::Surface &srcSurface, const Common::Rect &rect, bool directRendering);

        void clearDirtyRects() {
            dirtyRects.clear();
            fullRedraw = false;
        }

        void storeBackground(const Common::Rect &rect);
        void restoreBackground(const Common::Rect &rect);

        Graphics::Surface surf;
        const Palette *palette;
        bool cursorPositionChanged = true;
        bool cursorSurfaceChanged = true;
        bool cursorVisibilityChanged = false;
        DirtyRects dirtyRects;
        bool fullRedraw = false;
        Common::Rect oldCursorRect;
        int rez = -1;
        int mode = -1;
        Graphics::Surface *const offsettedSurf = &_offsettedSurf;

        int oldScreenSurfaceWidth = -1;
        int oldScreenSurfaceHeight = -1;
        int oldScreenSurfacePitch = -1;
        int oldOffsettedSurfaceWidth = -1;
        int oldOffsettedSurfaceHeight = -1;

    private:
        static constexpr size_t ALIGN = 16; // 16 bytes

        const AtariGraphicsManager *_manager;

        Graphics::Surface _offsettedSurf;
        // used by direct rendering
        Graphics::Surface _cursorBackgroundSurf;
    };
    Screen *_screen[BUFFER_COUNT] = {};
    Screen *_workScreen = nullptr;
    Screen *_oldWorkScreen = nullptr;   // used in hideOverlay()

    Graphics::Surface _chunkySurface;

    bool _overlayVisible = false;
    Graphics::Surface _overlaySurface;

    struct Cursor {
        void update(const Graphics::Surface &screen, bool isModified);

        bool visible = false;

        // position
        Common::Point getPosition() const {
            return Common::Point(_x, _y);
        }
        void setPosition(int x, int y) {
            _x = x;
            _y = y;
        }
        void updatePosition(int deltaX, int deltaY, const Graphics::Surface &screen);
        void swap() {
            const int tmpX = _oldX;
            const int tmpY = _oldY;

            _oldX = _x;
            _oldY = _y;

            _x = tmpX;
            _y = tmpY;
        }

        // surface
        void setSurface(const void *buf, int w, int h, int hotspotX, int hotspotY, uint32 keycolor);
        template <bool isClut8>
        void convertTo(const Graphics::PixelFormat &format);
        Graphics::Surface surface;
        Graphics::Surface surfaceMask;

        // rects (valid only if !outOfScreen)
        bool isClipped() const {
            return outOfScreen ? false : _width != srcRect.width();
        }
        bool outOfScreen = true;
        Common::Rect srcRect;
        Common::Rect dstRect;

        // palette (only used for the overlay)
        byte palette[256*3] = {};

    private:
        int _x = -1, _y = -1;
        int _oldX = -1, _oldY = -1;

        // related to 'surface'
        const byte *_buf = nullptr;
        int _width;
        int _height;
        int _hotspotX;
        int _hotspotY;
        uint32 _keycolor;

        int _rShift, _gShift, _bShift;
        int _rMask, _gMask, _bMask;
    };
    Cursor _cursor;

    Palette _palette;
    Palette _overlayPalette;
};

#endif