BACKENDS: Remove OpenGL and OpenGL SDL backend.
This breaks our Tizen port.
This commit is contained in:
Johannes Schickel
parent
0e2cf28d99
commit
8a6e57cba1
11 changed files with 2 additions and 3243 deletions
|
|
@ -1,67 +0,0 @@
|
|||
/* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "common/scummsys.h"
|
||||
|
||||
#if defined(DEBUG) && defined(USE_OPENGL)
|
||||
|
||||
#include "backends/graphics/opengl/glerrorcheck.h"
|
||||
#include "common/textconsole.h"
|
||||
#include "common/str.h"
|
||||
|
||||
#ifdef WIN32
|
||||
#if defined(ARRAYSIZE) && !defined(_WINDOWS_)
|
||||
#undef ARRAYSIZE
|
||||
#endif
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <windows.h>
|
||||
#undef ARRAYSIZE
|
||||
#endif
|
||||
|
||||
#if defined(USE_GLES)
|
||||
#include <GLES/gl.h>
|
||||
#elif defined(MACOSX)
|
||||
#include <OpenGL/gl.h>
|
||||
#else
|
||||
#include <GL/gl.h>
|
||||
#endif
|
||||
|
||||
static Common::String getGlErrStr(GLenum error) {
|
||||
switch (error) {
|
||||
case GL_NO_ERROR: return "GL_NO_ERROR";
|
||||
case GL_INVALID_ENUM: return "GL_INVALID_ENUM";
|
||||
case GL_INVALID_OPERATION: return "GL_INVALID_OPERATION";
|
||||
case GL_STACK_OVERFLOW: return "GL_STACK_OVERFLOW";
|
||||
case GL_STACK_UNDERFLOW: return "GL_STACK_UNDERFLOW";
|
||||
case GL_OUT_OF_MEMORY: return "GL_OUT_OF_MEMORY";
|
||||
}
|
||||
|
||||
return Common::String::format("(Unknown GL error code 0x%x)", error);
|
||||
}
|
||||
|
||||
void checkGlError(const char *file, int line) {
|
||||
GLenum error = glGetError();
|
||||
if (error != GL_NO_ERROR)
|
||||
warning("%s:%d: GL error: %s", file, line, getGlErrStr(error).c_str());
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
/* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#if !defined(DEBUG)
|
||||
|
||||
// If not in debug, do nothing
|
||||
#define CHECK_GL_ERROR() do {} while (false)
|
||||
|
||||
#else
|
||||
|
||||
// If in debug, check for an error after a GL call
|
||||
#define CHECK_GL_ERROR() checkGlError(__FILE__, __LINE__)
|
||||
|
||||
void checkGlError(const char *file, int line);
|
||||
|
||||
#endif
|
||||
|
|
@ -1,225 +0,0 @@
|
|||
/* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "common/scummsys.h"
|
||||
|
||||
#if defined(USE_OPENGL)
|
||||
|
||||
#include "backends/graphics/opengl/gltexture.h"
|
||||
#include "backends/graphics/opengl/glerrorcheck.h"
|
||||
|
||||
#include "common/rect.h"
|
||||
#include "common/array.h"
|
||||
#include "common/util.h"
|
||||
#include "common/tokenizer.h"
|
||||
|
||||
// Supported GL extensions
|
||||
static bool npot_supported = false;
|
||||
static bool glext_inited = false;
|
||||
|
||||
/*static inline GLint xdiv(int numerator, int denominator) {
|
||||
assert(numerator < (1 << 16));
|
||||
return (numerator << 16) / denominator;
|
||||
}*/
|
||||
|
||||
static GLuint nextHigher2(GLuint v) {
|
||||
if (v == 0)
|
||||
return 1;
|
||||
v--;
|
||||
v |= v >> 1;
|
||||
v |= v >> 2;
|
||||
v |= v >> 4;
|
||||
v |= v >> 8;
|
||||
v |= v >> 16;
|
||||
return ++v;
|
||||
}
|
||||
|
||||
void GLTexture::initGLExtensions() {
|
||||
|
||||
// Return if extensions were already checked
|
||||
if (glext_inited)
|
||||
return;
|
||||
|
||||
// Get a string with all extensions
|
||||
const char *ext_string = (const char *)glGetString(GL_EXTENSIONS);
|
||||
CHECK_GL_ERROR();
|
||||
Common::StringTokenizer tokenizer(ext_string, " ");
|
||||
// Iterate all string tokens
|
||||
while (!tokenizer.empty()) {
|
||||
Common::String token = tokenizer.nextToken();
|
||||
if (token == "GL_ARB_texture_non_power_of_two")
|
||||
npot_supported = true;
|
||||
}
|
||||
|
||||
glext_inited = true;
|
||||
}
|
||||
|
||||
GLTexture::GLTexture(byte bpp, GLenum internalFormat, GLenum format, GLenum type)
|
||||
:
|
||||
_bytesPerPixel(bpp),
|
||||
_internalFormat(internalFormat),
|
||||
_glFormat(format),
|
||||
_glType(type),
|
||||
_textureWidth(0),
|
||||
_textureHeight(0),
|
||||
_realWidth(0),
|
||||
_realHeight(0),
|
||||
_refresh(false),
|
||||
_filter(GL_NEAREST) {
|
||||
|
||||
// Generate the texture ID
|
||||
glGenTextures(1, &_textureName); CHECK_GL_ERROR();
|
||||
}
|
||||
|
||||
GLTexture::~GLTexture() {
|
||||
// Delete the texture
|
||||
glDeleteTextures(1, &_textureName); CHECK_GL_ERROR();
|
||||
}
|
||||
|
||||
void GLTexture::refresh() {
|
||||
// Delete previous texture
|
||||
glDeleteTextures(1, &_textureName); CHECK_GL_ERROR();
|
||||
|
||||
// Generate the texture ID
|
||||
glGenTextures(1, &_textureName); CHECK_GL_ERROR();
|
||||
_refresh = true;
|
||||
}
|
||||
|
||||
void GLTexture::allocBuffer(GLuint w, GLuint h) {
|
||||
_realWidth = w;
|
||||
_realHeight = h;
|
||||
|
||||
if (!_refresh) {
|
||||
if (npot_supported && _filter == GL_LINEAR) {
|
||||
// Check if we already allocated a correctly-sized buffer
|
||||
// This is so we don't need to duplicate the last row/column
|
||||
if (w == _textureWidth && h == _textureHeight)
|
||||
return;
|
||||
} else {
|
||||
// Check if we already have a large enough buffer
|
||||
if (w <= _textureWidth && h <= _textureHeight)
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (npot_supported) {
|
||||
_textureWidth = w;
|
||||
_textureHeight = h;
|
||||
} else {
|
||||
_textureWidth = nextHigher2(w);
|
||||
_textureHeight = nextHigher2(h);
|
||||
}
|
||||
|
||||
// Select this OpenGL texture
|
||||
glBindTexture(GL_TEXTURE_2D, _textureName); CHECK_GL_ERROR();
|
||||
|
||||
// Set the texture parameters
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, _filter); CHECK_GL_ERROR();
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, _filter); CHECK_GL_ERROR();
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); CHECK_GL_ERROR();
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); CHECK_GL_ERROR();
|
||||
|
||||
// Allocate room for the texture
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, _internalFormat,
|
||||
_textureWidth, _textureHeight, 0, _glFormat, _glType, NULL); CHECK_GL_ERROR();
|
||||
|
||||
_refresh = false;
|
||||
}
|
||||
|
||||
void GLTexture::updateBuffer(const void *buf, int pitch, GLuint x, GLuint y, GLuint w, GLuint h) {
|
||||
// Skip empty updates.
|
||||
if (w * h == 0)
|
||||
return;
|
||||
|
||||
// Select this OpenGL texture
|
||||
glBindTexture(GL_TEXTURE_2D, _textureName); CHECK_GL_ERROR();
|
||||
|
||||
// Check if the buffer has its data contiguously
|
||||
if ((int)w * _bytesPerPixel == pitch) {
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h,
|
||||
_glFormat, _glType, buf); CHECK_GL_ERROR();
|
||||
} else {
|
||||
// Update the texture row by row
|
||||
const byte *src = (const byte *)buf;
|
||||
GLuint curY = y;
|
||||
GLuint height = h;
|
||||
do {
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, x, curY,
|
||||
w, 1, _glFormat, _glType, src); CHECK_GL_ERROR();
|
||||
curY++;
|
||||
src += pitch;
|
||||
} while (--height);
|
||||
}
|
||||
|
||||
// If we're in linear filter mode, repeat the last row/column if the real dimensions
|
||||
// doesn't match the texture dimensions.
|
||||
if (_filter == GL_LINEAR) {
|
||||
if (_realWidth != _textureWidth && x + w == _realWidth) {
|
||||
const byte *src = (const byte *)buf + (w - 1) * _bytesPerPixel;
|
||||
GLuint curY = y;
|
||||
GLuint height = h;
|
||||
|
||||
do {
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, x + w,
|
||||
curY, 1, 1, _glFormat, _glType, src); CHECK_GL_ERROR();
|
||||
|
||||
curY++;
|
||||
src += pitch;
|
||||
} while (--height);
|
||||
}
|
||||
|
||||
if (_realHeight != _textureHeight && y + h == _realHeight) {
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, x, y + h,
|
||||
w, 1, _glFormat, _glType, (const byte *)buf + pitch * (h - 1)); CHECK_GL_ERROR();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void GLTexture::drawTexture(GLshort x, GLshort y, GLshort w, GLshort h) {
|
||||
// Select this OpenGL texture
|
||||
glBindTexture(GL_TEXTURE_2D, _textureName); CHECK_GL_ERROR();
|
||||
|
||||
// Calculate the texture rect that will be drawn
|
||||
const GLfloat texWidth = (GLfloat)_realWidth / _textureWidth;//xdiv(_surface.w, _textureWidth);
|
||||
const GLfloat texHeight = (GLfloat)_realHeight / _textureHeight;//xdiv(_surface.h, _textureHeight);
|
||||
const GLfloat texcoords[] = {
|
||||
0, 0,
|
||||
texWidth, 0,
|
||||
0, texHeight,
|
||||
texWidth, texHeight,
|
||||
};
|
||||
glTexCoordPointer(2, GL_FLOAT, 0, texcoords); CHECK_GL_ERROR();
|
||||
|
||||
// Calculate the screen rect where the texture will be drawn
|
||||
const GLshort vertices[] = {
|
||||
x, y,
|
||||
(GLshort)(x + w), y,
|
||||
x, (GLshort)(y + h),
|
||||
(GLshort)(x + w), (GLshort)(y + h),
|
||||
};
|
||||
glVertexPointer(2, GL_SHORT, 0, vertices); CHECK_GL_ERROR();
|
||||
|
||||
// Draw the texture to the screen buffer
|
||||
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); CHECK_GL_ERROR();
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,131 +0,0 @@
|
|||
/* 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_GLTEXTURE_H
|
||||
#define BACKENDS_GRAPHICS_OPENGL_GLTEXTURE_H
|
||||
|
||||
#include "common/scummsys.h"
|
||||
|
||||
#ifdef WIN32
|
||||
#if defined(ARRAYSIZE) && !defined(_WINDOWS_)
|
||||
#undef ARRAYSIZE
|
||||
#endif
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <windows.h>
|
||||
#undef ARRAYSIZE
|
||||
#endif
|
||||
|
||||
// HACK: At this point in Windows platforms, common/util.h has been included
|
||||
// via common/rect.h (from backends/graphics/sdl/sdl-graphics.h), via
|
||||
// backends/graphics/openglsdl/openglsdl-graphics.h. Thus, we end up with
|
||||
// COMMON_UTIL_H defined, and ARRAYSIZE undefined (bad!). Therefore,
|
||||
// ARRAYSIZE is undefined in openglsdl-graphics.cpp. This is a temporary
|
||||
// hackish solution fo fix compilation under Windows.
|
||||
#if !defined(ARRAYSIZE) && defined(COMMON_UTIL_H)
|
||||
#define ARRAYSIZE(x) ((int)(sizeof(x) / sizeof(x[0])))
|
||||
#endif
|
||||
|
||||
#if defined(TIZEN)
|
||||
#include <FGraphicsOpengl.h>
|
||||
using namespace Tizen::Graphics::Opengl;
|
||||
#elif defined(USE_GLES)
|
||||
#include <GLES/gl.h>
|
||||
#elif defined(SDL_BACKEND)
|
||||
#include <SDL_opengl.h>
|
||||
#else
|
||||
#include <GL/gl.h>
|
||||
#endif
|
||||
|
||||
#include "graphics/surface.h"
|
||||
|
||||
/**
|
||||
* OpenGL texture manager class
|
||||
*/
|
||||
class GLTexture {
|
||||
public:
|
||||
/**
|
||||
* Initialize OpenGL Extensions
|
||||
*/
|
||||
static void initGLExtensions();
|
||||
|
||||
GLTexture(byte bpp, GLenum internalFormat, GLenum format, GLenum type);
|
||||
~GLTexture();
|
||||
|
||||
/**
|
||||
* Refresh the texture after a context change. The
|
||||
* process will be completed on next allocBuffer call.
|
||||
*/
|
||||
void refresh();
|
||||
|
||||
/**
|
||||
* Allocates memory needed for the given size.
|
||||
*/
|
||||
void allocBuffer(GLuint width, GLuint height);
|
||||
|
||||
/**
|
||||
* Updates the texture pixels.
|
||||
*/
|
||||
void updateBuffer(const void *buf, int pitch, GLuint x, GLuint y,
|
||||
GLuint w, GLuint h);
|
||||
|
||||
/**
|
||||
* Draws the texture to the screen buffer.
|
||||
*/
|
||||
void drawTexture(GLshort x, GLshort y, GLshort w, GLshort h);
|
||||
|
||||
/**
|
||||
* Get the texture width.
|
||||
*/
|
||||
GLuint getWidth() const { return _realWidth; }
|
||||
|
||||
/**
|
||||
* Get the texture height.
|
||||
*/
|
||||
GLuint getHeight() const { return _realHeight; }
|
||||
|
||||
/**
|
||||
* Get the bytes per pixel.
|
||||
*/
|
||||
uint getBytesPerPixel() const { return _bytesPerPixel; }
|
||||
|
||||
/**
|
||||
* Set the texture filter.
|
||||
* @filter the filter type, GL_NEAREST or GL_LINEAR
|
||||
*/
|
||||
void setFilter(GLint filter) { _filter = filter; }
|
||||
|
||||
private:
|
||||
const byte _bytesPerPixel;
|
||||
const GLenum _internalFormat;
|
||||
const GLenum _glFormat;
|
||||
const GLenum _glType;
|
||||
|
||||
GLuint _realWidth;
|
||||
GLuint _realHeight;
|
||||
GLuint _textureName;
|
||||
GLuint _textureWidth;
|
||||
GLuint _textureHeight;
|
||||
GLint _filter;
|
||||
bool _refresh;
|
||||
};
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,351 +0,0 @@
|
|||
/* 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_H
|
||||
#define BACKENDS_GRAPHICS_OPENGL_H
|
||||
|
||||
#include "backends/graphics/opengl/gltexture.h"
|
||||
#include "backends/graphics/graphics.h"
|
||||
#include "common/array.h"
|
||||
#include "common/rect.h"
|
||||
#include "graphics/font.h"
|
||||
#include "graphics/pixelformat.h"
|
||||
|
||||
// Uncomment this to enable the 'on screen display' code.
|
||||
#define USE_OSD 1
|
||||
|
||||
namespace OpenGL {
|
||||
// The OpenGL GFX modes. They have to be inside the OpenGL namespace so they
|
||||
// do not clash with the SDL GFX modes.
|
||||
enum {
|
||||
GFX_NORMAL = 0,
|
||||
GFX_CONSERVE = 1,
|
||||
GFX_ORIGINAL = 2
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* OpenGL graphics manager. This is an abstract class, it does not do the
|
||||
* window and OpenGL context initialization.
|
||||
* Derived classes should at least override internUpdateScreen for doing
|
||||
* the buffers swap, and implement loadGFXMode for handling the window/context if
|
||||
* needed. If USE_RGB_COLOR is enabled, getSupportedFormats must be implemented.
|
||||
*/
|
||||
class OpenGLGraphicsManager : public GraphicsManager {
|
||||
public:
|
||||
OpenGLGraphicsManager();
|
||||
virtual ~OpenGLGraphicsManager();
|
||||
|
||||
virtual bool hasFeature(OSystem::Feature f);
|
||||
virtual void setFeatureState(OSystem::Feature f, bool enable);
|
||||
virtual bool getFeatureState(OSystem::Feature f);
|
||||
|
||||
static const OSystem::GraphicsMode *supportedGraphicsModes();
|
||||
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 initSize(uint width, uint height, const Graphics::PixelFormat *format = NULL);
|
||||
virtual int getScreenChangeID() const;
|
||||
|
||||
virtual void beginGFXTransaction();
|
||||
virtual OSystem::TransactionError endGFXTransaction();
|
||||
|
||||
virtual int16 getHeight();
|
||||
virtual int16 getWidth();
|
||||
protected:
|
||||
// PaletteManager API
|
||||
virtual void setPalette(const byte *colors, uint start, uint num);
|
||||
virtual void grabPalette(byte *colors, uint start, uint num);
|
||||
|
||||
public:
|
||||
virtual void copyRectToScreen(const void *buf, int pitch, int x, int y, int w, int h);
|
||||
virtual Graphics::Surface *lockScreen();
|
||||
virtual void unlockScreen();
|
||||
virtual void fillScreen(uint32 col);
|
||||
virtual void updateScreen();
|
||||
virtual void setShakePos(int shakeOffset);
|
||||
virtual void setFocusRectangle(const Common::Rect &rect);
|
||||
virtual void clearFocusRectangle();
|
||||
|
||||
virtual void showOverlay();
|
||||
virtual void hideOverlay();
|
||||
virtual Graphics::PixelFormat getOverlayFormat() const;
|
||||
virtual void clearOverlay();
|
||||
virtual void grabOverlay(void *buf, int pitch);
|
||||
virtual void copyRectToOverlay(const void *buf, int pitch, int x, int y, int w, int h);
|
||||
virtual int16 getOverlayHeight();
|
||||
virtual int16 getOverlayWidth();
|
||||
|
||||
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 = false, const Graphics::PixelFormat *format = NULL);
|
||||
virtual void setCursorPalette(const byte *colors, uint start, uint num);
|
||||
|
||||
virtual void displayMessageOnOSD(const char *msg);
|
||||
protected:
|
||||
/**
|
||||
* Setup OpenGL settings
|
||||
*/
|
||||
virtual void initGL();
|
||||
|
||||
/**
|
||||
* Creates and refreshs OpenGL textures.
|
||||
*/
|
||||
virtual void loadTextures();
|
||||
|
||||
//
|
||||
// GFX and video
|
||||
//
|
||||
enum {
|
||||
kTransactionNone = 0,
|
||||
kTransactionActive = 1,
|
||||
kTransactionRollback = 2
|
||||
};
|
||||
|
||||
struct TransactionDetails {
|
||||
bool sizeChanged;
|
||||
bool needRefresh;
|
||||
bool needUpdatescreen;
|
||||
bool filterChanged;
|
||||
#ifdef USE_RGB_COLOR
|
||||
bool formatChanged;
|
||||
#endif
|
||||
};
|
||||
TransactionDetails _transactionDetails;
|
||||
int _transactionMode;
|
||||
|
||||
struct VideoState {
|
||||
bool setup;
|
||||
|
||||
bool fullscreen;
|
||||
|
||||
int mode;
|
||||
int scaleFactor;
|
||||
bool antialiasing;
|
||||
bool aspectRatioCorrection;
|
||||
|
||||
int screenWidth, screenHeight;
|
||||
int overlayWidth, overlayHeight;
|
||||
int hardwareWidth, hardwareHeight;
|
||||
#ifdef USE_RGB_COLOR
|
||||
Graphics::PixelFormat format;
|
||||
#endif
|
||||
};
|
||||
VideoState _videoMode, _oldVideoMode;
|
||||
|
||||
/**
|
||||
* Sets the OpenGL texture format for the given pixel format. If format is not support will raise an error.
|
||||
*/
|
||||
virtual void getGLPixelFormat(Graphics::PixelFormat pixelFormat, byte &bpp, GLenum &intFormat, GLenum &glFormat, GLenum &type);
|
||||
|
||||
virtual void internUpdateScreen();
|
||||
virtual bool loadGFXMode();
|
||||
virtual void unloadGFXMode();
|
||||
|
||||
/**
|
||||
* Setup the fullscreen mode state.
|
||||
*/
|
||||
void setFullscreenMode(bool enable);
|
||||
|
||||
/**
|
||||
* Query the fullscreen state.
|
||||
*/
|
||||
inline bool getFullscreenMode() const { return _videoMode.fullscreen; }
|
||||
|
||||
/**
|
||||
* Set the scale factor.
|
||||
*
|
||||
* This can only be used in a GFX transaction.
|
||||
*
|
||||
* @param newScale New scale factor.
|
||||
*/
|
||||
void setScale(int newScale);
|
||||
|
||||
/**
|
||||
* Query the scale factor.
|
||||
*/
|
||||
inline int getScale() const { return _videoMode.scaleFactor; }
|
||||
|
||||
/**
|
||||
* Toggle the antialiasing state of the current video mode.
|
||||
*
|
||||
* This can only be used in a GFX transaction.
|
||||
*/
|
||||
void toggleAntialiasing();
|
||||
|
||||
/**
|
||||
* Query the antialiasing state.
|
||||
*/
|
||||
inline bool getAntialiasingState() const { return _videoMode.antialiasing; }
|
||||
|
||||
// Drawing coordinates for the current display mode and scale
|
||||
int _displayX;
|
||||
int _displayY;
|
||||
int _displayWidth;
|
||||
int _displayHeight;
|
||||
|
||||
virtual const char *getCurrentModeName();
|
||||
|
||||
virtual void calculateDisplaySize(int &width, int &height);
|
||||
virtual void refreshDisplaySize();
|
||||
|
||||
uint getAspectRatio() const;
|
||||
|
||||
void setFormatIsBGR(bool isBGR) { _formatBGR = isBGR; }
|
||||
bool _formatBGR;
|
||||
|
||||
//
|
||||
// Game screen
|
||||
//
|
||||
GLTexture *_gameTexture;
|
||||
Graphics::Surface _screenData;
|
||||
int _screenChangeCount;
|
||||
bool _screenNeedsRedraw;
|
||||
Common::Rect _screenDirtyRect;
|
||||
|
||||
#ifdef USE_RGB_COLOR
|
||||
Graphics::PixelFormat _screenFormat;
|
||||
#endif
|
||||
byte *_gamePalette;
|
||||
|
||||
virtual void refreshGameScreen();
|
||||
|
||||
// Shake mode
|
||||
int _shakePos;
|
||||
|
||||
//
|
||||
// Overlay
|
||||
//
|
||||
GLTexture *_overlayTexture;
|
||||
Graphics::Surface _overlayData;
|
||||
Graphics::PixelFormat _overlayFormat;
|
||||
bool _overlayVisible;
|
||||
bool _overlayNeedsRedraw;
|
||||
Common::Rect _overlayDirtyRect;
|
||||
|
||||
virtual void refreshOverlay();
|
||||
|
||||
//
|
||||
// Mouse
|
||||
//
|
||||
struct MousePos {
|
||||
// The mouse position in hardware screen coordinates.
|
||||
int16 x, y;
|
||||
|
||||
// The size and hotspot of the original cursor image.
|
||||
int16 w, h;
|
||||
int16 hotX, hotY;
|
||||
|
||||
// The size and hotspot of the scaled cursor, in real coordinates.
|
||||
int16 rW, rH;
|
||||
int16 rHotX, rHotY;
|
||||
|
||||
// The size and hotspot of the scaled cursor, in game coordinates.
|
||||
int16 vW, vH;
|
||||
int16 vHotX, vHotY;
|
||||
|
||||
MousePos() : x(0), y(0), w(0), h(0), hotX(0), hotY(0),
|
||||
rW(0), rH(0), rHotX(0), rHotY(0), vW(0), vH(0),
|
||||
vHotX(0), vHotY(0) {}
|
||||
};
|
||||
|
||||
GLTexture *_cursorTexture;
|
||||
Graphics::Surface _cursorData;
|
||||
Graphics::PixelFormat _cursorFormat;
|
||||
byte *_cursorPalette;
|
||||
bool _cursorPaletteDisabled;
|
||||
MousePos _cursorState;
|
||||
bool _cursorVisible;
|
||||
uint32 _cursorKeyColor;
|
||||
bool _cursorDontScale;
|
||||
bool _cursorNeedsRedraw;
|
||||
|
||||
/**
|
||||
* Set up the mouse position for graphics output.
|
||||
*
|
||||
* @param x X coordinate in native coordinates.
|
||||
* @param y Y coordinate in native coordinates.
|
||||
*/
|
||||
void setMousePosition(int x, int y) { _cursorState.x = x; _cursorState.y = y; }
|
||||
|
||||
virtual void refreshCursor();
|
||||
virtual void refreshCursorScale();
|
||||
|
||||
/**
|
||||
* Set up the mouse position for the (event) system.
|
||||
*
|
||||
* @param x X coordinate in native coordinates.
|
||||
* @param y Y coordinate in native coordinates.
|
||||
*/
|
||||
virtual void setInternalMousePosition(int x, int y) = 0;
|
||||
|
||||
/**
|
||||
* Adjusts hardware screen coordinates to either overlay or game screen
|
||||
* coordinates depending on whether the overlay is visible or not.
|
||||
*
|
||||
* @param x X coordinate of the mouse position.
|
||||
* @param y Y coordinate of the mouse position.
|
||||
*/
|
||||
virtual void adjustMousePosition(int16 &x, int16 &y);
|
||||
|
||||
//
|
||||
// Misc
|
||||
//
|
||||
virtual bool saveScreenshot(const char *filename);
|
||||
|
||||
#ifdef USE_OSD
|
||||
/**
|
||||
* Returns the font used for on screen display
|
||||
*/
|
||||
virtual const Graphics::Font *getFontOSD();
|
||||
|
||||
/**
|
||||
* Update the OSD texture / surface.
|
||||
*/
|
||||
void updateOSD();
|
||||
|
||||
/**
|
||||
* The OSD contents.
|
||||
*/
|
||||
Common::Array<Common::String> _osdLines;
|
||||
|
||||
GLTexture *_osdTexture;
|
||||
Graphics::Surface _osdSurface;
|
||||
uint8 _osdAlpha;
|
||||
uint32 _osdFadeStartTime;
|
||||
bool _requireOSDUpdate;
|
||||
enum {
|
||||
kOSDFadeOutDelay = 2 * 1000,
|
||||
kOSDFadeOutDuration = 500,
|
||||
kOSDInitialAlpha = 80
|
||||
};
|
||||
#endif
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,677 +0,0 @@
|
|||
/* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "common/scummsys.h"
|
||||
|
||||
#if defined(SDL_BACKEND) && defined(USE_OPENGL)
|
||||
|
||||
#include "backends/graphics/openglsdl/openglsdl-graphics.h"
|
||||
#include "backends/platform/sdl/sdl.h"
|
||||
#include "common/config-manager.h"
|
||||
#include "common/textconsole.h"
|
||||
#include "common/translation.h"
|
||||
|
||||
OpenGLSdlGraphicsManager::OpenGLSdlGraphicsManager(SdlEventSource *eventSource)
|
||||
:
|
||||
SdlGraphicsManager(eventSource),
|
||||
_hwscreen(0),
|
||||
_screenResized(false),
|
||||
_activeFullscreenMode(-2),
|
||||
_lastFullscreenModeWidth(0),
|
||||
_lastFullscreenModeHeight(0),
|
||||
_desktopWidth(0),
|
||||
_desktopHeight(0),
|
||||
_ignoreResizeFrames(0) {
|
||||
|
||||
// Initialize SDL video subsystem
|
||||
if (SDL_InitSubSystem(SDL_INIT_VIDEO) == -1) {
|
||||
error("Could not initialize SDL: %s", SDL_GetError());
|
||||
}
|
||||
|
||||
// This is also called in initSDL(), but initializing graphics
|
||||
// may reset it.
|
||||
SDL_EnableUNICODE(1);
|
||||
|
||||
// Disable OS cursor
|
||||
SDL_ShowCursor(SDL_DISABLE);
|
||||
|
||||
// Get desktop resolution
|
||||
// TODO: In case the OpenGL manager is created *after* a plain SDL manager
|
||||
// has been used, this will return the last setup graphics mode rather
|
||||
// than the desktop resolution. We should really look into a way to
|
||||
// properly retrieve the desktop resolution.
|
||||
const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
|
||||
if (videoInfo->current_w > 0 && videoInfo->current_h > 0) {
|
||||
_desktopWidth = videoInfo->current_w;
|
||||
_desktopHeight = videoInfo->current_h;
|
||||
}
|
||||
|
||||
if (ConfMan.hasKey("last_fullscreen_mode_width") && ConfMan.hasKey("last_fullscreen_mode_height")) {
|
||||
_lastFullscreenModeWidth = ConfMan.getInt("last_fullscreen_mode_width");
|
||||
_lastFullscreenModeHeight = ConfMan.getInt("last_fullscreen_mode_height");
|
||||
}
|
||||
}
|
||||
|
||||
OpenGLSdlGraphicsManager::~OpenGLSdlGraphicsManager() {
|
||||
// Unregister the event observer
|
||||
if (g_system->getEventManager()->getEventDispatcher() != NULL)
|
||||
g_system->getEventManager()->getEventDispatcher()->unregisterObserver(this);
|
||||
}
|
||||
|
||||
void OpenGLSdlGraphicsManager::initEventObserver() {
|
||||
// Register the graphics manager as a event observer
|
||||
g_system->getEventManager()->getEventDispatcher()->registerObserver(this, 10, false);
|
||||
}
|
||||
|
||||
bool OpenGLSdlGraphicsManager::hasFeature(OSystem::Feature f) {
|
||||
return
|
||||
(f == OSystem::kFeatureFullscreenMode) ||
|
||||
(f == OSystem::kFeatureIconifyWindow) ||
|
||||
OpenGLGraphicsManager::hasFeature(f);
|
||||
}
|
||||
|
||||
void OpenGLSdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
|
||||
switch (f) {
|
||||
case OSystem::kFeatureIconifyWindow:
|
||||
if (enable)
|
||||
SDL_WM_IconifyWindow();
|
||||
break;
|
||||
default:
|
||||
OpenGLGraphicsManager::setFeatureState(f, enable);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef USE_RGB_COLOR
|
||||
|
||||
Common::List<Graphics::PixelFormat> OpenGLSdlGraphicsManager::getSupportedFormats() const {
|
||||
assert(!_supportedFormats.empty());
|
||||
return _supportedFormats;
|
||||
}
|
||||
|
||||
void OpenGLSdlGraphicsManager::detectSupportedFormats() {
|
||||
|
||||
// Clear old list
|
||||
_supportedFormats.clear();
|
||||
|
||||
// Some tables with standard formats that we always list
|
||||
// as "supported". If frontend code tries to use one of
|
||||
// these, we will perform the necessary format
|
||||
// conversion in the background. Of course this incurs a
|
||||
// performance hit, but on desktop ports this should not
|
||||
// matter. We still push the currently active format to
|
||||
// the front, so if frontend code just uses the first
|
||||
// available format, it will get one that is "cheap" to
|
||||
// use.
|
||||
const Graphics::PixelFormat RGBList[] = {
|
||||
#if defined(ENABLE_32BIT)
|
||||
Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0), // RGBA8888
|
||||
#ifndef USE_GLES
|
||||
Graphics::PixelFormat(4, 8, 8, 8, 8, 16, 8, 0, 24), // ARGB8888
|
||||
#endif
|
||||
Graphics::PixelFormat(3, 8, 8, 8, 0, 16, 8, 0, 0), // RGB888
|
||||
#endif
|
||||
Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0), // RGB565
|
||||
Graphics::PixelFormat(2, 5, 5, 5, 1, 11, 6, 1, 0), // RGB5551
|
||||
Graphics::PixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0), // RGB555
|
||||
Graphics::PixelFormat(2, 4, 4, 4, 4, 12, 8, 4, 0), // RGBA4444
|
||||
#ifndef USE_GLES
|
||||
Graphics::PixelFormat(2, 4, 4, 4, 4, 8, 4, 0, 12) // ARGB4444
|
||||
#endif
|
||||
};
|
||||
#ifndef USE_GLES
|
||||
const Graphics::PixelFormat BGRList[] = {
|
||||
#ifdef ENABLE_32BIT
|
||||
Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24), // ABGR8888
|
||||
Graphics::PixelFormat(4, 8, 8, 8, 8, 8, 16, 24, 0), // BGRA8888
|
||||
Graphics::PixelFormat(3, 8, 8, 8, 0, 0, 8, 16, 0), // BGR888
|
||||
#endif
|
||||
Graphics::PixelFormat(2, 5, 6, 5, 0, 0, 5, 11, 0), // BGR565
|
||||
Graphics::PixelFormat(2, 5, 5, 5, 1, 1, 6, 11, 0), // BGRA5551
|
||||
Graphics::PixelFormat(2, 4, 4, 4, 4, 0, 4, 8, 12), // ABGR4444
|
||||
Graphics::PixelFormat(2, 4, 4, 4, 4, 4, 8, 12, 0) // BGRA4444
|
||||
};
|
||||
#endif
|
||||
|
||||
Graphics::PixelFormat format = Graphics::PixelFormat::createFormatCLUT8();
|
||||
if (_hwscreen) {
|
||||
// Get our currently set hardware format
|
||||
format = Graphics::PixelFormat(_hwscreen->format->BytesPerPixel,
|
||||
8 - _hwscreen->format->Rloss, 8 - _hwscreen->format->Gloss,
|
||||
8 - _hwscreen->format->Bloss, 8 - _hwscreen->format->Aloss,
|
||||
_hwscreen->format->Rshift, _hwscreen->format->Gshift,
|
||||
_hwscreen->format->Bshift, _hwscreen->format->Ashift);
|
||||
|
||||
// Workaround to SDL not providing an accurate Aloss value on Mac OS X.
|
||||
if (_hwscreen->format->Amask == 0)
|
||||
format.aLoss = 8;
|
||||
|
||||
// Push it first, as the prefered format if available
|
||||
for (int i = 0; i < ARRAYSIZE(RGBList); i++) {
|
||||
if (RGBList[i] == format) {
|
||||
_supportedFormats.push_back(format);
|
||||
break;
|
||||
}
|
||||
}
|
||||
#ifndef USE_GLES
|
||||
for (int i = 0; i < ARRAYSIZE(BGRList); i++) {
|
||||
if (BGRList[i] == format) {
|
||||
_supportedFormats.push_back(format);
|
||||
break;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// Push some RGB formats
|
||||
for (int i = 0; i < ARRAYSIZE(RGBList); i++) {
|
||||
if (_hwscreen && (RGBList[i].bytesPerPixel > format.bytesPerPixel))
|
||||
continue;
|
||||
if (RGBList[i] != format)
|
||||
_supportedFormats.push_back(RGBList[i]);
|
||||
}
|
||||
#ifndef USE_GLES
|
||||
// Push some BGR formats
|
||||
for (int i = 0; i < ARRAYSIZE(BGRList); i++) {
|
||||
if (_hwscreen && (BGRList[i].bytesPerPixel > format.bytesPerPixel))
|
||||
continue;
|
||||
if (BGRList[i] != format)
|
||||
_supportedFormats.push_back(BGRList[i]);
|
||||
}
|
||||
#endif
|
||||
_supportedFormats.push_back(Graphics::PixelFormat::createFormatCLUT8());
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
void OpenGLSdlGraphicsManager::setInternalMousePosition(int x, int y) {
|
||||
SDL_WarpMouse(x, y);
|
||||
}
|
||||
|
||||
void OpenGLSdlGraphicsManager::updateScreen() {
|
||||
if (_ignoreResizeFrames)
|
||||
_ignoreResizeFrames -= 1;
|
||||
|
||||
OpenGLGraphicsManager::updateScreen();
|
||||
}
|
||||
|
||||
//
|
||||
// Intern
|
||||
//
|
||||
|
||||
bool OpenGLSdlGraphicsManager::setupFullscreenMode() {
|
||||
SDL_Rect const* const*availableModes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_OPENGL);
|
||||
|
||||
// SDL_ListModes() returns -1 in case any dimension is okay. In that
|
||||
// case we'll reuse the current desktop resolution for fullscreen.
|
||||
if (availableModes == (void *)-1) {
|
||||
_videoMode.hardwareWidth = _desktopWidth;
|
||||
_videoMode.hardwareHeight = _desktopHeight;
|
||||
_activeFullscreenMode = -2;
|
||||
return true;
|
||||
}
|
||||
|
||||
// If -2, autodetect the fullscreen mode
|
||||
// The last used fullscreen mode will be prioritized, if there is no last fullscreen
|
||||
// mode, the desktop resolution will be used, and in case the desktop resolution
|
||||
// is not available as a fullscreen mode, the one with smallest metric will be selected.
|
||||
if (_activeFullscreenMode == -2) {
|
||||
// Desktop resolution
|
||||
int desktopModeIndex = -1;
|
||||
|
||||
// Best metric mode
|
||||
const SDL_Rect *bestMode = availableModes[0];
|
||||
int bestModeIndex = 0;
|
||||
uint bestMetric = (uint)-1;
|
||||
|
||||
// Iterate over all available fullscreen modes
|
||||
for (int i = 0; const SDL_Rect *mode = availableModes[i]; i++) {
|
||||
// Try to setup the last used fullscreen mode
|
||||
if (mode->w == _lastFullscreenModeWidth && mode->h == _lastFullscreenModeHeight) {
|
||||
_videoMode.hardwareWidth = _lastFullscreenModeWidth;
|
||||
_videoMode.hardwareHeight = _lastFullscreenModeHeight;
|
||||
_activeFullscreenMode = i;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (mode->w == _desktopWidth && mode->h == _desktopHeight)
|
||||
desktopModeIndex = i;
|
||||
|
||||
if (mode->w < _videoMode.overlayWidth)
|
||||
continue;
|
||||
if (mode->h < _videoMode.overlayHeight)
|
||||
continue;
|
||||
|
||||
uint metric = mode->w * mode->h - _videoMode.overlayWidth * _videoMode.overlayHeight;
|
||||
if (metric < bestMetric) {
|
||||
bestMode = mode;
|
||||
bestMetric = metric;
|
||||
bestModeIndex = i;
|
||||
}
|
||||
}
|
||||
|
||||
if (desktopModeIndex >= 0) {
|
||||
_videoMode.hardwareWidth = _desktopWidth;
|
||||
_videoMode.hardwareHeight = _desktopHeight;
|
||||
|
||||
_activeFullscreenMode = desktopModeIndex;
|
||||
return true;
|
||||
} else if (bestMode) {
|
||||
_videoMode.hardwareWidth = bestMode->w;
|
||||
_videoMode.hardwareHeight = bestMode->h;
|
||||
|
||||
_activeFullscreenMode = bestModeIndex;
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
// Use last fullscreen mode if looping backwards from the first mode
|
||||
if (_activeFullscreenMode == -1) {
|
||||
do {
|
||||
_activeFullscreenMode++;
|
||||
} while(availableModes[_activeFullscreenMode]);
|
||||
_activeFullscreenMode--;
|
||||
}
|
||||
|
||||
// Use first fullscreen mode if looping from last mode
|
||||
if (!availableModes[_activeFullscreenMode])
|
||||
_activeFullscreenMode = 0;
|
||||
|
||||
// Check if the fullscreen mode is valid
|
||||
if (availableModes[_activeFullscreenMode]) {
|
||||
_videoMode.hardwareWidth = availableModes[_activeFullscreenMode]->w;
|
||||
_videoMode.hardwareHeight = availableModes[_activeFullscreenMode]->h;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// Could not find any suiting fullscreen mode, return false.
|
||||
return false;
|
||||
}
|
||||
|
||||
bool OpenGLSdlGraphicsManager::loadGFXMode() {
|
||||
// If the screen was resized, do not change its size
|
||||
if (!_screenResized) {
|
||||
const int scaleFactor = getScale();
|
||||
_videoMode.overlayWidth = _videoMode.hardwareWidth = _videoMode.screenWidth * scaleFactor;
|
||||
_videoMode.overlayHeight = _videoMode.hardwareHeight = _videoMode.screenHeight * scaleFactor;
|
||||
|
||||
// The only modes where we need to adapt the aspect ratio are 320x200
|
||||
// and 640x400. That is since our aspect ratio correction in fact is
|
||||
// only used to ensure that the original pixel size aspect for these
|
||||
// modes is used.
|
||||
// (Non-square pixels on old monitors vs square pixel on new ones).
|
||||
if (_videoMode.aspectRatioCorrection) {
|
||||
if (_videoMode.screenWidth == 320 && _videoMode.screenHeight == 200)
|
||||
_videoMode.overlayHeight = _videoMode.hardwareHeight = 240 * scaleFactor;
|
||||
else if (_videoMode.screenWidth == 640 && _videoMode.screenHeight == 400)
|
||||
_videoMode.overlayHeight = _videoMode.hardwareHeight = 480 * scaleFactor;
|
||||
}
|
||||
}
|
||||
|
||||
_screenResized = false;
|
||||
|
||||
// Setup OpenGL attributes for SDL
|
||||
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
|
||||
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
|
||||
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
|
||||
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
|
||||
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
|
||||
|
||||
const bool isFullscreen = getFullscreenMode();
|
||||
|
||||
// In case we have an fullscreen mode and we are not in a rollback, detect
|
||||
// a proper mode to use. In case we are in a rollback, we already detected
|
||||
// a proper mode when setting up that mode, thus there is no need to run
|
||||
// the detection again.
|
||||
if (isFullscreen && _transactionMode != kTransactionRollback) {
|
||||
if (!setupFullscreenMode())
|
||||
// Failed setuping a fullscreen mode
|
||||
return false;
|
||||
}
|
||||
|
||||
_videoMode.overlayWidth = _videoMode.hardwareWidth;
|
||||
_videoMode.overlayHeight = _videoMode.hardwareHeight;
|
||||
|
||||
uint32 flags = SDL_OPENGL;
|
||||
|
||||
if (isFullscreen)
|
||||
flags |= SDL_FULLSCREEN;
|
||||
else
|
||||
flags |= SDL_RESIZABLE;
|
||||
|
||||
// Create our window
|
||||
_hwscreen = SDL_SetVideoMode(_videoMode.hardwareWidth, _videoMode.hardwareHeight, 32, flags);
|
||||
#ifdef USE_RGB_COLOR
|
||||
detectSupportedFormats();
|
||||
#endif
|
||||
|
||||
if (_hwscreen == NULL) {
|
||||
// DON'T use error(), as this tries to bring up the debug
|
||||
// console, which WON'T WORK now that _hwscreen is hosed.
|
||||
|
||||
if (!_oldVideoMode.setup) {
|
||||
warning("SDL_SetVideoMode says we can't switch to that mode (%s)", SDL_GetError());
|
||||
g_system->quit();
|
||||
} else
|
||||
// Cancel GFX load, and go back to last mode
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check if the screen is BGR format
|
||||
setFormatIsBGR(_hwscreen->format->Rshift != 0);
|
||||
|
||||
if (isFullscreen) {
|
||||
_lastFullscreenModeWidth = _videoMode.hardwareWidth;
|
||||
_lastFullscreenModeHeight = _videoMode.hardwareHeight;
|
||||
ConfMan.setInt("last_fullscreen_mode_width", _lastFullscreenModeWidth);
|
||||
ConfMan.setInt("last_fullscreen_mode_height", _lastFullscreenModeHeight);
|
||||
}
|
||||
|
||||
// Call and return parent implementation of this method
|
||||
return OpenGLGraphicsManager::loadGFXMode();
|
||||
}
|
||||
|
||||
void OpenGLSdlGraphicsManager::unloadGFXMode() {
|
||||
if (_hwscreen) {
|
||||
SDL_FreeSurface(_hwscreen);
|
||||
_hwscreen = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void OpenGLSdlGraphicsManager::internUpdateScreen() {
|
||||
// Call to parent implementation of this method
|
||||
OpenGLGraphicsManager::internUpdateScreen();
|
||||
|
||||
// Swap OpenGL buffers
|
||||
SDL_GL_SwapBuffers();
|
||||
}
|
||||
|
||||
#ifdef USE_OSD
|
||||
void OpenGLSdlGraphicsManager::displayModeChangedMsg() {
|
||||
const char *newModeName = getCurrentModeName();
|
||||
if (newModeName) {
|
||||
const int scaleFactor = getScale();
|
||||
|
||||
Common::String osdMessage = Common::String::format(
|
||||
"%s: %s\n%d x %d -> %d x %d",
|
||||
_("Current display mode"),
|
||||
newModeName,
|
||||
_videoMode.screenWidth * scaleFactor,
|
||||
_videoMode.screenHeight * scaleFactor,
|
||||
_hwscreen->w, _hwscreen->h
|
||||
);
|
||||
displayMessageOnOSD(osdMessage.c_str());
|
||||
}
|
||||
}
|
||||
void OpenGLSdlGraphicsManager::displayScaleChangedMsg() {
|
||||
const int scaleFactor = getScale();
|
||||
Common::String osdMessage = Common::String::format(
|
||||
"%s: x%d\n%d x %d -> %d x %d",
|
||||
_("Current scale"),
|
||||
scaleFactor,
|
||||
_videoMode.screenWidth, _videoMode.screenHeight,
|
||||
_videoMode.overlayWidth, _videoMode.overlayHeight
|
||||
);
|
||||
displayMessageOnOSD(osdMessage.c_str());
|
||||
}
|
||||
#endif
|
||||
|
||||
bool OpenGLSdlGraphicsManager::isHotkey(const Common::Event &event) {
|
||||
if ((event.kbd.flags & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
|
||||
if (event.kbd.keycode == Common::KEYCODE_PLUS || event.kbd.keycode == Common::KEYCODE_MINUS ||
|
||||
event.kbd.keycode == Common::KEYCODE_KP_PLUS || event.kbd.keycode == Common::KEYCODE_KP_MINUS ||
|
||||
event.kbd.keycode == 'a' || event.kbd.keycode == 'f')
|
||||
return true;
|
||||
} else if ((event.kbd.flags & (Common::KBD_CTRL|Common::KBD_SHIFT)) == (Common::KBD_CTRL|Common::KBD_SHIFT)) {
|
||||
if (event.kbd.keycode == 'a' || event.kbd.keycode == 'f')
|
||||
return true;
|
||||
} else if ((event.kbd.flags & (Common::KBD_ALT)) == (Common::KBD_ALT) && event.kbd.keycode == 's') {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void OpenGLSdlGraphicsManager::toggleFullScreen(int loop) {
|
||||
beginGFXTransaction();
|
||||
const bool isFullscreen = getFullscreenMode();
|
||||
|
||||
if (isFullscreen && loop) {
|
||||
_activeFullscreenMode += loop;
|
||||
setFullscreenMode(true);
|
||||
} else {
|
||||
_activeFullscreenMode = -2;
|
||||
setFullscreenMode(!isFullscreen);
|
||||
}
|
||||
|
||||
// HACK: We need to force a refresh here, since we change the
|
||||
// fullscreen mode.
|
||||
_transactionDetails.needRefresh = true;
|
||||
endGFXTransaction();
|
||||
|
||||
// Ignore resize events for the next 10 frames
|
||||
_ignoreResizeFrames = 10;
|
||||
|
||||
#ifdef USE_OSD
|
||||
Common::String osdMessage;
|
||||
if (getFullscreenMode())
|
||||
osdMessage = Common::String::format("%s\n%d x %d",
|
||||
_("Fullscreen mode"),
|
||||
_hwscreen->w, _hwscreen->h
|
||||
);
|
||||
else
|
||||
osdMessage = Common::String::format("%s\n%d x %d",
|
||||
_("Windowed mode"),
|
||||
_hwscreen->w, _hwscreen->h
|
||||
);
|
||||
displayMessageOnOSD(osdMessage.c_str());
|
||||
#endif
|
||||
}
|
||||
|
||||
bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) {
|
||||
switch (event.type) {
|
||||
case Common::EVENT_KEYDOWN:
|
||||
if (event.kbd.hasFlags(Common::KBD_ALT)) {
|
||||
// Alt-Return and Alt-Enter toggle full screen mode
|
||||
if (event.kbd.keycode == Common::KEYCODE_RETURN ||
|
||||
event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
|
||||
toggleFullScreen(0);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Alt-S create a screenshot
|
||||
if (event.kbd.keycode == 's') {
|
||||
Common::String filename;
|
||||
|
||||
for (int n = 0;; n++) {
|
||||
SDL_RWops *file;
|
||||
|
||||
filename = Common::String::format("scummvm%05d.bmp", n);
|
||||
file = SDL_RWFromFile(filename.c_str(), "r");
|
||||
if (!file)
|
||||
break;
|
||||
SDL_RWclose(file);
|
||||
}
|
||||
if (saveScreenshot(filename.c_str()))
|
||||
debug("Saved screenshot '%s'", filename.c_str());
|
||||
else
|
||||
warning("Could not save screenshot");
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_ALT)) {
|
||||
// Ctrl-Alt-Return and Ctrl-Alt-Enter switch between full screen modes
|
||||
if (event.kbd.keycode == Common::KEYCODE_RETURN ||
|
||||
event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
|
||||
toggleFullScreen(1);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Ctrl-Alt-a switch between display modes
|
||||
if (event.kbd.keycode == 'a') {
|
||||
beginGFXTransaction();
|
||||
setFeatureState(OSystem::kFeatureAspectRatioCorrection, !getFeatureState(OSystem::kFeatureAspectRatioCorrection));
|
||||
endGFXTransaction();
|
||||
#ifdef USE_OSD
|
||||
Common::String osdMessage;
|
||||
if (getFeatureState(OSystem::kFeatureAspectRatioCorrection))
|
||||
osdMessage = Common::String::format("%s\n%d x %d -> %d x %d",
|
||||
_("Enabled aspect ratio correction"),
|
||||
_videoMode.screenWidth, _videoMode.screenHeight,
|
||||
_hwscreen->w, _hwscreen->h);
|
||||
else
|
||||
osdMessage = Common::String::format("%s\n%d x %d -> %d x %d",
|
||||
_("Disabled aspect ratio correction"),
|
||||
_videoMode.screenWidth, _videoMode.screenHeight,
|
||||
_hwscreen->w, _hwscreen->h);
|
||||
displayMessageOnOSD(osdMessage.c_str());
|
||||
#endif
|
||||
internUpdateScreen();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Ctrl-Alt-f toggles antialiasing
|
||||
if (event.kbd.keycode == 'f') {
|
||||
beginGFXTransaction();
|
||||
toggleAntialiasing();
|
||||
endGFXTransaction();
|
||||
|
||||
#ifdef USE_OSD
|
||||
// TODO: This makes guesses about what internal antialiasing
|
||||
// modes we use, we might want to consider a better way of
|
||||
// displaying information to the user.
|
||||
if (getAntialiasingState())
|
||||
displayMessageOnOSD(_("Active filter mode: Linear"));
|
||||
else
|
||||
displayMessageOnOSD(_("Active filter mode: Nearest"));
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
SDLKey sdlKey = (SDLKey)event.kbd.keycode;
|
||||
|
||||
// Ctrl+Alt+Plus/Minus Increase/decrease the scale factor
|
||||
if ((sdlKey == SDLK_EQUALS || sdlKey == SDLK_PLUS || sdlKey == SDLK_MINUS ||
|
||||
sdlKey == SDLK_KP_PLUS || sdlKey == SDLK_KP_MINUS)) {
|
||||
int factor = getScale();
|
||||
factor += (sdlKey == SDLK_MINUS || sdlKey == SDLK_KP_MINUS) ? -1 : +1;
|
||||
if (0 < factor && factor < 4) {
|
||||
// Check if the desktop resolution has been detected
|
||||
if (_desktopWidth > 0 && _desktopHeight > 0)
|
||||
// If the new scale factor is too big, do not scale
|
||||
if (_videoMode.screenWidth * factor > _desktopWidth ||
|
||||
_videoMode.screenHeight * factor > _desktopHeight)
|
||||
return false;
|
||||
|
||||
beginGFXTransaction();
|
||||
setScale(factor);
|
||||
endGFXTransaction();
|
||||
#ifdef USE_OSD
|
||||
displayScaleChangedMsg();
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
const bool isNormalNumber = (SDLK_1 <= sdlKey && sdlKey <= SDLK_3);
|
||||
const bool isKeypadNumber = (SDLK_KP1 <= sdlKey && sdlKey <= SDLK_KP3);
|
||||
|
||||
// Ctrl-Alt-<number key> will change the GFX mode
|
||||
if (isNormalNumber || isKeypadNumber) {
|
||||
if (sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1) <= 3) {
|
||||
#ifdef USE_OSD
|
||||
int lastMode = _videoMode.mode;
|
||||
#endif
|
||||
// We need to query the scale and set it up, because
|
||||
// setGraphicsMode sets the default scale to 2
|
||||
int oldScale = getScale();
|
||||
beginGFXTransaction();
|
||||
setGraphicsMode(sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1));
|
||||
setScale(oldScale);
|
||||
endGFXTransaction();
|
||||
#ifdef USE_OSD
|
||||
if (lastMode != _videoMode.mode)
|
||||
displayModeChangedMsg();
|
||||
#endif
|
||||
internUpdateScreen();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_SHIFT)) {
|
||||
// Ctrl-Shift-Return and Ctrl-Shift-Enter switch backwards between full screen modes
|
||||
if (event.kbd.keycode == Common::KEYCODE_RETURN ||
|
||||
event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
|
||||
toggleFullScreen(-1);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case Common::EVENT_KEYUP:
|
||||
return isHotkey(event);
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void OpenGLSdlGraphicsManager::notifyVideoExpose() {
|
||||
}
|
||||
|
||||
void OpenGLSdlGraphicsManager::notifyResize(const uint width, const uint height) {
|
||||
// Do not resize if ignoring resize events.
|
||||
if (!_ignoreResizeFrames && !getFullscreenMode()) {
|
||||
bool scaleChanged = false;
|
||||
beginGFXTransaction();
|
||||
_videoMode.hardwareWidth = width;
|
||||
_videoMode.hardwareHeight = height;
|
||||
|
||||
_screenResized = true;
|
||||
|
||||
int scale = MIN(_videoMode.hardwareWidth / _videoMode.screenWidth,
|
||||
_videoMode.hardwareHeight / _videoMode.screenHeight);
|
||||
|
||||
if (getScale() != scale) {
|
||||
scaleChanged = true;
|
||||
setScale(MAX(MIN(scale, 3), 1));
|
||||
}
|
||||
|
||||
_transactionDetails.sizeChanged = true;
|
||||
endGFXTransaction();
|
||||
#ifdef USE_OSD
|
||||
if (scaleChanged)
|
||||
displayScaleChangedMsg();
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
void OpenGLSdlGraphicsManager::transformMouseCoordinates(Common::Point &point) {
|
||||
adjustMousePosition(point.x, point.y);
|
||||
}
|
||||
|
||||
void OpenGLSdlGraphicsManager::notifyMousePos(Common::Point mouse) {
|
||||
setMousePosition(mouse.x, mouse.y);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,124 +0,0 @@
|
|||
/* 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_OPENGLSDL_H
|
||||
#define BACKENDS_GRAPHICS_OPENGLSDL_H
|
||||
|
||||
#include "backends/platform/sdl/sdl-sys.h"
|
||||
#if defined(ARRAYSIZE) && !defined(_WINDOWS_)
|
||||
#undef ARRAYSIZE
|
||||
#endif
|
||||
#include "backends/graphics/sdl/sdl-graphics.h"
|
||||
#include "backends/graphics/opengl/opengl-graphics.h"
|
||||
|
||||
#include "common/events.h"
|
||||
|
||||
/**
|
||||
* SDL OpenGL graphics manager
|
||||
*/
|
||||
class OpenGLSdlGraphicsManager : public OpenGLGraphicsManager, public SdlGraphicsManager, public Common::EventObserver {
|
||||
public:
|
||||
OpenGLSdlGraphicsManager(SdlEventSource *eventSource);
|
||||
virtual ~OpenGLSdlGraphicsManager();
|
||||
|
||||
virtual bool hasFeature(OSystem::Feature f);
|
||||
virtual void setFeatureState(OSystem::Feature f, bool enable);
|
||||
|
||||
#ifdef USE_RGB_COLOR
|
||||
virtual Common::List<Graphics::PixelFormat> getSupportedFormats() const;
|
||||
#endif
|
||||
|
||||
virtual void initEventObserver();
|
||||
virtual bool notifyEvent(const Common::Event &event);
|
||||
|
||||
virtual void updateScreen();
|
||||
|
||||
// SdlGraphicsManager interface
|
||||
virtual void notifyVideoExpose();
|
||||
virtual void notifyResize(const uint width, const uint height);
|
||||
virtual void transformMouseCoordinates(Common::Point &point);
|
||||
virtual void notifyMousePos(Common::Point mouse);
|
||||
|
||||
protected:
|
||||
virtual void internUpdateScreen();
|
||||
|
||||
virtual bool loadGFXMode();
|
||||
virtual void unloadGFXMode();
|
||||
virtual bool isHotkey(const Common::Event &event);
|
||||
|
||||
#ifdef USE_RGB_COLOR
|
||||
Common::List<Graphics::PixelFormat> _supportedFormats;
|
||||
|
||||
/**
|
||||
* Update the list of supported pixel formats.
|
||||
* This method is invoked by loadGFXMode().
|
||||
*/
|
||||
void detectSupportedFormats();
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Toggles fullscreen.
|
||||
* @loop loop direction for switching fullscreen mode, if 0 toggles it.
|
||||
*/
|
||||
virtual void toggleFullScreen(int loop);
|
||||
|
||||
int _activeFullscreenMode;
|
||||
|
||||
/**
|
||||
* Setup the fullscreen mode.
|
||||
* @return false if failed finding a mode, true otherwise.
|
||||
*/
|
||||
virtual bool setupFullscreenMode();
|
||||
|
||||
virtual void setInternalMousePosition(int x, int y);
|
||||
|
||||
int _lastFullscreenModeWidth;
|
||||
int _lastFullscreenModeHeight;
|
||||
int _desktopWidth;
|
||||
int _desktopHeight;
|
||||
|
||||
// Hardware screen
|
||||
SDL_Surface *_hwscreen;
|
||||
|
||||
// If screen was resized by the user
|
||||
bool _screenResized;
|
||||
|
||||
// Ignore resize events for the number of updateScreen() calls.
|
||||
// Normaly resize events are user generated when resizing the window
|
||||
// from its borders, but in some cases a resize event can be generated
|
||||
// after a fullscreen change.
|
||||
int _ignoreResizeFrames;
|
||||
|
||||
#ifdef USE_OSD
|
||||
/**
|
||||
* Displays a mode change message in OSD
|
||||
*/
|
||||
void displayModeChangedMsg();
|
||||
|
||||
/**
|
||||
* Displays a scale change message in OSD
|
||||
*/
|
||||
void displayScaleChangedMsg();
|
||||
#endif
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -40,14 +40,6 @@ MODULE_OBJS += \
|
|||
keymapper/remap-dialog.o
|
||||
endif
|
||||
|
||||
ifdef USE_OPENGL
|
||||
MODULE_OBJS += \
|
||||
graphics/opengl/glerrorcheck.o \
|
||||
graphics/opengl/gltexture.o \
|
||||
graphics/opengl/opengl-graphics.o \
|
||||
graphics/openglsdl/openglsdl-graphics.o
|
||||
endif
|
||||
|
||||
ifdef ENABLE_VKEYBD
|
||||
MODULE_OBJS += \
|
||||
vkeybd/image-map.o \
|
||||
|
|
|
|||
|
|
@ -47,10 +47,6 @@
|
|||
#include "backends/mutex/sdl/sdl-mutex.h"
|
||||
#include "backends/timer/sdl/sdl-timer.h"
|
||||
#include "backends/graphics/surfacesdl/surfacesdl-graphics.h"
|
||||
#ifdef USE_OPENGL
|
||||
#include "backends/graphics/openglsdl/openglsdl-graphics.h"
|
||||
#include "graphics/cursorman.h"
|
||||
#endif
|
||||
|
||||
#include "icons/scummvm.xpm"
|
||||
|
||||
|
|
@ -64,12 +60,6 @@
|
|||
|
||||
OSystem_SDL::OSystem_SDL()
|
||||
:
|
||||
#ifdef USE_OPENGL
|
||||
_graphicsModes(0),
|
||||
_graphicsMode(0),
|
||||
_sdlModesCount(0),
|
||||
_glModesCount(0),
|
||||
#endif
|
||||
_inited(false),
|
||||
_initedSDL(false),
|
||||
_logger(0),
|
||||
|
|
@ -110,10 +100,6 @@ OSystem_SDL::~OSystem_SDL() {
|
|||
delete _mutexManager;
|
||||
_mutexManager = 0;
|
||||
|
||||
#ifdef USE_OPENGL
|
||||
delete[] _graphicsModes;
|
||||
#endif
|
||||
|
||||
delete _logger;
|
||||
_logger = 0;
|
||||
|
||||
|
|
@ -143,11 +129,6 @@ void OSystem_SDL::init() {
|
|||
if (_taskbarManager == 0)
|
||||
_taskbarManager = new Common::TaskbarManager();
|
||||
#endif
|
||||
|
||||
#ifdef USE_OPENGL
|
||||
// Setup a list with both SDL and OpenGL graphics modes
|
||||
setupGraphicsModes();
|
||||
#endif
|
||||
}
|
||||
|
||||
void OSystem_SDL::initBackend() {
|
||||
|
|
@ -159,36 +140,8 @@ void OSystem_SDL::initBackend() {
|
|||
if (_eventSource == 0)
|
||||
_eventSource = new SdlEventSource();
|
||||
|
||||
int graphicsManagerType = 0;
|
||||
|
||||
if (_graphicsManager == 0) {
|
||||
#ifdef USE_OPENGL
|
||||
if (ConfMan.hasKey("gfx_mode")) {
|
||||
Common::String gfxMode(ConfMan.get("gfx_mode"));
|
||||
bool use_opengl = false;
|
||||
const OSystem::GraphicsMode *mode = OpenGLSdlGraphicsManager::supportedGraphicsModes();
|
||||
int i = 0;
|
||||
while (mode->name) {
|
||||
if (scumm_stricmp(mode->name, gfxMode.c_str()) == 0) {
|
||||
_graphicsMode = i + _sdlModesCount;
|
||||
use_opengl = true;
|
||||
}
|
||||
|
||||
mode++;
|
||||
++i;
|
||||
}
|
||||
|
||||
// If the gfx_mode is from OpenGL, create the OpenGL graphics manager
|
||||
if (use_opengl) {
|
||||
_graphicsManager = new OpenGLSdlGraphicsManager(_eventSource);
|
||||
graphicsManagerType = 1;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if (_graphicsManager == 0) {
|
||||
_graphicsManager = new SurfaceSdlGraphicsManager(_eventSource);
|
||||
graphicsManagerType = 0;
|
||||
}
|
||||
_graphicsManager = new SurfaceSdlGraphicsManager(_eventSource);
|
||||
}
|
||||
|
||||
if (_savefileManager == 0)
|
||||
|
|
@ -230,13 +183,7 @@ void OSystem_SDL::initBackend() {
|
|||
// so the virtual keyboard can be initialized, but we have to add the
|
||||
// graphics manager as an event observer after initializing the event
|
||||
// manager.
|
||||
if (graphicsManagerType == 0)
|
||||
((SurfaceSdlGraphicsManager *)_graphicsManager)->initEventObserver();
|
||||
#ifdef USE_OPENGL
|
||||
else if (graphicsManagerType == 1)
|
||||
((OpenGLSdlGraphicsManager *)_graphicsManager)->initEventObserver();
|
||||
#endif
|
||||
|
||||
((SurfaceSdlGraphicsManager *)_graphicsManager)->initEventObserver();
|
||||
}
|
||||
|
||||
#if defined(USE_TASKBAR)
|
||||
|
|
@ -531,160 +478,3 @@ Common::TimerManager *OSystem_SDL::getTimerManager() {
|
|||
return _timerManager;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef USE_OPENGL
|
||||
|
||||
const OSystem::GraphicsMode *OSystem_SDL::getSupportedGraphicsModes() const {
|
||||
return _graphicsModes;
|
||||
}
|
||||
|
||||
int OSystem_SDL::getDefaultGraphicsMode() const {
|
||||
// Return the default graphics mode from the current graphics manager
|
||||
if (_graphicsMode < _sdlModesCount)
|
||||
return _graphicsManager->getDefaultGraphicsMode();
|
||||
else
|
||||
return _graphicsManager->getDefaultGraphicsMode() + _sdlModesCount;
|
||||
}
|
||||
|
||||
bool OSystem_SDL::setGraphicsMode(int mode) {
|
||||
const OSystem::GraphicsMode *srcMode;
|
||||
int i;
|
||||
|
||||
// Check if mode is from SDL or OpenGL
|
||||
if (mode < _sdlModesCount) {
|
||||
srcMode = SurfaceSdlGraphicsManager::supportedGraphicsModes();
|
||||
i = 0;
|
||||
} else {
|
||||
srcMode = OpenGLSdlGraphicsManager::supportedGraphicsModes();
|
||||
i = _sdlModesCount;
|
||||
}
|
||||
|
||||
// Very hacky way to set up the old graphics manager state, in case we
|
||||
// switch from SDL->OpenGL or OpenGL->SDL.
|
||||
//
|
||||
// This is a probably temporary workaround to fix bugs like #3368143
|
||||
// "SDL/OpenGL: Crash when switching renderer backend".
|
||||
const int screenWidth = _graphicsManager->getWidth();
|
||||
const int screenHeight = _graphicsManager->getHeight();
|
||||
const bool arState = _graphicsManager->getFeatureState(kFeatureAspectRatioCorrection);
|
||||
const bool fullscreen = _graphicsManager->getFeatureState(kFeatureFullscreenMode);
|
||||
const bool cursorPalette = _graphicsManager->getFeatureState(kFeatureCursorPalette);
|
||||
#ifdef USE_RGB_COLOR
|
||||
const Graphics::PixelFormat pixelFormat = _graphicsManager->getScreenFormat();
|
||||
#endif
|
||||
|
||||
bool switchedManager = false;
|
||||
|
||||
// Loop through modes
|
||||
while (srcMode->name) {
|
||||
if (i == mode) {
|
||||
// If the new mode and the current mode are not from the same graphics
|
||||
// manager, delete and create the new mode graphics manager
|
||||
if (_graphicsMode >= _sdlModesCount && mode < _sdlModesCount) {
|
||||
debug(1, "switching to plain SDL graphics");
|
||||
delete _graphicsManager;
|
||||
_graphicsManager = new SurfaceSdlGraphicsManager(_eventSource);
|
||||
((SurfaceSdlGraphicsManager *)_graphicsManager)->initEventObserver();
|
||||
_graphicsManager->beginGFXTransaction();
|
||||
|
||||
switchedManager = true;
|
||||
} else if (_graphicsMode < _sdlModesCount && mode >= _sdlModesCount) {
|
||||
debug(1, "switching to OpenGL graphics");
|
||||
delete _graphicsManager;
|
||||
_graphicsManager = new OpenGLSdlGraphicsManager(_eventSource);
|
||||
((OpenGLSdlGraphicsManager *)_graphicsManager)->initEventObserver();
|
||||
_graphicsManager->beginGFXTransaction();
|
||||
|
||||
switchedManager = true;
|
||||
}
|
||||
|
||||
_graphicsMode = mode;
|
||||
|
||||
if (switchedManager) {
|
||||
#ifdef USE_RGB_COLOR
|
||||
_graphicsManager->initSize(screenWidth, screenHeight, &pixelFormat);
|
||||
#else
|
||||
_graphicsManager->initSize(screenWidth, screenHeight, 0);
|
||||
#endif
|
||||
_graphicsManager->setFeatureState(kFeatureAspectRatioCorrection, arState);
|
||||
_graphicsManager->setFeatureState(kFeatureFullscreenMode, fullscreen);
|
||||
_graphicsManager->setFeatureState(kFeatureCursorPalette, cursorPalette);
|
||||
|
||||
// Worst part about this right now, tell the cursor manager to
|
||||
// resetup the cursor + cursor palette if necessarily
|
||||
|
||||
// First we need to try to setup the old state on the new manager...
|
||||
if (_graphicsManager->endGFXTransaction() != kTransactionSuccess) {
|
||||
// Oh my god if this failed the client code might just explode.
|
||||
return false;
|
||||
}
|
||||
|
||||
// Next setup the cursor again
|
||||
CursorMan.pushCursor(0, 0, 0, 0, 0, 0);
|
||||
CursorMan.popCursor();
|
||||
|
||||
// Next setup cursor palette if needed
|
||||
if (cursorPalette) {
|
||||
CursorMan.pushCursorPalette(0, 0, 0);
|
||||
CursorMan.popCursorPalette();
|
||||
}
|
||||
|
||||
_graphicsManager->beginGFXTransaction();
|
||||
// Oh my god if this failed the client code might just explode.
|
||||
return _graphicsManager->setGraphicsMode(srcMode->id);
|
||||
} else {
|
||||
return _graphicsManager->setGraphicsMode(srcMode->id);
|
||||
}
|
||||
}
|
||||
|
||||
i++;
|
||||
srcMode++;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
int OSystem_SDL::getGraphicsMode() const {
|
||||
return _graphicsMode;
|
||||
}
|
||||
|
||||
void OSystem_SDL::setupGraphicsModes() {
|
||||
const OSystem::GraphicsMode *sdlGraphicsModes = SurfaceSdlGraphicsManager::supportedGraphicsModes();
|
||||
const OSystem::GraphicsMode *openglGraphicsModes = OpenGLSdlGraphicsManager::supportedGraphicsModes();
|
||||
_sdlModesCount = 0;
|
||||
_glModesCount = 0;
|
||||
|
||||
// Count the number of graphics modes
|
||||
const OSystem::GraphicsMode *srcMode = sdlGraphicsModes;
|
||||
while (srcMode->name) {
|
||||
_sdlModesCount++;
|
||||
srcMode++;
|
||||
}
|
||||
srcMode = openglGraphicsModes;
|
||||
while (srcMode->name) {
|
||||
_glModesCount++;
|
||||
srcMode++;
|
||||
}
|
||||
|
||||
// Allocate enough space for merged array of modes
|
||||
_graphicsModes = new OSystem::GraphicsMode[_glModesCount + _sdlModesCount + 1];
|
||||
|
||||
// Copy SDL graphics modes
|
||||
memcpy((void *)_graphicsModes, sdlGraphicsModes, _sdlModesCount * sizeof(OSystem::GraphicsMode));
|
||||
|
||||
// Copy OpenGL graphics modes
|
||||
memcpy((void *)(_graphicsModes + _sdlModesCount), openglGraphicsModes, _glModesCount * sizeof(OSystem::GraphicsMode));
|
||||
|
||||
// Set a null mode at the end
|
||||
memset((void *)(_graphicsModes + _sdlModesCount + _glModesCount), 0, sizeof(OSystem::GraphicsMode));
|
||||
|
||||
// Set new internal ids for all modes
|
||||
int i = 0;
|
||||
OSystem::GraphicsMode *mode = _graphicsModes;
|
||||
while (mode->name) {
|
||||
mode->id = i++;
|
||||
mode++;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -104,23 +104,6 @@ protected:
|
|||
// Logging
|
||||
virtual Common::WriteStream *createLogFile() { return 0; }
|
||||
Backends::Log::Log *_logger;
|
||||
|
||||
#ifdef USE_OPENGL
|
||||
OSystem::GraphicsMode *_graphicsModes;
|
||||
int _graphicsMode;
|
||||
int _sdlModesCount;
|
||||
int _glModesCount;
|
||||
|
||||
/**
|
||||
* Creates the merged graphics modes list
|
||||
*/
|
||||
virtual void setupGraphicsModes();
|
||||
|
||||
virtual const OSystem::GraphicsMode *getSupportedGraphicsModes() const;
|
||||
virtual int getDefaultGraphicsMode() const;
|
||||
virtual bool setGraphicsMode(int mode);
|
||||
virtual int getGraphicsMode() const;
|
||||
#endif
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue