windowed.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_WINDOWED_H
#define BACKENDS_GRAPHICS_WINDOWED_H

#include "backends/graphics/graphics.h"
#include "common/frac.h"
#include "common/rect.h"
#include "common/config-manager.h"
#include "common/textconsole.h"
#include "graphics/scaler/aspect.h"

enum {
    STRETCH_CENTER = 0,
    STRETCH_INTEGRAL = 1,
    STRETCH_INTEGRAL_AR = 2,
    STRETCH_FIT = 3,
    STRETCH_STRETCH = 4,
    STRETCH_FIT_FORCE_ASPECT = 5
};

enum {
    SCREEN_ALIGN_CENTER = 0,
    SCREEN_ALIGN_LEFT = 1,
    SCREEN_ALIGN_RIGHT = 2,
    SCREEN_ALIGN_XMASK = 3,
    SCREEN_ALIGN_MIDDLE = 0,
    SCREEN_ALIGN_TOP = 4,
    SCREEN_ALIGN_BOTTOM = 8,
    SCREEN_ALIGN_YMASK = 12
};

class WindowedGraphicsManager : virtual public GraphicsManager {
public:
    WindowedGraphicsManager() :
        _windowWidth(0),
        _windowHeight(0),
        _screenAlign(SCREEN_ALIGN_CENTER | SCREEN_ALIGN_MIDDLE),
        _rotationMode(Common::kRotationNormal),
        _overlayVisible(false),
        _overlayInGUI(false),
        _gameScreenShakeXOffset(0),
        _gameScreenShakeYOffset(0),
        _forceRedraw(false),
        _cursorVisible(false),
        _cursorX(0),
        _cursorY(0),
        _cursorNeedsRedraw(false),
        _cursorLastInActiveArea(true) {}

    void showOverlay(bool inGUI) override {
        _overlayInGUI = inGUI;

        if (inGUI) {
            _activeArea.drawRect = _overlayDrawRect;
            _activeArea.width = getOverlayWidth();
            _activeArea.height = getOverlayHeight();
        } else {
            _activeArea.drawRect = _gameDrawRect;
            _activeArea.width = getWidth();
            _activeArea.height = getHeight();
        }

        if (_overlayVisible)
            return;

        _overlayVisible = true;
        _forceRedraw = true;
        notifyActiveAreaChanged();
    }

    void hideOverlay() override {
        if (!_overlayVisible)
            return;

        _overlayInGUI = false;

        _activeArea.drawRect = _gameDrawRect;
        _activeArea.width = getWidth();
        _activeArea.height = getHeight();
        _overlayVisible = false;
        _forceRedraw = true;
        notifyActiveAreaChanged();
    }

    bool isOverlayVisible() const override { return _overlayVisible; }

