OPENGL: Add new generic OpenGL (ES) backend.

This backend is based on ideas of the old OpenGL backend, of the Android GL
backend and of the iPhone GL backend.

1 files changed, 418 insertions, 0 deletions

diff --git a/backends/graphics/opengl/opengl-graphics.h b/backends/graphics/opengl/opengl-graphics.h
new file mode 100644
index 0000000000..e21bda4b8a
--- /dev/null
+++ b/backends/graphics/opengl/opengl-graphics.h
@@ -0,0 +1,418 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef BACKENDS_GRAPHICS_OPENGL_OPENGL_GRAPHICS_H
+#define BACKENDS_GRAPHICS_OPENGL_OPENGL_GRAPHICS_H
+
+#include "backends/graphics/opengl/opengl-sys.h"
+#include "backends/graphics/graphics.h"
+
+#include "common/frac.h"
+
+namespace OpenGL {
+
+class Texture;
+
+enum {
+	GFX_LINEAR = 0,
+	GFX_NEAREST = 1
+};
+
+class OpenGLGraphicsManager : public GraphicsManager {
+public:
+	OpenGLGraphicsManager();
+	virtual ~OpenGLGraphicsManager();
+
+	// GraphicsManager API
+	virtual bool hasFeature(OSystem::Feature f);
+	virtual void setFeatureState(OSystem::Feature f, bool enable);
+	virtual bool getFeatureState(OSystem::Feature f);
+
+	virtual const OSystem::GraphicsMode *getSupportedGraphicsModes() const;
+	virtual int getDefaultGraphicsMode() const;
+	virtual bool setGraphicsMode(int mode);
+	virtual int getGraphicsMode() const;
+
+	virtual void resetGraphicsScale() {}
+
+#ifdef USE_RGB_COLOR
+	virtual Graphics::PixelFormat getScreenFormat() const;
+	virtual Common::List<Graphics::PixelFormat> getSupportedFormats() const = 0;
+#endif
+
+	virtual void beginGFXTransaction();
+	virtual OSystem::TransactionError endGFXTransaction();
+
+	virtual int getScreenChangeID() const;
+
+	virtual void initSize(uint width, uint height, const Graphics::PixelFormat *format);
+
+	virtual int16 getWidth();
+	virtual int16 getHeight();
+
+	virtual void copyRectToScreen(const void *buf, int pitch, int x, int y, int w, int h);
+	virtual void fillScreen(uint32 col);
+
+	virtual void setShakePos(int shakeOffset);
+
+	virtual void updateScreen();
+
+	virtual Graphics::Surface *lockScreen();
+	virtual void unlockScreen();
+
+	virtual void setFocusRectangle(const Common::Rect& rect);
+	virtual void clearFocusRectangle();
+
+	virtual int16 getOverlayWidth();
+	virtual int16 getOverlayHeight();
+
+	virtual void showOverlay();
+	virtual void hideOverlay();
+
+	virtual Graphics::PixelFormat getOverlayFormat() const;
+
+	virtual void copyRectToOverlay(const void *buf, int pitch, int x, int y, int w, int h);
+	virtual void clearOverlay();
+	virtual void grabOverlay(void *buf, int pitch);
+
+	virtual bool showMouse(bool visible);
+	virtual void warpMouse(int x, int y);
+	virtual void setMouseCursor(const void *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, bool dontScale, const Graphics::PixelFormat *format);
+	virtual void setCursorPalette(const byte *colors, uint start, uint num);
+
+	virtual void displayMessageOnOSD(const char *msg);
+
+	// PaletteManager interface
+	virtual void setPalette(const byte *colors, uint start, uint num);
+	virtual void grabPalette(byte *colors, uint start, uint num);
+
+protected:
+	/**
+	 * Set up the actual screen size available for the OpenGL code to do any
+	 * drawing.
+	 *
+	 * @param width  The width of the screen.
+	 * @param height The height of the screen.
+	 */
+	void setActualScreenSize(uint width, uint height);
+
+	/**
+	 * Notify the manager of a OpenGL context change. This should be the first
+	 * thing to call when you create an OpenGL (ES) context!
+	 *
+	 * @param defaultFormat      The new default format for the game screen
+	 *                           (this is used for the CLUT8 game screens).
+	 * @param defaultFromatAlpha The new default format with an alpha channel
+	 *                           (this is used for the overlay and cursor).
+	 */
+	void notifyContextChange(const Graphics::PixelFormat &defaultFormat, const Graphics::PixelFormat &defaultFormatAlpha);
+
+	/**
+	 * Adjust the physical mouse coordinates according to the currently visible screen.
+	 */
+	void adjustMousePosition(int16 &x, int16 &y);
+
+	/**
+	 * Set up the mouse position for graphics output.
+	 *
+	 * @param x X coordinate in physical coordinates.
+	 * @param y Y coordinate in physical coordinates.
+	 */
+	void setMousePosition(int x, int y) { _cursorX = x; _cursorY = y; }
+
+	/**
+	 * Set up the mouse position for the (event) system.
+	 *
+	 * @param x X coordinate in physical coordinates.
+	 * @param y Y coordinate in physical coordinates.
+	 */
+	virtual void setInternalMousePosition(int x, int y) = 0;
+
+private:
+	//
+	// Transaction support
+	//
+	struct VideoState {
+		VideoState() : valid(false), gameWidth(0), gameHeight(0),
+#ifdef USE_RGB_COLOR
+		    gameFormat(),
+#endif
+		    aspectRatioCorrection(false), graphicsMode(GFX_LINEAR) {
+		}
+
+		bool valid;
+
+		uint gameWidth, gameHeight;
+#ifdef USE_RGB_COLOR
+		Graphics::PixelFormat gameFormat;
+#endif
+		bool aspectRatioCorrection;
+		int graphicsMode;
+
+		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;
+		}
+
+		bool operator!=(const VideoState &right) {
+			return !(*this == right);
+		}
+	};
+
+	/**
+	 * The currently setup video state.
+	 */
+	VideoState _currentState;
+
+	/**
+	 * The old video state used when doing a transaction rollback.
+	 */
+	VideoState _oldState;
+
+protected:
+	enum TransactionMode {
+		kTransactionNone = 0,
+		kTransactionActive = 1,
+		kTransactionRollback = 2
+	};
+
+	TransactionMode getTransactionMode() const { return _transactionMode; }
+
+private:
+	/**
+	 * The current transaction mode.
+	 */
+	TransactionMode _transactionMode;
+
+	/**
+	 * The current screen change ID.
+	 */
+	int _screenChangeID;
+
+protected:
+	/**
+	 * Set up the requested video mode. This takes parameters which describe
+	 * what resolution the game screen requests (this is possibly aspect ratio
+	 * corrected!).
+	 *
+	 * A sub-class should take these parameters as hints. It might very well
+	 * set up a mode which it thinks suites the situation best.
+	 *
+	 * @parma requestedWidth  This is the requested actual game screen width.
+	 * @param requestedHeight This is the requested actual game screen height.
+	 * @param format          This is the requested pixel format of the virtual game screen.
+	 * @return true on success, false otherwise
+	 */
+	virtual bool loadVideoMode(uint requestedWidth, uint requestedHeight, const Graphics::PixelFormat &format) = 0;
+
+private:
+	//
+	// OpenGL utilities
+	//
+
+	/**
+	 * Try to determine the internal parameters for a given pixel format.
+	 *
+	 * @return true when the format can be used, false otherwise.
+	 */
+	bool getGLPixelFormat(const Graphics::PixelFormat &pixelFormat, GLenum &glIntFormat, GLenum &glFormat, GLenum &glType) const;
+
+	//
+	// Actual hardware screen
+	//
+
+	/**
+	 * The width of the physical output.
+	 */
+	uint _outputScreenWidth;
+
+	/**
+	 * The height of the physical output.
+	 */
+	uint _outputScreenHeight;
+
+	/**
+	 * @return The desired aspect of the game screen.
+	 */
+	frac_t getDesiredGameScreenAspect() const;
+
+	/**
+	 * Recalculates the area used to display the game screen.
+	 */
+	void recalculateDisplayArea();
+
+	/**
+	 * The X coordinate of the game screen.
+	 */
+	uint _displayX;
+
+	/**
+	 * The Y coordinate of the game screen.
+	 */
+	uint _displayY;
+
+	/**
+	 * The width of the game screen in physical coordinates.
+	 */
+	uint _displayWidth;
+
+	/**
+	 * The height of the game screen in physical coordinates.
+	 */
+	uint _displayHeight;
+
+	/**
+	 * The default pixel format of the backend.
+	 */
+	Graphics::PixelFormat _defaultFormat;
+
+	/**
+	 * The default pixel format with an alpha channel.
+	 */
+	Graphics::PixelFormat _defaultFormatAlpha;
+
+	//
+	// Game screen
+	//
+
+	/**
+	 * The virtual game screen.
+	 */
+	Texture *_gameScreen;
+
+	/**
+	 * The game palette if in CLUT8 mode.
+	 */
+	byte _gamePalette[3 * 256];
+
+	/**
+	 * The offset by which the screen is moved vertically.
+	 */
+	int _gameScreenShakeOffset;
+
+	//
+	// Overlay
+	//
+
+	/**
+	 * The overlay screen.
+	 */
+	Texture *_overlay;
+
+	/**
+	 * Whether the overlay is visible or not.
+	 */
+	bool _overlayVisible;
+
+	//
+	// Cursor
+	//
+
+	/**
+	 * Set up the correct cursor palette.
+	 */
+	void updateCursorPalette();
+
+	/**
+	 * The cursor image.
+	 */
+	Texture *_cursor;
+
+	/**
+	 * X coordinate of the cursor in phyiscal coordinates.
+	 */
+	uint _cursorX;
+
+	/**
+	 * Y coordinate of the cursor in physical coordinates.
+	 */
+	uint _cursorY;
+
+	/**
+	 * The X offset for the cursor hotspot in unscaled coordinates.
+	 */
+	uint _cursorHotspotX;
+
+	/**
+	 * The Y offset for the cursor hotspot in unscaled coordinates.
+	 */
+	uint _cursorHotspotY;
+
+	/**
+	 * Recalculate the cursor scaling. Scaling is always done according to
+	 * the game screen.
+	 */
+	void recalculateCursorScaling();
+
+	/**
+	 * The X offset for the cursor hotspot in scaled coordinates.
+	 */
+	uint _cursorHotspotXScaled;
+
+	/**
+	 * The Y offset for the cursor hotspot in scaled coordinates.
+	 */
+	uint _cursorHotspotYScaled;
+
+	/**
+	 * The width of the cursor scaled coordinates.
+	 */
+	uint _cursorWidthScaled;
+
+	/**
+	 * The height of the cursor scaled coordinates.
+	 */
+	uint _cursorHeightScaled;
+
+	/**
+	 * The key color.
+	 */
+	uint32 _cursorKeyColor;
+
+	/**
+	 * Whether the cursor is actually visible.
+	 */
+	bool _cursorVisible;
+
+	/**
+	 * Whether no cursor scaling should be applied.
+	 */
+	bool _cursorDontScale;
+
+	/**
+	 * Whether the special cursor palette is enabled.
+	 */
+	bool _cursorPaletteEnabled;
+
+	/**
+	 * The special cursor palette in case enabled.
+	 */
+	byte _cursorPalette[3 * 256];
+};
+
+} // End of namespace OpenGL
+
+#endif