/**************************************************************************** ** ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). ** Contact: http://www.qt-project.org/legal ** ** This file is part of the QtGui module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and Digia. For licensing terms and ** conditions see http://qt.digia.com/licensing. For further information ** use the contact form at http://qt.digia.com/contact-us. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 2.1 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 2.1 requirements ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, Digia gives you certain additional ** rights. These rights are described in the Digia Qt LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU ** General Public License version 3.0 as published by the Free Software ** Foundation and appearing in the file LICENSE.GPL included in the ** packaging of this file. Please review the following information to ** ensure the GNU General Public License version 3.0 requirements will be ** met: http://www.gnu.org/copyleft/gpl.html. ** ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #include #include #include #include #include // Must not include QOpenGLFunctions or anything that pulls in qopengl.h. // Otherwise we end up with errors about inconsistent linkage. #include #include #if defined(QT_OPENGL_ES) || defined(QT_OPENGL_ES_2) # error "Proxy GL is not compatible with static ES builds" #endif // This should not be an issue with the compilers used on Windows, but just in case: #ifndef Q_COMPILER_VARIADIC_MACROS # error "Proxy GL requires variadic macro support" #endif // Disable inconsistent dll linkage warnings. gl.h and egl.h are included and these mark // the egl and (w)gl functions as imported. We will mark them as exported. #if defined(Q_CC_MSVC) # pragma warning(disable : 4273) #elif defined(Q_CC_MINGW) # pragma GCC diagnostic ignored "-Wattributes" #endif #ifdef Q_OS_WIN64 typedef signed long long int khronos_intptr_t; typedef signed long long int khronos_ssize_t; #else typedef signed long int khronos_intptr_t; typedef signed long int khronos_ssize_t; #endif typedef char GLchar; typedef khronos_intptr_t GLintptr; typedef khronos_ssize_t GLsizeiptr; Q_LOGGING_CATEGORY(qglLc, "qt.gui.openglproxy") class QAbstractWindowsOpenGL { public: QAbstractWindowsOpenGL(); virtual ~QAbstractWindowsOpenGL() { } enum LibType { // must match QOpenGLFunctions::PlatformGLType DesktopGL = 0, GLES2 }; LibType libraryType() const { return m_libraryType; } HMODULE libraryHandle() const { return m_lib; } bool functionsReady() const { return m_loaded; } // WGL BOOL (WINAPI * CopyContext)(HGLRC src, HGLRC dst, UINT mask); HGLRC (WINAPI * CreateContext)(HDC dc); HGLRC (WINAPI * CreateLayerContext)(HDC dc, int plane); BOOL (WINAPI * DeleteContext)(HGLRC context); HGLRC (WINAPI * GetCurrentContext)(); HDC (WINAPI * GetCurrentDC)(); PROC (WINAPI * GetProcAddress)(LPCSTR name); BOOL (WINAPI * MakeCurrent)(HDC dc, HGLRC context); BOOL (WINAPI * ShareLists)(HGLRC context1, HGLRC context2); BOOL (WINAPI * UseFontBitmapsW)(HDC dc, DWORD first, DWORD count, DWORD base); BOOL (WINAPI * UseFontOutlinesW)(HDC dc, DWORD first, DWORD count, DWORD base, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT gmf); BOOL (WINAPI * DescribeLayerPlane)(HDC dc, int pixelFormat, int plane, UINT n, LPLAYERPLANEDESCRIPTOR planeDescriptor); int (WINAPI * SetLayerPaletteEntries)(HDC dc, int plane, int start, int entries, CONST COLORREF *colors); int (WINAPI * GetLayerPaletteEntries)(HDC dc, int plane, int start, int entries, COLORREF *color); BOOL (WINAPI * RealizeLayerPalette)(HDC dc, int plane, BOOL realize); BOOL (WINAPI * SwapLayerBuffers)(HDC dc, UINT planes); DWORD (WINAPI * SwapMultipleBuffers)(UINT n, CONST WGLSWAP *buffers); // EGL EGLint (EGLAPIENTRY * EGL_GetError)(void); EGLDisplay (EGLAPIENTRY * EGL_GetDisplay)(EGLNativeDisplayType display_id); EGLBoolean (EGLAPIENTRY * EGL_Initialize)(EGLDisplay dpy, EGLint *major, EGLint *minor); EGLBoolean (EGLAPIENTRY * EGL_Terminate)(EGLDisplay dpy); const char * (EGLAPIENTRY * EGL_QueryString)(EGLDisplay dpy, EGLint name); EGLBoolean (EGLAPIENTRY * EGL_GetConfigs)(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config); EGLBoolean (EGLAPIENTRY * EGL_ChooseConfig)(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config); EGLBoolean (EGLAPIENTRY * EGL_GetConfigAttrib)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value); EGLSurface (EGLAPIENTRY * EGL_CreateWindowSurface)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list); EGLSurface (EGLAPIENTRY * EGL_CreatePbufferSurface)(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list); EGLSurface (EGLAPIENTRY * EGL_CreatePixmapSurface)(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list); EGLBoolean (EGLAPIENTRY * EGL_DestroySurface)(EGLDisplay dpy, EGLSurface surface); EGLBoolean (EGLAPIENTRY * EGL_QuerySurface)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value); EGLBoolean (EGLAPIENTRY * EGL_BindAPI)(EGLenum api); EGLenum (EGLAPIENTRY * EGL_QueryAPI)(void); EGLBoolean (EGLAPIENTRY * EGL_WaitClient)(void); EGLBoolean (EGLAPIENTRY * EGL_ReleaseThread)(void); EGLSurface (EGLAPIENTRY * EGL_CreatePbufferFromClientBuffer)(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list); EGLBoolean (EGLAPIENTRY * EGL_SurfaceAttrib)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value); EGLBoolean (EGLAPIENTRY * EGL_BindTexImage)(EGLDisplay dpy, EGLSurface surface, EGLint buffer); EGLBoolean (EGLAPIENTRY * EGL_ReleaseTexImage)(EGLDisplay dpy, EGLSurface surface, EGLint buffer); EGLBoolean (EGLAPIENTRY * EGL_SwapInterval)(EGLDisplay dpy, EGLint interval); EGLContext (EGLAPIENTRY * EGL_CreateContext)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list); EGLBoolean (EGLAPIENTRY * EGL_DestroyContext)(EGLDisplay dpy, EGLContext ctx); EGLBoolean (EGLAPIENTRY * EGL_MakeCurrent)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx); EGLContext (EGLAPIENTRY * EGL_GetCurrentContext)(void); EGLSurface (EGLAPIENTRY * EGL_GetCurrentSurface)(EGLint readdraw); EGLDisplay (EGLAPIENTRY * EGL_GetCurrentDisplay)(void); EGLBoolean (EGLAPIENTRY * EGL_QueryContext)(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value); EGLBoolean (EGLAPIENTRY * EGL_WaitGL)(void); EGLBoolean (EGLAPIENTRY * EGL_WaitNative)(EGLint engine); EGLBoolean (EGLAPIENTRY * EGL_SwapBuffers)(EGLDisplay dpy, EGLSurface surface); EGLBoolean (EGLAPIENTRY * EGL_CopyBuffers)(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target); __eglMustCastToProperFunctionPointerType (EGLAPIENTRY * EGL_GetProcAddress)(const char *procname); // OpenGL 1.0 void (APIENTRY * Viewport)(GLint x, GLint y, GLsizei width, GLsizei height); void (APIENTRY * DepthRange)(GLdouble nearVal, GLdouble farVal); GLboolean (APIENTRY * IsEnabled)(GLenum cap); void (APIENTRY * GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params); void (APIENTRY * GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params); void (APIENTRY * GetTexParameteriv)(GLenum target, GLenum pname, GLint *params); void (APIENTRY * GetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params); void (APIENTRY * GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels); const GLubyte * (APIENTRY * GetString)(GLenum name); void (APIENTRY * GetIntegerv)(GLenum pname, GLint *params); void (APIENTRY * GetFloatv)(GLenum pname, GLfloat *params); GLenum (APIENTRY * GetError)(); void (APIENTRY * GetDoublev)(GLenum pname, GLdouble *params); void (APIENTRY * GetBooleanv)(GLenum pname, GLboolean *params); void (APIENTRY * ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels); void (APIENTRY * ReadBuffer)(GLenum mode); void (APIENTRY * PixelStorei)(GLenum pname, GLint param); void (APIENTRY * PixelStoref)(GLenum pname, GLfloat param); void (APIENTRY * DepthFunc)(GLenum func); void (APIENTRY * StencilOp)(GLenum fail, GLenum zfail, GLenum zpass); void (APIENTRY * StencilFunc)(GLenum func, GLint ref, GLuint mask); void (APIENTRY * LogicOp)(GLenum opcode); void (APIENTRY * BlendFunc)(GLenum sfactor, GLenum dfactor); void (APIENTRY * Flush)(); void (APIENTRY * Finish)(); void (APIENTRY * Enable)(GLenum cap); void (APIENTRY * Disable)(GLenum cap); void (APIENTRY * DepthMask)(GLboolean flag); void (APIENTRY * ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); void (APIENTRY * StencilMask)(GLuint mask); void (APIENTRY * ClearDepth)(GLdouble depth); void (APIENTRY * ClearStencil)(GLint s); void (APIENTRY * ClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); void (APIENTRY * Clear)(GLbitfield mask); void (APIENTRY * DrawBuffer)(GLenum mode); void (APIENTRY * TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels); void (APIENTRY * TexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels); void (APIENTRY * TexParameteriv)(GLenum target, GLenum pname, const GLint *params); void (APIENTRY * TexParameteri)(GLenum target, GLenum pname, GLint param); void (APIENTRY * TexParameterfv)(GLenum target, GLenum pname, const GLfloat *params); void (APIENTRY * TexParameterf)(GLenum target, GLenum pname, GLfloat param); void (APIENTRY * Scissor)(GLint x, GLint y, GLsizei width, GLsizei height); void (APIENTRY * PolygonMode)(GLenum face, GLenum mode); void (APIENTRY * PointSize)(GLfloat size); void (APIENTRY * LineWidth)(GLfloat width); void (APIENTRY * Hint)(GLenum target, GLenum mode); void (APIENTRY * FrontFace)(GLenum mode); void (APIENTRY * CullFace)(GLenum mode); void (APIENTRY * Translatef)(GLfloat x, GLfloat y, GLfloat z); void (APIENTRY * Translated)(GLdouble x, GLdouble y, GLdouble z); void (APIENTRY * Scalef)(GLfloat x, GLfloat y, GLfloat z); void (APIENTRY * Scaled)(GLdouble x, GLdouble y, GLdouble z); void (APIENTRY * Rotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); void (APIENTRY * Rotated)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); void (APIENTRY * PushMatrix)(); void (APIENTRY * PopMatrix)(); void (APIENTRY * Ortho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); void (APIENTRY * MultMatrixd)(const GLdouble *m); void (APIENTRY * MultMatrixf)(const GLfloat *m); void (APIENTRY * MatrixMode)(GLenum mode); void (APIENTRY * LoadMatrixd)(const GLdouble *m); void (APIENTRY * LoadMatrixf)(const GLfloat *m); void (APIENTRY * LoadIdentity)(); void (APIENTRY * Frustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); GLboolean (APIENTRY * IsList)(GLuint list); void (APIENTRY * GetTexGeniv)(GLenum coord, GLenum pname, GLint *params); void (APIENTRY * GetTexGenfv)(GLenum coord, GLenum pname, GLfloat *params); void (APIENTRY * GetTexGendv)(GLenum coord, GLenum pname, GLdouble *params); void (APIENTRY * GetTexEnviv)(GLenum target, GLenum pname, GLint *params); void (APIENTRY * GetTexEnvfv)(GLenum target, GLenum pname, GLfloat *params); void (APIENTRY * GetPolygonStipple)(GLubyte *mask); void (APIENTRY * GetPixelMapusv)(GLenum map, GLushort *values); void (APIENTRY * GetPixelMapuiv)(GLenum map, GLuint *values); void (APIENTRY * GetPixelMapfv)(GLenum map, GLfloat *values); void (APIENTRY * GetMaterialiv)(GLenum face, GLenum pname, GLint *params); void (APIENTRY * GetMaterialfv)(GLenum face, GLenum pname, GLfloat *params); void (APIENTRY * GetMapiv)(GLenum target, GLenum query, GLint *v); void (APIENTRY * GetMapfv)(GLenum target, GLenum query, GLfloat *v); void (APIENTRY * GetMapdv)(GLenum target, GLenum query, GLdouble *v); void (APIENTRY * GetLightiv)(GLenum light, GLenum pname, GLint *params); void (APIENTRY * GetLightfv)(GLenum light, GLenum pname, GLfloat *params); void (APIENTRY * GetClipPlane)(GLenum plane, GLdouble *equation); void (APIENTRY * DrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); void (APIENTRY * CopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); void (APIENTRY * PixelMapusv)(GLenum map, GLint mapsize, const GLushort *values); void (APIENTRY * PixelMapuiv)(GLenum map, GLint mapsize, const GLuint *values); void (APIENTRY * PixelMapfv)(GLenum map, GLint mapsize, const GLfloat *values); void (APIENTRY * PixelTransferi)(GLenum pname, GLint param); void (APIENTRY * PixelTransferf)(GLenum pname, GLfloat param); void (APIENTRY * PixelZoom)(GLfloat xfactor, GLfloat yfactor); void (APIENTRY * AlphaFunc)(GLenum func, GLfloat ref); void (APIENTRY * EvalPoint2)(GLint i, GLint j); void (APIENTRY * EvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); void (APIENTRY * EvalPoint1)(GLint i); void (APIENTRY * EvalMesh1)(GLenum mode, GLint i1, GLint i2); void (APIENTRY * EvalCoord2fv)(const GLfloat *u); void (APIENTRY * EvalCoord2f)(GLfloat u, GLfloat v); void (APIENTRY * EvalCoord2dv)(const GLdouble *u); void (APIENTRY * EvalCoord2d)(GLdouble u, GLdouble v); void (APIENTRY * EvalCoord1fv)(const GLfloat *u); void (APIENTRY * EvalCoord1f)(GLfloat u); void (APIENTRY * EvalCoord1dv)(const GLdouble *u); void (APIENTRY * EvalCoord1d)(GLdouble u); void (APIENTRY * MapGrid2f)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); void (APIENTRY * MapGrid2d)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); void (APIENTRY * MapGrid1f)(GLint un, GLfloat u1, GLfloat u2); void (APIENTRY * MapGrid1d)(GLint un, GLdouble u1, GLdouble u2); void (APIENTRY * Map2f)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points); void (APIENTRY * Map2d)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points); void (APIENTRY * Map1f)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points); void (APIENTRY * Map1d)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points); void (APIENTRY * PushAttrib)(GLbitfield mask); void (APIENTRY * PopAttrib)(); void (APIENTRY * Accum)(GLenum op, GLfloat value); void (APIENTRY * IndexMask)(GLuint mask); void (APIENTRY * ClearIndex)(GLfloat c); void (APIENTRY * ClearAccum)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); void (APIENTRY * PushName)(GLuint name); void (APIENTRY * PopName)(); void (APIENTRY * PassThrough)(GLfloat token); void (APIENTRY * LoadName)(GLuint name); void (APIENTRY * InitNames)(); GLint (APIENTRY * RenderMode)(GLenum mode); void (APIENTRY * SelectBuffer)(GLsizei size, GLuint *buffer); void (APIENTRY * FeedbackBuffer)(GLsizei size, GLenum type, GLfloat *buffer); void (APIENTRY * TexGeniv)(GLenum coord, GLenum pname, const GLint *params); void (APIENTRY * TexGeni)(GLenum coord, GLenum pname, GLint param); void (APIENTRY * TexGenfv)(GLenum coord, GLenum pname, const GLfloat *params); void (APIENTRY * TexGenf)(GLenum coord, GLenum pname, GLfloat param); void (APIENTRY * TexGendv)(GLenum coord, GLenum pname, const GLdouble *params); void (APIENTRY * TexGend)(GLenum coord, GLenum pname, GLdouble param); void (APIENTRY * TexEnviv)(GLenum target, GLenum pname, const GLint *params); void (APIENTRY * TexEnvi)(GLenum target, GLenum pname, GLint param); void (APIENTRY * TexEnvfv)(GLenum target, GLenum pname, const GLfloat *params); void (APIENTRY * TexEnvf)(GLenum target, GLenum pname, GLfloat param); void (APIENTRY * ShadeModel)(GLenum mode); void (APIENTRY * PolygonStipple)(const GLubyte *mask); void (APIENTRY * Materialiv)(GLenum face, GLenum pname, const GLint *params); void (APIENTRY * Materiali)(GLenum face, GLenum pname, GLint param); void (APIENTRY * Materialfv)(GLenum face, GLenum pname, const GLfloat *params); void (APIENTRY * Materialf)(GLenum face, GLenum pname, GLfloat param); void (APIENTRY * LineStipple)(GLint factor, GLushort pattern); void (APIENTRY * LightModeliv)(GLenum pname, const GLint *params); void (APIENTRY * LightModeli)(GLenum pname, GLint param); void (APIENTRY * LightModelfv)(GLenum pname, const GLfloat *params); void (APIENTRY * LightModelf)(GLenum pname, GLfloat param); void (APIENTRY * Lightiv)(GLenum light, GLenum pname, const GLint *params); void (APIENTRY * Lighti)(GLenum light, GLenum pname, GLint param); void (APIENTRY * Lightfv)(GLenum light, GLenum pname, const GLfloat *params); void (APIENTRY * Lightf)(GLenum light, GLenum pname, GLfloat param); void (APIENTRY * Fogiv)(GLenum pname, const GLint *params); void (APIENTRY * Fogi)(GLenum pname, GLint param); void (APIENTRY * Fogfv)(GLenum pname, const GLfloat *params); void (APIENTRY * Fogf)(GLenum pname, GLfloat param); void (APIENTRY * ColorMaterial)(GLenum face, GLenum mode); void (APIENTRY * ClipPlane)(GLenum plane, const GLdouble *equation); void (APIENTRY * Vertex4sv)(const GLshort *v); void (APIENTRY * Vertex4s)(GLshort x, GLshort y, GLshort z, GLshort w); void (APIENTRY * Vertex4iv)(const GLint *v); void (APIENTRY * Vertex4i)(GLint x, GLint y, GLint z, GLint w); void (APIENTRY * Vertex4fv)(const GLfloat *v); void (APIENTRY * Vertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); void (APIENTRY * Vertex4dv)(const GLdouble *v); void (APIENTRY * Vertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); void (APIENTRY * Vertex3sv)(const GLshort *v); void (APIENTRY * Vertex3s)(GLshort x, GLshort y, GLshort z); void (APIENTRY * Vertex3iv)(const GLint *v); void (APIENTRY * Vertex3i)(GLint x, GLint y, GLint z); void (APIENTRY * Vertex3fv)(const GLfloat *v); void (APIENTRY * Vertex3f)(GLfloat x, GLfloat y, GLfloat z); void (APIENTRY * Vertex3dv)(const GLdouble *v); void (APIENTRY * Vertex3d)(GLdouble x, GLdouble y, GLdouble z); void (APIENTRY * Vertex2sv)(const GLshort *v); void (APIENTRY * Vertex2s)(GLshort x, GLshort y); void (APIENTRY * Vertex2iv)(const GLint *v); void (APIENTRY * Vertex2i)(GLint x, GLint y); void (APIENTRY * Vertex2fv)(const GLfloat *v); void (APIENTRY * Vertex2f)(GLfloat x, GLfloat y); void (APIENTRY * Vertex2dv)(const GLdouble *v); void (APIENTRY * Vertex2d)(GLdouble x, GLdouble y); void (APIENTRY * TexCoord4sv)(const GLshort *v); void (APIENTRY * TexCoord4s)(GLshort s, GLshort t, GLshort r, GLshort q); void (APIENTRY * TexCoord4iv)(const GLint *v); void (APIENTRY * TexCoord4i)(GLint s, GLint t, GLint r, GLint q); void (APIENTRY * TexCoord4fv)(const GLfloat *v); void (APIENTRY * TexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q); void (APIENTRY * TexCoord4dv)(const GLdouble *v); void (APIENTRY * TexCoord4d)(GLdouble s, GLdouble t, GLdouble r, GLdouble q); void (APIENTRY * TexCoord3sv)(const GLshort *v); void (APIENTRY * TexCoord3s)(GLshort s, GLshort t, GLshort r); void (APIENTRY * TexCoord3iv)(const GLint *v); void (APIENTRY * TexCoord3i)(GLint s, GLint t, GLint r); void (APIENTRY * TexCoord3fv)(const GLfloat *v); void (APIENTRY * TexCoord3f)(GLfloat s, GLfloat t, GLfloat r); void (APIENTRY * TexCoord3dv)(const GLdouble *v); void (APIENTRY * TexCoord3d)(GLdouble s, GLdouble t, GLdouble r); void (APIENTRY * TexCoord2sv)(const GLshort *v); void (APIENTRY * TexCoord2s)(GLshort s, GLshort t); void (APIENTRY * TexCoord2iv)(const GLint *v); void (APIENTRY * TexCoord2i)(GLint s, GLint t); void (APIENTRY * TexCoord2fv)(const GLfloat *v); void (APIENTRY * TexCoord2f)(GLfloat s, GLfloat t); void (APIENTRY * TexCoord2dv)(const GLdouble *v); void (APIENTRY * TexCoord2d)(GLdouble s, GLdouble t); void (APIENTRY * TexCoord1sv)(const GLshort *v); void (APIENTRY * TexCoord1s)(GLshort s); void (APIENTRY * TexCoord1iv)(const GLint *v); void (APIENTRY * TexCoord1i)(GLint s); void (APIENTRY * TexCoord1fv)(const GLfloat *v); void (APIENTRY * TexCoord1f)(GLfloat s); void (APIENTRY * TexCoord1dv)(const GLdouble *v); void (APIENTRY * TexCoord1d)(GLdouble s); void (APIENTRY * Rectsv)(const GLshort *v1, const GLshort *v2); void (APIENTRY * Rects)(GLshort x1, GLshort y1, GLshort x2, GLshort y2); void (APIENTRY * Rectiv)(const GLint *v1, const GLint *v2); void (APIENTRY * Recti)(GLint x1, GLint y1, GLint x2, GLint y2); void (APIENTRY * Rectfv)(const GLfloat *v1, const GLfloat *v2); void (APIENTRY * Rectf)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); void (APIENTRY * Rectdv)(const GLdouble *v1, const GLdouble *v2); void (APIENTRY * Rectd)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); void (APIENTRY * RasterPos4sv)(const GLshort *v); void (APIENTRY * RasterPos4s)(GLshort x, GLshort y, GLshort z, GLshort w); void (APIENTRY * RasterPos4iv)(const GLint *v); void (APIENTRY * RasterPos4i)(GLint x, GLint y, GLint z, GLint w); void (APIENTRY * RasterPos4fv)(const GLfloat *v); void (APIENTRY * RasterPos4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); void (APIENTRY * RasterPos4dv)(const GLdouble *v); void (APIENTRY * RasterPos4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); void (APIENTRY * RasterPos3sv)(const GLshort *v); void (APIENTRY * RasterPos3s)(GLshort x, GLshort y, GLshort z); void (APIENTRY * RasterPos3iv)(const GLint *v); void (APIENTRY * RasterPos3i)(GLint x, GLint y, GLint z); void (APIENTRY * RasterPos3fv)(const GLfloat *v); void (APIENTRY * RasterPos3f)(GLfloat x, GLfloat y, GLfloat z); void (APIENTRY * RasterPos3dv)(const GLdouble *v); void (APIENTRY * RasterPos3d)(GLdouble x, GLdouble y, GLdouble z); void (APIENTRY * RasterPos2sv)(const GLshort *v); void (APIENTRY * RasterPos2s)(GLshort x, GLshort y); void (APIENTRY * RasterPos2iv)(const GLint *v); void (APIENTRY * RasterPos2i)(GLint x, GLint y); void (APIENTRY * RasterPos2fv)(const GLfloat *v); void (APIENTRY * RasterPos2f)(GLfloat x, GLfloat y); void (APIENTRY * RasterPos2dv)(const GLdouble *v); void (APIENTRY * RasterPos2d)(GLdouble x, GLdouble y); void (APIENTRY * Normal3sv)(const GLshort *v); void (APIENTRY * Normal3s)(GLshort nx, GLshort ny, GLshort nz); void (APIENTRY * Normal3iv)(const GLint *v); void (APIENTRY * Normal3i)(GLint nx, GLint ny, GLint nz); void (APIENTRY * Normal3fv)(const GLfloat *v); void (APIENTRY * Normal3f)(GLfloat nx, GLfloat ny, GLfloat nz); void (APIENTRY * Normal3dv)(const GLdouble *v); void (APIENTRY * Normal3d)(GLdouble nx, GLdouble ny, GLdouble nz); void (APIENTRY * Normal3bv)(const GLbyte *v); void (APIENTRY * Normal3b)(GLbyte nx, GLbyte ny, GLbyte nz); void (APIENTRY * Indexsv)(const GLshort *c); void (APIENTRY * Indexs)(GLshort c); void (APIENTRY * Indexiv)(const GLint *c); void (APIENTRY * Indexi)(GLint c); void (APIENTRY * Indexfv)(const GLfloat *c); void (APIENTRY * Indexf)(GLfloat c); void (APIENTRY * Indexdv)(const GLdouble *c); void (APIENTRY * Indexd)(GLdouble c); void (APIENTRY * End)(); void (APIENTRY * EdgeFlagv)(const GLboolean *flag); void (APIENTRY * EdgeFlag)(GLboolean flag); void (APIENTRY * Color4usv)(const GLushort *v); void (APIENTRY * Color4us)(GLushort red, GLushort green, GLushort blue, GLushort alpha); void (APIENTRY * Color4uiv)(const GLuint *v); void (APIENTRY * Color4ui)(GLuint red, GLuint green, GLuint blue, GLuint alpha); void (APIENTRY * Color4ubv)(const GLubyte *v); void (APIENTRY * Color4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); void (APIENTRY * Color4sv)(const GLshort *v); void (APIENTRY * Color4s)(GLshort red, GLshort green, GLshort blue, GLshort alpha); void (APIENTRY * Color4iv)(const GLint *v); void (APIENTRY * Color4i)(GLint red, GLint green, GLint blue, GLint alpha); void (APIENTRY * Color4fv)(const GLfloat *v); void (APIENTRY * Color4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); void (APIENTRY * Color4dv)(const GLdouble *v); void (APIENTRY * Color4d)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); void (APIENTRY * Color4bv)(const GLbyte *v); void (APIENTRY * Color4b)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); void (APIENTRY * Color3usv)(const GLushort *v); void (APIENTRY * Color3us)(GLushort red, GLushort green, GLushort blue); void (APIENTRY * Color3uiv)(const GLuint *v); void (APIENTRY * Color3ui)(GLuint red, GLuint green, GLuint blue); void (APIENTRY * Color3ubv)(const GLubyte *v); void (APIENTRY * Color3ub)(GLubyte red, GLubyte green, GLubyte blue); void (APIENTRY * Color3sv)(const GLshort *v); void (APIENTRY * Color3s)(GLshort red, GLshort green, GLshort blue); void (APIENTRY * Color3iv)(const GLint *v); void (APIENTRY * Color3i)(GLint red, GLint green, GLint blue); void (APIENTRY * Color3fv)(const GLfloat *v); void (APIENTRY * Color3f)(GLfloat red, GLfloat green, GLfloat blue); void (APIENTRY * Color3dv)(const GLdouble *v); void (APIENTRY * Color3d)(GLdouble red, GLdouble green, GLdouble blue); void (APIENTRY * Color3bv)(const GLbyte *v); void (APIENTRY * Color3b)(GLbyte red, GLbyte green, GLbyte blue); void (APIENTRY * Bitmap)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap); void (APIENTRY * Begin)(GLenum mode); void (APIENTRY * ListBase)(GLuint base); GLuint (APIENTRY * GenLists)(GLsizei range); void (APIENTRY * DeleteLists)(GLuint list, GLsizei range); void (APIENTRY * CallLists)(GLsizei n, GLenum type, const GLvoid *lists); void (APIENTRY * CallList)(GLuint list); void (APIENTRY * EndList)(); void (APIENTRY * NewList)(GLuint list, GLenum mode); // OpenGL 1.1 void (APIENTRY * Indexubv)(const GLubyte *c); void (APIENTRY * Indexub)(GLubyte c); GLboolean (APIENTRY * IsTexture)(GLuint texture); void (APIENTRY * GenTextures)(GLsizei n, GLuint *textures); void (APIENTRY * DeleteTextures)(GLsizei n, const GLuint *textures); void (APIENTRY * BindTexture)(GLenum target, GLuint texture); void (APIENTRY * TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); void (APIENTRY * TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels); void (APIENTRY * CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); void (APIENTRY * CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); void (APIENTRY * CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); void (APIENTRY * CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); void (APIENTRY * PolygonOffset)(GLfloat factor, GLfloat units); void (APIENTRY * GetPointerv)(GLenum pname, GLvoid* *params); void (APIENTRY * DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices); void (APIENTRY * DrawArrays)(GLenum mode, GLint first, GLsizei count); void (APIENTRY * PushClientAttrib)(GLbitfield mask); void (APIENTRY * PopClientAttrib)(); void (APIENTRY * PrioritizeTextures)(GLsizei n, const GLuint *textures, const GLfloat *priorities); GLboolean (APIENTRY * AreTexturesResident)(GLsizei n, const GLuint *textures, GLboolean *residences); void (APIENTRY * VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); void (APIENTRY * TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); void (APIENTRY * NormalPointer)(GLenum type, GLsizei stride, const GLvoid *pointer); void (APIENTRY * InterleavedArrays)(GLenum format, GLsizei stride, const GLvoid *pointer); void (APIENTRY * IndexPointer)(GLenum type, GLsizei stride, const GLvoid *pointer); void (APIENTRY * EnableClientState)(GLenum array); void (APIENTRY * EdgeFlagPointer)(GLsizei stride, const GLvoid *pointer); void (APIENTRY * DisableClientState)(GLenum array); void (APIENTRY * ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); void (APIENTRY * ArrayElement)(GLint i); // OpenGL ES 2.0 void (APIENTRY * ActiveTexture)(GLenum texture); void (APIENTRY * AttachShader)(GLuint program, GLuint shader); void (APIENTRY * BindAttribLocation)(GLuint program, GLuint index, const GLchar* name); void (APIENTRY * BindBuffer)(GLenum target, GLuint buffer); void (APIENTRY * BindFramebuffer)(GLenum target, GLuint framebuffer); void (APIENTRY * BindRenderbuffer)(GLenum target, GLuint renderbuffer); void (APIENTRY * BlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); void (APIENTRY * BlendEquation)(GLenum mode); void (APIENTRY * BlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha); void (APIENTRY * BlendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); void (APIENTRY * BufferData)(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); void (APIENTRY * BufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); GLenum (APIENTRY * CheckFramebufferStatus)(GLenum target); void (APIENTRY * ClearDepthf)(GLclampf depth); void (APIENTRY * CompileShader)(GLuint shader); void (APIENTRY * CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); void (APIENTRY * CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); GLuint (APIENTRY * CreateProgram)(void); GLuint (APIENTRY * CreateShader)(GLenum type); void (APIENTRY * DeleteBuffers)(GLsizei n, const GLuint* buffers); void (APIENTRY * DeleteFramebuffers)(GLsizei n, const GLuint* framebuffers); void (APIENTRY * DeleteProgram)(GLuint program); void (APIENTRY * DeleteRenderbuffers)(GLsizei n, const GLuint* renderbuffers); void (APIENTRY * DeleteShader)(GLuint shader); void (APIENTRY * DepthRangef)(GLclampf zNear, GLclampf zFar); void (APIENTRY * DetachShader)(GLuint program, GLuint shader); void (APIENTRY * DisableVertexAttribArray)(GLuint index); void (APIENTRY * EnableVertexAttribArray)(GLuint index); void (APIENTRY * FramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); void (APIENTRY * FramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); void (APIENTRY * GenBuffers)(GLsizei n, GLuint* buffers); void (APIENTRY * GenerateMipmap)(GLenum target); void (APIENTRY * GenFramebuffers)(GLsizei n, GLuint* framebuffers); void (APIENTRY * GenRenderbuffers)(GLsizei n, GLuint* renderbuffers); void (APIENTRY * GetActiveAttrib)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); void (APIENTRY * GetActiveUniform)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name); void (APIENTRY * GetAttachedShaders)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders); int (APIENTRY * GetAttribLocation)(GLuint program, const GLchar* name); void (APIENTRY * GetBufferParameteriv)(GLenum target, GLenum pname, GLint* params); void (APIENTRY * GetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params); void (APIENTRY * GetProgramiv)(GLuint program, GLenum pname, GLint* params); void (APIENTRY * GetProgramInfoLog)(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog); void (APIENTRY * GetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params); void (APIENTRY * GetShaderiv)(GLuint shader, GLenum pname, GLint* params); void (APIENTRY * GetShaderInfoLog)(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog); void (APIENTRY * GetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision); void (APIENTRY * GetShaderSource)(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source); void (APIENTRY * GetUniformfv)(GLuint program, GLint location, GLfloat* params); void (APIENTRY * GetUniformiv)(GLuint program, GLint location, GLint* params); int (APIENTRY * GetUniformLocation)(GLuint program, const GLchar* name); void (APIENTRY * GetVertexAttribfv)(GLuint index, GLenum pname, GLfloat* params); void (APIENTRY * GetVertexAttribiv)(GLuint index, GLenum pname, GLint* params); void (APIENTRY * GetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid** pointer); GLboolean (APIENTRY * IsBuffer)(GLuint buffer); GLboolean (APIENTRY * IsFramebuffer)(GLuint framebuffer); GLboolean (APIENTRY * IsProgram)(GLuint program); GLboolean (APIENTRY * IsRenderbuffer)(GLuint renderbuffer); GLboolean (APIENTRY * IsShader)(GLuint shader); void (APIENTRY * LinkProgram)(GLuint program); void (APIENTRY * ReleaseShaderCompiler)(void); void (APIENTRY * RenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); void (APIENTRY * SampleCoverage)(GLclampf value, GLboolean invert); void (APIENTRY * ShaderBinary)(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length); void (APIENTRY * ShaderSource)(GLuint shader, GLsizei count, const GLchar* *string, const GLint* length); void (APIENTRY * StencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask); void (APIENTRY * StencilMaskSeparate)(GLenum face, GLuint mask); void (APIENTRY * StencilOpSeparate)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass); void (APIENTRY * Uniform1f)(GLint location, GLfloat x); void (APIENTRY * Uniform1fv)(GLint location, GLsizei count, const GLfloat* v); void (APIENTRY * Uniform1i)(GLint location, GLint x); void (APIENTRY * Uniform1iv)(GLint location, GLsizei count, const GLint* v); void (APIENTRY * Uniform2f)(GLint location, GLfloat x, GLfloat y); void (APIENTRY * Uniform2fv)(GLint location, GLsizei count, const GLfloat* v); void (APIENTRY * Uniform2i)(GLint location, GLint x, GLint y); void (APIENTRY * Uniform2iv)(GLint location, GLsizei count, const GLint* v); void (APIENTRY * Uniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat z); void (APIENTRY * Uniform3fv)(GLint location, GLsizei count, const GLfloat* v); void (APIENTRY * Uniform3i)(GLint location, GLint x, GLint y, GLint z); void (APIENTRY * Uniform3iv)(GLint location, GLsizei count, const GLint* v); void (APIENTRY * Uniform4f)(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w); void (APIENTRY * Uniform4fv)(GLint location, GLsizei count, const GLfloat* v); void (APIENTRY * Uniform4i)(GLint location, GLint x, GLint y, GLint z, GLint w); void (APIENTRY * Uniform4iv)(GLint location, GLsizei count, const GLint* v); void (APIENTRY * UniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); void (APIENTRY * UniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); void (APIENTRY * UniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); void (APIENTRY * UseProgram)(GLuint program); void (APIENTRY * ValidateProgram)(GLuint program); void (APIENTRY * VertexAttrib1f)(GLuint indx, GLfloat x); void (APIENTRY * VertexAttrib1fv)(GLuint indx, const GLfloat* values); void (APIENTRY * VertexAttrib2f)(GLuint indx, GLfloat x, GLfloat y); void (APIENTRY * VertexAttrib2fv)(GLuint indx, const GLfloat* values); void (APIENTRY * VertexAttrib3f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z); void (APIENTRY * VertexAttrib3fv)(GLuint indx, const GLfloat* values); void (APIENTRY * VertexAttrib4f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w); void (APIENTRY * VertexAttrib4fv)(GLuint indx, const GLfloat* values); void (APIENTRY * VertexAttribPointer)(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr); protected: HMODULE m_lib; LibType m_libraryType; bool m_loaded; }; class QWindowsOpenGL : public QAbstractWindowsOpenGL { public: QWindowsOpenGL(); ~QWindowsOpenGL(); private: bool load(const char *glName, const char *eglName); void unload(); void resolve(); void resolveWGL(); void resolveEGL(); void resolveGLCommon(); void resolveGL11(); void resolveGLES2(); FARPROC resolveFunc(const char *name); FARPROC resolveEglFunc(const char *name); bool testDesktopGL(); HMODULE m_eglLib; }; static QString qgl_windowsErrorMessage(unsigned long errorCode) { QString rc = QString::fromLatin1("#%1: ").arg(errorCode); ushort *lpMsgBuf; const int len = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorCode, 0, (LPTSTR)&lpMsgBuf, 0, NULL); if (len) { rc = QString::fromUtf16(lpMsgBuf, len); LocalFree(lpMsgBuf); } else { rc += QString::fromLatin1(""); } return rc; } static HMODULE qgl_loadLib(const char *name, bool warnOnFail = true) { HMODULE lib = LoadLibraryA(name); if (lib) return lib; if (warnOnFail) { QString msg = qgl_windowsErrorMessage(GetLastError()); qCWarning(qglLc, "Failed to load %s (%s)", name, qPrintable(msg)); } return 0; } QWindowsOpenGL::QWindowsOpenGL() : m_eglLib(0) { qglLc().setEnabled(QtWarningMsg, true); if (qEnvironmentVariableIsSet("QT_OPENGLPROXY_DEBUG")) qglLc().setEnabled(QtDebugMsg, true); enum RequestedLib { Unknown, Desktop, GLES } req = Unknown; // Check if the application has requested a certain implementation. if (QCoreApplication::testAttribute(Qt::AA_UseDesktopOpenGL)) req = Desktop; else if (QCoreApplication::testAttribute(Qt::AA_UseOpenGLES)) req = GLES; // Check if an implementation is forced through the environment variable. QByteArray requested = qgetenv("QT_OPENGL"); if (requested == QByteArrayLiteral("desktop")) req = Desktop; else if (requested == QByteArrayLiteral("angle")) req = GLES; bool desktopTested = false; if (req == Unknown) { // No explicit request. Start testing. opengl32.dll is preferred. Angle is the fallback. desktopTested = true; if (testDesktopGL()) req = Desktop; else req = GLES; } Q_ASSERT(req != Unknown); if (req == GLES) { qCDebug(qglLc, "Using Angle"); #ifdef QT_DEBUG m_loaded = load("libglesv2d.dll", "libegld.dll"); #else m_loaded = load("libglesv2.dll", "libegl.dll"); #endif if (m_loaded) { m_libraryType = QWindowsOpenGL::GLES2; } else { // Could not load Angle. Try opengl32.dll. if (!desktopTested && testDesktopGL()) req = Desktop; } } if (req == Desktop) { qCDebug(qglLc, "Using desktop OpenGL"); m_loaded = load("opengl32.dll", 0); if (m_loaded) m_libraryType = QWindowsOpenGL::DesktopGL; } if (m_loaded) resolve(); // When no library is loaded, keep on running. All EGL/WGL/GL functions will // return 0 in this case without further errors. It is up to the clients // (application code, Qt Quick, etc.) to act when eglInitialize() and // friends fail, i.e. when QOpenGLContext::create() returns false due to the // platform plugin's failure to create a platform context. } QWindowsOpenGL::~QWindowsOpenGL() { unload(); } bool QWindowsOpenGL::load(const char *glName, const char *eglName) { qCDebug(qglLc, "Loading %s %s", glName, eglName ? eglName : ""); bool result = true; if (glName) { m_lib = qgl_loadLib(glName); result &= m_lib != 0; } if (eglName) { m_eglLib = qgl_loadLib(eglName); result &= m_eglLib != 0; } if (!result) unload(); return result; } void QWindowsOpenGL::unload() { if (m_lib) { FreeLibrary(m_lib); m_lib = 0; } if (m_eglLib) { FreeLibrary(m_eglLib); m_eglLib = 0; } m_loaded = false; } FARPROC QWindowsOpenGL::resolveFunc(const char *name) { FARPROC proc = m_lib ? ::GetProcAddress(m_lib, name) : 0; if (!proc) qCDebug(qglLc, "Failed to resolve GL function %s", name); return proc; } FARPROC QWindowsOpenGL::resolveEglFunc(const char *name) { FARPROC proc = m_eglLib ? ::GetProcAddress(m_eglLib, name) : 0; if (!proc) qCDebug(qglLc, "Failed to resolve EGL function %s", name); return proc; } void QWindowsOpenGL::resolveWGL() { CopyContext = reinterpret_cast(resolveFunc("wglCopyContext")); CreateContext = reinterpret_cast(resolveFunc("wglCreateContext")); CreateLayerContext = reinterpret_cast(resolveFunc("wglCreateLayerContext")); DeleteContext = reinterpret_cast(resolveFunc("wglDeleteContext")); GetCurrentContext = reinterpret_cast(resolveFunc("wglGetCurrentContext")); GetCurrentDC = reinterpret_cast(resolveFunc("wglGetCurrentDC")); GetProcAddress = reinterpret_cast(resolveFunc("wglGetProcAddress")); MakeCurrent = reinterpret_cast(resolveFunc("wglMakeCurrent")); ShareLists = reinterpret_cast(resolveFunc("wglShareLists")); UseFontBitmapsW = reinterpret_cast(resolveFunc("wglUseFontBitmapsW")); UseFontOutlinesW = reinterpret_cast(resolveFunc("wglUseFontOutlinesW")); DescribeLayerPlane = reinterpret_cast(resolveFunc("wglDescribeLayerPlane")); SetLayerPaletteEntries = reinterpret_cast(resolveFunc("wglSetLayerPaletteEntries")); GetLayerPaletteEntries = reinterpret_cast(resolveFunc("wglGetLayerPaletteEntries")); RealizeLayerPalette = reinterpret_cast(resolveFunc("wglRealizeLayerPalette")); SwapLayerBuffers = reinterpret_cast(resolveFunc("wglSwapLayerBuffers")); SwapMultipleBuffers = reinterpret_cast(resolveFunc("wglSwapMultipleBuffers")); } void QWindowsOpenGL::resolveEGL() { EGL_GetError = reinterpret_cast(resolveEglFunc("eglGetError")); EGL_GetDisplay = reinterpret_cast(resolveEglFunc("eglGetDisplay")); EGL_Initialize = reinterpret_cast(resolveEglFunc("eglInitialize")); EGL_Terminate = reinterpret_cast(resolveEglFunc("eglTerminate")); EGL_QueryString = reinterpret_cast(resolveEglFunc("eglQueryString")); EGL_GetConfigs = reinterpret_cast(resolveEglFunc("eglGetConfigs")); EGL_ChooseConfig = reinterpret_cast(resolveEglFunc("eglChooseConfig")); EGL_GetConfigAttrib = reinterpret_cast(resolveEglFunc("eglGetConfigAttrib")); EGL_CreateWindowSurface = reinterpret_cast(resolveEglFunc("eglCreateWindowSurface")); EGL_CreatePbufferSurface = reinterpret_cast(resolveEglFunc("eglCreatePbufferSurface")); EGL_CreatePixmapSurface = reinterpret_cast(resolveEglFunc("eglCreatePixmapSurface")); EGL_DestroySurface = reinterpret_cast(resolveEglFunc("eglDestroySurface")); EGL_QuerySurface = reinterpret_cast(resolveEglFunc("eglQuerySurface")); EGL_BindAPI = reinterpret_cast(resolveEglFunc("eglBindAPI")); EGL_QueryAPI = reinterpret_cast(resolveEglFunc("eglQueryAPI")); EGL_WaitClient = reinterpret_cast(resolveEglFunc("eglWaitClient")); EGL_ReleaseThread = reinterpret_cast(resolveEglFunc("eglReleaseThread")); EGL_CreatePbufferFromClientBuffer = reinterpret_cast(resolveEglFunc("eglCreatePbufferFromClientBuffer")); EGL_SurfaceAttrib = reinterpret_cast(resolveEglFunc("eglSurfaceAttrib")); EGL_BindTexImage = reinterpret_cast(resolveEglFunc("eglBindTexImage")); EGL_ReleaseTexImage = reinterpret_cast(resolveEglFunc("eglReleaseTexImage")); EGL_SwapInterval = reinterpret_cast(resolveEglFunc("eglSwapInterval")); EGL_CreateContext = reinterpret_cast(resolveEglFunc("eglCreateContext")); EGL_DestroyContext = reinterpret_cast(resolveEglFunc("eglDestroyContext")); EGL_MakeCurrent = reinterpret_cast(resolveEglFunc("eglMakeCurrent")); EGL_GetCurrentContext = reinterpret_cast(resolveEglFunc("eglGetCurrentContext")); EGL_GetCurrentSurface = reinterpret_cast(resolveEglFunc("eglGetCurrentSurface")); EGL_GetCurrentDisplay = reinterpret_cast(resolveEglFunc("eglGetCurrentDisplay")); EGL_QueryContext = reinterpret_cast(resolveEglFunc("eglQueryContext")); EGL_WaitGL = reinterpret_cast(resolveEglFunc("eglWaitGL")); EGL_WaitNative = reinterpret_cast(resolveEglFunc("eglWaitNative")); EGL_SwapBuffers = reinterpret_cast(resolveEglFunc("eglSwapBuffers")); EGL_CopyBuffers = reinterpret_cast(resolveEglFunc("eglCopyBuffers")); EGL_GetProcAddress = reinterpret_cast<__eglMustCastToProperFunctionPointerType (EGLAPIENTRY * )(const char *)>(resolveEglFunc("eglGetProcAddress")); } void QWindowsOpenGL::resolveGLCommon() { Viewport = reinterpret_cast(resolveFunc("glViewport")); IsEnabled = reinterpret_cast(resolveFunc("glIsEnabled")); GetTexParameteriv = reinterpret_cast(resolveFunc("glGetTexParameteriv")); GetTexParameterfv = reinterpret_cast(resolveFunc("glGetTexParameterfv")); GetString = reinterpret_cast(resolveFunc("glGetString")); GetIntegerv = reinterpret_cast(resolveFunc("glGetIntegerv")); GetFloatv = reinterpret_cast(resolveFunc("glGetFloatv")); GetError = reinterpret_cast(resolveFunc("glGetError")); GetBooleanv = reinterpret_cast(resolveFunc("glGetBooleanv")); ReadPixels = reinterpret_cast(resolveFunc("glReadPixels")); PixelStorei = reinterpret_cast(resolveFunc("glPixelStorei")); DepthFunc = reinterpret_cast(resolveFunc("glDepthFunc")); StencilOp = reinterpret_cast(resolveFunc("glStencilOp")); StencilFunc = reinterpret_cast(resolveFunc("glStencilFunc")); BlendFunc = reinterpret_cast(resolveFunc("glBlendFunc")); Flush = reinterpret_cast(resolveFunc("glFlush")); Finish = reinterpret_cast(resolveFunc("glFinish")); Enable = reinterpret_cast(resolveFunc("glEnable")); Disable = reinterpret_cast(resolveFunc("glDisable")); DepthMask = reinterpret_cast(resolveFunc("glDepthMask")); ColorMask = reinterpret_cast(resolveFunc("glColorMask")); StencilMask = reinterpret_cast(resolveFunc("glStencilMask")); ClearStencil = reinterpret_cast(resolveFunc("glClearStencil")); ClearColor = reinterpret_cast(resolveFunc("glClearColor")); Clear = reinterpret_cast(resolveFunc("glClear")); TexImage2D = reinterpret_cast(resolveFunc("glTexImage2D")); TexParameteriv = reinterpret_cast(resolveFunc("glTexParameteriv")); TexParameteri = reinterpret_cast(resolveFunc("glTexParameteri")); TexParameterfv = reinterpret_cast(resolveFunc("glTexParameterfv")); TexParameterf = reinterpret_cast(resolveFunc("glTexParameterf")); Scissor = reinterpret_cast(resolveFunc("glScissor")); LineWidth = reinterpret_cast(resolveFunc("glLineWidth")); Hint = reinterpret_cast(resolveFunc("glHint")); FrontFace = reinterpret_cast(resolveFunc("glFrontFace")); CullFace = reinterpret_cast(resolveFunc("glCullFace")); IsTexture = reinterpret_cast(resolveFunc("glIsTexture")); GenTextures = reinterpret_cast(resolveFunc("glGenTextures")); DeleteTextures = reinterpret_cast(resolveFunc("glDeleteTextures")); BindTexture = reinterpret_cast(resolveFunc("glBindTexture")); TexSubImage2D = reinterpret_cast(resolveFunc("glTexSubImage2D")); CopyTexSubImage2D = reinterpret_cast(resolveFunc("glCopyTexSubImage2D")); CopyTexImage2D = reinterpret_cast(resolveFunc("glCopyTexImage2D")); PolygonOffset = reinterpret_cast(resolveFunc("glPolygonOffset")); DrawElements = reinterpret_cast(resolveFunc("glDrawElements")); DrawArrays = reinterpret_cast(resolveFunc("glDrawArrays")); } void QWindowsOpenGL::resolveGL11() { DepthRange = reinterpret_cast(resolveFunc("glDepthRange")); GetTexImage = reinterpret_cast(resolveFunc("glGetTexImage")); LogicOp = reinterpret_cast(resolveFunc("glLogicOp")); ClearDepth = reinterpret_cast(resolveFunc("glClearDepth")); PolygonMode = reinterpret_cast(resolveFunc("glPolygonMode")); PointSize = reinterpret_cast(resolveFunc("glPointSize")); GetTexLevelParameteriv = reinterpret_cast(resolveFunc("glGetTexLevelParameteriv")); GetTexLevelParameterfv = reinterpret_cast(resolveFunc("glGetTexLevelParameterfv")); GetDoublev = reinterpret_cast(resolveFunc("glGetDoublev")); PixelStoref = reinterpret_cast(resolveFunc("glPixelStoref")); ReadBuffer = reinterpret_cast(resolveFunc("glReadBuffer")); DrawBuffer = reinterpret_cast(resolveFunc("glDrawBuffer")); TexImage1D = reinterpret_cast(resolveFunc("glTexImage1D")); Translatef = reinterpret_cast(resolveFunc("glTranslatef")); Translated = reinterpret_cast(resolveFunc("glTranslated")); Scalef = reinterpret_cast(resolveFunc("glScalef")); Scaled = reinterpret_cast(resolveFunc("glScaled")); Rotatef = reinterpret_cast(resolveFunc("glRotatef")); Rotated = reinterpret_cast(resolveFunc("glRotated")); PushMatrix = reinterpret_cast(resolveFunc("glPushMatrix")); PopMatrix = reinterpret_cast(resolveFunc("glPopMatrix")); Ortho = reinterpret_cast(resolveFunc("glOrtho")); MultMatrixd = reinterpret_cast(resolveFunc("glMultMatrixd")); MultMatrixf = reinterpret_cast(resolveFunc("glMultMatrixf")); MatrixMode = reinterpret_cast(resolveFunc("glMatrixMode")); LoadMatrixd = reinterpret_cast(resolveFunc("glLoadMatrixd")); LoadMatrixf = reinterpret_cast(resolveFunc("glLoadMatrixf")); LoadIdentity = reinterpret_cast(resolveFunc("glLoadIdentity")); Frustum = reinterpret_cast(resolveFunc("glFrustum")); IsList = reinterpret_cast(resolveFunc("glIsList")); GetTexGeniv = reinterpret_cast(resolveFunc("glGetTexGeniv")); GetTexGenfv = reinterpret_cast(resolveFunc("glGetTexGenfv")); GetTexGendv = reinterpret_cast(resolveFunc("glGetTexGendv")); GetTexEnviv = reinterpret_cast(resolveFunc("glGetTexEnviv")); GetTexEnvfv = reinterpret_cast(resolveFunc("glGetTexEnvfv")); GetPolygonStipple = reinterpret_cast(resolveFunc("glGetPolygonStipple")); GetPixelMapusv = reinterpret_cast(resolveFunc("glGetPixelMapusv")); GetPixelMapuiv = reinterpret_cast(resolveFunc("glGetPixelMapuiv")); GetPixelMapfv = reinterpret_cast(resolveFunc("glGetPixelMapfv")); GetMaterialiv = reinterpret_cast(resolveFunc("glGetMaterialiv")); GetMaterialfv = reinterpret_cast(resolveFunc("glGetMaterialfv")); GetMapiv = reinterpret_cast(resolveFunc("glGetMapiv")); GetMapfv = reinterpret_cast(resolveFunc("glGetMapfv")); GetMapdv = reinterpret_cast(resolveFunc("glGetMapdv")); GetLightiv = reinterpret_cast(resolveFunc("glGetLightiv")); GetLightfv = reinterpret_cast(resolveFunc("glGetLightfv")); GetClipPlane = reinterpret_cast(resolveFunc("glGetClipPlane")); DrawPixels = reinterpret_cast(resolveFunc("glDrawPixels")); CopyPixels = reinterpret_cast(resolveFunc("glCopyPixels")); PixelMapusv = reinterpret_cast(resolveFunc("glPixelMapusv")); PixelMapuiv = reinterpret_cast(resolveFunc("glPixelMapuiv")); PixelMapfv = reinterpret_cast(resolveFunc("glPixelMapfv")); PixelTransferi = reinterpret_cast(resolveFunc("glPixelTransferi")); PixelTransferf = reinterpret_cast(resolveFunc("glPixelTransferf")); PixelZoom = reinterpret_cast(resolveFunc("glPixelZoom")); AlphaFunc = reinterpret_cast(resolveFunc("glAlphaFunc")); EvalPoint2 = reinterpret_cast(resolveFunc("glEvalPoint2")); EvalMesh2 = reinterpret_cast(resolveFunc("glEvalMesh2")); EvalPoint1 = reinterpret_cast(resolveFunc("glEvalPoint1")); EvalMesh1 = reinterpret_cast(resolveFunc("glEvalMesh1")); EvalCoord2fv = reinterpret_cast(resolveFunc("glEvalCoord2fv")); EvalCoord2f = reinterpret_cast(resolveFunc("glEvalCoord2f")); EvalCoord2dv = reinterpret_cast(resolveFunc("glEvalCoord2dv")); EvalCoord2d = reinterpret_cast(resolveFunc("glEvalCoord2d")); EvalCoord1fv = reinterpret_cast(resolveFunc("glEvalCoord1fv")); EvalCoord1f = reinterpret_cast(resolveFunc("glEvalCoord1f")); EvalCoord1dv = reinterpret_cast(resolveFunc("glEvalCoord1dv")); EvalCoord1d = reinterpret_cast(resolveFunc("glEvalCoord1d")); MapGrid2f = reinterpret_cast(resolveFunc("glMapGrid2f")); MapGrid2d = reinterpret_cast(resolveFunc("glMapGrid2d")); MapGrid1f = reinterpret_cast(resolveFunc("glMapGrid1f")); MapGrid1d = reinterpret_cast(resolveFunc("glMapGrid1d")); Map2f = reinterpret_cast(resolveFunc("glMap2f")); Map2d = reinterpret_cast(resolveFunc("glMap2d")); Map1f = reinterpret_cast(resolveFunc("glMap1f")); Map1d = reinterpret_cast(resolveFunc("glMap1d")); PushAttrib = reinterpret_cast(resolveFunc("glPushAttrib")); PopAttrib = reinterpret_cast(resolveFunc("glPopAttrib")); Accum = reinterpret_cast(resolveFunc("glAccum")); IndexMask = reinterpret_cast(resolveFunc("glIndexMask")); ClearIndex = reinterpret_cast(resolveFunc("glClearIndex")); ClearAccum = reinterpret_cast(resolveFunc("glClearAccum")); PushName = reinterpret_cast(resolveFunc("glPushName")); PopName = reinterpret_cast(resolveFunc("glPopName")); PassThrough = reinterpret_cast(resolveFunc("glPassThrough")); LoadName = reinterpret_cast(resolveFunc("glLoadName")); InitNames = reinterpret_cast(resolveFunc("glInitNames")); RenderMode = reinterpret_cast(resolveFunc("glRenderMode")); SelectBuffer = reinterpret_cast(resolveFunc("glSelectBuffer")); FeedbackBuffer = reinterpret_cast(resolveFunc("glFeedbackBuffer")); TexGeniv = reinterpret_cast(resolveFunc("glTexGeniv")); TexGeni = reinterpret_cast(resolveFunc("glTexGeni")); TexGenfv = reinterpret_cast(resolveFunc("glTexGenfv")); TexGenf = reinterpret_cast(resolveFunc("glTexGenf")); TexGendv = reinterpret_cast(resolveFunc("glTexGendv")); TexGend = reinterpret_cast(resolveFunc("glTexGend")); TexEnviv = reinterpret_cast(resolveFunc("glTexEnviv")); TexEnvi = reinterpret_cast(resolveFunc("glTexEnvi")); TexEnvfv = reinterpret_cast(resolveFunc("glTexEnvfv")); TexEnvf = reinterpret_cast(resolveFunc("glTexEnvf")); ShadeModel = reinterpret_cast(resolveFunc("glShadeModel")); PolygonStipple = reinterpret_cast(resolveFunc("glPolygonStipple")); Materialiv = reinterpret_cast(resolveFunc("glMaterialiv")); Materiali = reinterpret_cast(resolveFunc("glMateriali")); Materialfv = reinterpret_cast(resolveFunc("glMaterialfv")); Materialf = reinterpret_cast(resolveFunc("glMaterialf")); LineStipple = reinterpret_cast(resolveFunc("glLineStipple")); LightModeliv = reinterpret_cast(resolveFunc("glLightModeliv")); LightModeli = reinterpret_cast(resolveFunc("glLightModeli")); LightModelfv = reinterpret_cast(resolveFunc("glLightModelfv")); LightModelf = reinterpret_cast(resolveFunc("glLightModelf")); Lightiv = reinterpret_cast(resolveFunc("glLightiv")); Lighti = reinterpret_cast(resolveFunc("glLighti")); Lightfv = reinterpret_cast(resolveFunc("glLightfv")); Lightf = reinterpret_cast(resolveFunc("glLightf")); Fogiv = reinterpret_cast(resolveFunc("glFogiv")); Fogi = reinterpret_cast(resolveFunc("glFogi")); Fogfv = reinterpret_cast(resolveFunc("glFogfv")); Fogf = reinterpret_cast(resolveFunc("glFogf")); ColorMaterial = reinterpret_cast(resolveFunc("glColorMaterial")); ClipPlane = reinterpret_cast(resolveFunc("glClipPlane")); Vertex4sv = reinterpret_cast(resolveFunc("glVertex4sv")); Vertex4s = reinterpret_cast(resolveFunc("glVertex4s")); Vertex4iv = reinterpret_cast(resolveFunc("glVertex4iv")); Vertex4i = reinterpret_cast(resolveFunc("glVertex4i")); Vertex4fv = reinterpret_cast(resolveFunc("glVertex4fv")); Vertex4f = reinterpret_cast(resolveFunc("glVertex4f")); Vertex4dv = reinterpret_cast(resolveFunc("glVertex4dv")); Vertex4d = reinterpret_cast(resolveFunc("glVertex4d")); Vertex3sv = reinterpret_cast(resolveFunc("glVertex3sv")); Vertex3s = reinterpret_cast(resolveFunc("glVertex3s")); Vertex3iv = reinterpret_cast(resolveFunc("glVertex3iv")); Vertex3i = reinterpret_cast(resolveFunc("glVertex3i")); Vertex3fv = reinterpret_cast(resolveFunc("glVertex3fv")); Vertex3f = reinterpret_cast(resolveFunc("glVertex3f")); Vertex3dv = reinterpret_cast(resolveFunc("glVertex3dv")); Vertex3d = reinterpret_cast(resolveFunc("glVertex3d")); Vertex2sv = reinterpret_cast(resolveFunc("glVertex2sv")); Vertex2s = reinterpret_cast(resolveFunc("glVertex2s")); Vertex2iv = reinterpret_cast(resolveFunc("glVertex2iv")); Vertex2i = reinterpret_cast(resolveFunc("glVertex2i")); Vertex2fv = reinterpret_cast(resolveFunc("glVertex2fv")); Vertex2f = reinterpret_cast(resolveFunc("glVertex2f")); Vertex2dv = reinterpret_cast(resolveFunc("glVertex2dv")); Vertex2d = reinterpret_cast(resolveFunc("glVertex2d")); TexCoord4sv = reinterpret_cast(resolveFunc("glTexCoord4sv")); TexCoord4s = reinterpret_cast(resolveFunc("glTexCoord4s")); TexCoord4iv = reinterpret_cast(resolveFunc("glTexCoord4iv")); TexCoord4i = reinterpret_cast(resolveFunc("glTexCoord4i")); TexCoord4fv = reinterpret_cast(resolveFunc("glTexCoord4fv")); TexCoord4f = reinterpret_cast(resolveFunc("glTexCoord4f")); TexCoord4dv = reinterpret_cast(resolveFunc("glTexCoord4dv")); TexCoord4d = reinterpret_cast(resolveFunc("glTexCoord4d")); TexCoord3sv = reinterpret_cast(resolveFunc("glTexCoord3sv")); TexCoord3s = reinterpret_cast(resolveFunc("glTexCoord3s")); TexCoord3iv = reinterpret_cast(resolveFunc("glTexCoord3iv")); TexCoord3i = reinterpret_cast(resolveFunc("glTexCoord3i")); TexCoord3fv = reinterpret_cast(resolveFunc("glTexCoord3fv")); TexCoord3f = reinterpret_cast(resolveFunc("glTexCoord3f")); TexCoord3dv = reinterpret_cast(resolveFunc("glTexCoord3dv")); TexCoord3d = reinterpret_cast(resolveFunc("glTexCoord3d")); TexCoord2sv = reinterpret_cast(resolveFunc("glTexCoord2sv")); TexCoord2s = reinterpret_cast(resolveFunc("glTexCoord2s")); TexCoord2iv = reinterpret_cast(resolveFunc("glTexCoord2iv")); TexCoord2i = reinterpret_cast(resolveFunc("glTexCoord2i")); TexCoord2fv = reinterpret_cast(resolveFunc("glTexCoord2fv")); TexCoord2f = reinterpret_cast(resolveFunc("glTexCoord2f")); TexCoord2dv = reinterpret_cast(resolveFunc("glTexCoord2dv")); TexCoord2d = reinterpret_cast(resolveFunc("glTexCoord2d")); TexCoord1sv = reinterpret_cast(resolveFunc("glTexCoord1sv")); TexCoord1s = reinterpret_cast(resolveFunc("glTexCoord1s")); TexCoord1iv = reinterpret_cast(resolveFunc("glTexCoord1iv")); TexCoord1i = reinterpret_cast(resolveFunc("glTexCoord1i")); TexCoord1fv = reinterpret_cast(resolveFunc("glTexCoord1fv")); TexCoord1f = reinterpret_cast(resolveFunc("glTexCoord1f")); TexCoord1dv = reinterpret_cast(resolveFunc("glTexCoord1dv")); TexCoord1d = reinterpret_cast(resolveFunc("glTexCoord1d")); Rectsv = reinterpret_cast(resolveFunc("glRectsv")); Rects = reinterpret_cast(resolveFunc("glRects")); Rectiv = reinterpret_cast(resolveFunc("glRectiv")); Recti = reinterpret_cast(resolveFunc("glRecti")); Rectfv = reinterpret_cast(resolveFunc("glRectfv")); Rectf = reinterpret_cast(resolveFunc("glRectf")); Rectdv = reinterpret_cast(resolveFunc("glRectdv")); Rectd = reinterpret_cast(resolveFunc("glRectd")); RasterPos4sv = reinterpret_cast(resolveFunc("glRasterPos4sv")); RasterPos4s = reinterpret_cast(resolveFunc("glRasterPos4s")); RasterPos4iv = reinterpret_cast(resolveFunc("glRasterPos4iv")); RasterPos4i = reinterpret_cast(resolveFunc("glRasterPos4i")); RasterPos4fv = reinterpret_cast(resolveFunc("glRasterPos4fv")); RasterPos4f = reinterpret_cast(resolveFunc("glRasterPos4f")); RasterPos4dv = reinterpret_cast(resolveFunc("glRasterPos4dv")); RasterPos4d = reinterpret_cast(resolveFunc("glRasterPos4d")); RasterPos3sv = reinterpret_cast(resolveFunc("glRasterPos3sv")); RasterPos3s = reinterpret_cast(resolveFunc("glRasterPos3s")); RasterPos3iv = reinterpret_cast(resolveFunc("glRasterPos3iv")); RasterPos3i = reinterpret_cast(resolveFunc("glRasterPos3i")); RasterPos3fv = reinterpret_cast(resolveFunc("glRasterPos3fv")); RasterPos3f = reinterpret_cast(resolveFunc("glRasterPos3f")); RasterPos3dv = reinterpret_cast(resolveFunc("glRasterPos3dv")); RasterPos3d = reinterpret_cast(resolveFunc("glRasterPos3d")); RasterPos2sv = reinterpret_cast(resolveFunc("glRasterPos2sv")); RasterPos2s = reinterpret_cast(resolveFunc("glRasterPos2s")); RasterPos2iv = reinterpret_cast(resolveFunc("glRasterPos2iv")); RasterPos2i = reinterpret_cast(resolveFunc("glRasterPos2i")); RasterPos2fv = reinterpret_cast(resolveFunc("glRasterPos2fv")); RasterPos2f = reinterpret_cast(resolveFunc("glRasterPos2f")); RasterPos2dv = reinterpret_cast(resolveFunc("glRasterPos2dv")); RasterPos2d = reinterpret_cast(resolveFunc("glRasterPos2d")); Normal3sv = reinterpret_cast(resolveFunc("glNormal3sv")); Normal3s = reinterpret_cast(resolveFunc("glNormal3s")); Normal3iv = reinterpret_cast(resolveFunc("glNormal3iv")); Normal3i = reinterpret_cast(resolveFunc("glNormal3i")); Normal3fv = reinterpret_cast(resolveFunc("glNormal3fv")); Normal3f = reinterpret_cast(resolveFunc("glNormal3f")); Normal3dv = reinterpret_cast(resolveFunc("glNormal3dv")); Normal3d = reinterpret_cast(resolveFunc("glNormal3d")); Normal3bv = reinterpret_cast(resolveFunc("glNormal3bv")); Normal3b = reinterpret_cast(resolveFunc("glNormal3b")); Indexsv = reinterpret_cast(resolveFunc("glIndexsv")); Indexs = reinterpret_cast(resolveFunc("glIndexs")); Indexiv = reinterpret_cast(resolveFunc("glIndexiv")); Indexi = reinterpret_cast(resolveFunc("glIndexi")); Indexfv = reinterpret_cast(resolveFunc("glIndexfv")); Indexf = reinterpret_cast(resolveFunc("glIndexf")); Indexdv = reinterpret_cast(resolveFunc("glIndexdv")); Indexd = reinterpret_cast(resolveFunc("glIndexd")); End = reinterpret_cast(resolveFunc("glEnd")); EdgeFlagv = reinterpret_cast(resolveFunc("glEdgeFlagv")); EdgeFlag = reinterpret_cast(resolveFunc("glEdgeFlag")); Color4usv = reinterpret_cast(resolveFunc("glColor4usv")); Color4us = reinterpret_cast(resolveFunc("glColor4us")); Color4uiv = reinterpret_cast(resolveFunc("glColor4uiv")); Color4ui = reinterpret_cast(resolveFunc("glColor4ui")); Color4ubv = reinterpret_cast(resolveFunc("glColor4ubv")); Color4ub = reinterpret_cast(resolveFunc("glColor4ub")); Color4sv = reinterpret_cast(resolveFunc("glColor4sv")); Color4s = reinterpret_cast(resolveFunc("glColor4s")); Color4iv = reinterpret_cast(resolveFunc("glColor4iv")); Color4i = reinterpret_cast(resolveFunc("glColor4i")); Color4fv = reinterpret_cast(resolveFunc("glColor4fv")); Color4f = reinterpret_cast(resolveFunc("glColor4f")); Color4dv = reinterpret_cast(resolveFunc("glColor4dv")); Color4d = reinterpret_cast(resolveFunc("glColor4d")); Color4bv = reinterpret_cast(resolveFunc("glColor4bv")); Color4b = reinterpret_cast(resolveFunc("glColor4b")); Color3usv = reinterpret_cast(resolveFunc("glColor3usv")); Color3us = reinterpret_cast(resolveFunc("glColor3us")); Color3uiv = reinterpret_cast(resolveFunc("glColor3uiv")); Color3ui = reinterpret_cast(resolveFunc("glColor3ui")); Color3ubv = reinterpret_cast(resolveFunc("glColor3ubv")); Color3ub = reinterpret_cast(resolveFunc("glColor3ub")); Color3sv = reinterpret_cast(resolveFunc("glColor3sv")); Color3s = reinterpret_cast(resolveFunc("glColor3s")); Color3iv = reinterpret_cast(resolveFunc("glColor3iv")); Color3i = reinterpret_cast(resolveFunc("glColor3i")); Color3fv = reinterpret_cast(resolveFunc("glColor3fv")); Color3f = reinterpret_cast(resolveFunc("glColor3f")); Color3dv = reinterpret_cast(resolveFunc("glColor3dv")); Color3d = reinterpret_cast(resolveFunc("glColor3d")); Color3bv = reinterpret_cast(resolveFunc("glColor3bv")); Color3b = reinterpret_cast(resolveFunc("glColor3b")); Bitmap = reinterpret_cast(resolveFunc("glBitmap")); Begin = reinterpret_cast(resolveFunc("glBegin")); ListBase = reinterpret_cast(resolveFunc("glListBase")); GenLists = reinterpret_cast(resolveFunc("glGenLists")); DeleteLists = reinterpret_cast(resolveFunc("glDeleteLists")); CallLists = reinterpret_cast(resolveFunc("glCallLists")); CallList = reinterpret_cast(resolveFunc("glCallList")); EndList = reinterpret_cast(resolveFunc("glEndList")); NewList = reinterpret_cast(resolveFunc("glNewList")); Indexubv = reinterpret_cast(resolveFunc("glIndexubv")); Indexub = reinterpret_cast(resolveFunc("glIndexub")); TexSubImage1D = reinterpret_cast(resolveFunc("glTexSubImage1D")); CopyTexSubImage1D = reinterpret_cast(resolveFunc("glCopyTexSubImage1D")); CopyTexImage1D = reinterpret_cast(resolveFunc("glCopyTexImage1D")); GetPointerv = reinterpret_cast(resolveFunc("glGetPointerv")); PushClientAttrib = reinterpret_cast(resolveFunc("glPushClientAttrib")); PopClientAttrib = reinterpret_cast(resolveFunc("glPopClientAttrib")); PrioritizeTextures = reinterpret_cast(resolveFunc("glPrioritizeTextures")); AreTexturesResident = reinterpret_cast(resolveFunc("glAreTexturesResident")); VertexPointer = reinterpret_cast(resolveFunc("glVertexPointer")); TexCoordPointer = reinterpret_cast(resolveFunc("glTexCoordPointer")); NormalPointer = reinterpret_cast(resolveFunc("glNormalPointer")); InterleavedArrays = reinterpret_cast(resolveFunc("glInterleavedArrays")); IndexPointer = reinterpret_cast(resolveFunc("glIndexPointer")); EnableClientState = reinterpret_cast(resolveFunc("glEnableClientState")); EdgeFlagPointer = reinterpret_cast(resolveFunc("glEdgeFlagPointer")); DisableClientState = reinterpret_cast(resolveFunc("glDisableClientState")); ColorPointer = reinterpret_cast(resolveFunc("glColorPointer")); ArrayElement = reinterpret_cast(resolveFunc("glArrayElement")); } void QWindowsOpenGL::resolveGLES2() { ActiveTexture = reinterpret_cast(resolveFunc("glActiveTexture")); AttachShader = reinterpret_cast(resolveFunc("glAttachShader")); BindAttribLocation = reinterpret_cast(resolveFunc("glBindAttribLocation")); BindBuffer = reinterpret_cast(resolveFunc("glBindBuffer")); BindFramebuffer = reinterpret_cast(resolveFunc("glBindFramebuffer")); BindRenderbuffer = reinterpret_cast(resolveFunc("glBindRenderbuffer")); BlendColor = reinterpret_cast