    Common::Rect getSafeOverlayArea(int16 *width, int16 *height) const override {
        Insets insets = getSafeAreaInsets();

        // Create the overlay rect cut of the insets
        // in the window coordinate space
        // Make sure to avoid a negative size (and an invalid rect)
        const int safeLeft = MAX(_overlayDrawRect.left, insets.left),
                  safeTop = MAX(_overlayDrawRect.top, insets.top);
        Common::Rect safeArea(safeLeft, safeTop,
                MAX(safeLeft, MIN((int)_overlayDrawRect.right, _windowWidth - insets.right)),
                MAX(safeTop, MIN((int)_overlayDrawRect.bottom, _windowHeight - insets.bottom)));

        // Convert this safe area in the overlay coordinate space
        const int targetWidth = getOverlayWidth(),
                  targetHeight = getOverlayHeight(),
                  sourceWidth = _overlayDrawRect.width(),
                  sourceHeight = _overlayDrawRect.height();

        if (width) *width = targetWidth;
        if (height) *height = targetHeight;

        int rotatedTargetWidth = targetWidth,
            rotatedTargetHeight = targetHeight;
        if (_rotationMode == Common::kRotation90 || _rotationMode == Common::kRotation270) {
            SWAP(rotatedTargetWidth, rotatedTargetHeight);
        }

        // First make it relative to overlay origin and scale it
        safeArea.left = ((safeArea.left - _overlayDrawRect.left) * rotatedTargetWidth) / sourceWidth;
        safeArea.top = ((safeArea.top - _overlayDrawRect.top) * rotatedTargetHeight) / sourceHeight;
        safeArea.right = ((safeArea.right - _overlayDrawRect.left) * rotatedTargetWidth) / sourceWidth;
        safeArea.bottom = ((safeArea.bottom - _overlayDrawRect.top) * rotatedTargetHeight) / sourceHeight;

        // Now rotate it
        switch (_rotationMode) {
        default:
        case Common::kRotationNormal:
            // Nothing to do
            break;
        case Common::kRotation90: {
            int16 tmp = safeArea.left;
            safeArea.left = safeArea.top;
            safeArea.top = rotatedTargetWidth - safeArea.right;
            //safeArea.right = targetWidth - (rotatedTargetHeight - safeArea.bottom);
            safeArea.right = safeArea.bottom; // targetWidth == rotatedTargetHeight
            safeArea.bottom = targetHeight - tmp;
            break;
        }
        case Common::kRotation180: {
            int16 tmp;
            tmp = safeArea.left;
            safeArea.left = rotatedTargetWidth - safeArea.right;
            safeArea.right = rotatedTargetWidth - tmp;
            tmp = safeArea.top;
            safeArea.top = rotatedTargetHeight - safeArea.bottom;
            safeArea.bottom = rotatedTargetHeight - tmp;
            break;
        }
        case Common::kRotation270: {
            int16 tmp = safeArea.left;
            safeArea.left = rotatedTargetHeight - safeArea.bottom;
            //safeArea.bottom = targetHeight - (rotatedTargetWidth - safeArea.right);
            safeArea.bottom = safeArea.right; // targetHeight == rotatedTargetWidth
            safeArea.right = targetWidth - safeArea.top;
            safeArea.top = tmp;
            break;
        }
        }

        return safeArea;
    }

    void setShakePos(int shakeXOffset, int shakeYOffset) override {
        if (_gameScreenShakeXOffset != shakeXOffset || _gameScreenShakeYOffset != shakeYOffset) {
            _gameScreenShakeXOffset = shakeXOffset;
            _gameScreenShakeYOffset = shakeYOffset;
            recalculateDisplayAreas();
            _cursorNeedsRedraw = true;
        }
    }

    int getWindowWidth() const { return _windowWidth; }
    int getWindowHeight() const { return _windowHeight; }

protected:
    virtual bool gameNeedsAspectRatioCorrection() const = 0;

    virtual void handleResizeImpl(const int width, const int height) = 0;

    Common::Point convertVirtualToWindow(const int x, const int y) const {
        const int targetX = _activeArea.drawRect.left;
        const int targetY = _activeArea.drawRect.top;
        const int targetWidth = _activeArea.drawRect.width();
        const int targetHeight = _activeArea.drawRect.height();
        const int sourceWidth = _activeArea.width;
        const int sourceHeight = _activeArea.height;

        if (sourceWidth == 0 || sourceHeight == 0) {
            error("convertVirtualToWindow called without a valid draw rect");
        }

        int windowX, windowY;
        switch (_rotationMode) {
        default:
        case Common::kRotationNormal:
            windowX = targetX + (x * targetWidth + sourceWidth / 2) / sourceWidth;
            windowY = targetY + (y * targetHeight + sourceHeight / 2) / sourceHeight;
            break;
        case Common::kRotation90:
            windowX = targetX + ((y - (sourceHeight - 1)) * targetWidth + sourceHeight / 2) / sourceHeight;
            windowY = targetY + (x * targetHeight + sourceWidth / 2) / sourceWidth;
            break;
        case Common::kRotation180:
            windowX = targetX + ((x - (sourceWidth - 1)) * targetWidth + sourceWidth / 2) / sourceWidth;
            windowY = targetY + ((y - (sourceHeight - 1)) * targetHeight + sourceHeight / 2) / sourceHeight;
            break;
        case Common::kRotation270:
            windowX = targetX + (y * targetWidth + sourceHeight / 2) / sourceHeight;
            windowY = targetY + ((x - (sourceWidth - 1)) * targetHeight + sourceWidth / 2) / sourceWidth;
            break;
        }

        return Common::Point(CLIP<int>(windowX, targetX, targetX + targetWidth - 1),
                             CLIP<int>(windowY, targetY, targetY + targetHeight - 1));
    }

