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, const Graphics::PixelFormat *format, const byte *mask, frac_t scaleX, frac_t scaleY) 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;
 
    float _cursorScaleX;
 
    float _cursorScaleY;
 
    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