opengl-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_OPENGL_OPENGL_GRAPHICS_H
#define BACKENDS_GRAPHICS_OPENGL_OPENGL_GRAPHICS_H

#include "backends/graphics/opengl/framebuffer.h"
#include "backends/graphics/windowed.h"

#include "base/plugins.h"

#include "common/frac.h"
#include "common/mutex.h"
#include "common/ustr.h"

#include "graphics/surface.h"

namespace Graphics {
class Font;
} // End of namespace Graphics

namespace OpenGL {

// HACK: We use glColor in the OSD code. This might not be working on GL ES but
// we still enable it because Tizen already shipped with it. Also, the
// SurfaceSDL backend enables it and disabling it can cause issues in sdl.cpp.
#define USE_OSD 1

class Surface;
class Pipeline;
#if !USE_FORCED_GLES
class LibRetroPipeline;
#endif
#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
class Renderer3D;
#endif

enum {
    GFX_OPENGL = 0
};

class OpenGLGraphicsManager : virtual public WindowedGraphicsManager {
public:
    OpenGLGraphicsManager();
    virtual ~OpenGLGraphicsManager();

    // GraphicsManager API
    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;
    int getDefaultGraphicsMode() const override;
    bool setGraphicsMode(int mode, uint flags = OSystem::kGfxModeNoFlags) override;
    int getGraphicsMode() const override;

#ifdef USE_RGB_COLOR
    Graphics::PixelFormat getScreenFormat() const override;
    Common::List<Graphics::PixelFormat> getSupportedFormats() const override;
#endif

    const OSystem::GraphicsMode *getSupportedStretchModes() const override;
    int getDefaultStretchMode() const override;
    bool setStretchMode(int mode) override;
    int getStretchMode() const override;

#ifdef USE_SCALERS
    uint getDefaultScaler() const override;
    uint getDefaultScaleFactor() const override;
    bool setScaler(uint mode, int factor) override;
    uint getScaler() const override;
    uint getScaleFactor() const override;
#endif

#if !USE_FORCED_GLES
    bool setShader(const Common::Path &fileNode) override;
#endif

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

    int getScreenChangeID() const override;

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

    int16 getWidth() const override;
    int16 getHeight() const override;

    void copyRectToScreen(const void *buf, int pitch, int x, int y, int w, int h) override;
    void fillScreen(uint32 col) override;
    void fillScreen(const Common::Rect &r, uint32 col) override;

    void updateScreen() override;
    void presentBuffer() override;

    Graphics::Surface *lockScreen() override;
    void unlockScreen() override;

    void setFocusRectangle(const Common::Rect& rect) override;
    void clearFocusRectangle() override;

    int16 getOverlayWidth() const override;
    int16 getOverlayHeight() const override;
    void showOverlay(bool inGUI) override;
    void hideOverlay() override;

    Graphics::PixelFormat getOverlayFormat() const override;

    void copyRectToOverlay(const void *buf, int pitch, int x, int y, int w, int h) override;
    void clearOverlay() override;
    void grabOverlay(Graphics::Surface &surface) const override;

    void setMouseCursor(const void *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, bool dontScale, const Graphics::PixelFormat *format, const byte *mask) override;
    void setCursorPalette(const byte *colors, uint start, uint num) override;

    void displayMessageOnOSD(const Common::U32String &msg) override;
    void displayActivityIconOnOSD(const Graphics::Surface *icon) override;

    // PaletteManager interface
    void setPalette(const byte *colors, uint start, uint num) override;
    void grabPalette(byte *colors, uint start, uint num) const override;

protected:
    void renderCursor();

    bool isGLESContext() const { return OpenGLContext.type == kContextGLES || OpenGLContext.type == kContextGLES2; }

    void notifyContextCreate(
            ContextType type,
            Framebuffer *target,
            const Graphics::PixelFormat &defaultFormat,
            const Graphics::PixelFormat &defaultFormatAlpha);

    void notifyContextDestroy();

    Surface *createSurface(const Graphics::PixelFormat &format, bool wantAlpha = false, bool wantScaler = false, bool wantMask = false);

    //
    // Transaction support
    //
    struct VideoState {
        VideoState() : valid(false), gameWidth(0), gameHeight(0),
#ifdef USE_RGB_COLOR
            gameFormat(),
#endif
            aspectRatioCorrection(false), graphicsMode(GFX_OPENGL), flags(0),
            filtering(true), scalerIndex(0), scaleFactor(1), shader() {
        }