    Common::Point convertWindowToVirtual(int x, int y) const {
        const int sourceX = _activeArea.drawRect.left;
        const int sourceY = _activeArea.drawRect.top;
        const int sourceMaxX = _activeArea.drawRect.right - 1;
        const int sourceMaxY = _activeArea.drawRect.bottom - 1;
        const int sourceWidth = _activeArea.drawRect.width();
        const int sourceHeight = _activeArea.drawRect.height();
        const int targetWidth = _activeArea.width;
        const int targetHeight = _activeArea.height;

        if (sourceWidth == 0 || sourceHeight == 0) {
            error("convertWindowToVirtual called without a valid draw rect");
        }

        x = CLIP<int>(x, sourceX, sourceMaxX);
        y = CLIP<int>(y, sourceY, sourceMaxY);

        int virtualX, virtualY;
        switch (_rotationMode) {
        default:
        case Common::kRotationNormal:
            virtualX = ((x - sourceX) * targetWidth + sourceWidth / 2) / sourceWidth;
            virtualY = ((y - sourceY) * targetHeight + sourceHeight / 2) / sourceHeight;
            break;
        case Common::kRotation90:
            virtualY = targetHeight - 1 - ((x - sourceX) * targetHeight + sourceWidth / 2) / sourceWidth;
            virtualX = ((y - sourceY) * targetWidth + sourceHeight / 2) / sourceHeight;
            break;
        case Common::kRotation180:
            virtualX = targetWidth - 1 - ((x - sourceX) * targetWidth + sourceWidth / 2) / sourceWidth;
            virtualY = targetHeight - 1 - ((y - sourceY) * targetHeight + sourceHeight / 2) / sourceHeight;
            break;
        case Common::kRotation270:
            virtualY = ((x - sourceX) * targetHeight + sourceWidth / 2) / sourceWidth;
            virtualX = targetWidth - 1 - ((y - sourceY) * targetWidth + sourceHeight / 2) / sourceHeight;
            break;
        }

        return Common::Point(CLIP<int>(virtualX, 0, targetWidth - 1),
                             CLIP<int>(virtualY, 0, targetHeight - 1));
    }

    frac_t getDesiredGameAspectRatio() const {
        if (getHeight() == 0 || gameNeedsAspectRatioCorrection()) {
            return intToFrac(4) / 3;
        }

        return intToFrac(getWidth()) / getHeight();
    }

    virtual int getGameRenderScale() const {
        return 1;
    }

    struct Insets {
        int16 left;
        int16 top;
        int16 right;
        int16 bottom;
    };

    virtual Insets getSafeAreaInsets() const {
        return {0, 0, 0, 0};
    }

    void handleResize(const int width, const int height) {
        _windowWidth = width;
        _windowHeight = height;
        handleResizeImpl(width, height);
    }

    virtual void recalculateDisplayAreas() {
        if (_windowHeight == 0) {
            return;
        }

        // Compute a safe area rectangle out of the insets
        Insets insets = getSafeAreaInsets();
        Common::Rect safeArea(insets.left, insets.top,
                _windowWidth - insets.right,
                _windowHeight - insets.bottom);

        // Create a game draw rect using the safe are dimensions
        populateDisplayAreaDrawRect(getDesiredGameAspectRatio(),
                getWidth() * getGameRenderScale(), getHeight() * getGameRenderScale(),
                safeArea, _gameDrawRect);

        // Move the game draw rect in the safe area
        _gameDrawRect.constrain(safeArea);

        if (getOverlayHeight()) {
            const int16 overlayWidth = getOverlayWidth(),
                        overlayHeight = getOverlayHeight();
            const frac_t overlayAspect = intToFrac(overlayWidth) / overlayHeight;
            populateDisplayAreaDrawRect(overlayAspect, overlayWidth, overlayHeight,
                    Common::Rect(_windowWidth, _windowHeight),_overlayDrawRect);
        }

        if (_overlayInGUI) {
            _activeArea.drawRect = _overlayDrawRect;
            _activeArea.width = getOverlayWidth();
            _activeArea.height = getOverlayHeight();
        } else {
            _activeArea.drawRect = _gameDrawRect;
            _activeArea.width = getWidth();
            _activeArea.height = getHeight();
        }
        notifyActiveAreaChanged();
    }

    virtual void setSystemMousePosition(const int x, const int y) = 0;

    virtual void notifyActiveAreaChanged() {}

    bool showMouse(bool visible) override {
        if (_cursorVisible == visible) {
            return visible;
        }

        const bool last = _cursorVisible;
        _cursorVisible = visible;
        _cursorNeedsRedraw = true;
        return last;
    }

    void warpMouse(int x, int y) override {
        // Check active coordinate instead of window coordinate to avoid warping
        // the mouse if it is still within the same virtual pixel
        const Common::Point virtualCursor = convertWindowToVirtual(_cursorX, _cursorY);
        if (virtualCursor.x != x || virtualCursor.y != y) {
            // Warping the mouse in SDL generates a mouse movement event, so
            // `setMousePosition` would be called eventually through the
            // `notifyMousePosition` callback if we *only* set the system mouse
            // position here. However, this can cause problems with some games.
            // For example, the cannon script in CoMI calls to warp the mouse
            // twice each time the cannon is reloaded, and unless we update the
            // mouse position immediately, the second call is ignored, which
            // causes the cannon to change its aim.
            const Common::Point windowCursor = convertVirtualToWindow(x, y);
            setMousePosition(windowCursor.x, windowCursor.y);
            setSystemMousePosition(windowCursor.x, windowCursor.y);
        }
    }

    void setMousePosition(int x, int y) {
        if (_cursorX != x || _cursorY != y) {
            _cursorNeedsRedraw = true;
        }

        _cursorX = x;
        _cursorY = y;
    }

    int _windowWidth;

    int _windowHeight;

    int _screenAlign;

    Common::RotationMode _rotationMode;

    bool _overlayVisible;

    bool _overlayInGUI;

    int _gameScreenShakeXOffset;

    int _gameScreenShakeYOffset;

    Common::Rect _gameDrawRect;

    Common::Rect _overlayDrawRect;

    struct DisplayArea {
        Common::Rect drawRect;

        int width;

        int height;
    };

    DisplayArea _activeArea;

    bool _forceRedraw;

    bool _cursorVisible;

    bool _cursorNeedsRedraw;

    bool _cursorLastInActiveArea;

