1 files changed, 133 insertions, 21 deletions
diff --git a/backends/graphics/opengl/opengl-sys.h b/backends/graphics/opengl/opengl-sys.h
index 4e21894380..4495128f32 100644
--- a/backends/graphics/opengl/opengl-sys.h
+++ b/backends/graphics/opengl/opengl-sys.h
@@ -23,35 +23,147 @@
 #ifndef BACKENDS_GRAPHICS_OPENGL_OPENGL_SYS_H
 #define BACKENDS_GRAPHICS_OPENGL_OPENGL_SYS_H
 
-// The purpose of this header is to include the OpenGL headers in an uniform
-// fashion. A notable example for a non standard port is the Tizen port.
-
 #include "common/scummsys.h"
 
-#ifdef WIN32
-#if defined(ARRAYSIZE) && !defined(_WINDOWS_)
-#undef ARRAYSIZE
-#endif
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#undef ARRAYSIZE
+#include "backends/graphics/opengl/debug.h"
+#ifdef SDL_BACKEND
+#include "backends/platform/sdl/sdl-sys.h"
 #endif
 
-// HACK: In case common/util.h has been included already we need to make sure
-// to define ARRAYSIZE again in case of Windows.
-#if !defined(ARRAYSIZE) && defined(COMMON_UTIL_H)
-#define ARRAYSIZE(x) ((int)(sizeof(x) / sizeof(x[0])))
+// On OS X we only support GL contexts. The reason is that Apple's GL interface
+// uses "void *" for GLhandleARB which is not type compatible with GLint. This
+// kills our aliasing trick for extension functions and thus would force us to
+// supply two different Shader class implementations or introduce other
+// wrappers. OS X only supports GL contexts right now anyway (at least
+// according to SDL2 sources), thus it is not much of an issue.
+#if defined(MACOSX) && (!defined(USE_GLES_MODE) || USE_GLES_MODE != 0)
+//#warning "Only forced OpenGL mode is supported on Mac OS X. Overriding settings."
+#undef USE_GLES_MODE
+#define USE_GLES_MODE 0
 #endif
 
+// We allow to force GL or GLES modes on compile time.
+// For this the USE_GLES_MODE define is used. The following values represent
+// the given selection choices:
+//  0 - Force OpenGL context
+//  1 - Force OpenGL ES context
+//  2 - Force OpenGL ES 2.0 context
+#define USE_FORCED_GL    (defined(USE_GLES_MODE) && USE_GLES_MODE == 0)
+#define USE_FORCED_GLES  (defined(USE_GLES_MODE) && USE_GLES_MODE == 1)
+#define USE_FORCED_GLES2 (defined(USE_GLES_MODE) && USE_GLES_MODE == 2)
+
+// On Tizen we include the toolchain's OpenGL file. This is something we
+// actually want to avoid. However, since Tizen uses eglGetProcAddress which
+// is not required to return valid function pointers to non OpenGL extension
+// functions, we need the system's definitions to resolve all OpenGL
+// functions.
+// TODO: See if there is an alternative which allows us to avoid including
+// Tizen's OpenGL header here.
 #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>
+	#include <FGraphicsOpengl.h>
+	using namespace Tizen::Graphics::Opengl;
+	#define USE_BUILTIN_OPENGL
 #else
-#include <GL/gl.h>
+	#include "backends/graphics/opengl/opengl-defs.h"
 #endif
 
+#ifdef SDL_BACKEND
+	// Win32 needs OpenGL functions declared with APIENTRY.
+	// However, SDL does not define APIENTRY in it's SDL.h file on non-Windows
+	// targets, thus if it is not available, we just dummy define it.
+	#ifndef APIENTRY
+		#define APIENTRY
+	#endif
+	#define GL_CALL_CONV APIENTRY
+#else
+	#define GL_CALL_CONV
+#endif
+
+namespace OpenGL {
+
+enum ContextType {
+	kContextGL,
+	kContextGLES,
+	kContextGLES2
+};
+
+class Pipeline;
+class Framebuffer;
+
+/**
+ * Description structure of the OpenGL (ES) context.
+ */
+struct Context {
+	/** The type of the active context. */
+	ContextType type;
+
+	/**
+	 * Reset context.
+	 *
+	 * This marks all extensions as unavailable and clears all function
+	 * pointers.
+	 */
+	void reset();
+
+	/** The maximum texture size supported by the context. */
+	GLint maxTextureSize;
+
+	/** Whether GL_ARB_texture_non_power_of_two is available or not. */
+	bool NPOTSupported;
+
+	/** Whether shader support is available or not. */
+	bool shadersSupported;
+
+	/** Whether multi texture support is available or not. */
+	bool multitextureSupported;
+
+	/** Whether FBO support is available or not. */
+	bool framebufferObjectSupported;
+
+#define GL_FUNC_DEF(ret, name, param) ret (GL_CALL_CONV *name)param
+#include "backends/graphics/opengl/opengl-func.h"
+#undef GL_FUNC_DEF
+
+	//
+	// Wrapper functionality to handle fixed-function pipelines and
+	// programmable pipelines in the same fashion.
+	//
+
+private:
+	/** Currently active rendering pipeline. */
+	Pipeline *activePipeline;
+
+public:
+	/**
+	 * Set new pipeline.
+	 *
+	 * Client is responsible for any memory management related to pipelines.
+	 *
+	 * @param pipeline Pipeline to activate.
+	 * @return Formerly active pipeline.
+	 */
+	Pipeline *setPipeline(Pipeline *pipeline);
+
+	/**
+	 * Query the currently active rendering pipeline.
+	 */
+	Pipeline *getActivePipeline() const { return activePipeline; }
+};
+
+/**
+ * The (active) OpenGL context.
+ */
+extern Context g_context;
+
+} // End of namespace OpenGL
+
+#define GL_CALL(x)                 GL_WRAP_DEBUG(g_context.x, x)
+#define GL_CALL_SAFE(func, params) \
+	do { \
+		if (g_context.func) { \
+			GL_CALL(func params); \
+		} \
+	} while (0)
+#define GL_ASSIGN(var, x)          GL_WRAP_DEBUG(var = g_context.x, x)
+
 #endif