        bool valid;

        uint gameWidth, gameHeight;
#ifdef USE_RGB_COLOR
        Graphics::PixelFormat gameFormat;
#endif
        bool aspectRatioCorrection;
        int graphicsMode;
        uint flags;
        bool filtering;

        uint scalerIndex;
        int scaleFactor;

        Common::Path shader;

        bool operator==(const VideoState &right) {
            return gameWidth == right.gameWidth && gameHeight == right.gameHeight
#ifdef USE_RGB_COLOR
                && gameFormat == right.gameFormat
#endif
                && aspectRatioCorrection == right.aspectRatioCorrection
                && graphicsMode == right.graphicsMode
                && flags == right.flags
                && filtering == right.filtering
                && shader == right.shader;
        }

        bool operator!=(const VideoState &right) {
            return !(*this == right);
        }
    };

    VideoState _currentState;

    VideoState _oldState;

protected:
    enum TransactionMode {
        kTransactionNone = 0,
        kTransactionActive = 1,
        kTransactionRollback = 2
    };

    TransactionMode getTransactionMode() const { return _transactionMode; }

private:
    TransactionMode _transactionMode;

    int _screenChangeID;

    int _stretchMode;

    Common::Point _shakeOffsetScaled;

protected:
    virtual bool loadVideoMode(uint requestedWidth, uint requestedHeight, bool resizable, int antialiasing) = 0;

    bool loadShader(const Common::Path &fileName);

    virtual void refreshScreen() = 0;

    bool saveScreenshot(const Common::Path &filename) const;

    // Do not hide the argument-less saveScreenshot from the base class
    using WindowedGraphicsManager::saveScreenshot;

private:
    //
    // OpenGL utilities
    //

    void initializeGLContext();

    Pipeline *_pipeline;

#if !USE_FORCED_GLES

    LibRetroPipeline *_libretroPipeline;
#endif

protected:
    bool getGLPixelFormat(const Graphics::PixelFormat &pixelFormat, GLenum &glIntFormat, GLenum &glFormat, GLenum &glType) const;

    bool gameNeedsAspectRatioCorrection() const override;
    int getGameRenderScale() const override;
    void recalculateDisplayAreas() override;
    void handleResizeImpl(const int width, const int height) override;

    void updateTextureSettings();

    Pipeline *getPipeline() const { return _pipeline; }

    Graphics::PixelFormat _defaultFormat;

    Graphics::PixelFormat _defaultFormatAlpha;

    Framebuffer *_targetBuffer;

    Surface *_gameScreen;

#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)

    Renderer3D *_renderer3d;
#endif

    byte _gamePalette[3 * 256];

    //
    // Overlay
    //

    Surface *_overlay;

    //
    // Cursor
    //

    void updateCursorPalette();

    Surface *_cursor;

    Surface *_cursorMask;

    int _cursorHotspotX;

    int _cursorHotspotY;

    void recalculateCursorScaling();

    int _cursorHotspotXScaled;

    int _cursorHotspotYScaled;

    float _cursorWidthScaled;

    float _cursorHeightScaled;

    uint32 _cursorKeyColor;

    bool _cursorUseKey;

    bool _cursorDontScale;

    bool _cursorPaletteEnabled;

    byte _cursorPalette[3 * 256];

#ifdef USE_SCALERS

    const PluginList &_scalerPlugins;
#endif

#ifdef USE_OSD
    //
    // OSD
    //
protected:
    virtual const Graphics::Font *getFontOSD() const;

private:
    bool _osdMessageChangeRequest;

    Common::U32String _osdMessageNextData;

    void osdMessageUpdateSurface();

    Surface *_osdMessageSurface;

    uint8 _osdMessageAlpha;

    uint32 _osdMessageFadeStartTime;

    enum {
        kOSDMessageFadeOutDelay = 2 * 1000,
        kOSDMessageFadeOutDuration = 500,
        kOSDMessageInitialAlpha = 80
    };

    Surface *_osdIconSurface;

    enum {
        kOSDIconTopMargin = 10,
        kOSDIconRightMargin = 10
    };
#endif
};

} // End of namespace OpenGL

#endif