    int _cursorX, _cursorY;

private:
    void populateDisplayAreaDrawRect(const frac_t displayAspect, int originalWidth, int originalHeight, const Common::Rect &safeArea, Common::Rect &drawRect) const {
        int mode = getStretchMode();

        Common::Rect rotatedSafeArea(safeArea);
        int rotatedWindowWidth = _windowWidth,
            rotatedWindowHeight = _windowHeight;

        if (_rotationMode == Common::kRotation90 || _rotationMode == Common::kRotation270) {
            SWAP(rotatedSafeArea.left, rotatedSafeArea.top);
            SWAP(rotatedSafeArea.right, rotatedSafeArea.bottom);
            SWAP(rotatedWindowWidth, rotatedWindowHeight);
        }
        const int rotatedSafeWidth = rotatedSafeArea.width(),
            rotatedSafeHeight = rotatedSafeArea.height();

        // Mode Center   = use original size, or divide by an integral amount if window is smaller than game surface
        // Mode Integral = scale by an integral amount.
        // Mode Fit      = scale to fit the window while respecting the aspect ratio
        // Mode Stretch  = scale and stretch to fit the window without respecting the aspect ratio
        // Mode Fit Force Aspect = scale to fit the window while forcing a 4:3 aspect ratio
        int width = 0, height = 0;
        if (mode == STRETCH_CENTER || mode == STRETCH_INTEGRAL || mode == STRETCH_INTEGRAL_AR) {
            width = originalWidth;
            height = intToFrac(width) / displayAspect;
            if (width > rotatedSafeWidth || height > rotatedSafeHeight) {
                int fac = 1 + MAX((width - 1) / rotatedSafeWidth, (height - 1) / rotatedSafeHeight);
                width /= fac;
                height /= fac;
            } else if (mode == STRETCH_INTEGRAL) {
                int fac = MIN(rotatedSafeWidth / width, rotatedSafeHeight / height);
                width *= fac;
                height *= fac;
            }  else if (mode == STRETCH_INTEGRAL_AR) {
                int targetHeight = height;
                int horizontalFac = rotatedSafeWidth / width;
                do {
                    width = originalWidth * horizontalFac;
                    int verticalFac = (targetHeight * horizontalFac + originalHeight / 2) / originalHeight;
                    height = originalHeight * verticalFac;
                    --horizontalFac;
                } while (horizontalFac > 0 && height > rotatedSafeHeight);
                if (height > rotatedSafeHeight)
                    height = targetHeight;
            }
        } else {
            frac_t windowAspect = intToFrac(rotatedSafeWidth) / rotatedSafeHeight;
            width = rotatedSafeWidth;
            height = rotatedSafeHeight;
            if (mode == STRETCH_FIT_FORCE_ASPECT) {
                frac_t ratio = intToFrac(4) / 3;
                if (windowAspect < ratio)
                    height = intToFrac(width) / ratio;
                else if (windowAspect > ratio)
                    width = fracToInt(height * ratio);
            } else if (mode != STRETCH_STRETCH) {
                if (windowAspect < displayAspect)
                    height = intToFrac(width) / displayAspect;
                else if (windowAspect > displayAspect)
                    width = fracToInt(height * displayAspect);
            }
        }

        int16 alignX, alignY;
        switch (_screenAlign & SCREEN_ALIGN_XMASK) {
            default:
            case SCREEN_ALIGN_CENTER:
                alignX = ((rotatedWindowWidth - width) / 2);
                break;
            case SCREEN_ALIGN_LEFT:
                alignX = 0;
                break;
            case SCREEN_ALIGN_RIGHT:
                alignX = (rotatedSafeArea.right - width);
                break;
        }

        switch (_screenAlign & SCREEN_ALIGN_YMASK) {
            default:
            case SCREEN_ALIGN_MIDDLE:
                alignY = ((rotatedWindowHeight - height) / 2);
                break;
            case SCREEN_ALIGN_TOP:
                alignY = 0;
                break;
            case SCREEN_ALIGN_BOTTOM:
                alignY = (rotatedSafeArea.bottom - height);
                break;
        }

        rotatedSafeArea.constrain(alignX, alignY, width, height);

        alignX += _gameScreenShakeXOffset * width / getWidth();
        alignY += _gameScreenShakeYOffset * height / getHeight();

        if (_rotationMode == Common::kRotation90 || _rotationMode == Common::kRotation270) {
            drawRect.top = alignX;
            drawRect.left = alignY;
            drawRect.setWidth(height);
            drawRect.setHeight(width);
        } else {
            drawRect.left = alignX;
            drawRect.top = alignY;
            drawRect.setWidth(width);
            drawRect.setHeight(height);
        }
    }
};

#endif