[Scummvm-git-logs] scummvm master -> 1e4696f6d0c82efc6aa2e644545baf8537c83df4
lephilousophe
noreply at scummvm.org
Sun Apr 3 20:17:25 UTC 2022
This automated email contains information about 3 new commits which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .
Summary:
06bc7a25fa OPENGL: Indicate support of OpenGL even in 2D mode
b978cd1caa OPENGL: Allow engines to detect OpenGL info without switching
1e4696f6d0 OPENGL: Rework renderer selection code
Commit: 06bc7a25fa83195b1e0ab2df0977e825f009c15f
https://github.com/scummvm/scummvm/commit/06bc7a25fa83195b1e0ab2df0977e825f009c15f
Author: Le Philousophe (lephilousophe at users.noreply.github.com)
Date: 2022-04-03T22:17:19+02:00
Commit Message:
OPENGL: Indicate support of OpenGL even in 2D mode
This allows to check for OpenGL support in backend without having to
call initGraphics3d
Changed paths:
backends/graphics/sdl/sdl-graphics.cpp
backends/platform/android/android.cpp
backends/platform/sdl/sdl.cpp
diff --git a/backends/graphics/sdl/sdl-graphics.cpp b/backends/graphics/sdl/sdl-graphics.cpp
index dca66c26c9d..ec8ea78dbb1 100644
--- a/backends/graphics/sdl/sdl-graphics.cpp
+++ b/backends/graphics/sdl/sdl-graphics.cpp
@@ -390,13 +390,15 @@ bool SdlGraphicsManager::notifyEvent(const Common::Event &event) {
}
void SdlGraphicsManager::toggleFullScreen() {
+ /* Don't use g_system for kFeatureOpenGLForGame as it's always supported
+ * We want to check if we are a 3D graphics manager */
+ bool is3D = hasFeature(OSystem::kFeatureOpenGLForGame);
+
if (!g_system->hasFeature(OSystem::kFeatureFullscreenMode) ||
- (!g_system->hasFeature(OSystem::kFeatureFullscreenToggleKeepsContext) && g_system->hasFeature(OSystem::kFeatureOpenGLForGame))) {
+ (!g_system->hasFeature(OSystem::kFeatureFullscreenToggleKeepsContext) && is3D)) {
return;
}
- bool is3D = g_system->hasFeature(OSystem::kFeatureOpenGLForGame);
-
if (!is3D)
beginGFXTransaction();
setFeatureState(OSystem::kFeatureFullscreenMode, !getFeatureState(OSystem::kFeatureFullscreenMode));
diff --git a/backends/platform/android/android.cpp b/backends/platform/android/android.cpp
index 5624de31a18..ff45e2e2438 100644
--- a/backends/platform/android/android.cpp
+++ b/backends/platform/android/android.cpp
@@ -506,6 +506,9 @@ bool OSystem_Android::hasFeature(Feature f) {
f == kFeatureClipboardSupport) {
return true;
}
+ /* Even if we are using the 2D graphics manager,
+ * we are at one initGraphics3d call of supporting GLES2 */
+ if (f == kFeatureOpenGLForGame) return true;
return ModularGraphicsBackend::hasFeature(f);
}
diff --git a/backends/platform/sdl/sdl.cpp b/backends/platform/sdl/sdl.cpp
index 1e7d06faca5..cdf834db336 100644
--- a/backends/platform/sdl/sdl.cpp
+++ b/backends/platform/sdl/sdl.cpp
@@ -180,6 +180,11 @@ bool OSystem_SDL::hasFeature(Feature f) {
if (f == kFeatureJoystickDeadzone || f == kFeatureKbdMouseSpeed) {
return _eventSource->isJoystickConnected();
}
+#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
+ /* Even if we are using the 2D graphics manager,
+ * we are at one initGraphics3d call of supporting OpenGL */
+ if (f == kFeatureOpenGLForGame) return true;
+#endif
return ModularGraphicsBackend::hasFeature(f);
}
Commit: b978cd1caa37964b60cf0b64d5123b3c1e34177c
https://github.com/scummvm/scummvm/commit/b978cd1caa37964b60cf0b64d5123b3c1e34177c
Author: Le Philousophe (lephilousophe at users.noreply.github.com)
Date: 2022-04-03T22:17:19+02:00
Commit Message:
OPENGL: Allow engines to detect OpenGL info without switching
For now only OpenGL type and shaders support are available
Changed paths:
backends/platform/android/android.cpp
backends/platform/android/android.h
backends/platform/sdl/sdl.cpp
backends/platform/sdl/sdl.h
common/system.h
graphics/opengl/context.cpp
graphics/opengl/context.h
diff --git a/backends/platform/android/android.cpp b/backends/platform/android/android.cpp
index ff45e2e2438..007cb5c7b67 100644
--- a/backends/platform/android/android.cpp
+++ b/backends/platform/android/android.cpp
@@ -509,6 +509,8 @@ bool OSystem_Android::hasFeature(Feature f) {
/* Even if we are using the 2D graphics manager,
* we are at one initGraphics3d call of supporting GLES2 */
if (f == kFeatureOpenGLForGame) return true;
+ /* GLES2 always supports shaders */
+ if (f == kFeatureShadersForGame) return true;
return ModularGraphicsBackend::hasFeature(f);
}
diff --git a/backends/platform/android/android.h b/backends/platform/android/android.h
index 75fe0d8cddc..35a5a66cebc 100644
--- a/backends/platform/android/android.h
+++ b/backends/platform/android/android.h
@@ -192,6 +192,8 @@ public:
bool setGraphicsMode(int mode, uint flags) override;
int getGraphicsMode() const override;
+ OpenGL::ContextOGLType getOpenGLType() const override { return OpenGL::kOGLContextGLES2; }
+
#ifdef ANDROID_DEBUG_GL_CALLS
bool isRunningInMainThread() { return pthread_self() == _main_thread; }
#endif
diff --git a/backends/platform/sdl/sdl.cpp b/backends/platform/sdl/sdl.cpp
index cdf834db336..a25e91587a7 100644
--- a/backends/platform/sdl/sdl.cpp
+++ b/backends/platform/sdl/sdl.cpp
@@ -184,6 +184,7 @@ bool OSystem_SDL::hasFeature(Feature f) {
/* Even if we are using the 2D graphics manager,
* we are at one initGraphics3d call of supporting OpenGL */
if (f == kFeatureOpenGLForGame) return true;
+ if (f == kFeatureShadersForGame) return _supportsShaders;
#endif
return ModularGraphicsBackend::hasFeature(f);
}
@@ -221,7 +222,7 @@ void OSystem_SDL::initBackend() {
debug(1, "Using SDL Video Driver \"%s\"", sdlDriverName);
#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
- detectFramebufferSupport();
+ detectOpenGLFeaturesSupport();
detectAntiAliasingSupport();
#endif
@@ -318,11 +319,15 @@ void OSystem_SDL::initBackend() {
}
#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
-void OSystem_SDL::detectFramebufferSupport() {
+void OSystem_SDL::detectOpenGLFeaturesSupport() {
+ _oglType = OpenGL::kOGLContextNone;
_supportsFrameBuffer = false;
+ _supportsShaders = false;
#if USE_FORCED_GLES2
- // Framebuffers are always available with GLES2
+ // Framebuffers and shaders are always available with GLES2
+ _oglType = kOGLContextGLES2;
_supportsFrameBuffer = true;
+ _supportsShaders = true;
#elif !defined(AMIGAOS) && !defined(__MORPHOS__)
// Spawn a 32x32 window off-screen with a GL context to test if framebuffers are supported
#if SDL_VERSION_ATLEAST(2, 0, 0)
@@ -332,7 +337,6 @@ void OSystem_SDL::detectFramebufferSupport() {
}
int glContextProfileMask, glContextMajor;
- OpenGL::ContextOGLType glContextType;
if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &glContextProfileMask) != 0) {
SDL_DestroyWindow(window);
return;
@@ -343,13 +347,13 @@ void OSystem_SDL::detectFramebufferSupport() {
return;
}
if (glContextMajor == 2) {
- glContextType = OpenGL::kOGLContextGLES2;
+ _oglType = OpenGL::kOGLContextGLES2;
} else {
SDL_DestroyWindow(window);
return;
}
} else {
- glContextType = OpenGL::kOGLContextGL;
+ _oglType = OpenGL::kOGLContextGL;
}
SDL_GLContext glContext = SDL_GL_CreateContext(window);
if (!glContext) {
@@ -357,8 +361,9 @@ void OSystem_SDL::detectFramebufferSupport() {
return;
}
- OpenGLContext.initialize(glContextType);
+ OpenGLContext.initialize(_oglType);
_supportsFrameBuffer = OpenGLContext.framebufferObjectSupported;
+ _supportsShaders = OpenGLContext.shadersSupported;
OpenGLContext.reset();
SDL_GL_DeleteContext(glContext);
SDL_DestroyWindow(window);
@@ -367,8 +372,10 @@ void OSystem_SDL::detectFramebufferSupport() {
SDL_SetVideoMode(32, 32, 0, SDL_OPENGL);
SDL_putenv(const_cast<char *>("SDL_VIDEO_WINDOW_POS=center"));
// SDL 1.2 only supports OpenGL
- OpenGLContext.initialize(OpenGL::kOGLContextGL);
+ _oglType = OpenGL::kOGLContextGL;
+ OpenGLContext.initialize(_oglType);
_supportsFrameBuffer = OpenGLContext.framebufferObjectSupported;
+ _supportsShaders = OpenGLContext.shadersSupported;
OpenGLContext.reset();
#endif
#endif
diff --git a/backends/platform/sdl/sdl.h b/backends/platform/sdl/sdl.h
index 5de4e01343e..3569db2c966 100644
--- a/backends/platform/sdl/sdl.h
+++ b/backends/platform/sdl/sdl.h
@@ -95,6 +95,7 @@ public:
#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
Common::Array<uint> getSupportedAntiAliasingLevels() const override;
+ OpenGL::ContextOGLType getOpenGLType() const override { return _oglType; }
#endif
protected:
@@ -139,10 +140,12 @@ protected:
#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
// Graphics capabilities
- void detectFramebufferSupport();
+ void detectOpenGLFeaturesSupport();
void detectAntiAliasingSupport();
+ OpenGL::ContextOGLType _oglType;
bool _supportsFrameBuffer;
+ bool _supportsShaders;
Common::Array<uint> _antiAliasLevels;
#endif
diff --git a/common/system.h b/common/system.h
index 315dff4f751..34db3d089cb 100644
--- a/common/system.h
+++ b/common/system.h
@@ -29,6 +29,7 @@
#include "common/ustr.h"
#include "graphics/pixelformat.h"
#include "graphics/mode.h"
+#include "graphics/opengl/context.h"
namespace Audio {
class Mixer;
@@ -406,6 +407,12 @@ public:
*/
kFeatureOpenGLForGame,
+ /**
+ * This feature flag can be used to check if shaders are supported
+ * and can be used for 3D game rendering.
+ */
+ kFeatureShadersForGame,
+
/**
* If supported, this feature flag can be used to check if
* waiting for vertical sync before refreshing the screen to reduce
@@ -728,6 +735,20 @@ public:
return Common::Array<uint>();
}
+ /**
+ * Return the chosen OpenGL type.
+ *
+ * This function works even when a 2D graphical manager is active and
+ * let to select a proper renderer before changing mode.
+ * Implementation having feature kFeatureOpenGLForGame are expected to
+ * override this function.
+ *
+ * @return the OpenGL type of context which is supported.
+ */
+ virtual OpenGL::ContextOGLType getOpenGLType() const {
+ return OpenGL::kOGLContextNone;
+ }
+
/**
* Retrieve a list of all hardware shaders supported by this backend.
*
diff --git a/graphics/opengl/context.cpp b/graphics/opengl/context.cpp
index 8ad8fb1e4d1..c2029a2f169 100644
--- a/graphics/opengl/context.cpp
+++ b/graphics/opengl/context.cpp
@@ -71,6 +71,7 @@ ContextGL::ContextGL() {
}
void ContextGL::reset() {
+ type = kOGLContextNone;
maxTextureSize = 0;
NPOTSupported = false;
@@ -86,6 +87,9 @@ void ContextGL::reset() {
void ContextGL::initialize(ContextOGLType contextType) {
// Initialize default state.
reset();
+ if (contextType == kOGLContextNone) {
+ return;
+ }
type = contextType;
@@ -178,6 +182,9 @@ void ContextGL::initialize(ContextOGLType contextType) {
// Log context type.
switch (type) {
+ case kOGLContextNone:
+ /* Shouldn't happen */
+ break;
case kOGLContextGL:
debug(5, "OpenGL: GL context initialized");
break;
diff --git a/graphics/opengl/context.h b/graphics/opengl/context.h
index 6d1992be554..bfe0642b6bb 100644
--- a/graphics/opengl/context.h
+++ b/graphics/opengl/context.h
@@ -27,6 +27,7 @@
namespace OpenGL {
enum ContextOGLType {
+ kOGLContextNone,
kOGLContextGL,
kOGLContextGLES2
};
Commit: 1e4696f6d0c82efc6aa2e644545baf8537c83df4
https://github.com/scummvm/scummvm/commit/1e4696f6d0c82efc6aa2e644545baf8537c83df4
Author: Le Philousophe (lephilousophe at users.noreply.github.com)
Date: 2022-04-03T22:17:19+02:00
Commit Message:
OPENGL: Rework renderer selection code
Add a class to group all renderer related (static) functions.
This allows to have getBestMatchingAvailableType inline in all engines.
The matching code is now shared between all engines but allows
customization for engines needing it (Grim, WME3D).
The new code takes runtime availability of features to select the
best renderer.
It avoid crashes when user choosed OpenGL but GLES2 is used.
Changed paths:
base/commandLine.cpp
engines/grim/debugger.cpp
engines/grim/grim.cpp
engines/grim/lua_v1.cpp
engines/myst3/gfx.cpp
engines/myst3/myst3.cpp
engines/playground3d/gfx.cpp
engines/playground3d/playground3d.cpp
engines/stark/gfx/driver.cpp
engines/stark/stark.cpp
engines/wintermute/base/base_game.cpp
graphics/renderer.cpp
graphics/renderer.h
gui/options.cpp
diff --git a/base/commandLine.cpp b/base/commandLine.cpp
index 407d4d945f0..fc885ca1953 100644
--- a/base/commandLine.cpp
+++ b/base/commandLine.cpp
@@ -783,7 +783,7 @@ Common::String parseCommandLine(Common::StringMap &settings, int argc, const cha
END_OPTION
DO_LONG_OPTION("renderer")
- Graphics::RendererType renderer = Graphics::parseRendererTypeCode(option);
+ Graphics::RendererType renderer = Graphics::Renderer::parseTypeCode(option);
if (renderer == Graphics::kRendererTypeDefault)
usage("Unrecognized renderer type '%s'", option);
END_OPTION
diff --git a/engines/grim/debugger.cpp b/engines/grim/debugger.cpp
index 5b844475c47..0c575eca645 100644
--- a/engines/grim/debugger.cpp
+++ b/engines/grim/debugger.cpp
@@ -95,13 +95,13 @@ bool Debugger::cmd_set_renderer(int argc, const char **argv) {
return true;
}
- Graphics::RendererType renderer = Graphics::parseRendererTypeCode(argv[1]);
+ Graphics::RendererType renderer = Graphics::Renderer::parseTypeCode(argv[1]);
if (renderer == Graphics::kRendererTypeDefault) {
debugPrintf("Invalid renderer '%s'\n", argv[1]);
return true;
}
- ConfMan.set("renderer", Graphics::getRendererTypeCode(renderer));
+ ConfMan.set("renderer", Graphics::Renderer::getTypeCode(renderer));
g_grim->changeHardwareState();
return false;
}
diff --git a/engines/grim/grim.cpp b/engines/grim/grim.cpp
index 2debac53bee..54099f7205d 100644
--- a/engines/grim/grim.cpp
+++ b/engines/grim/grim.cpp
@@ -261,47 +261,45 @@ LuaBase *GrimEngine::createLua() {
GfxBase *GrimEngine::createRenderer(int screenW, int screenH) {
Common::String rendererConfig = ConfMan.get("renderer");
- Graphics::RendererType desiredRendererType = Graphics::parseRendererTypeCode(rendererConfig);
- Graphics::RendererType matchingRendererType = Graphics::getBestMatchingAvailableRendererType(desiredRendererType);
-
- _softRenderer = matchingRendererType == Graphics::kRendererTypeTinyGL;
- if (!_softRenderer) {
- initGraphics3d(screenW, screenH);
- } else {
- initGraphics(screenW, screenH, nullptr);
- }
-
-#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
- bool backendCapableOpenGL = g_system->hasFeature(OSystem::kFeatureOpenGLForGame);
-#endif
+ Graphics::RendererType desiredRendererType = Graphics::Renderer::parseTypeCode(rendererConfig);
+ uint32 availableRendererTypes = Graphics::Renderer::getAvailableTypes();
+ availableRendererTypes &=
#if defined(USE_OPENGL_GAME)
- // Check the OpenGL context actually supports shaders
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGLShaders && !OpenGLContext.shadersSupported) {
- matchingRendererType = Graphics::kRendererTypeOpenGL;
- }
+ Graphics::kRendererTypeOpenGL |
+#endif
+#if defined(USE_OPENGL_SHADERS)
+ Graphics::kRendererTypeOpenGLShaders |
+#endif
+#if defined(USE_TINYGL)
+ Graphics::kRendererTypeTinyGL |
+#endif
+ 0;
- // For Grim Fandango, OpenGL renderer without shaders is preferred
+ // For Grim Fandango, OpenGL renderer without shaders is preferred if available
if (desiredRendererType == Graphics::kRendererTypeDefault &&
- matchingRendererType == Graphics::kRendererTypeOpenGLShaders &&
+ (availableRendererTypes & Graphics::kRendererTypeOpenGL) &&
getGameType() == GType_GRIM) {
- matchingRendererType = Graphics::kRendererTypeOpenGL;
+ availableRendererTypes &= ~Graphics::kRendererTypeOpenGLShaders;
}
-#endif
- if (matchingRendererType != desiredRendererType && desiredRendererType != Graphics::kRendererTypeDefault) {
- // Display a warning if unable to use the desired renderer
- warning("Unable to create a '%s' renderer", rendererConfig.c_str());
+ Graphics::RendererType matchingRendererType = Graphics::Renderer::getBestMatchingType(desiredRendererType, availableRendererTypes);
+
+ _softRenderer = matchingRendererType == Graphics::kRendererTypeTinyGL;
+ if (!_softRenderer) {
+ initGraphics3d(screenW, screenH);
+ } else {
+ initGraphics(screenW, screenH, nullptr);
}
GfxBase *renderer = nullptr;
#if defined(USE_OPENGL_SHADERS)
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGLShaders) {
+ if (matchingRendererType == Graphics::kRendererTypeOpenGLShaders) {
renderer = CreateGfxOpenGLShader();
}
#endif
#if defined(USE_OPENGL_GAME)
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGL) {
+ if (matchingRendererType == Graphics::kRendererTypeOpenGL) {
renderer = CreateGfxOpenGL();
}
#endif
@@ -310,8 +308,10 @@ GfxBase *GrimEngine::createRenderer(int screenW, int screenH) {
renderer = CreateGfxTinyGL();
}
#endif
+
if (!renderer) {
- error("Unable to create a '%s' renderer", rendererConfig.c_str());
+ /* We should never end up here, getBestMatchingRendererType would have failed before */
+ error("Unable to create a renderer");
}
renderer->setupScreen(screenW, screenH);
diff --git a/engines/grim/lua_v1.cpp b/engines/grim/lua_v1.cpp
index a595114ee04..25e6aac29d0 100644
--- a/engines/grim/lua_v1.cpp
+++ b/engines/grim/lua_v1.cpp
@@ -289,8 +289,18 @@ void Lua_V1::SetHardwareState() {
bool accel = getbool(1);
Graphics::RendererType renderer = accel ? Graphics::kRendererTypeOpenGL : Graphics::kRendererTypeTinyGL;
- renderer = Graphics::getBestMatchingAvailableRendererType(renderer);
- ConfMan.set("renderer", Graphics::getRendererTypeCode(renderer));
+ renderer = Graphics::Renderer::getBestMatchingAvailableType(renderer,
+#if defined(USE_OPENGL_GAME)
+ Graphics::kRendererTypeOpenGL |
+#endif
+#if defined(USE_OPENGL_SHADERS)
+ Graphics::kRendererTypeOpenGLShaders |
+#endif
+#if defined(USE_TINYGL)
+ Graphics::kRendererTypeTinyGL |
+#endif
+ 0);
+ ConfMan.set("renderer", Graphics::Renderer::getTypeCode(renderer));
g_grim->changeHardwareState();
}
diff --git a/engines/myst3/gfx.cpp b/engines/myst3/gfx.cpp
index 36d400636f3..8c145e836f3 100644
--- a/engines/myst3/gfx.cpp
+++ b/engines/myst3/gfx.cpp
@@ -189,8 +189,18 @@ void Renderer::flipVertical(Graphics::Surface *s) {
Renderer *createRenderer(OSystem *system) {
Common::String rendererConfig = ConfMan.get("renderer");
- Graphics::RendererType desiredRendererType = Graphics::parseRendererTypeCode(rendererConfig);
- Graphics::RendererType matchingRendererType = Graphics::getBestMatchingAvailableRendererType(desiredRendererType);
+ Graphics::RendererType desiredRendererType = Graphics::Renderer::parseTypeCode(rendererConfig);
+ Graphics::RendererType matchingRendererType = Graphics::Renderer::getBestMatchingAvailableType(desiredRendererType,
+#if defined(USE_OPENGL_GAME)
+ Graphics::kRendererTypeOpenGL |
+#endif
+#if defined(USE_OPENGL_SHADERS)
+ Graphics::kRendererTypeOpenGLShaders |
+#endif
+#if defined(USE_TINYGL)
+ Graphics::kRendererTypeTinyGL |
+#endif
+ 0);
bool isAccelerated = matchingRendererType != Graphics::kRendererTypeTinyGL;
@@ -208,29 +218,13 @@ Renderer *createRenderer(OSystem *system) {
initGraphics(width, height, nullptr);
}
-#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
- bool backendCapableOpenGL = g_system->hasFeature(OSystem::kFeatureOpenGLForGame);
-#endif
-
-#if defined(USE_OPENGL_GAME)
- // Check the OpenGL context actually supports shaders
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGLShaders && !OpenGLContext.shadersSupported) {
- matchingRendererType = Graphics::kRendererTypeOpenGL;
- }
-#endif
-
- if (matchingRendererType != desiredRendererType && desiredRendererType != Graphics::kRendererTypeDefault) {
- // Display a warning if unable to use the desired renderer
- warning("Unable to create a '%s' renderer", rendererConfig.c_str());
- }
-
#if defined(USE_OPENGL_SHADERS)
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGLShaders) {
+ if (matchingRendererType == Graphics::kRendererTypeOpenGLShaders) {
return CreateGfxOpenGLShader(system);
}
#endif
#if defined(USE_OPENGL_GAME)
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGL) {
+ if (matchingRendererType == Graphics::kRendererTypeOpenGL) {
return CreateGfxOpenGL(system);
}
#endif
@@ -239,7 +233,8 @@ Renderer *createRenderer(OSystem *system) {
return CreateGfxTinyGL(system);
}
#endif
- error("Unable to create a '%s' renderer", rendererConfig.c_str());
+ /* We should never end up here, getBestMatchingRendererType would have failed before */
+ error("Unable to create a renderer");
}
void Renderer::renderDrawable(Drawable *drawable, Window *window) {
diff --git a/engines/myst3/myst3.cpp b/engines/myst3/myst3.cpp
index 11efa3e72c5..6c98e1009d7 100644
--- a/engines/myst3/myst3.cpp
+++ b/engines/myst3/myst3.cpp
@@ -127,8 +127,18 @@ Myst3Engine::~Myst3Engine() {
bool Myst3Engine::hasFeature(EngineFeature f) const {
// The TinyGL renderer does not support arbitrary resolutions for now
Common::String rendererConfig = ConfMan.get("renderer");
- Graphics::RendererType desiredRendererType = Graphics::parseRendererTypeCode(rendererConfig);
- Graphics::RendererType matchingRendererType = Graphics::getBestMatchingAvailableRendererType(desiredRendererType);
+ Graphics::RendererType desiredRendererType = Graphics::Renderer::parseTypeCode(rendererConfig);
+ Graphics::RendererType matchingRendererType = Graphics::Renderer::getBestMatchingAvailableType(desiredRendererType,
+#if defined(USE_OPENGL_GAME)
+ Graphics::kRendererTypeOpenGL |
+#endif
+#if defined(USE_OPENGL_SHADERS)
+ Graphics::kRendererTypeOpenGLShaders |
+#endif
+#if defined(USE_TINYGL)
+ Graphics::kRendererTypeTinyGL |
+#endif
+ 0);
bool softRenderer = matchingRendererType == Graphics::kRendererTypeTinyGL;
return
diff --git a/engines/playground3d/gfx.cpp b/engines/playground3d/gfx.cpp
index 2f30f063cf2..9e101cd6fd9 100644
--- a/engines/playground3d/gfx.cpp
+++ b/engines/playground3d/gfx.cpp
@@ -113,8 +113,18 @@ void Renderer::setupCameraPerspective(float pitch, float heading, float fov) {
Renderer *createRenderer(OSystem *system) {
Common::String rendererConfig = ConfMan.get("renderer");
- Graphics::RendererType desiredRendererType = Graphics::parseRendererTypeCode(rendererConfig);
- Graphics::RendererType matchingRendererType = Graphics::getBestMatchingAvailableRendererType(desiredRendererType);
+ Graphics::RendererType desiredRendererType = Graphics::Renderer::parseTypeCode(rendererConfig);
+ Graphics::RendererType matchingRendererType = Graphics::Renderer::getBestMatchingAvailableType(desiredRendererType,
+#if defined(USE_OPENGL_GAME)
+ Graphics::kRendererTypeOpenGL |
+#endif
+#if defined(USE_OPENGL_SHADERS)
+ Graphics::kRendererTypeOpenGLShaders |
+#endif
+#if defined(USE_TINYGL)
+ Graphics::kRendererTypeTinyGL |
+#endif
+ 0);
bool isAccelerated = matchingRendererType != Graphics::kRendererTypeTinyGL;
@@ -127,29 +137,13 @@ Renderer *createRenderer(OSystem *system) {
initGraphics(width, height, nullptr);
}
-#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
- bool backendCapableOpenGL = g_system->hasFeature(OSystem::kFeatureOpenGLForGame);
-#endif
-
-#if defined(USE_OPENGL_GAME)
- // Check the OpenGL context actually supports shaders
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGLShaders && !OpenGLContext.shadersSupported) {
- matchingRendererType = Graphics::kRendererTypeOpenGL;
- }
-#endif
-
- if (matchingRendererType != desiredRendererType && desiredRendererType != Graphics::kRendererTypeDefault) {
- // Display a warning if unable to use the desired renderer
- warning("Unable to create a '%s' renderer", rendererConfig.c_str());
- }
-
#if defined(USE_OPENGL_SHADERS)
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGLShaders) {
+ if (matchingRendererType == Graphics::kRendererTypeOpenGLShaders) {
return CreateGfxOpenGLShader(system);
}
#endif
#if defined(USE_OPENGL_GAME)
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGL) {
+ if (matchingRendererType == Graphics::kRendererTypeOpenGL) {
return CreateGfxOpenGL(system);
}
#endif
@@ -159,7 +153,8 @@ Renderer *createRenderer(OSystem *system) {
}
#endif
- error("Unable to create a '%s' renderer", rendererConfig.c_str());
+ /* We should never end up here, getBestMatchingRendererType would have failed before */
+ error("Unable to create a renderer");
}
} // End of namespace Playground3d
diff --git a/engines/playground3d/playground3d.cpp b/engines/playground3d/playground3d.cpp
index f024682b386..768dbb38b81 100644
--- a/engines/playground3d/playground3d.cpp
+++ b/engines/playground3d/playground3d.cpp
@@ -34,8 +34,18 @@ namespace Playground3d {
bool Playground3dEngine::hasFeature(EngineFeature f) const {
// The TinyGL renderer does not support arbitrary resolutions for now
Common::String rendererConfig = ConfMan.get("renderer");
- Graphics::RendererType desiredRendererType = Graphics::parseRendererTypeCode(rendererConfig);
- Graphics::RendererType matchingRendererType = Graphics::getBestMatchingAvailableRendererType(desiredRendererType);
+ Graphics::RendererType desiredRendererType = Graphics::Renderer::parseTypeCode(rendererConfig);
+ Graphics::RendererType matchingRendererType = Graphics::Renderer::getBestMatchingAvailableType(desiredRendererType,
+#if defined(USE_OPENGL_GAME)
+ Graphics::kRendererTypeOpenGL |
+#endif
+#if defined(USE_OPENGL_SHADERS)
+ Graphics::kRendererTypeOpenGLShaders |
+#endif
+#if defined(USE_TINYGL)
+ Graphics::kRendererTypeTinyGL |
+#endif
+ 0);
bool softRenderer = matchingRendererType == Graphics::kRendererTypeTinyGL;
return
diff --git a/engines/stark/gfx/driver.cpp b/engines/stark/gfx/driver.cpp
index cef32fd433e..93ef6647ddc 100644
--- a/engines/stark/gfx/driver.cpp
+++ b/engines/stark/gfx/driver.cpp
@@ -44,49 +44,43 @@ namespace Gfx {
Driver *Driver::create() {
Common::String rendererConfig = ConfMan.get("renderer");
- Graphics::RendererType desiredRendererType = Graphics::parseRendererTypeCode(rendererConfig);
- Graphics::RendererType matchingRendererType = Graphics::getBestMatchingAvailableRendererType(desiredRendererType);
+ Graphics::RendererType desiredRendererType = Graphics::Renderer::parseTypeCode(rendererConfig);
+ Graphics::RendererType matchingRendererType = Graphics::Renderer::getBestMatchingAvailableType(desiredRendererType,
+#if defined(USE_OPENGL_GAME)
+ Graphics::kRendererTypeOpenGL |
+#endif
+#if defined(USE_OPENGL_SHADERS)
+ Graphics::kRendererTypeOpenGLShaders |
+#endif
+#if defined(USE_TINYGL)
+ Graphics::kRendererTypeTinyGL |
+#endif
+ 0);
-#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
bool softRenderer = matchingRendererType == Graphics::kRendererTypeTinyGL;
if (!softRenderer) {
initGraphics3d(kOriginalWidth, kOriginalHeight);
} else {
-#endif
initGraphics(kOriginalWidth, kOriginalHeight, nullptr);
-#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
- }
-#endif
-
- if (matchingRendererType != desiredRendererType && desiredRendererType != Graphics::kRendererTypeDefault) {
- // Display a warning if unable to use the desired renderer
- warning("Unable to match a '%s' renderer", rendererConfig.c_str());
}
- Driver *driver = nullptr;
-
#if defined(USE_OPENGL_SHADERS)
- bool backendCapableOpenGLShaders = g_system->hasFeature(OSystem::kFeatureOpenGLForGame) && OpenGLContext.shadersSupported;
- if (backendCapableOpenGLShaders && matchingRendererType == Graphics::kRendererTypeOpenGLShaders) {
- driver = new OpenGLSDriver();
+ if (matchingRendererType == Graphics::kRendererTypeOpenGLShaders) {
+ return new OpenGLSDriver();
}
#endif
#if defined(USE_OPENGL_GAME)
- bool backendCapableOpenGL = g_system->hasFeature(OSystem::kFeatureOpenGLForGame);
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGL) {
- driver = new OpenGLDriver();
+ if (matchingRendererType == Graphics::kRendererTypeOpenGL) {
+ return new OpenGLDriver();
}
#endif
#if defined(USE_TINYGL)
if (matchingRendererType == Graphics::kRendererTypeTinyGL) {
- driver = new TinyGLDriver();
+ return new TinyGLDriver();
}
#endif
- if (driver)
- return driver;
- warning("No renderers have been found for this game");
- GUI::displayErrorDialog(Common::U32String::format(_("No renderers have been found for this game")));
- return driver;
+ /* We should never end up here, getBestMatchingRendererType would have failed before */
+ error("Unable to create a renderer");
}
const Graphics::PixelFormat Driver::getRGBAPixelFormat() {
diff --git a/engines/stark/stark.cpp b/engines/stark/stark.cpp
index 435c67c6401..b4b561716d3 100644
--- a/engines/stark/stark.cpp
+++ b/engines/stark/stark.cpp
@@ -336,8 +336,18 @@ void StarkEngine::checkRecommendedDatafiles() {
bool StarkEngine::hasFeature(EngineFeature f) const {
// The TinyGL renderer does not support arbitrary resolutions for now
Common::String rendererConfig = ConfMan.get("renderer");
- Graphics::RendererType desiredRendererType = Graphics::parseRendererTypeCode(rendererConfig);
- Graphics::RendererType matchingRendererType = Graphics::getBestMatchingAvailableRendererType(desiredRendererType);
+ Graphics::RendererType desiredRendererType = Graphics::Renderer::parseTypeCode(rendererConfig);
+ Graphics::RendererType matchingRendererType = Graphics::Renderer::getBestMatchingAvailableType(desiredRendererType,
+#if defined(USE_OPENGL_GAME)
+ Graphics::kRendererTypeOpenGL |
+#endif
+#if defined(USE_OPENGL_SHADERS)
+ Graphics::kRendererTypeOpenGLShaders |
+#endif
+#if defined(USE_TINYGL)
+ Graphics::kRendererTypeTinyGL |
+#endif
+ 0);
bool softRenderer = matchingRendererType == Graphics::kRendererTypeTinyGL;
return
diff --git a/engines/wintermute/base/base_game.cpp b/engines/wintermute/base/base_game.cpp
index 5e85319e5d6..fb13200e986 100644
--- a/engines/wintermute/base/base_game.cpp
+++ b/engines/wintermute/base/base_game.cpp
@@ -502,63 +502,60 @@ bool BaseGame::initialize1() {
bool BaseGame::initialize2() { // we know whether we are going to be accelerated
#ifdef ENABLE_WME3D
Common::String rendererConfig = ConfMan.get("renderer");
- Graphics::RendererType desiredRendererType = Graphics::parseRendererTypeCode(rendererConfig);
- Graphics::RendererType matchingRendererType = Graphics::getBestMatchingAvailableRendererType(desiredRendererType);
-
- if (!_playing3DGame && (desiredRendererType == Graphics::kRendererTypeTinyGL || desiredRendererType == Graphics::kRendererTypeDefault)) {
- _renderer = makeOSystemRenderer(this);
- if (_renderer == nullptr) {
- return STATUS_FAILED;
- }
- return STATUS_OK;
- }
-
-#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
- initGraphics3d(_settings->getResWidth(), _settings->getResHeight());
- bool backendCapableOpenGL = g_system->hasFeature(OSystem::kFeatureOpenGLForGame);
-#endif
+ Graphics::RendererType desiredRendererType = Graphics::Renderer::parseTypeCode(rendererConfig);
+ uint32 availableRendererTypes = Graphics::Renderer::getAvailableTypes();
+ availableRendererTypes &=
#if defined(USE_OPENGL_GAME)
- // Check the OpenGL context actually supports shaders
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGLShaders && !OpenGLContext.shadersSupported) {
- matchingRendererType = Graphics::kRendererTypeOpenGL;
- }
+ Graphics::kRendererTypeOpenGL |
+#endif
+#if defined(USE_OPENGL_SHADERS)
+ Graphics::kRendererTypeOpenGLShaders |
+#endif
+#if defined(USE_TINYGL)
+ Graphics::kRendererTypeTinyGL |
#endif
+ 0;
- if (matchingRendererType != desiredRendererType && desiredRendererType != Graphics::kRendererTypeDefault) {
- // Display a warning if unable to use the desired renderer
- warning("Unable to create a '%s' renderer", rendererConfig.c_str());
+ /* When playing 2D, TinyGL is not really TinyGL but software and is always available */
+ if (!_playing3DGame) {
+ availableRendererTypes |= Graphics::kRendererTypeTinyGL;
}
-#if defined(USE_OPENGL_SHADERS)
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGLShaders) {
+ Graphics::RendererType matchingRendererType = Graphics::Renderer::getBestMatchingType(desiredRendererType, availableRendererTypes);
+
+ #if defined(USE_OPENGL_SHADERS)
+ if (matchingRendererType == Graphics::kRendererTypeOpenGLShaders) {
+ initGraphics3d(_settings->getResWidth(), _settings->getResHeight());
_renderer3D = makeOpenGL3DShaderRenderer(this);
}
-#endif // defined(USE_OPENGL_SHADERS)
-#if defined(USE_OPENGL_GAME)
- if (backendCapableOpenGL && matchingRendererType == Graphics::kRendererTypeOpenGL) {
+ #endif // defined(USE_OPENGL_SHADERS)
+ #if defined(USE_OPENGL_GAME)
+ if (matchingRendererType == Graphics::kRendererTypeOpenGL) {
+ initGraphics3d(_settings->getResWidth(), _settings->getResHeight());
_renderer3D = makeOpenGL3DRenderer(this);
}
-#endif // defined(USE_OPENGL)
-#if defined(USE_TINYGL)
- if (_playing3DGame && matchingRendererType == Graphics::kRendererTypeTinyGL) {
- _renderer3D = nullptr;// TODO: makeTinyGL3DRenderer(this);
- error("3D software renderered is not supported yet");
+ #endif // defined(USE_OPENGL)
+ if (matchingRendererType == Graphics::kRendererTypeTinyGL) {
+ if (_playing3DGame) {
+ _renderer3D = nullptr;// TODO: makeTinyGL3DRenderer(this);
+ error("3D software renderered is not supported yet");
+ }
}
-#endif
_renderer = _renderer3D;
-#if !defined(USE_OPENGL_GAME) && !defined(USE_OPENGL_SHADERS)
- if (!_playing3DGame && !_renderer3D)
+
+ if (!_renderer && !_playing3DGame) {
_renderer = makeOSystemRenderer(this);
-#endif
+ }
#else
_renderer = makeOSystemRenderer(this);
#endif
+
if (_renderer == nullptr) {
return STATUS_FAILED;
+ } else {
+ return STATUS_OK;
}
-
- return STATUS_OK;
}
diff --git a/graphics/renderer.cpp b/graphics/renderer.cpp
index 636f880433a..b3b42bed9f2 100644
--- a/graphics/renderer.cpp
+++ b/graphics/renderer.cpp
@@ -22,6 +22,9 @@
#include "graphics/renderer.h"
#include "common/translation.h"
+#include "common/system.h"
+
+#include "graphics/opengl/context.h"
namespace Graphics {
@@ -40,12 +43,12 @@ static const RendererTypeDescription rendererTypes[] = {
DECLARE_TRANSLATION_ADDITIONAL_CONTEXT("OpenGL with shaders", "lowres")
-const RendererTypeDescription *listRendererTypes() {
+const RendererTypeDescription *Renderer::listTypes() {
return rendererTypes;
}
-RendererType parseRendererTypeCode(const Common::String &code) {
- const RendererTypeDescription *rt = listRendererTypes();
+RendererType Renderer::parseTypeCode(const Common::String &code) {
+ const RendererTypeDescription *rt = listTypes();
while (rt->code) {
if (rt->code == code) {
return rt->id;
@@ -56,8 +59,8 @@ RendererType parseRendererTypeCode(const Common::String &code) {
return kRendererTypeDefault;
}
-Common::String getRendererTypeCode(RendererType type) {
- const RendererTypeDescription *rt = listRendererTypes();
+Common::String Renderer::getTypeCode(RendererType type) {
+ const RendererTypeDescription *rt = listTypes();
while (rt->code) {
if (rt->id == type) {
return rt->code;
@@ -68,30 +71,62 @@ Common::String getRendererTypeCode(RendererType type) {
return "";
}
-RendererType getBestMatchingAvailableRendererType(RendererType desired) {
- if (desired == kRendererTypeDefault) {
- desired = kRendererTypeOpenGLShaders;
+uint32 Renderer::getAvailableTypes() {
+ uint32 available = 0;
+
+#if defined(USE_TINYGL)
+ /* TinyGL doesn't depend on hardware support */
+ available |= kRendererTypeTinyGL;
+#endif
+
+#if defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS)
+ bool backendCapableOpenGL = g_system->hasFeature(OSystem::kFeatureOpenGLForGame);
+
+ if (backendCapableOpenGL) {
+ /* Backend either support OpenGL or OpenGL ES(2) */
+#if defined(USE_OPENGL_GAME)
+ /* OpenGL classic is compiled in, check if hardware supports it */
+ if (g_system->getOpenGLType() == OpenGL::kOGLContextGL) {
+ available |= kRendererTypeOpenGL;
+ }
+#endif
+#if defined(USE_OPENGL_SHADERS)
+ /* OpenGL with shaders is compiled in, check if hardware supports it */
+ if (g_system->hasFeature(OSystem::kFeatureShadersForGame)) {
+ available |= kRendererTypeOpenGLShaders;
+ }
+#endif
}
+#endif // defined(USE_OPENGL_GAME) || defined(USE_OPENGL_SHADERS
+ return available;
+}
-#if !defined(USE_OPENGL_SHADERS)
- if (desired == kRendererTypeOpenGLShaders) {
- desired = kRendererTypeOpenGL;
+RendererType Renderer::getBestMatchingType(RendererType desired, uint32 available) {
+ /* What we want is possible */
+ if (available & desired) {
+ return desired;
}
-#endif
-#if (!defined(USE_OPENGL_GAME) && defined(USE_OPENGL_SHADERS))
- if (desired == kRendererTypeOpenGL) {
- desired = kRendererTypeOpenGLShaders;
+ /* We apply the same logic when nothing is desired and when what we want is not possible */
+ if (desired != kRendererTypeDefault) {
+ warning("Unable to create a '%s' renderer", getTypeCode(desired).c_str());
}
-#endif
-#if !defined(USE_OPENGL_GAME) && !defined(USE_OPENGL_SHADERS)
- if (desired == kRendererTypeOpenGL || desired == kRendererTypeOpenGLShaders) {
- desired = kRendererTypeTinyGL;
+ /* Shaders are the best experience */
+ if (available & kRendererTypeOpenGLShaders) {
+ return kRendererTypeOpenGLShaders;
+ }
+ /* then OpenGL */
+ if (available & kRendererTypeOpenGL) {
+ return kRendererTypeOpenGL;
+ }
+ /* then TinyGL */
+ if (available & kRendererTypeTinyGL) {
+ return kRendererTypeTinyGL;
}
-#endif
- return desired;
+ /* Failure is not an option */
+ error("Unable to create a renderer");
}
} // End of namespace Graphics
diff --git a/graphics/renderer.h b/graphics/renderer.h
index 00d58cee629..33615d128bd 100644
--- a/graphics/renderer.h
+++ b/graphics/renderer.h
@@ -41,11 +41,11 @@ namespace Graphics {
*
* It specifies which rendering driver to use
*/
-enum RendererType {
+enum RendererType : uint32 {
kRendererTypeDefault = 0,
kRendererTypeOpenGL = 1,
kRendererTypeOpenGLShaders = 2,
- kRendererTypeTinyGL = 3
+ kRendererTypeTinyGL = 4
};
struct RendererTypeDescription {
@@ -54,16 +54,27 @@ struct RendererTypeDescription {
RendererType id;
};
-const RendererTypeDescription *listRendererTypes();
+class Renderer {
+public:
+ static const RendererTypeDescription *listTypes();
-/** Convert a renderer code to a RendererType enum value */
-RendererType parseRendererTypeCode(const Common::String &code);
+ /** Convert a renderer code to a RendererType enum value */
+ static RendererType parseTypeCode(const Common::String &code);
-/** Get a character string code from a RendererType enum value */
-Common::String getRendererTypeCode(RendererType type);
+ /** Get a character string code from a RendererType enum value */
+ static Common::String getTypeCode(RendererType type);
-/** Get the best matching renderer among available renderers */
-RendererType getBestMatchingAvailableRendererType(RendererType desired);
+ /** Get a bitmask of available renderers */
+ static uint32 getAvailableTypes();
+
+ /** Perform renderer selection amongst available ones */
+ static RendererType getBestMatchingType(RendererType desired, uint32 available);
+
+ /** Get the best matching renderer among available and supported renderers */
+ static RendererType getBestMatchingAvailableType(RendererType desired, uint32 supported) {
+ return getBestMatchingType(desired, getAvailableTypes() & supported);
+ }
+};
/** @} */
} // End of namespace Graphics
diff --git a/gui/options.cpp b/gui/options.cpp
index da87041e512..f3fb5a47f40 100644
--- a/gui/options.cpp
+++ b/gui/options.cpp
@@ -403,7 +403,7 @@ void OptionsDialog::build() {
_vsyncCheckbox->setState(ConfMan.getBool("vsync", _domain));
_rendererTypePopUp->setEnabled(true);
- _rendererTypePopUp->setSelectedTag(Graphics::parseRendererTypeCode(ConfMan.get("renderer", _domain)));
+ _rendererTypePopUp->setSelectedTag(Graphics::Renderer::parseTypeCode(ConfMan.get("renderer", _domain)));
_antiAliasPopUp->setEnabled(true);
if (ConfMan.hasKey("antialiasing", _domain)) {
@@ -642,7 +642,7 @@ void OptionsDialog::apply() {
if (_rendererTypePopUp->getSelectedTag() > 0) {
Graphics::RendererType selected = (Graphics::RendererType) _rendererTypePopUp->getSelectedTag();
- ConfMan.set("renderer", Graphics::getRendererTypeCode(selected), _domain);
+ ConfMan.set("renderer", Graphics::Renderer::getTypeCode(selected), _domain);
} else {
ConfMan.removeKey("renderer", _domain);
}
@@ -1446,7 +1446,7 @@ void OptionsDialog::addGraphicControls(GuiObject *boss, const Common::String &pr
_rendererTypePopUp = new PopUpWidget(boss, prefix + "grRendererTypePopup");
_rendererTypePopUp->appendEntry(_("<default>"), Graphics::kRendererTypeDefault);
_rendererTypePopUp->appendEntry("");
- const Graphics::RendererTypeDescription *rt = Graphics::listRendererTypes();
+ const Graphics::RendererTypeDescription *rt = Graphics::Renderer::listTypes();
for (; rt->code; ++rt) {
if (g_system->getOverlayWidth() > 320)
_rendererTypePopUp->appendEntry(_(rt->description), rt->id);
More information about the Scummvm-git-logs
mailing list