Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
qeglplatformcontext.cpp
Go to the documentation of this file.
1// Copyright (C) 2021 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "qeglplatformcontext_p.h"
5#include "qeglconvenience_p.h"
6#include "qeglpbuffer_p.h"
7#include <qpa/qplatformwindow.h>
8#include <QtGui/qopenglcontext.h>
9#include <QtCore/qdebug.h>
10
11#ifdef Q_OS_ANDROID
12#include <QtCore/private/qjnihelpers_p.h>
13#endif
14#ifndef Q_OS_WIN
15#include <dlfcn.h>
16#endif
17
18QT_BEGIN_NAMESPACE
19
20/*!
21 \class QEGLPlatformContext
22 \brief An EGL context implementation.
23 \since 5.2
24 \internal
25 \ingroup qpa
26
27 Implement QPlatformOpenGLContext using EGL. To use it in platform
28 plugins a subclass must be created since
29 eglSurfaceForPlatformSurface() has to be reimplemented. This
30 function is used for mapping platform surfaces (windows) to EGL
31 surfaces and is necessary since different platform plugins may
32 have different ways of handling native windows (for example, a
33 plugin may choose not to back every platform window by a real EGL
34 surface). Other than that, no further customization is necessary.
35 */
36
37// Constants from EGL_KHR_create_context
38#ifndef EGL_CONTEXT_MINOR_VERSION_KHR
39#define EGL_CONTEXT_MINOR_VERSION_KHR 0x30FB
40#endif
41#ifndef EGL_CONTEXT_FLAGS_KHR
42#define EGL_CONTEXT_FLAGS_KHR 0x30FC
43#endif
44#ifndef EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR
45#define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30FD
46#endif
47#ifndef EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR
48#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001
49#endif
50#ifndef EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR
51#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
52#endif
53#ifndef EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR
54#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
55#endif
56#ifndef EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR
57#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
58#endif
59
60// Constants for OpenGL which are not available in the ES headers.
61#ifndef GL_CONTEXT_FLAGS
62#define GL_CONTEXT_FLAGS 0x821E
63#endif
64#ifndef GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT
65#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x0001
66#endif
67#ifndef GL_CONTEXT_FLAG_DEBUG_BIT
68#define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002
69#endif
70#ifndef GL_CONTEXT_PROFILE_MASK
71#define GL_CONTEXT_PROFILE_MASK 0x9126
72#endif
73#ifndef GL_CONTEXT_CORE_PROFILE_BIT
74#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
75#endif
76#ifndef GL_CONTEXT_COMPATIBILITY_PROFILE_BIT
77#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
78#endif
79
80QEGLPlatformContext::QEGLPlatformContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share, EGLDisplay display,
81 EGLConfig *config, Flags flags)
82 : m_eglDisplay(display)
83 , m_flags(flags)
84 , m_ownsContext(true)
85{
86 m_eglConfig = config ? *config : q_configFromGLFormat(display, format);
87
88 m_format = q_glFormatFromConfig(m_eglDisplay, m_eglConfig, format);
89 // m_format now has the renderableType() resolved (it cannot be Default anymore)
90 // but does not yet contain version, profile, options.
91 m_shareContext = share ? static_cast<QEGLPlatformContext *>(share)->m_eglContext : nullptr;
92
93 QList<EGLint> contextAttrs;
94 contextAttrs.append(EGL_CONTEXT_CLIENT_VERSION);
95 contextAttrs.append(format.majorVersion());
96 const bool hasKHRCreateContext = q_hasEglExtension(m_eglDisplay, "EGL_KHR_create_context");
97 if (hasKHRCreateContext) {
98 contextAttrs.append(EGL_CONTEXT_MINOR_VERSION_KHR);
99 contextAttrs.append(format.minorVersion());
100 int flags = 0;
101 // The debug bit is supported both for OpenGL and OpenGL ES.
102 if (format.testOption(QSurfaceFormat::DebugContext))
103 flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
104 // The fwdcompat bit is only for OpenGL 3.0+.
105 if (m_format.renderableType() == QSurfaceFormat::OpenGL
106 && format.majorVersion() >= 3
107 && !format.testOption(QSurfaceFormat::DeprecatedFunctions))
108 flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
109 if (flags) {
110 contextAttrs.append(EGL_CONTEXT_FLAGS_KHR);
111 contextAttrs.append(flags);
112 }
113 // Profiles are OpenGL only and mandatory in 3.2+. The value is silently ignored for < 3.2.
114 if (m_format.renderableType() == QSurfaceFormat::OpenGL) {
115 contextAttrs.append(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR);
116 contextAttrs.append(format.profile() == QSurfaceFormat::CoreProfile
117 ? EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR
118 : EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR);
119 }
120 }
121
122#ifdef EGL_EXT_protected_content
123 if (format.testOption(QSurfaceFormat::ProtectedContent)) {
124 if (q_hasEglExtension(m_eglDisplay, "EGL_EXT_protected_content")) {
125 contextAttrs.append(EGL_PROTECTED_CONTENT_EXT);
126 contextAttrs.append(EGL_TRUE);
127 } else {
128 m_format.setOption(QSurfaceFormat::ProtectedContent, false);
129 }
130 }
131#endif
132
133 // Special Options for OpenVG surfaces
134 if (m_format.renderableType() == QSurfaceFormat::OpenVG) {
135 contextAttrs.append(EGL_ALPHA_MASK_SIZE);
136 contextAttrs.append(8);
137 }
138
139 contextAttrs.append(EGL_NONE);
140 m_contextAttrs = contextAttrs;
141
142 switch (m_format.renderableType()) {
143 case QSurfaceFormat::OpenVG:
144 m_api = EGL_OPENVG_API;
145 break;
146#ifdef EGL_VERSION_1_4
147 case QSurfaceFormat::OpenGL:
148 m_api = EGL_OPENGL_API;
149 break;
150#endif // EGL_VERSION_1_4
151 default:
152 m_api = EGL_OPENGL_ES_API;
153 break;
154 }
155
156 eglBindAPI(m_api);
157 m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, m_shareContext, contextAttrs.constData());
158 if (m_eglContext == EGL_NO_CONTEXT && m_shareContext != EGL_NO_CONTEXT) {
159 m_shareContext = nullptr;
160 m_eglContext = eglCreateContext(m_eglDisplay, m_eglConfig, nullptr, contextAttrs.constData());
161 }
162
163 if (m_eglContext == EGL_NO_CONTEXT) {
164 qWarning("QEGLPlatformContext: Failed to create context: %x", eglGetError());
165 return;
166 }
167
168 static const bool printConfig = qEnvironmentVariableIntValue("QT_QPA_EGLFS_DEBUG");
169 if (printConfig) {
170 qDebug() << "Created context for format" << format << "with config:";
171 q_printEglConfig(m_eglDisplay, m_eglConfig);
172
173 static const bool printAllConfigs = qEnvironmentVariableIntValue("QT_QPA_EGLFS_DEBUG") > 1;
174 if (printAllConfigs) {
175 EGLint numConfigs = 0;
176 eglGetConfigs(m_eglDisplay, nullptr, 0, &numConfigs);
177 QVector<EGLConfig> configs;
178 configs.resize(numConfigs);
179 eglGetConfigs(m_eglDisplay, configs.data(), numConfigs, &numConfigs);
180 qDebug("\nAll EGLConfigs: count=%d", numConfigs);
181 for (EGLint i = 0; i < numConfigs; ++i) {
182 qDebug("EGLConfig #%d", i);
183 q_printEglConfig(m_eglDisplay, configs[i]);
184 }
185 qDebug("\n");
186 }
187 }
188
189 // Cannot just call updateFormatFromGL() since it relies on virtuals. Defer it to initialize().
190}
191
192void QEGLPlatformContext::adopt(EGLContext context, EGLDisplay display, QPlatformOpenGLContext *share)
193{
194 Q_ASSERT(!m_ownsContext);
195
196 m_eglDisplay = display;
197
198 // Figure out the EGLConfig.
199 EGLint value = 0;
200 eglQueryContext(m_eglDisplay, context, EGL_CONFIG_ID, &value);
201 EGLint n = 0;
202 EGLConfig cfg;
203 const EGLint attribs[] = { EGL_CONFIG_ID, value, EGL_NONE };
204 if (eglChooseConfig(m_eglDisplay, attribs, &cfg, 1, &n) && n == 1) {
205 m_eglConfig = cfg;
206 m_format = q_glFormatFromConfig(m_eglDisplay, m_eglConfig);
207 } else {
208 qWarning("QEGLPlatformContext: Failed to get framebuffer configuration for context");
209 }
210
211 // Fetch client API type.
212 value = 0;
213 eglQueryContext(m_eglDisplay, context, EGL_CONTEXT_CLIENT_TYPE, &value);
214 if (value == EGL_OPENGL_API || value == EGL_OPENGL_ES_API) {
215 // if EGL config supports both OpenGL and OpenGL ES render type,
216 // q_glFormatFromConfig() with the default "referenceFormat" parameter
217 // will always figure it out as OpenGL render type.
218 // We can override it to match user's real render type.
219 if (value == EGL_OPENGL_ES_API)
220 m_format.setRenderableType(QSurfaceFormat::OpenGLES);
221 m_api = value;
222 eglBindAPI(m_api);
223 } else {
224 qWarning("QEGLPlatformContext: Failed to get client API type");
225 m_api = EGL_OPENGL_ES_API;
226 }
227
228 m_eglContext = context;
229 m_shareContext = share ? static_cast<QEGLPlatformContext *>(share)->m_eglContext : nullptr;
230 updateFormatFromGL();
231}
232
233void QEGLPlatformContext::initialize()
234{
235 if (m_eglContext != EGL_NO_CONTEXT)
236 updateFormatFromGL();
237}
238
239// Base implementation for pbuffers. Subclasses will handle the specialized cases for
240// platforms without pbuffers.
241EGLSurface QEGLPlatformContext::createTemporaryOffscreenSurface()
242{
243 // Make the context current to ensure the GL version query works. This needs a surface too.
244 const EGLint pbufferAttributes[] = {
245 EGL_WIDTH, 1,
246 EGL_HEIGHT, 1,
247 EGL_LARGEST_PBUFFER, EGL_FALSE,
248 EGL_NONE
249 };
250
251 // Cannot just pass m_eglConfig because it may not be suitable for pbuffers. Instead,
252 // do what QEGLPbuffer would do: request a config with the same attributes but with
253 // PBUFFER_BIT set.
254 EGLConfig config = q_configFromGLFormat(m_eglDisplay, m_format, false, EGL_PBUFFER_BIT);
255
256 return eglCreatePbufferSurface(m_eglDisplay, config, pbufferAttributes);
257}
258
259void QEGLPlatformContext::destroyTemporaryOffscreenSurface(EGLSurface surface)
260{
261 eglDestroySurface(m_eglDisplay, surface);
262}
263
264void QEGLPlatformContext::runGLChecks()
265{
266 // Nothing to do here, subclasses may override in order to perform OpenGL
267 // queries needing a context.
268}
269
270void QEGLPlatformContext::updateFormatFromGL()
271{
272#ifndef QT_NO_OPENGL
273 // Have to save & restore to prevent QOpenGLContext::currentContext() from becoming
274 // inconsistent after QOpenGLContext::create().
275 EGLDisplay prevDisplay = eglGetCurrentDisplay();
276 if (prevDisplay == EGL_NO_DISPLAY) // when no context is current
277 prevDisplay = m_eglDisplay;
278 EGLContext prevContext = eglGetCurrentContext();
279 EGLSurface prevSurfaceDraw = eglGetCurrentSurface(EGL_DRAW);
280 EGLSurface prevSurfaceRead = eglGetCurrentSurface(EGL_READ);
281
282 // Rely on the surfaceless extension, if available. This is beneficial since we can
283 // avoid creating an extra pbuffer surface which is apparently troublesome with some
284 // drivers (Mesa) when certain attributes are present (multisampling).
285 EGLSurface tempSurface = EGL_NO_SURFACE;
286 EGLContext tempContext = EGL_NO_CONTEXT;
287 if (m_flags.testFlag(NoSurfaceless) || !q_hasEglExtension(m_eglDisplay, "EGL_KHR_surfaceless_context"))
288 tempSurface = createTemporaryOffscreenSurface();
289
290 EGLBoolean ok = eglMakeCurrent(m_eglDisplay, tempSurface, tempSurface, m_eglContext);
291 if (!ok) {
292 EGLConfig config = q_configFromGLFormat(m_eglDisplay, m_format, false, EGL_PBUFFER_BIT);
293 tempContext = eglCreateContext(m_eglDisplay, config, nullptr, m_contextAttrs.constData());
294 if (tempContext != EGL_NO_CONTEXT)
295 ok = eglMakeCurrent(m_eglDisplay, tempSurface, tempSurface, tempContext);
296 }
297 if (ok) {
298 if (m_format.renderableType() == QSurfaceFormat::OpenGL
299 || m_format.renderableType() == QSurfaceFormat::OpenGLES) {
300 const GLubyte *s = glGetString(GL_VERSION);
301 if (s) {
302 QByteArray version = QByteArray(reinterpret_cast<const char *>(s));
303 int major, minor;
304 if (QPlatformOpenGLContext::parseOpenGLVersion(version, major, minor)) {
305 m_format.setMajorVersion(major);
306 m_format.setMinorVersion(minor);
307 }
308 }
309 m_format.setProfile(QSurfaceFormat::NoProfile);
310 m_format.setOptions(QSurfaceFormat::FormatOptions());
311 if (m_format.renderableType() == QSurfaceFormat::OpenGL) {
312 // Check profile and options.
313 if (m_format.majorVersion() < 3) {
314 m_format.setOption(QSurfaceFormat::DeprecatedFunctions);
315 } else {
316 GLint value = 0;
317 glGetIntegerv(GL_CONTEXT_FLAGS, &value);
318 if (!(value & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT))
319 m_format.setOption(QSurfaceFormat::DeprecatedFunctions);
320 if (value & GL_CONTEXT_FLAG_DEBUG_BIT)
321 m_format.setOption(QSurfaceFormat::DebugContext);
322 if (m_format.version() >= std::pair(3, 2)) {
323 value = 0;
324 glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &value);
325 if (value & GL_CONTEXT_CORE_PROFILE_BIT)
326 m_format.setProfile(QSurfaceFormat::CoreProfile);
327 else if (value & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
328 m_format.setProfile(QSurfaceFormat::CompatibilityProfile);
329 }
330 }
331 }
332 }
333 runGLChecks();
334 eglMakeCurrent(prevDisplay, prevSurfaceDraw, prevSurfaceRead, prevContext);
335 } else {
336 qWarning("QEGLPlatformContext: Failed to make temporary surface current, format not updated (%x)", eglGetError());
337 }
338 if (tempSurface != EGL_NO_SURFACE)
339 destroyTemporaryOffscreenSurface(tempSurface);
340 if (tempContext != EGL_NO_CONTEXT)
341 eglDestroyContext(m_eglDisplay, tempContext);
342#endif // QT_NO_OPENGL
343}
344
345bool QEGLPlatformContext::makeCurrent(QPlatformSurface *surface)
346{
347 Q_ASSERT(surface->surface()->supportsOpenGL());
348
349 eglBindAPI(m_api);
350
351 EGLSurface eglSurface = eglSurfaceForPlatformSurface(surface);
352
353 // shortcut: on some GPUs, eglMakeCurrent is not a cheap operation
354 if (eglGetCurrentContext() == m_eglContext &&
355 eglGetCurrentDisplay() == m_eglDisplay &&
356 eglGetCurrentSurface(EGL_READ) == eglSurface &&
357 eglGetCurrentSurface(EGL_DRAW) == eglSurface) {
358 return true;
359 }
360
361 const bool ok = eglMakeCurrent(m_eglDisplay, eglSurface, eglSurface, m_eglContext);
362 if (ok) {
363 if (!m_swapIntervalEnvChecked) {
364 m_swapIntervalEnvChecked = true;
365 if (qEnvironmentVariableIsSet("QT_QPA_EGLFS_SWAPINTERVAL")) {
366 QByteArray swapIntervalString = qgetenv("QT_QPA_EGLFS_SWAPINTERVAL");
367 bool intervalOk;
368 const int swapInterval = swapIntervalString.toInt(&intervalOk);
369 if (intervalOk)
370 m_swapIntervalFromEnv = swapInterval;
371 }
372 }
373 const int requestedSwapInterval = m_swapIntervalFromEnv >= 0
374 ? m_swapIntervalFromEnv
375 : surface->format().swapInterval();
376 if (requestedSwapInterval >= 0 && m_swapInterval != requestedSwapInterval) {
377 m_swapInterval = requestedSwapInterval;
378 if (eglSurface != EGL_NO_SURFACE) // skip if using surfaceless context
379 eglSwapInterval(eglDisplay(), m_swapInterval);
380 }
381#if defined(Q_OS_VXWORKS) && defined(Q_PROCESSOR_X86_64)
382 // Clear set of framebuffers as workaround for display artifacts found
383 // in Wind River's Mesa OpenGL implementation
384 static bool firstWindow = true;
385 if (firstWindow && (QSurface::Window == surface->surface()->surfaceClass())) {
386 glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
387 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
388 swapBuffers(surface);
389 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
390 swapBuffers(surface);
391 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
392 swapBuffers(surface);
393 firstWindow = false;
394 }
395#endif
396 } else {
397 qWarning("QEGLPlatformContext: eglMakeCurrent failed: %x", eglGetError());
398 }
399
400 return ok;
401}
402
403QEGLPlatformContext::~QEGLPlatformContext()
404{
405 if (m_ownsContext && m_eglContext != EGL_NO_CONTEXT)
406 eglDestroyContext(m_eglDisplay, m_eglContext);
407
408 m_eglContext = EGL_NO_CONTEXT;
409}
410
411void QEGLPlatformContext::doneCurrent()
412{
413 eglBindAPI(m_api);
414 bool ok = eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
415 if (!ok)
416 qWarning("QEGLPlatformContext: eglMakeCurrent failed: %x", eglGetError());
417}
418
419void QEGLPlatformContext::swapBuffers(QPlatformSurface *surface)
420{
421 eglBindAPI(m_api);
422 EGLSurface eglSurface = eglSurfaceForPlatformSurface(surface);
423 if (eglSurface != EGL_NO_SURFACE) { // skip if using surfaceless context
424 bool ok = eglSwapBuffers(m_eglDisplay, eglSurface);
425 if (!ok)
426 qWarning("QEGLPlatformContext: eglSwapBuffers failed: %x", eglGetError());
427 }
428}
429
430QFunctionPointer QEGLPlatformContext::getProcAddress(const char *procName)
431{
432 eglBindAPI(m_api);
433 QFunctionPointer proc = (QFunctionPointer) eglGetProcAddress(procName);
434#if !defined(Q_OS_WIN) && !defined(Q_OS_INTEGRITY)
435 if (!proc)
436 proc = (QFunctionPointer) dlsym(RTLD_DEFAULT, procName);
437#elif !defined(QT_OPENGL_DYNAMIC)
438 // On systems without KHR_get_all_proc_addresses and without
439 // dynamic linking there still has to be a way to access the
440 // standard GLES functions. QOpenGL(Extra)Functions never makes
441 // direct GL API calls since Qt 5.7, so all such workarounds are
442 // expected to be handled in the platform plugin.
443 if (!proc) {
444 static struct StdFunc {
445 const char *name;
446 QFunctionPointer func;
447 } standardFuncs[] = {
448#if QT_CONFIG(opengles2)
449 { "glBindTexture", (QFunctionPointer) ::glBindTexture },
450 { "glBlendFunc", (QFunctionPointer) ::glBlendFunc },
451 { "glClear", (QFunctionPointer) ::glClear },
452 { "glClearColor", (QFunctionPointer) ::glClearColor },
453 { "glClearStencil", (QFunctionPointer) ::glClearStencil },
454 { "glColorMask", (QFunctionPointer) ::glColorMask },
455 { "glCopyTexImage2D", (QFunctionPointer) ::glCopyTexImage2D },
456 { "glCopyTexSubImage2D", (QFunctionPointer) ::glCopyTexSubImage2D },
457 { "glCullFace", (QFunctionPointer) ::glCullFace },
458 { "glDeleteTextures", (QFunctionPointer) ::glDeleteTextures },
459 { "glDepthFunc", (QFunctionPointer) ::glDepthFunc },
460 { "glDepthMask", (QFunctionPointer) ::glDepthMask },
461 { "glDisable", (QFunctionPointer) ::glDisable },
462 { "glDrawArrays", (QFunctionPointer) ::glDrawArrays },
463 { "glDrawElements", (QFunctionPointer) ::glDrawElements },
464 { "glEnable", (QFunctionPointer) ::glEnable },
465 { "glFinish", (QFunctionPointer) ::glFinish },
466 { "glFlush", (QFunctionPointer) ::glFlush },
467 { "glFrontFace", (QFunctionPointer) ::glFrontFace },
468 { "glGenTextures", (QFunctionPointer) ::glGenTextures },
469 { "glGetBooleanv", (QFunctionPointer) ::glGetBooleanv },
470 { "glGetError", (QFunctionPointer) ::glGetError },
471 { "glGetFloatv", (QFunctionPointer) ::glGetFloatv },
472 { "glGetIntegerv", (QFunctionPointer) ::glGetIntegerv },
473 { "glGetString", (QFunctionPointer) ::glGetString },
474 { "glGetTexParameterfv", (QFunctionPointer) ::glGetTexParameterfv },
475 { "glGetTexParameteriv", (QFunctionPointer) ::glGetTexParameteriv },
476 { "glHint", (QFunctionPointer) ::glHint },
477 { "glIsEnabled", (QFunctionPointer) ::glIsEnabled },
478 { "glIsTexture", (QFunctionPointer) ::glIsTexture },
479 { "glLineWidth", (QFunctionPointer) ::glLineWidth },
480 { "glPixelStorei", (QFunctionPointer) ::glPixelStorei },
481 { "glPolygonOffset", (QFunctionPointer) ::glPolygonOffset },
482 { "glReadPixels", (QFunctionPointer) ::glReadPixels },
483 { "glScissor", (QFunctionPointer) ::glScissor },
484 { "glStencilFunc", (QFunctionPointer) ::glStencilFunc },
485 { "glStencilMask", (QFunctionPointer) ::glStencilMask },
486 { "glStencilOp", (QFunctionPointer) ::glStencilOp },
487 { "glTexImage2D", (QFunctionPointer) ::glTexImage2D },
488 { "glTexParameterf", (QFunctionPointer) ::glTexParameterf },
489 { "glTexParameterfv", (QFunctionPointer) ::glTexParameterfv },
490 { "glTexParameteri", (QFunctionPointer) ::glTexParameteri },
491 { "glTexParameteriv", (QFunctionPointer) ::glTexParameteriv },
492 { "glTexSubImage2D", (QFunctionPointer) ::glTexSubImage2D },
493 { "glViewport", (QFunctionPointer) ::glViewport },
494
495 { "glActiveTexture", (QFunctionPointer) ::glActiveTexture },
496 { "glAttachShader", (QFunctionPointer) ::glAttachShader },
497 { "glBindAttribLocation", (QFunctionPointer) ::glBindAttribLocation },
498 { "glBindBuffer", (QFunctionPointer) ::glBindBuffer },
499 { "glBindFramebuffer", (QFunctionPointer) ::glBindFramebuffer },
500 { "glBindRenderbuffer", (QFunctionPointer) ::glBindRenderbuffer },
501 { "glBlendColor", (QFunctionPointer) ::glBlendColor },
502 { "glBlendEquation", (QFunctionPointer) ::glBlendEquation },
503 { "glBlendEquationSeparate", (QFunctionPointer) ::glBlendEquationSeparate },
504 { "glBlendFuncSeparate", (QFunctionPointer) ::glBlendFuncSeparate },
505 { "glBufferData", (QFunctionPointer) ::glBufferData },
506 { "glBufferSubData", (QFunctionPointer) ::glBufferSubData },
507 { "glCheckFramebufferStatus", (QFunctionPointer) ::glCheckFramebufferStatus },
508 { "glCompileShader", (QFunctionPointer) ::glCompileShader },
509 { "glCompressedTexImage2D", (QFunctionPointer) ::glCompressedTexImage2D },
510 { "glCompressedTexSubImage2D", (QFunctionPointer) ::glCompressedTexSubImage2D },
511 { "glCreateProgram", (QFunctionPointer) ::glCreateProgram },
512 { "glCreateShader", (QFunctionPointer) ::glCreateShader },
513 { "glDeleteBuffers", (QFunctionPointer) ::glDeleteBuffers },
514 { "glDeleteFramebuffers", (QFunctionPointer) ::glDeleteFramebuffers },
515 { "glDeleteProgram", (QFunctionPointer) ::glDeleteProgram },
516 { "glDeleteRenderbuffers", (QFunctionPointer) ::glDeleteRenderbuffers },
517 { "glDeleteShader", (QFunctionPointer) ::glDeleteShader },
518 { "glDetachShader", (QFunctionPointer) ::glDetachShader },
519 { "glDisableVertexAttribArray", (QFunctionPointer) ::glDisableVertexAttribArray },
520 { "glEnableVertexAttribArray", (QFunctionPointer) ::glEnableVertexAttribArray },
521 { "glFramebufferRenderbuffer", (QFunctionPointer) ::glFramebufferRenderbuffer },
522 { "glFramebufferTexture2D", (QFunctionPointer) ::glFramebufferTexture2D },
523 { "glGenBuffers", (QFunctionPointer) ::glGenBuffers },
524 { "glGenerateMipmap", (QFunctionPointer) ::glGenerateMipmap },
525 { "glGenFramebuffers", (QFunctionPointer) ::glGenFramebuffers },
526 { "glGenRenderbuffers", (QFunctionPointer) ::glGenRenderbuffers },
527 { "glGetActiveAttrib", (QFunctionPointer) ::glGetActiveAttrib },
528 { "glGetActiveUniform", (QFunctionPointer) ::glGetActiveUniform },
529 { "glGetAttachedShaders", (QFunctionPointer) ::glGetAttachedShaders },
530 { "glGetAttribLocation", (QFunctionPointer) ::glGetAttribLocation },
531 { "glGetBufferParameteriv", (QFunctionPointer) ::glGetBufferParameteriv },
532 { "glGetFramebufferAttachmentParameteriv", (QFunctionPointer) ::glGetFramebufferAttachmentParameteriv },
533 { "glGetProgramiv", (QFunctionPointer) ::glGetProgramiv },
534 { "glGetProgramInfoLog", (QFunctionPointer) ::glGetProgramInfoLog },
535 { "glGetRenderbufferParameteriv", (QFunctionPointer) ::glGetRenderbufferParameteriv },
536 { "glGetShaderiv", (QFunctionPointer) ::glGetShaderiv },
537 { "glGetShaderInfoLog", (QFunctionPointer) ::glGetShaderInfoLog },
538 { "glGetShaderPrecisionFormat", (QFunctionPointer) ::glGetShaderPrecisionFormat },
539 { "glGetShaderSource", (QFunctionPointer) ::glGetShaderSource },
540 { "glGetUniformfv", (QFunctionPointer) ::glGetUniformfv },
541 { "glGetUniformiv", (QFunctionPointer) ::glGetUniformiv },
542 { "glGetUniformLocation", (QFunctionPointer) ::glGetUniformLocation },
543 { "glGetVertexAttribfv", (QFunctionPointer) ::glGetVertexAttribfv },
544 { "glGetVertexAttribiv", (QFunctionPointer) ::glGetVertexAttribiv },
545 { "glGetVertexAttribPointerv", (QFunctionPointer) ::glGetVertexAttribPointerv },
546 { "glIsBuffer", (QFunctionPointer) ::glIsBuffer },
547 { "glIsFramebuffer", (QFunctionPointer) ::glIsFramebuffer },
548 { "glIsProgram", (QFunctionPointer) ::glIsProgram },
549 { "glIsRenderbuffer", (QFunctionPointer) ::glIsRenderbuffer },
550 { "glIsShader", (QFunctionPointer) ::glIsShader },
551 { "glLinkProgram", (QFunctionPointer) ::glLinkProgram },
552 { "glReleaseShaderCompiler", (QFunctionPointer) ::glReleaseShaderCompiler },
553 { "glRenderbufferStorage", (QFunctionPointer) ::glRenderbufferStorage },
554 { "glSampleCoverage", (QFunctionPointer) ::glSampleCoverage },
555 { "glShaderBinary", (QFunctionPointer) ::glShaderBinary },
556 { "glShaderSource", (QFunctionPointer) ::glShaderSource },
557 { "glStencilFuncSeparate", (QFunctionPointer) ::glStencilFuncSeparate },
558 { "glStencilMaskSeparate", (QFunctionPointer) ::glStencilMaskSeparate },
559 { "glStencilOpSeparate", (QFunctionPointer) ::glStencilOpSeparate },
560 { "glUniform1f", (QFunctionPointer) ::glUniform1f },
561 { "glUniform1fv", (QFunctionPointer) ::glUniform1fv },
562 { "glUniform1i", (QFunctionPointer) ::glUniform1i },
563 { "glUniform1iv", (QFunctionPointer) ::glUniform1iv },
564 { "glUniform2f", (QFunctionPointer) ::glUniform2f },
565 { "glUniform2fv", (QFunctionPointer) ::glUniform2fv },
566 { "glUniform2i", (QFunctionPointer) ::glUniform2i },
567 { "glUniform2iv", (QFunctionPointer) ::glUniform2iv },
568 { "glUniform3f", (QFunctionPointer) ::glUniform3f },
569 { "glUniform3fv", (QFunctionPointer) ::glUniform3fv },
570 { "glUniform3i", (QFunctionPointer) ::glUniform3i },
571 { "glUniform3iv", (QFunctionPointer) ::glUniform3iv },
572 { "glUniform4f", (QFunctionPointer) ::glUniform4f },
573 { "glUniform4fv", (QFunctionPointer) ::glUniform4fv },
574 { "glUniform4i", (QFunctionPointer) ::glUniform4i },
575 { "glUniform4iv", (QFunctionPointer) ::glUniform4iv },
576 { "glUniformMatrix2fv", (QFunctionPointer) ::glUniformMatrix2fv },
577 { "glUniformMatrix3fv", (QFunctionPointer) ::glUniformMatrix3fv },
578 { "glUniformMatrix4fv", (QFunctionPointer) ::glUniformMatrix4fv },
579 { "glUseProgram", (QFunctionPointer) ::glUseProgram },
580 { "glValidateProgram", (QFunctionPointer) ::glValidateProgram },
581 { "glVertexAttrib1f", (QFunctionPointer) ::glVertexAttrib1f },
582 { "glVertexAttrib1fv", (QFunctionPointer) ::glVertexAttrib1fv },
583 { "glVertexAttrib2f", (QFunctionPointer) ::glVertexAttrib2f },
584 { "glVertexAttrib2fv", (QFunctionPointer) ::glVertexAttrib2fv },
585 { "glVertexAttrib3f", (QFunctionPointer) ::glVertexAttrib3f },
586 { "glVertexAttrib3fv", (QFunctionPointer) ::glVertexAttrib3fv },
587 { "glVertexAttrib4f", (QFunctionPointer) ::glVertexAttrib4f },
588 { "glVertexAttrib4fv", (QFunctionPointer) ::glVertexAttrib4fv },
589 { "glVertexAttribPointer", (QFunctionPointer) ::glVertexAttribPointer },
590
591 { "glClearDepthf", (QFunctionPointer) ::glClearDepthf },
592 { "glDepthRangef", (QFunctionPointer) ::glDepthRangef },
593#endif // QT_CONFIG(opengles2)
594
595#if QT_CONFIG(opengles3)
596 { "glBeginQuery", (QFunctionPointer) ::glBeginQuery },
597 { "glBeginTransformFeedback", (QFunctionPointer) ::glBeginTransformFeedback },
598 { "glBindBufferBase", (QFunctionPointer) ::glBindBufferBase },
599 { "glBindBufferRange", (QFunctionPointer) ::glBindBufferRange },
600 { "glBindSampler", (QFunctionPointer) ::glBindSampler },
601 { "glBindTransformFeedback", (QFunctionPointer) ::glBindTransformFeedback },
602 { "glBindVertexArray", (QFunctionPointer) ::glBindVertexArray },
603 { "glBlitFramebuffer", (QFunctionPointer) ::glBlitFramebuffer },
604 { "glClearBufferfi", (QFunctionPointer) ::glClearBufferfi },
605 { "glClearBufferfv", (QFunctionPointer) ::glClearBufferfv },
606 { "glClearBufferiv", (QFunctionPointer) ::glClearBufferiv },
607 { "glClearBufferuiv", (QFunctionPointer) ::glClearBufferuiv },
608 { "glClientWaitSync", (QFunctionPointer) ::glClientWaitSync },
609 { "glCompressedTexImage3D", (QFunctionPointer) ::glCompressedTexImage3D },
610 { "glCompressedTexSubImage3D", (QFunctionPointer) ::glCompressedTexSubImage3D },
611 { "glCopyBufferSubData", (QFunctionPointer) ::glCopyBufferSubData },
612 { "glCopyTexSubImage3D", (QFunctionPointer) ::glCopyTexSubImage3D },
613 { "glDeleteQueries", (QFunctionPointer) ::glDeleteQueries },
614 { "glDeleteSamplers", (QFunctionPointer) ::glDeleteSamplers },
615 { "glDeleteSync", (QFunctionPointer) ::glDeleteSync },
616 { "glDeleteTransformFeedbacks", (QFunctionPointer) ::glDeleteTransformFeedbacks },
617 { "glDeleteVertexArrays", (QFunctionPointer) ::glDeleteVertexArrays },
618 { "glDrawArraysInstanced", (QFunctionPointer) ::glDrawArraysInstanced },
619 { "glDrawBuffers", (QFunctionPointer) ::glDrawBuffers },
620 { "glDrawElementsInstanced", (QFunctionPointer) ::glDrawElementsInstanced },
621 { "glDrawRangeElements", (QFunctionPointer) ::glDrawRangeElements },
622 { "glEndQuery", (QFunctionPointer) ::glEndQuery },
623 { "glEndTransformFeedback", (QFunctionPointer) ::glEndTransformFeedback },
624 { "glFenceSync", (QFunctionPointer) ::glFenceSync },
625 { "glFlushMappedBufferRange", (QFunctionPointer) ::glFlushMappedBufferRange },
626 { "glFramebufferTextureLayer", (QFunctionPointer) ::glFramebufferTextureLayer },
627 { "glGenQueries", (QFunctionPointer) ::glGenQueries },
628 { "glGenSamplers", (QFunctionPointer) ::glGenSamplers },
629 { "glGenTransformFeedbacks", (QFunctionPointer) ::glGenTransformFeedbacks },
630 { "glGenVertexArrays", (QFunctionPointer) ::glGenVertexArrays },
631 { "glGetActiveUniformBlockName", (QFunctionPointer) ::glGetActiveUniformBlockName },
632 { "glGetActiveUniformBlockiv", (QFunctionPointer) ::glGetActiveUniformBlockiv },
633 { "glGetActiveUniformsiv", (QFunctionPointer) ::glGetActiveUniformsiv },
634 { "glGetBufferParameteri64v", (QFunctionPointer) ::glGetBufferParameteri64v },
635 { "glGetBufferPointerv", (QFunctionPointer) ::glGetBufferPointerv },
636 { "glGetFragDataLocation", (QFunctionPointer) ::glGetFragDataLocation },
637 { "glGetInteger64i_v", (QFunctionPointer) ::glGetInteger64i_v },
638 { "glGetInteger64v", (QFunctionPointer) ::glGetInteger64v },
639 { "glGetIntegeri_v", (QFunctionPointer) ::glGetIntegeri_v },
640 { "glGetInternalformativ", (QFunctionPointer) ::glGetInternalformativ },
641 { "glGetProgramBinary", (QFunctionPointer) ::glGetProgramBinary },
642 { "glGetQueryObjectuiv", (QFunctionPointer) ::glGetQueryObjectuiv },
643 { "glGetQueryiv", (QFunctionPointer) ::glGetQueryiv },
644 { "glGetSamplerParameterfv", (QFunctionPointer) ::glGetSamplerParameterfv },
645 { "glGetSamplerParameteriv", (QFunctionPointer) ::glGetSamplerParameteriv },
646 { "glGetStringi", (QFunctionPointer) ::glGetStringi },
647 { "glGetSynciv", (QFunctionPointer) ::glGetSynciv },
648 { "glGetTransformFeedbackVarying", (QFunctionPointer) ::glGetTransformFeedbackVarying },
649 { "glGetUniformBlockIndex", (QFunctionPointer) ::glGetUniformBlockIndex },
650 { "glGetUniformIndices", (QFunctionPointer) ::glGetUniformIndices },
651 { "glGetUniformuiv", (QFunctionPointer) ::glGetUniformuiv },
652 { "glGetVertexAttribIiv", (QFunctionPointer) ::glGetVertexAttribIiv },
653 { "glGetVertexAttribIuiv", (QFunctionPointer) ::glGetVertexAttribIuiv },
654 { "glInvalidateFramebuffer", (QFunctionPointer) ::glInvalidateFramebuffer },
655 { "glInvalidateSubFramebuffer", (QFunctionPointer) ::glInvalidateSubFramebuffer },
656 { "glIsQuery", (QFunctionPointer) ::glIsQuery },
657 { "glIsSampler", (QFunctionPointer) ::glIsSampler },
658 { "glIsSync", (QFunctionPointer) ::glIsSync },
659 { "glIsTransformFeedback", (QFunctionPointer) ::glIsTransformFeedback },
660 { "glIsVertexArray", (QFunctionPointer) ::glIsVertexArray },
661 { "glMapBufferRange", (QFunctionPointer) ::glMapBufferRange },
662 { "glPauseTransformFeedback", (QFunctionPointer) ::glPauseTransformFeedback },
663 { "glProgramBinary", (QFunctionPointer) ::glProgramBinary },
664 { "glProgramParameteri", (QFunctionPointer) ::glProgramParameteri },
665 { "glReadBuffer", (QFunctionPointer) ::glReadBuffer },
666 { "glRenderbufferStorageMultisample", (QFunctionPointer) ::glRenderbufferStorageMultisample },
667 { "glResumeTransformFeedback", (QFunctionPointer) ::glResumeTransformFeedback },
668 { "glSamplerParameterf", (QFunctionPointer) ::glSamplerParameterf },
669 { "glSamplerParameterfv", (QFunctionPointer) ::glSamplerParameterfv },
670 { "glSamplerParameteri", (QFunctionPointer) ::glSamplerParameteri },
671 { "glSamplerParameteriv", (QFunctionPointer) ::glSamplerParameteriv },
672 { "glTexImage3D", (QFunctionPointer) ::glTexImage3D },
673 { "glTexStorage2D", (QFunctionPointer) ::glTexStorage2D },
674 { "glTexStorage3D", (QFunctionPointer) ::glTexStorage3D },
675 { "glTexSubImage3D", (QFunctionPointer) ::glTexSubImage3D },
676 { "glTransformFeedbackVaryings", (QFunctionPointer) ::glTransformFeedbackVaryings },
677 { "glUniform1ui", (QFunctionPointer) ::glUniform1ui },
678 { "glUniform1uiv", (QFunctionPointer) ::glUniform1uiv },
679 { "glUniform2ui", (QFunctionPointer) ::glUniform2ui },
680 { "glUniform2uiv", (QFunctionPointer) ::glUniform2uiv },
681 { "glUniform3ui", (QFunctionPointer) ::glUniform3ui },
682 { "glUniform3uiv", (QFunctionPointer) ::glUniform3uiv },
683 { "glUniform4ui", (QFunctionPointer) ::glUniform4ui },
684 { "glUniform4uiv", (QFunctionPointer) ::glUniform4uiv },
685 { "glUniformBlockBinding", (QFunctionPointer) ::glUniformBlockBinding },
686 { "glUniformMatrix2x3fv", (QFunctionPointer) ::glUniformMatrix2x3fv },
687 { "glUniformMatrix2x4fv", (QFunctionPointer) ::glUniformMatrix2x4fv },
688 { "glUniformMatrix3x2fv", (QFunctionPointer) ::glUniformMatrix3x2fv },
689 { "glUniformMatrix3x4fv", (QFunctionPointer) ::glUniformMatrix3x4fv },
690 { "glUniformMatrix4x2fv", (QFunctionPointer) ::glUniformMatrix4x2fv },
691 { "glUniformMatrix4x3fv", (QFunctionPointer) ::glUniformMatrix4x3fv },
692 { "glUnmapBuffer", (QFunctionPointer) ::glUnmapBuffer },
693 { "glVertexAttribDivisor", (QFunctionPointer) ::glVertexAttribDivisor },
694 { "glVertexAttribI4i", (QFunctionPointer) ::glVertexAttribI4i },
695 { "glVertexAttribI4iv", (QFunctionPointer) ::glVertexAttribI4iv },
696 { "glVertexAttribI4ui", (QFunctionPointer) ::glVertexAttribI4ui },
697 { "glVertexAttribI4uiv", (QFunctionPointer) ::glVertexAttribI4uiv },
698 { "glVertexAttribIPointer", (QFunctionPointer) ::glVertexAttribIPointer },
699 { "glWaitSync", (QFunctionPointer) ::glWaitSync },
700#endif // QT_CONFIG(opengles3)
701
702#if QT_CONFIG(opengles31)
703 { "glActiveShaderProgram", (QFunctionPointer) ::glActiveShaderProgram },
704 { "glBindImageTexture", (QFunctionPointer) ::glBindImageTexture },
705 { "glBindProgramPipeline", (QFunctionPointer) ::glBindProgramPipeline },
706 { "glBindVertexBuffer", (QFunctionPointer) ::glBindVertexBuffer },
707 { "glCreateShaderProgramv", (QFunctionPointer) ::glCreateShaderProgramv },
708 { "glDeleteProgramPipelines", (QFunctionPointer) ::glDeleteProgramPipelines },
709 { "glDispatchCompute", (QFunctionPointer) ::glDispatchCompute },
710 { "glDispatchComputeIndirect", (QFunctionPointer) ::glDispatchComputeIndirect },
711 { "glDrawArraysIndirect", (QFunctionPointer) ::glDrawArraysIndirect },
712 { "glDrawElementsIndirect", (QFunctionPointer) ::glDrawElementsIndirect },
713 { "glFramebufferParameteri", (QFunctionPointer) ::glFramebufferParameteri },
714 { "glGenProgramPipelines", (QFunctionPointer) ::glGenProgramPipelines },
715 { "glGetBooleani_v", (QFunctionPointer) ::glGetBooleani_v },
716 { "glGetFramebufferParameteriv", (QFunctionPointer) ::glGetFramebufferParameteriv },
717 { "glGetMultisamplefv", (QFunctionPointer) ::glGetMultisamplefv },
718 { "glGetProgramInterfaceiv", (QFunctionPointer) ::glGetProgramInterfaceiv },
719 { "glGetProgramPipelineInfoLog", (QFunctionPointer) ::glGetProgramPipelineInfoLog },
720 { "glGetProgramPipelineiv", (QFunctionPointer) ::glGetProgramPipelineiv },
721 { "glGetProgramResourceIndex", (QFunctionPointer) ::glGetProgramResourceIndex },
722 { "glGetProgramResourceLocation", (QFunctionPointer) ::glGetProgramResourceLocation },
723 { "glGetProgramResourceName", (QFunctionPointer) ::glGetProgramResourceName },
724 { "glGetProgramResourceiv", (QFunctionPointer) ::glGetProgramResourceiv },
725 { "glGetTexLevelParameterfv", (QFunctionPointer) ::glGetTexLevelParameterfv },
726 { "glGetTexLevelParameteriv", (QFunctionPointer) ::glGetTexLevelParameteriv },
727 { "glIsProgramPipeline", (QFunctionPointer) ::glIsProgramPipeline },
728 { "glMemoryBarrier", (QFunctionPointer) ::glMemoryBarrier },
729 { "glMemoryBarrierByRegion", (QFunctionPointer) ::glMemoryBarrierByRegion },
730 { "glProgramUniform1f", (QFunctionPointer) ::glProgramUniform1f },
731 { "glProgramUniform1fv", (QFunctionPointer) ::glProgramUniform1fv },
732 { "glProgramUniform1i", (QFunctionPointer) ::glProgramUniform1i },
733 { "glProgramUniform1iv", (QFunctionPointer) ::glProgramUniform1iv },
734 { "glProgramUniform1ui", (QFunctionPointer) ::glProgramUniform1ui },
735 { "glProgramUniform1uiv", (QFunctionPointer) ::glProgramUniform1uiv },
736 { "glProgramUniform2f", (QFunctionPointer) ::glProgramUniform2f },
737 { "glProgramUniform2fv", (QFunctionPointer) ::glProgramUniform2fv },
738 { "glProgramUniform2i", (QFunctionPointer) ::glProgramUniform2i },
739 { "glProgramUniform2iv", (QFunctionPointer) ::glProgramUniform2iv },
740 { "glProgramUniform2ui", (QFunctionPointer) ::glProgramUniform2ui },
741 { "glProgramUniform2uiv", (QFunctionPointer) ::glProgramUniform2uiv },
742 { "glProgramUniform3f", (QFunctionPointer) ::glProgramUniform3f },
743 { "glProgramUniform3fv", (QFunctionPointer) ::glProgramUniform3fv },
744 { "glProgramUniform3i", (QFunctionPointer) ::glProgramUniform3i },
745 { "glProgramUniform3iv", (QFunctionPointer) ::glProgramUniform3iv },
746 { "glProgramUniform3ui", (QFunctionPointer) ::glProgramUniform3ui },
747 { "glProgramUniform3uiv", (QFunctionPointer) ::glProgramUniform3uiv },
748 { "glProgramUniform4f", (QFunctionPointer) ::glProgramUniform4f },
749 { "glProgramUniform4fv", (QFunctionPointer) ::glProgramUniform4fv },
750 { "glProgramUniform4i", (QFunctionPointer) ::glProgramUniform4i },
751 { "glProgramUniform4iv", (QFunctionPointer) ::glProgramUniform4iv },
752 { "glProgramUniform4ui", (QFunctionPointer) ::glProgramUniform4ui },
753 { "glProgramUniform4uiv", (QFunctionPointer) ::glProgramUniform4uiv },
754 { "glProgramUniformMatrix2fv", (QFunctionPointer) ::glProgramUniformMatrix2fv },
755 { "glProgramUniformMatrix2x3fv", (QFunctionPointer) ::glProgramUniformMatrix2x3fv },
756 { "glProgramUniformMatrix2x4fv", (QFunctionPointer) ::glProgramUniformMatrix2x4fv },
757 { "glProgramUniformMatrix3fv", (QFunctionPointer) ::glProgramUniformMatrix3fv },
758 { "glProgramUniformMatrix3x2fv", (QFunctionPointer) ::glProgramUniformMatrix3x2fv },
759 { "glProgramUniformMatrix3x4fv", (QFunctionPointer) ::glProgramUniformMatrix3x4fv },
760 { "glProgramUniformMatrix4fv", (QFunctionPointer) ::glProgramUniformMatrix4fv },
761 { "glProgramUniformMatrix4x2fv", (QFunctionPointer) ::glProgramUniformMatrix4x2fv },
762 { "glProgramUniformMatrix4x3fv", (QFunctionPointer) ::glProgramUniformMatrix4x3fv },
763 { "glSampleMaski", (QFunctionPointer) ::glSampleMaski },
764 { "glTexStorage2DMultisample", (QFunctionPointer) ::glTexStorage2DMultisample },
765 { "glUseProgramStages", (QFunctionPointer) ::glUseProgramStages },
766 { "glValidateProgramPipeline", (QFunctionPointer) ::glValidateProgramPipeline },
767 { "glVertexAttribBinding", (QFunctionPointer) ::glVertexAttribBinding },
768 { "glVertexAttribFormat", (QFunctionPointer) ::glVertexAttribFormat },
769 { "glVertexAttribIFormat", (QFunctionPointer) ::glVertexAttribIFormat },
770 { "glVertexBindingDivisor", (QFunctionPointer) ::glVertexBindingDivisor },
771#endif // QT_CONFIG(opengles31)
772
773#if QT_CONFIG(opengles32)
774 { "glBlendBarrier", (QFunctionPointer) ::glBlendBarrier },
775 { "glCopyImageSubData", (QFunctionPointer) ::glCopyImageSubData },
776 { "glDebugMessageControl", (QFunctionPointer) ::glDebugMessageControl },
777 { "glDebugMessageInsert", (QFunctionPointer) ::glDebugMessageInsert },
778 { "glDebugMessageCallback", (QFunctionPointer) ::glDebugMessageCallback },
779 { "glGetDebugMessageLog", (QFunctionPointer) ::glGetDebugMessageLog },
780 { "glPushDebugGroup", (QFunctionPointer) ::glPushDebugGroup },
781 { "glPopDebugGroup", (QFunctionPointer) ::glPopDebugGroup },
782 { "glObjectLabel", (QFunctionPointer) ::glObjectLabel },
783 { "glGetObjectLabel", (QFunctionPointer) ::glGetObjectLabel },
784 { "glObjectPtrLabel", (QFunctionPointer) ::glObjectPtrLabel },
785 { "glGetObjectPtrLabel", (QFunctionPointer) ::glGetObjectPtrLabel },
786 { "glGetPointerv", (QFunctionPointer) ::glGetPointerv },
787 { "glEnablei", (QFunctionPointer) ::glEnablei },
788 { "glDisablei", (QFunctionPointer) ::glDisablei },
789 { "glBlendEquationi", (QFunctionPointer) ::glBlendEquationi },
790 { "glBlendEquationSeparatei", (QFunctionPointer) ::glBlendEquationSeparatei },
791 { "glBlendFunci", (QFunctionPointer) ::glBlendFunci },
792 { "glBlendFuncSeparatei", (QFunctionPointer) ::glBlendFuncSeparatei },
793 { "glColorMaski", (QFunctionPointer) ::glColorMaski },
794 { "glIsEnabledi", (QFunctionPointer) ::glIsEnabledi },
795 { "glDrawElementsBaseVertex", (QFunctionPointer) ::glDrawElementsBaseVertex },
796 { "glDrawRangeElementsBaseVertex", (QFunctionPointer) ::glDrawRangeElementsBaseVertex },
797 { "glDrawElementsInstancedBaseVertex", (QFunctionPointer) ::glDrawElementsInstancedBaseVertex },
798 { "glFramebufferTexture", (QFunctionPointer) ::glFramebufferTexture },
799 { "glPrimitiveBoundingBox", (QFunctionPointer) ::glPrimitiveBoundingBox },
800 { "glGetGraphicsResetStatus", (QFunctionPointer) ::glGetGraphicsResetStatus },
801 { "glReadnPixels", (QFunctionPointer) ::glReadnPixels },
802 { "glGetnUniformfv", (QFunctionPointer) ::glGetnUniformfv },
803 { "glGetnUniformiv", (QFunctionPointer) ::glGetnUniformiv },
804 { "glGetnUniformuiv", (QFunctionPointer) ::glGetnUniformuiv },
805 { "glMinSampleShading", (QFunctionPointer) ::glMinSampleShading },
806 { "glPatchParameteri", (QFunctionPointer) ::glPatchParameteri },
807 { "glTexParameterIiv", (QFunctionPointer) ::glTexParameterIiv },
808 { "glTexParameterIuiv", (QFunctionPointer) ::glTexParameterIuiv },
809 { "glGetTexParameterIiv", (QFunctionPointer) ::glGetTexParameterIiv },
810 { "glGetTexParameterIuiv", (QFunctionPointer) ::glGetTexParameterIuiv },
811 { "glSamplerParameterIiv", (QFunctionPointer) ::glSamplerParameterIiv },
812 { "glSamplerParameterIuiv", (QFunctionPointer) ::glSamplerParameterIuiv },
813 { "glGetSamplerParameterIiv", (QFunctionPointer) ::glGetSamplerParameterIiv },
814 { "glGetSamplerParameterIuiv", (QFunctionPointer) ::glGetSamplerParameterIuiv },
815 { "glTexBuffer", (QFunctionPointer) ::glTexBuffer },
816 { "glTexBufferRange", (QFunctionPointer) ::glTexBufferRange },
817 { "glTexStorage3DMultisample", (QFunctionPointer) ::glTexStorage3DMultisample },
818#endif // QT_CONFIG(opengles32)
819 };
820
821 for (size_t i = 0; i < sizeof(standardFuncs) / sizeof(StdFunc); ++i) {
822 if (!qstrcmp(procName, standardFuncs[i].name)) {
823 proc = standardFuncs[i].func;
824 break;
825 }
826 }
827 }
828#endif
829
830 return proc;
831}
832
833QSurfaceFormat QEGLPlatformContext::format() const
834{
835 return m_format;
836}
837
838EGLContext QEGLPlatformContext::eglContext() const
839{
840 return m_eglContext;
841}
842
843EGLDisplay QEGLPlatformContext::eglDisplay() const
844{
845 return m_eglDisplay;
846}
847
848EGLConfig QEGLPlatformContext::eglConfig() const
849{
850 return m_eglConfig;
851}
852
853QT_END_NAMESPACE
EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR
#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR
Definition qeglplatformcontext.cpp:48
GL_CONTEXT_PROFILE_MASK
#define GL_CONTEXT_PROFILE_MASK
Definition qeglplatformcontext.cpp:71
EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR
#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR
Definition qeglplatformcontext.cpp:51
EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR
#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR
Definition qeglplatformcontext.cpp:54
EGL_CONTEXT_MINOR_VERSION_KHR
#define EGL_CONTEXT_MINOR_VERSION_KHR
Definition qeglplatformcontext.cpp:39
GL_CONTEXT_COMPATIBILITY_PROFILE_BIT
#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT
Definition qeglplatformcontext.cpp:77
EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR
#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR
Definition qeglplatformcontext.cpp:57
GL_CONTEXT_CORE_PROFILE_BIT
#define GL_CONTEXT_CORE_PROFILE_BIT
Definition qeglplatformcontext.cpp:74
EGL_CONTEXT_FLAGS_KHR
#define EGL_CONTEXT_FLAGS_KHR
Definition qeglplatformcontext.cpp:42
GL_CONTEXT_FLAGS
#define GL_CONTEXT_FLAGS
Definition qeglplatformcontext.cpp:62
GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT
#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT
Definition qeglplatformcontext.cpp:65
GL_CONTEXT_FLAG_DEBUG_BIT
#define GL_CONTEXT_FLAG_DEBUG_BIT
Definition qeglplatformcontext.cpp:68
EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR
#define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR
Definition qeglplatformcontext.cpp:45