~CallLogWrapper (void);
// EGL API is exposed as member functions
-#include "egluApiPrototypes.inl"
+#include "egluCallLogWrapperApi.inl"
void enableLogging (bool enable) { m_enableLog = enable; }
-/* WARNING! THIS IS A PROGRAMMATICALLY GENERATED CODE. DO NOT MODIFY THE CODE,
- * SINCE THE CHANGES WILL BE LOST! MODIFY THE GENERATING PYTHON INSTEAD.
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ *
+ * Generated from Khronos EGL API description (egl.xml) revision 28861.
*/
-EGLint CallLogWrapper::eglGetError ()
+EGLBoolean CallLogWrapper::eglBindAPI (EGLenum api)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglGetError(" << ");" << TestLog::EndMessage;
- EGLint returnValue = ::eglGetError();
+ m_log << TestLog::Message << "eglBindAPI(" << getAPIStr(api) << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglBindAPI(api);
if (m_enableLog)
- m_log << TestLog::Message << "// " << getErrorStr(returnValue) << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLDisplay CallLogWrapper::eglGetDisplay (EGLNativeDisplayType param0)
+EGLBoolean CallLogWrapper::eglBindTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglGetDisplay(" << toHex(param0) << ");" << TestLog::EndMessage;
- EGLDisplay returnValue = ::eglGetDisplay(param0);
+ m_log << TestLog::Message << "eglBindTexImage(" << dpy << ", " << toHex(surface) << ", " << buffer << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglBindTexImage(dpy, surface, buffer);
if (m_enableLog)
- m_log << TestLog::Message << "// " << getEGLDisplayStr(returnValue) << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglInitialize (EGLDisplay param0, EGLint* param1, EGLint* param2)
+EGLBoolean CallLogWrapper::eglChooseConfig (EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglInitialize(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglInitialize(param0, param1, param2);
+ m_log << TestLog::Message << "eglChooseConfig(" << dpy << ", " << getConfigAttribListStr(attrib_list) << ", " << configs << ", " << config_size << ", " << num_config << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
- return returnValue;
-}
-
-EGLBoolean CallLogWrapper::eglTerminate (EGLDisplay param0)
-{
- if (m_enableLog)
- m_log << TestLog::Message << "eglTerminate(" << getEGLDisplayStr(param0) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglTerminate(param0);
+ {
+ m_log << TestLog::Message << "// configs = " << getPointerStr(configs, (num_config && returnValue) ? deMin32(config_size, *num_config) : 0) << TestLog::EndMessage;
+ m_log << TestLog::Message << "// num_config = " << (num_config ? de::toString(*num_config) : "NULL") << TestLog::EndMessage;
+ }
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-const char* CallLogWrapper::eglQueryString (EGLDisplay param0, EGLint param1)
+EGLBoolean CallLogWrapper::eglCopyBuffers (EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglQueryString(" << getEGLDisplayStr(param0) << ", " << param1 << ");" << TestLog::EndMessage;
- const char* returnValue = ::eglQueryString(param0, param1);
+ m_log << TestLog::Message << "eglCopyBuffers(" << dpy << ", " << toHex(surface) << ", " << toHex(target) << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglCopyBuffers(dpy, surface, target);
if (m_enableLog)
- m_log << TestLog::Message << "// " << getStringStr(returnValue) << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglGetConfigs (EGLDisplay param0, EGLConfig* param1, EGLint param2, EGLint* param3)
+EGLContext CallLogWrapper::eglCreateContext (EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglGetConfigs(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << param2 << ", " << toHex(param3) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglGetConfigs(param0, param1, param2, param3);
+ m_log << TestLog::Message << "eglCreateContext(" << dpy << ", " << toHex(config) << ", " << share_context << ", " << getContextAttribListStr(attrib_list) << ");" << TestLog::EndMessage;
+ EGLContext returnValue = ::eglCreateContext(dpy, config, share_context, attrib_list);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglChooseConfig (EGLDisplay param0, const EGLint* param1, EGLConfig* param2, EGLint param3, EGLint* param4)
+EGLSurface CallLogWrapper::eglCreatePbufferFromClientBuffer (EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglChooseConfig(" << getEGLDisplayStr(param0) << ", " << getConfigAttribListStr(param1) << ", " << toHex(param2) << ", " << param3 << ", " << toHex(param4) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglChooseConfig(param0, param1, param2, param3, param4);
+ m_log << TestLog::Message << "eglCreatePbufferFromClientBuffer(" << dpy << ", " << toHex(buftype) << ", " << toHex(buffer) << ", " << toHex(config) << ", " << attrib_list << ");" << TestLog::EndMessage;
+ EGLSurface returnValue = ::eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
if (m_enableLog)
- {
- m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, (param4 && returnValue) ? deMin32(param3, *param4) : 0) << TestLog::EndMessage;
- m_log << TestLog::Message << "// param 4 = " << (param4 ? de::toString(*param4) : "NULL") << TestLog::EndMessage;
- }
- if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglGetConfigAttrib (EGLDisplay param0, EGLConfig param1, EGLint param2, EGLint* param3)
+EGLSurface CallLogWrapper::eglCreatePbufferSurface (EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglGetConfigAttrib(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << getConfigAttribStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglGetConfigAttrib(param0, param1, param2, param3);
+ m_log << TestLog::Message << "eglCreatePbufferSurface(" << dpy << ", " << toHex(config) << ", " << getSurfaceAttribListStr(attrib_list) << ");" << TestLog::EndMessage;
+ EGLSurface returnValue = ::eglCreatePbufferSurface(dpy, config, attrib_list);
if (m_enableLog)
- {
- m_log << TestLog::Message << "// param 3 = " << getConfigAttribValuePointerStr(param2, param3) << TestLog::EndMessage;
- }
- if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLSurface CallLogWrapper::eglCreateWindowSurface (EGLDisplay param0, EGLConfig param1, EGLNativeWindowType param2, const EGLint* param3)
+EGLSurface CallLogWrapper::eglCreatePixmapSurface (EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglCreateWindowSurface(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ", " << getSurfaceAttribListStr(param3) << ");" << TestLog::EndMessage;
- EGLSurface returnValue = ::eglCreateWindowSurface(param0, param1, param2, param3);
+ m_log << TestLog::Message << "eglCreatePixmapSurface(" << dpy << ", " << toHex(config) << ", " << toHex(pixmap) << ", " << getSurfaceAttribListStr(attrib_list) << ");" << TestLog::EndMessage;
+ EGLSurface returnValue = ::eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
if (m_enableLog)
m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLSurface CallLogWrapper::eglCreatePbufferSurface (EGLDisplay param0, EGLConfig param1, const EGLint* param2)
+EGLSurface CallLogWrapper::eglCreateWindowSurface (EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglCreatePbufferSurface(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << getSurfaceAttribListStr(param2) << ");" << TestLog::EndMessage;
- EGLSurface returnValue = ::eglCreatePbufferSurface(param0, param1, param2);
+ m_log << TestLog::Message << "eglCreateWindowSurface(" << dpy << ", " << toHex(config) << ", " << toHex(win) << ", " << getSurfaceAttribListStr(attrib_list) << ");" << TestLog::EndMessage;
+ EGLSurface returnValue = ::eglCreateWindowSurface(dpy, config, win, attrib_list);
if (m_enableLog)
m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLSurface CallLogWrapper::eglCreatePixmapSurface (EGLDisplay param0, EGLConfig param1, EGLNativePixmapType param2, const EGLint* param3)
+EGLBoolean CallLogWrapper::eglDestroyContext (EGLDisplay dpy, EGLContext ctx)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglCreatePixmapSurface(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ", " << getSurfaceAttribListStr(param3) << ");" << TestLog::EndMessage;
- EGLSurface returnValue = ::eglCreatePixmapSurface(param0, param1, param2, param3);
+ m_log << TestLog::Message << "eglDestroyContext(" << dpy << ", " << ctx << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglDestroyContext(dpy, ctx);
if (m_enableLog)
- m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglDestroySurface (EGLDisplay param0, EGLSurface param1)
+EGLBoolean CallLogWrapper::eglDestroySurface (EGLDisplay dpy, EGLSurface surface)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglDestroySurface(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglDestroySurface(param0, param1);
+ m_log << TestLog::Message << "eglDestroySurface(" << dpy << ", " << toHex(surface) << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglDestroySurface(dpy, surface);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglQuerySurface (EGLDisplay param0, EGLSurface param1, EGLint param2, EGLint* param3)
+EGLBoolean CallLogWrapper::eglGetConfigAttrib (EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglQuerySurface(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << getSurfaceAttribStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglQuerySurface(param0, param1, param2, param3);
+ m_log << TestLog::Message << "eglGetConfigAttrib(" << dpy << ", " << toHex(config) << ", " << getConfigAttribStr(attribute) << ", " << value << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglGetConfigAttrib(dpy, config, attribute, value);
if (m_enableLog)
{
- m_log << TestLog::Message << "// param 3 = " << getSurfaceAttribValuePointerStr(param2, param3) << TestLog::EndMessage;
+ m_log << TestLog::Message << "// value = " << getConfigAttribValuePointerStr(attribute, value) << TestLog::EndMessage;
}
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglBindAPI (EGLenum param0)
+EGLBoolean CallLogWrapper::eglGetConfigs (EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglBindAPI(" << getAPIStr(param0) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglBindAPI(param0);
+ m_log << TestLog::Message << "eglGetConfigs(" << dpy << ", " << configs << ", " << config_size << ", " << num_config << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglGetConfigs(dpy, configs, config_size, num_config);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLenum CallLogWrapper::eglQueryAPI ()
+EGLContext CallLogWrapper::eglGetCurrentContext ()
{
if (m_enableLog)
- m_log << TestLog::Message << "eglQueryAPI(" << ");" << TestLog::EndMessage;
- EGLenum returnValue = ::eglQueryAPI();
+ m_log << TestLog::Message << "eglGetCurrentContext(" << ");" << TestLog::EndMessage;
+ EGLContext returnValue = ::eglGetCurrentContext();
if (m_enableLog)
- m_log << TestLog::Message << "// " << getAPIStr(returnValue) << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglWaitClient ()
+EGLDisplay CallLogWrapper::eglGetCurrentDisplay ()
{
if (m_enableLog)
- m_log << TestLog::Message << "eglWaitClient(" << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglWaitClient();
+ m_log << TestLog::Message << "eglGetCurrentDisplay(" << ");" << TestLog::EndMessage;
+ EGLDisplay returnValue = ::eglGetCurrentDisplay();
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglReleaseThread ()
+EGLSurface CallLogWrapper::eglGetCurrentSurface (EGLint readdraw)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglReleaseThread(" << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglReleaseThread();
+ m_log << TestLog::Message << "eglGetCurrentSurface(" << getSurfaceTargetStr(readdraw) << ");" << TestLog::EndMessage;
+ EGLSurface returnValue = ::eglGetCurrentSurface(readdraw);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLSurface CallLogWrapper::eglCreatePbufferFromClientBuffer (EGLDisplay param0, EGLenum param1, EGLClientBuffer param2, EGLConfig param3, const EGLint* param4)
+EGLDisplay CallLogWrapper::eglGetDisplay (EGLNativeDisplayType display_id)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglCreatePbufferFromClientBuffer(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
- EGLSurface returnValue = ::eglCreatePbufferFromClientBuffer(param0, param1, param2, param3, param4);
+ m_log << TestLog::Message << "eglGetDisplay(" << toHex(display_id) << ");" << TestLog::EndMessage;
+ EGLDisplay returnValue = ::eglGetDisplay(display_id);
if (m_enableLog)
- m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglSurfaceAttrib (EGLDisplay param0, EGLSurface param1, EGLint param2, EGLint param3)
+EGLint CallLogWrapper::eglGetError ()
{
if (m_enableLog)
- m_log << TestLog::Message << "eglSurfaceAttrib(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << getSurfaceAttribStr(param2) << ", " << getSurfaceAttribValueStr(param2, param3) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglSurfaceAttrib(param0, param1, param2, param3);
+ m_log << TestLog::Message << "eglGetError(" << ");" << TestLog::EndMessage;
+ EGLint returnValue = ::eglGetError();
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getErrorStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglBindTexImage (EGLDisplay param0, EGLSurface param1, EGLint param2)
+__eglMustCastToProperFunctionPointerType CallLogWrapper::eglGetProcAddress (const char *procname)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglBindTexImage(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << param2 << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglBindTexImage(param0, param1, param2);
+ m_log << TestLog::Message << "eglGetProcAddress(" << getStringStr(procname) << ");" << TestLog::EndMessage;
+ __eglMustCastToProperFunctionPointerType returnValue = ::eglGetProcAddress(procname);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << tcu::toHex(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglReleaseTexImage (EGLDisplay param0, EGLSurface param1, EGLint param2)
+EGLBoolean CallLogWrapper::eglInitialize (EGLDisplay dpy, EGLint *major, EGLint *minor)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglReleaseTexImage(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << param2 << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglReleaseTexImage(param0, param1, param2);
+ m_log << TestLog::Message << "eglInitialize(" << dpy << ", " << major << ", " << minor << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglInitialize(dpy, major, minor);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglSwapInterval (EGLDisplay param0, EGLint param1)
+EGLBoolean CallLogWrapper::eglMakeCurrent (EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglSwapInterval(" << getEGLDisplayStr(param0) << ", " << param1 << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglSwapInterval(param0, param1);
+ m_log << TestLog::Message << "eglMakeCurrent(" << dpy << ", " << toHex(draw) << ", " << toHex(read) << ", " << ctx << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglMakeCurrent(dpy, draw, read, ctx);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLContext CallLogWrapper::eglCreateContext (EGLDisplay param0, EGLConfig param1, EGLContext param2, const EGLint* param3)
+EGLenum CallLogWrapper::eglQueryAPI ()
{
if (m_enableLog)
- m_log << TestLog::Message << "eglCreateContext(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << getEGLContextStr(param2) << ", " << getContextAttribListStr(param3) << ");" << TestLog::EndMessage;
- EGLContext returnValue = ::eglCreateContext(param0, param1, param2, param3);
+ m_log << TestLog::Message << "eglQueryAPI(" << ");" << TestLog::EndMessage;
+ EGLenum returnValue = ::eglQueryAPI();
if (m_enableLog)
- m_log << TestLog::Message << "// " << getEGLContextStr(returnValue) << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getAPIStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglDestroyContext (EGLDisplay param0, EGLContext param1)
+EGLBoolean CallLogWrapper::eglQueryContext (EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglDestroyContext(" << getEGLDisplayStr(param0) << ", " << getEGLContextStr(param1) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglDestroyContext(param0, param1);
+ m_log << TestLog::Message << "eglQueryContext(" << dpy << ", " << ctx << ", " << getContextAttribStr(attribute) << ", " << value << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglQueryContext(dpy, ctx, attribute, value);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ {
+ m_log << TestLog::Message << "// value = " << getContextAttribValuePointerStr(attribute, value) << TestLog::EndMessage;
+ }
+ if (m_enableLog)
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglMakeCurrent (EGLDisplay param0, EGLSurface param1, EGLSurface param2, EGLContext param3)
+const char * CallLogWrapper::eglQueryString (EGLDisplay dpy, EGLint name)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglMakeCurrent(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ", " << getEGLContextStr(param3) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglMakeCurrent(param0, param1, param2, param3);
+ m_log << TestLog::Message << "eglQueryString(" << dpy << ", " << name << ");" << TestLog::EndMessage;
+ const char * returnValue = ::eglQueryString(dpy, name);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getStringStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLContext CallLogWrapper::eglGetCurrentContext ()
+EGLBoolean CallLogWrapper::eglQuerySurface (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglGetCurrentContext(" << ");" << TestLog::EndMessage;
- EGLContext returnValue = ::eglGetCurrentContext();
+ m_log << TestLog::Message << "eglQuerySurface(" << dpy << ", " << toHex(surface) << ", " << getSurfaceAttribStr(attribute) << ", " << value << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglQuerySurface(dpy, surface, attribute, value);
+ if (m_enableLog)
+ {
+ m_log << TestLog::Message << "// value = " << getSurfaceAttribValuePointerStr(attribute, value) << TestLog::EndMessage;
+ }
if (m_enableLog)
- m_log << TestLog::Message << "// " << getEGLContextStr(returnValue) << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLSurface CallLogWrapper::eglGetCurrentSurface (EGLint param0)
+EGLBoolean CallLogWrapper::eglReleaseTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglGetCurrentSurface(" << getSurfaceTargetStr(param0) << ");" << TestLog::EndMessage;
- EGLSurface returnValue = ::eglGetCurrentSurface(param0);
+ m_log << TestLog::Message << "eglReleaseTexImage(" << dpy << ", " << toHex(surface) << ", " << buffer << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglReleaseTexImage(dpy, surface, buffer);
if (m_enableLog)
- m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLDisplay CallLogWrapper::eglGetCurrentDisplay ()
+EGLBoolean CallLogWrapper::eglReleaseThread ()
{
if (m_enableLog)
- m_log << TestLog::Message << "eglGetCurrentDisplay(" << ");" << TestLog::EndMessage;
- EGLDisplay returnValue = ::eglGetCurrentDisplay();
+ m_log << TestLog::Message << "eglReleaseThread(" << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglReleaseThread();
if (m_enableLog)
- m_log << TestLog::Message << "// " << getEGLDisplayStr(returnValue) << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglQueryContext (EGLDisplay param0, EGLContext param1, EGLint param2, EGLint* param3)
+EGLBoolean CallLogWrapper::eglSurfaceAttrib (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglQueryContext(" << getEGLDisplayStr(param0) << ", " << getEGLContextStr(param1) << ", " << getContextAttribStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglQueryContext(param0, param1, param2, param3);
+ m_log << TestLog::Message << "eglSurfaceAttrib(" << dpy << ", " << toHex(surface) << ", " << getSurfaceAttribStr(attribute) << ", " << getSurfaceAttribValueStr(attribute, value) << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglSurfaceAttrib(dpy, surface, attribute, value);
if (m_enableLog)
- {
- m_log << TestLog::Message << "// param 3 = " << getContextAttribValuePointerStr(param2, param3) << TestLog::EndMessage;
- }
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
+ return returnValue;
+}
+
+EGLBoolean CallLogWrapper::eglSwapBuffers (EGLDisplay dpy, EGLSurface surface)
+{
+ if (m_enableLog)
+ m_log << TestLog::Message << "eglSwapBuffers(" << dpy << ", " << toHex(surface) << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglSwapBuffers(dpy, surface);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglWaitGL ()
+EGLBoolean CallLogWrapper::eglSwapInterval (EGLDisplay dpy, EGLint interval)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglWaitGL(" << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglWaitGL();
+ m_log << TestLog::Message << "eglSwapInterval(" << dpy << ", " << interval << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglSwapInterval(dpy, interval);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglWaitNative (EGLint param0)
+EGLBoolean CallLogWrapper::eglTerminate (EGLDisplay dpy)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglWaitNative(" << param0 << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglWaitNative(param0);
+ m_log << TestLog::Message << "eglTerminate(" << dpy << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglTerminate(dpy);
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglSwapBuffers (EGLDisplay param0, EGLSurface param1)
+EGLBoolean CallLogWrapper::eglWaitClient ()
{
if (m_enableLog)
- m_log << TestLog::Message << "eglSwapBuffers(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglSwapBuffers(param0, param1);
+ m_log << TestLog::Message << "eglWaitClient(" << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglWaitClient();
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-EGLBoolean CallLogWrapper::eglCopyBuffers (EGLDisplay param0, EGLSurface param1, EGLNativePixmapType param2)
+EGLBoolean CallLogWrapper::eglWaitGL ()
{
if (m_enableLog)
- m_log << TestLog::Message << "eglCopyBuffers(" << getEGLDisplayStr(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
- EGLBoolean returnValue = ::eglCopyBuffers(param0, param1, param2);
+ m_log << TestLog::Message << "eglWaitGL(" << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglWaitGL();
if (m_enableLog)
- m_log << TestLog::Message << "// " << (returnValue != EGL_FALSE ? "EGL_TRUE" : "EGL_FALSE") << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-__eglMustCastToProperFunctionPointerType CallLogWrapper::eglGetProcAddress (const char* param0)
+EGLBoolean CallLogWrapper::eglWaitNative (EGLint engine)
{
if (m_enableLog)
- m_log << TestLog::Message << "eglGetProcAddress(" << getStringStr(param0) << ");" << TestLog::EndMessage;
- __eglMustCastToProperFunctionPointerType returnValue = ::eglGetProcAddress(param0);
+ m_log << TestLog::Message << "eglWaitNative(" << engine << ");" << TestLog::EndMessage;
+ EGLBoolean returnValue = ::eglWaitNative(engine);
if (m_enableLog)
- m_log << TestLog::Message << "// " << tcu::toHex(returnValue) << " returned" << TestLog::EndMessage;
+ m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
-/* WARNING! THIS IS A PROGRAMMATICALLY GENERATED CODE. DO NOT MODIFY THE CODE,
- * SINCE THE CHANGES WILL BE LOST! MODIFY THE GENERATING PYTHON INSTEAD.
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ *
+ * Generated from Khronos EGL API description (egl.xml) revision 28861.
*/
-
-EGLint eglGetError ();
-EGLDisplay eglGetDisplay (EGLNativeDisplayType display_id);
-EGLBoolean eglInitialize (EGLDisplay dpy, EGLint* major, EGLint* minor);
-EGLBoolean eglTerminate (EGLDisplay dpy);
-const char* eglQueryString (EGLDisplay dpy, EGLint name);
-EGLBoolean eglGetConfigs (EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config);
-EGLBoolean eglChooseConfig (EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config);
-EGLBoolean eglGetConfigAttrib (EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value);
-EGLSurface eglCreateWindowSurface (EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list);
-EGLSurface eglCreatePbufferSurface (EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list);
-EGLSurface eglCreatePixmapSurface (EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint* attrib_list);
-EGLBoolean eglDestroySurface (EGLDisplay dpy, EGLSurface surface);
-EGLBoolean eglQuerySurface (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint* value);
EGLBoolean eglBindAPI (EGLenum api);
-EGLenum eglQueryAPI ();
-EGLBoolean eglWaitClient ();
-EGLBoolean eglReleaseThread ();
-EGLSurface eglCreatePbufferFromClientBuffer (EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint* attrib_list);
-EGLBoolean eglSurfaceAttrib (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
EGLBoolean eglBindTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
-EGLBoolean eglReleaseTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
-EGLBoolean eglSwapInterval (EGLDisplay dpy, EGLint interval);
-EGLContext eglCreateContext (EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list);
+EGLBoolean eglChooseConfig (EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+EGLBoolean eglCopyBuffers (EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
+EGLContext eglCreateContext (EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
+EGLSurface eglCreatePbufferFromClientBuffer (EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
+EGLSurface eglCreatePbufferSurface (EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
+EGLSurface eglCreatePixmapSurface (EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);
+EGLSurface eglCreateWindowSurface (EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list);
EGLBoolean eglDestroyContext (EGLDisplay dpy, EGLContext ctx);
-EGLBoolean eglMakeCurrent (EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
-EGLContext eglGetCurrentContext ();
+EGLBoolean eglDestroySurface (EGLDisplay dpy, EGLSurface surface);
+EGLBoolean eglGetConfigAttrib (EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
+EGLBoolean eglGetConfigs (EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+EGLContext eglGetCurrentContext (void);
+EGLDisplay eglGetCurrentDisplay (void);
EGLSurface eglGetCurrentSurface (EGLint readdraw);
-EGLDisplay eglGetCurrentDisplay ();
-EGLBoolean eglQueryContext (EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value);
-EGLBoolean eglWaitGL ();
-EGLBoolean eglWaitNative (EGLint engine);
+EGLDisplay eglGetDisplay (EGLNativeDisplayType display_id);
+EGLint eglGetError (void);
+__eglMustCastToProperFunctionPointerType eglGetProcAddress (const char *procname);
+EGLBoolean eglInitialize (EGLDisplay dpy, EGLint *major, EGLint *minor);
+EGLBoolean eglMakeCurrent (EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+EGLenum eglQueryAPI (void);
+EGLBoolean eglQueryContext (EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
+const char * eglQueryString (EGLDisplay dpy, EGLint name);
+EGLBoolean eglQuerySurface (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
+EGLBoolean eglReleaseTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+EGLBoolean eglReleaseThread (void);
+EGLBoolean eglSurfaceAttrib (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
EGLBoolean eglSwapBuffers (EGLDisplay dpy, EGLSurface surface);
-EGLBoolean eglCopyBuffers (EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
-__eglMustCastToProperFunctionPointerType eglGetProcAddress (const char* procname);
+EGLBoolean eglSwapInterval (EGLDisplay dpy, EGLint interval);
+EGLBoolean eglTerminate (EGLDisplay dpy);
+EGLBoolean eglWaitClient (void);
+EGLBoolean eglWaitGL (void);
+EGLBoolean eglWaitNative (EGLint engine);
-/* WARNING! THIS IS A PROGRAMMATICALLY GENERATED CODE. DO NOT MODIFY THE CODE,
- * SINCE THE CHANGES WILL BE LOST! MODIFY THE GENERATING PYTHON INSTEAD.
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ *
+ * Generated from Khronos EGL API description (egl.xml) revision 28861.
*/
const char* getBooleanName (int value)
tcu::Format::BitDesc(EGL_OPENGL_ES_BIT, "EGL_OPENGL_ES_BIT"),
tcu::Format::BitDesc(EGL_OPENGL_ES2_BIT, "EGL_OPENGL_ES2_BIT"),
tcu::Format::BitDesc(EGL_OPENGL_ES3_BIT_KHR, "EGL_OPENGL_ES3_BIT_KHR"),
- tcu::Format::BitDesc(EGL_OPENVG_BIT, "EGL_OPENVG_BIT")
+ tcu::Format::BitDesc(EGL_OPENVG_BIT, "EGL_OPENVG_BIT"),
};
return tcu::Format::Bitfield<16>(value, &s_desc[0], &s_desc[DE_LENGTH_OF_ARRAY(s_desc)]);
}
tcu::Format::BitDesc(EGL_VG_ALPHA_FORMAT_PRE_BIT, "EGL_VG_ALPHA_FORMAT_PRE_BIT"),
tcu::Format::BitDesc(EGL_VG_COLORSPACE_LINEAR_BIT, "EGL_VG_COLORSPACE_LINEAR_BIT"),
tcu::Format::BitDesc(EGL_LOCK_SURFACE_BIT_KHR, "EGL_LOCK_SURFACE_BIT_KHR"),
- tcu::Format::BitDesc(EGL_OPTIMAL_FORMAT_BIT_KHR, "EGL_OPTIMAL_FORMAT_BIT_KHR")
+ tcu::Format::BitDesc(EGL_OPTIMAL_FORMAT_BIT_KHR, "EGL_OPTIMAL_FORMAT_BIT_KHR"),
};
return tcu::Format::Bitfield<16>(value, &s_desc[0], &s_desc[DE_LENGTH_OF_ARRAY(s_desc)]);
}
-/* WARNING! THIS IS A PROGRAMMATICALLY GENERATED CODE. DO NOT MODIFY THE CODE,
- * SINCE THE CHANGES WILL BE LOST! MODIFY THE GENERATING PYTHON INSTEAD.
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ *
+ * Generated from Khronos EGL API description (egl.xml) revision 28861.
*/
-
-const char* getBooleanName (int value);
-const char* getBoolDontCareName (int value);
-const char* getAPIName (int value);
-const char* getErrorName (int value);
-const char* getContextAttribName (int value);
-const char* getConfigAttribName (int value);
-const char* getSurfaceAttribName (int value);
-const char* getSurfaceTargetName (int value);
-const char* getColorBufferTypeName (int value);
-const char* getConfigCaveatName (int value);
-const char* getTransparentTypeName (int value);
-const char* getMultisampleResolveName (int value);
-const char* getRenderBufferName (int value);
-const char* getSwapBehaviorName (int value);
-const char* getTextureFormatName (int value);
-const char* getTextureTargetName (int value);
-const char* getVGAlphaFormatName (int value);
-const char* getVGColorspaceName (int value);
-
-tcu::Format::Bitfield<16> getAPIBitsStr (int value);
-tcu::Format::Bitfield<16> getSurfaceBitsStr (int value);
-
-inline tcu::Format::Enum getBooleanStr (int value) { return tcu::Format::Enum(getBooleanName, value); }
-inline tcu::Format::Enum getBoolDontCareStr (int value) { return tcu::Format::Enum(getBoolDontCareName, value); }
-inline tcu::Format::Enum getAPIStr (int value) { return tcu::Format::Enum(getAPIName, value); }
-inline tcu::Format::Enum getErrorStr (int value) { return tcu::Format::Enum(getErrorName, value); }
-inline tcu::Format::Enum getContextAttribStr (int value) { return tcu::Format::Enum(getContextAttribName, value); }
-inline tcu::Format::Enum getConfigAttribStr (int value) { return tcu::Format::Enum(getConfigAttribName, value); }
-inline tcu::Format::Enum getSurfaceAttribStr (int value) { return tcu::Format::Enum(getSurfaceAttribName, value); }
-inline tcu::Format::Enum getSurfaceTargetStr (int value) { return tcu::Format::Enum(getSurfaceTargetName, value); }
-inline tcu::Format::Enum getColorBufferTypeStr (int value) { return tcu::Format::Enum(getColorBufferTypeName, value); }
-inline tcu::Format::Enum getConfigCaveatStr (int value) { return tcu::Format::Enum(getConfigCaveatName, value); }
-inline tcu::Format::Enum getTransparentTypeStr (int value) { return tcu::Format::Enum(getTransparentTypeName, value); }
-inline tcu::Format::Enum getMultisampleResolveStr (int value) { return tcu::Format::Enum(getMultisampleResolveName, value); }
-inline tcu::Format::Enum getRenderBufferStr (int value) { return tcu::Format::Enum(getRenderBufferName, value); }
-inline tcu::Format::Enum getSwapBehaviorStr (int value) { return tcu::Format::Enum(getSwapBehaviorName, value); }
-inline tcu::Format::Enum getTextureFormatStr (int value) { return tcu::Format::Enum(getTextureFormatName, value); }
-inline tcu::Format::Enum getTextureTargetStr (int value) { return tcu::Format::Enum(getTextureTargetName, value); }
-inline tcu::Format::Enum getVGAlphaFormatStr (int value) { return tcu::Format::Enum(getVGAlphaFormatName, value); }
-inline tcu::Format::Enum getVGColorspaceStr (int value) { return tcu::Format::Enum(getVGColorspaceName, value); }
+const char* getBooleanName (int value);
+const char* getBoolDontCareName (int value);
+const char* getAPIName (int value);
+const char* getErrorName (int value);
+const char* getContextAttribName (int value);
+const char* getConfigAttribName (int value);
+const char* getSurfaceAttribName (int value);
+const char* getSurfaceTargetName (int value);
+const char* getColorBufferTypeName (int value);
+const char* getConfigCaveatName (int value);
+const char* getTransparentTypeName (int value);
+const char* getMultisampleResolveName (int value);
+const char* getRenderBufferName (int value);
+const char* getSwapBehaviorName (int value);
+const char* getTextureFormatName (int value);
+const char* getTextureTargetName (int value);
+const char* getVGAlphaFormatName (int value);
+const char* getVGColorspaceName (int value);
+tcu::Format::Bitfield<16> getAPIBitsStr (int value);
+tcu::Format::Bitfield<16> getSurfaceBitsStr (int value);
+inline tcu::Format::Enum getBooleanStr (int value) { return tcu::Format::Enum(getBooleanName, value); }
+inline tcu::Format::Enum getBoolDontCareStr (int value) { return tcu::Format::Enum(getBoolDontCareName, value); }
+inline tcu::Format::Enum getAPIStr (int value) { return tcu::Format::Enum(getAPIName, value); }
+inline tcu::Format::Enum getErrorStr (int value) { return tcu::Format::Enum(getErrorName, value); }
+inline tcu::Format::Enum getContextAttribStr (int value) { return tcu::Format::Enum(getContextAttribName, value); }
+inline tcu::Format::Enum getConfigAttribStr (int value) { return tcu::Format::Enum(getConfigAttribName, value); }
+inline tcu::Format::Enum getSurfaceAttribStr (int value) { return tcu::Format::Enum(getSurfaceAttribName, value); }
+inline tcu::Format::Enum getSurfaceTargetStr (int value) { return tcu::Format::Enum(getSurfaceTargetName, value); }
+inline tcu::Format::Enum getColorBufferTypeStr (int value) { return tcu::Format::Enum(getColorBufferTypeName, value); }
+inline tcu::Format::Enum getConfigCaveatStr (int value) { return tcu::Format::Enum(getConfigCaveatName, value); }
+inline tcu::Format::Enum getTransparentTypeStr (int value) { return tcu::Format::Enum(getTransparentTypeName, value); }
+inline tcu::Format::Enum getMultisampleResolveStr (int value) { return tcu::Format::Enum(getMultisampleResolveName, value); }
+inline tcu::Format::Enum getRenderBufferStr (int value) { return tcu::Format::Enum(getRenderBufferName, value); }
+inline tcu::Format::Enum getSwapBehaviorStr (int value) { return tcu::Format::Enum(getSwapBehaviorName, value); }
+inline tcu::Format::Enum getTextureFormatStr (int value) { return tcu::Format::Enum(getTextureFormatName, value); }
+inline tcu::Format::Enum getTextureTargetStr (int value) { return tcu::Format::Enum(getTextureTargetName, value); }
+inline tcu::Format::Enum getVGAlphaFormatStr (int value) { return tcu::Format::Enum(getVGAlphaFormatName, value); }
+inline tcu::Format::Enum getVGColorspaceStr (int value) { return tcu::Format::Enum(getVGColorspaceName, value); }
#include "egluStrUtil.hpp"
#include "tcuTestLog.hpp"
-#include <vector>
-#include <string>
-#include <algorithm>
-#include <cctype>
-
#if !defined(EGL_OPENGL_ES3_BIT_KHR)
# define EGL_OPENGL_ES3_BIT_KHR 0x0040
#endif
-using tcu::TestLog;
-
namespace deqp
{
namespace egl
namespace
{
+using tcu::TestLog;
+
// Function name strings generated from API headers
#include "teglGetProcAddressTests.inl"
-std::vector<std::string> makeStringVector (const char** cStrArray)
+struct FunctionNames
{
- std::vector<std::string> out;
+ int numFunctions;
+ const char* const* functions;
- for (int ndx = 0; cStrArray[ndx] != DE_NULL; ndx++)
+ FunctionNames (int numFunctions_, const char* const* functions_)
+ : numFunctions (numFunctions_)
+ , functions (functions_)
{
- out.push_back(std::string(cStrArray[ndx]));
}
+};
- return out;
-}
-
-std::vector<std::string> getExtensionNames (void)
-{
- return makeStringVector(getExtensionStrs());
-}
-
-std::vector<std::string> getExtFunctionNames (const std::string& extName)
+FunctionNames getExtFunctionNames (const std::string& extName)
{
- const char** names_raw = getExtensionFuncStrs(extName);
+ for (int ndx = 0; ndx <= DE_LENGTH_OF_ARRAY(s_extensions); ndx++)
+ {
+ if (extName == s_extensions[ndx].name)
+ return FunctionNames(s_extensions[ndx].numFunctions, s_extensions[ndx].functions);
+ }
- return (names_raw != 0) ? makeStringVector(names_raw) : std::vector<std::string>();
+ DE_ASSERT(false);
+ return FunctionNames(0, DE_NULL);
}
-std::vector<std::string> getCoreFunctionNames (EGLint apiBit)
+FunctionNames getCoreFunctionNames (EGLint apiBit)
{
switch (apiBit)
{
- case 0: return makeStringVector(getCoreFunctionStrs());
- case EGL_OPENGL_ES_BIT: return makeStringVector(getGlesFunctionStrs());
- case EGL_OPENGL_ES2_BIT: return makeStringVector(getGles2FunctionStrs());
- case EGL_OPENGL_ES3_BIT_KHR: return makeStringVector(getGles3FunctionStrs());
+ case 0: return FunctionNames(DE_LENGTH_OF_ARRAY(s_EGL14), s_EGL14);
+ case EGL_OPENGL_ES_BIT: return FunctionNames(DE_LENGTH_OF_ARRAY(s_GLES10), s_GLES10);
+ case EGL_OPENGL_ES2_BIT: return FunctionNames(DE_LENGTH_OF_ARRAY(s_GLES20), s_GLES20);
+ case EGL_OPENGL_ES3_BIT_KHR: return FunctionNames(DE_LENGTH_OF_ARRAY(s_GLES30), s_GLES30);
default:
- DE_ASSERT(DE_FALSE);
+ DE_ASSERT(false);
}
- return std::vector<std::string>();
+ return FunctionNames(0, DE_NULL);
}
} // anonymous
void executeTest (void)
{
- TestLog& log = m_testCtx.getLog();
- bool supported = isSupported(m_extName);
- const std::vector<std::string> funcNames = getExtFunctionNames(m_extName);
+ TestLog& log = m_testCtx.getLog();
+ bool supported = isSupported(m_extName);
+ const FunctionNames funcNames = getExtFunctionNames(m_extName);
- DE_ASSERT(!funcNames.empty());
+ DE_ASSERT(funcNames.numFunctions > 0);
log << TestLog::Message << m_extName << ": " << (supported ? "supported" : "not supported") << TestLog::EndMessage;
log << TestLog::Message << TestLog::EndMessage;
- for (std::vector<std::string>::const_iterator funcIter = funcNames.begin(); funcIter != funcNames.end(); funcIter++)
+ for (int funcNdx = 0; funcNdx < funcNames.numFunctions; funcNdx++)
{
- const std::string& funcName = *funcIter;
- void (*funcPtr)(void);
+ const char* funcName = funcNames.functions[funcNdx];
+ void (*funcPtr)(void);
- funcPtr = eglGetProcAddress(funcName.c_str());
+ funcPtr = eglGetProcAddress(funcName);
TCU_CHECK_EGL();
if (supported && funcPtr == 0)
class GetProcAddressCoreFunctionsCase : public GetProcAddressCase
{
public:
- GetProcAddressCoreFunctionsCase (EglTestContext& eglTestCtx, const char* name, const char* description, const EGLint apiBit = 0)
+ GetProcAddressCoreFunctionsCase (EglTestContext& eglTestCtx, const char* name, const char* description, const EGLint apiBit)
: GetProcAddressCase (eglTestCtx, name, description)
- , m_funcNames (getCoreFunctionNames(apiBit))
, m_apiBit (apiBit)
{
}
void executeTest (void)
{
- TestLog& log = m_testCtx.getLog();
- const bool funcPtrSupported = isSupported("EGL_KHR_get_all_proc_addresses");
- const bool apiSupported = isApiSupported();
+ TestLog& log = m_testCtx.getLog();
+ const bool funcPtrSupported = isSupported("EGL_KHR_get_all_proc_addresses");
+ const bool apiSupported = isApiSupported();
+ const FunctionNames funcNames = getCoreFunctionNames(m_apiBit);
log << TestLog::Message << "EGL_KHR_get_all_proc_addresses: " << (funcPtrSupported ? "supported" : "not supported") << TestLog::EndMessage;
log << TestLog::Message << TestLog::EndMessage;
log << TestLog::Message << TestLog::EndMessage;
}
- for (std::vector<std::string>::const_iterator funcIter = m_funcNames.begin(); funcIter != m_funcNames.end(); funcIter++)
+ for (int funcNdx = 0; funcNdx < funcNames.numFunctions; funcNdx++)
{
- const std::string& funcName = *funcIter;
- void (*funcPtr)(void);
+ const char* funcName = funcNames.functions[funcNdx];
+ void (*funcPtr)(void);
- funcPtr = eglGetProcAddress(funcName.c_str());
+ funcPtr = eglGetProcAddress(funcName);
TCU_CHECK_EGL();
if (apiSupported && funcPtrSupported && (funcPtr == 0))
}
private:
- const std::vector<std::string> m_funcNames;
- const EGLint m_apiBit;
+ const EGLint m_apiBit;
};
GetProcAddressTests::GetProcAddressTests (EglTestContext& eglTestCtx)
tcu::TestCaseGroup* extensionsGroup = new tcu::TestCaseGroup(m_testCtx, "extension", "Test EGL extensions");
addChild(extensionsGroup);
- const std::vector<std::string> extNames = getExtensionNames();
-
- for (std::vector<std::string>::const_iterator extIter = extNames.begin(); extIter != extNames.end(); extIter++)
+ for (int extNdx = 0; extNdx < DE_LENGTH_OF_ARRAY(s_extensions); extNdx++)
{
- const std::string& extName = *extIter;
- const std::vector<std::string> funcNames = getExtFunctionNames(extName);
-
- std::string testName (extName);
-
- if (funcNames.empty())
- continue;
+ const std::string& extName = s_extensions[extNdx].name;
+ std::string testName (extName);
for (size_t ndx = 0; ndx < extName.length(); ndx++)
testName[ndx] = std::tolower(extName[ndx]);
tcu::TestCaseGroup* coreFuncGroup = new tcu::TestCaseGroup(m_testCtx, "core", "Test core functions");
addChild(coreFuncGroup);
- coreFuncGroup->addChild(new GetProcAddressCoreFunctionsCase (m_eglTestCtx, "egl", "Test EGL core functions"));
+ coreFuncGroup->addChild(new GetProcAddressCoreFunctionsCase (m_eglTestCtx, "egl", "Test EGL core functions", 0));
coreFuncGroup->addChild(new GetProcAddressCoreFunctionsCase (m_eglTestCtx, "gles", "Test OpenGL ES core functions", EGL_OPENGL_ES_BIT));
coreFuncGroup->addChild(new GetProcAddressCoreFunctionsCase (m_eglTestCtx, "gles2", "Test OpenGL ES 2 core functions", EGL_OPENGL_ES2_BIT));
coreFuncGroup->addChild(new GetProcAddressCoreFunctionsCase (m_eglTestCtx, "gles3", "Test OpenGL ES 3 core functions", EGL_OPENGL_ES3_BIT_KHR));
-/* WARNING! THIS IS A PROGRAMMATICALLY GENERATED CODE. DO NOT MODIFY THE CODE,
- * SINCE THE CHANGES WILL BE LOST! MODIFY THE GENERATING PYTHON INSTEAD.
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ *
+ * Generated from Khronos EGL API description (egl.xml) revision 28861.
*/
-const char** getCoreFunctionStrs (void)
-{
- static const char* funcs[] =
- {
- "eglGetError",
- "eglGetDisplay",
- "eglInitialize",
- "eglTerminate",
- "eglQueryString",
- "eglGetConfigs",
- "eglChooseConfig",
- "eglGetConfigAttrib",
- "eglCreateWindowSurface",
- "eglCreatePbufferSurface",
- "eglCreatePixmapSurface",
- "eglDestroySurface",
- "eglQuerySurface",
- "eglBindAPI",
- "eglQueryAPI",
- "eglWaitClient",
- "eglReleaseThread",
- "eglCreatePbufferFromClientBuffer",
- "eglSurfaceAttrib",
- "eglBindTexImage",
- "eglReleaseTexImage",
- "eglSwapInterval",
- "eglCreateContext",
- "eglDestroyContext",
- "eglMakeCurrent",
- "eglGetCurrentContext",
- "eglGetCurrentSurface",
- "eglGetCurrentDisplay",
- "eglQueryContext",
- "eglWaitGL",
- "eglWaitNative",
- "eglSwapBuffers",
- "eglCopyBuffers",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getGlesFunctionStrs (void)
-{
- static const char* funcs[] =
- {
- "glActiveTexture",
- "glAlphaFunc",
- "glAlphaFuncx",
- "glBindTexture",
- "glBlendFunc",
- "glClear",
- "glClearColor",
- "glClearColorx",
- "glClearDepthf",
- "glClearDepthx",
- "glClearStencil",
- "glClientActiveTexture",
- "glColor4f",
- "glColor4x",
- "glColorMask",
- "glColorPointer",
- "glCompressedTexImage2D",
- "glCompressedTexSubImage2D",
- "glCopyTexImage2D",
- "glCopyTexSubImage2D",
- "glCullFace",
- "glDeleteTextures",
- "glDepthFunc",
- "glDepthMask",
- "glDepthRangef",
- "glDepthRangex",
- "glDisable",
- "glDisableClientState",
- "glDrawArrays",
- "glDrawElements",
- "glEnable",
- "glEnableClientState",
- "glFinish",
- "glFlush",
- "glFogf",
- "glFogfv",
- "glFogx",
- "glFogxv",
- "glFrontFace",
- "glFrustumf",
- "glFrustumx",
- "glGenTextures",
- "glGetError",
- "glGetIntegerv",
- "glGetString",
- "glHint",
- "glLightModelf",
- "glLightModelfv",
- "glLightModelx",
- "glLightModelxv",
- "glLightf",
- "glLightfv",
- "glLightx",
- "glLightxv",
- "glLineWidth",
- "glLineWidthx",
- "glLoadIdentity",
- "glLoadMatrixf",
- "glLoadMatrixx",
- "glLogicOp",
- "glMaterialf",
- "glMaterialfv",
- "glMaterialx",
- "glMaterialxv",
- "glMatrixMode",
- "glMultMatrixf",
- "glMultMatrixx",
- "glMultiTexCoord4f",
- "glMultiTexCoord4x",
- "glNormal3f",
- "glNormal3x",
- "glNormalPointer",
- "glOrthof",
- "glOrthox",
- "glPixelStorei",
- "glPointSize",
- "glPointSizex",
- "glPolygonOffset",
- "glPolygonOffsetx",
- "glPopMatrix",
- "glPushMatrix",
- "glReadPixels",
- "glRotatef",
- "glRotatex",
- "glSampleCoverage",
- "glSampleCoveragex",
- "glScalef",
- "glScalex",
- "glScissor",
- "glShadeModel",
- "glStencilFunc",
- "glStencilMask",
- "glStencilOp",
- "glTexCoordPointer",
- "glTexEnvf",
- "glTexEnvfv",
- "glTexEnvx",
- "glTexEnvxv",
- "glTexImage2D",
- "glTexParameterf",
- "glTexParameterx",
- "glTexSubImage2D",
- "glTranslatef",
- "glTranslatex",
- "glVertexPointer",
- "glViewport",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getGles2FunctionStrs (void)
-{
- static const char* funcs[] =
- {
- "glAttachShader",
- "glBindAttribLocation",
- "glBindBuffer",
- "glBindFramebuffer",
- "glBindRenderbuffer",
- "glBlendColor",
- "glBlendEquation",
- "glBlendEquationSeparate",
- "glBlendFuncSeparate",
- "glBufferData",
- "glBufferSubData",
- "glCheckFramebufferStatus",
- "glCompileShader",
- "glCreateProgram",
- "glCreateShader",
- "glDeleteBuffers",
- "glDeleteFramebuffers",
- "glDeleteProgram",
- "glDeleteRenderbuffers",
- "glDeleteShader",
- "glDetachShader",
- "glDisableVertexAttribArray",
- "glEnableVertexAttribArray",
- "glFramebufferRenderbuffer",
- "glFramebufferTexture2D",
- "glGenBuffers",
- "glGenerateMipmap",
- "glGenFramebuffers",
- "glGenRenderbuffers",
- "glGetActiveAttrib",
- "glGetActiveUniform",
- "glGetAttachedShaders",
- "glGetAttribLocation",
- "glGetBooleanv",
- "glGetBufferParameteriv",
- "glGetFloatv",
- "glGetFramebufferAttachmentParameteriv",
- "glGetProgramiv",
- "glGetProgramInfoLog",
- "glGetRenderbufferParameteriv",
- "glGetShaderiv",
- "glGetShaderInfoLog",
- "glGetShaderPrecisionFormat",
- "glGetShaderSource",
- "glGetTexParameterfv",
- "glGetTexParameteriv",
- "glGetUniformfv",
- "glGetUniformiv",
- "glGetUniformLocation",
- "glGetVertexAttribfv",
- "glGetVertexAttribiv",
- "glGetVertexAttribPointerv",
- "glIsBuffer",
- "glIsEnabled",
- "glIsFramebuffer",
- "glIsProgram",
- "glIsRenderbuffer",
- "glIsShader",
- "glIsTexture",
- "glLinkProgram",
- "glReleaseShaderCompiler",
- "glRenderbufferStorage",
- "glShaderBinary",
- "glShaderSource",
- "glStencilFuncSeparate",
- "glStencilMaskSeparate",
- "glStencilOpSeparate",
- "glTexParameterfv",
- "glTexParameteri",
- "glTexParameteriv",
- "glUniform1f",
- "glUniform1fv",
- "glUniform1i",
- "glUniform1iv",
- "glUniform2f",
- "glUniform2fv",
- "glUniform2i",
- "glUniform2iv",
- "glUniform3f",
- "glUniform3fv",
- "glUniform3i",
- "glUniform3iv",
- "glUniform4f",
- "glUniform4fv",
- "glUniform4i",
- "glUniform4iv",
- "glUniformMatrix2fv",
- "glUniformMatrix3fv",
- "glUniformMatrix4fv",
- "glUseProgram",
- "glValidateProgram",
- "glVertexAttrib1f",
- "glVertexAttrib1fv",
- "glVertexAttrib2f",
- "glVertexAttrib2fv",
- "glVertexAttrib3f",
- "glVertexAttrib3fv",
- "glVertexAttrib4f",
- "glVertexAttrib4fv",
- "glVertexAttribPointer",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getGles3FunctionStrs (void)
-{
- static const char* funcs[] =
- {
- "glReadBuffer",
- "glDrawRangeElements",
- "glTexImage3D",
- "glTexSubImage3D",
- "glCopyTexSubImage3D",
- "glCompressedTexImage3D",
- "glCompressedTexSubImage3D",
- "glGenQueries",
- "glDeleteQueries",
- "glIsQuery",
- "glBeginQuery",
- "glEndQuery",
- "glGetQueryiv",
- "glGetQueryObjectuiv",
- "glUnmapBuffer",
- "glGetBufferPointerv",
- "glDrawBuffers",
- "glUniformMatrix2x3fv",
- "glUniformMatrix3x2fv",
- "glUniformMatrix2x4fv",
- "glUniformMatrix4x2fv",
- "glUniformMatrix3x4fv",
- "glUniformMatrix4x3fv",
- "glBlitFramebuffer",
- "glRenderbufferStorageMultisample",
- "glFramebufferTextureLayer",
- "glMapBufferRange",
- "glFlushMappedBufferRange",
- "glBindVertexArray",
- "glDeleteVertexArrays",
- "glGenVertexArrays",
- "glIsVertexArray",
- "glGetIntegeri_v",
- "glBeginTransformFeedback",
- "glEndTransformFeedback",
- "glBindBufferRange",
- "glBindBufferBase",
- "glTransformFeedbackVaryings",
- "glGetTransformFeedbackVarying",
- "glVertexAttribIPointer",
- "glGetVertexAttribIiv",
- "glGetVertexAttribIuiv",
- "glVertexAttribI4i",
- "glVertexAttribI4ui",
- "glVertexAttribI4iv",
- "glVertexAttribI4uiv",
- "glGetUniformuiv",
- "glGetFragDataLocation",
- "glUniform1ui",
- "glUniform2ui",
- "glUniform3ui",
- "glUniform4ui",
- "glUniform1uiv",
- "glUniform2uiv",
- "glUniform3uiv",
- "glUniform4uiv",
- "glClearBufferiv",
- "glClearBufferuiv",
- "glClearBufferfv",
- "glClearBufferfi",
- "glGetStringi",
- "glCopyBufferSubData",
- "glGetUniformIndices",
- "glGetActiveUniformsiv",
- "glGetUniformBlockIndex",
- "glGetActiveUniformBlockiv",
- "glGetActiveUniformBlockName",
- "glUniformBlockBinding",
- "glDrawArraysInstanced",
- "glDrawElementsInstanced",
- "glFenceSync",
- "glIsSync",
- "glDeleteSync",
- "glClientWaitSync",
- "glWaitSync",
- "glGetInteger64v",
- "glGetSynciv",
- "glGetInteger64i_v",
- "glGetBufferParameteri64v",
- "glGenSamplers",
- "glDeleteSamplers",
- "glIsSampler",
- "glBindSampler",
- "glSamplerParameteri",
- "glSamplerParameteriv",
- "glSamplerParameterf",
- "glSamplerParameterfv",
- "glGetSamplerParameteriv",
- "glGetSamplerParameterfv",
- "glVertexAttribDivisor",
- "glBindTransformFeedback",
- "glDeleteTransformFeedbacks",
- "glGenTransformFeedbacks",
- "glIsTransformFeedback",
- "glPauseTransformFeedback",
- "glResumeTransformFeedback",
- "glGetProgramBinary",
- "glProgramBinary",
- "glProgramParameteri",
- "glInvalidateFramebuffer",
- "glInvalidateSubFramebuffer",
- "glTexStorage2D",
- "glTexStorage3D",
- "glGetInternalformativ",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getKhrLockSurfaceFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglLockSurfaceKHR",
- "eglUnlockSurfaceKHR",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesSinglePrecisionFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glDepthRangefOES",
- "glFrustumfOES",
- "glOrthofOES",
- "glClipPlanefOES",
- "glGetClipPlanefOES",
- "glClearDepthfOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getQcomTiledRenderingFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glStartTilingQCOM",
- "glEndTilingQCOM",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getNvNativeQueryFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglQueryNativeDisplayNV",
- "eglQueryNativeWindowNV",
- "eglQueryNativePixmapNV",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getMesaDrmImageFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglCreateDRMImageMESA",
- "eglExportDRMImageMESA",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getNvFenceFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glDeleteFencesNV",
- "glGenFencesNV",
- "glIsFenceNV",
- "glTestFenceNV",
- "glGetFenceivNV",
- "glFinishFenceNV",
- "glSetFenceNV",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesBlendSubtractFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glBlendEquationOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getKhrStreamConsumerGltextureFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglStreamConsumerGLTextureExternalKHR",
- "eglStreamConsumerAcquireKHR",
- "eglStreamConsumerReleaseKHR",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getQcomExtendedGet2FuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glExtGetShadersQCOM",
- "glExtGetProgramsQCOM",
- "glExtIsProgramBinaryQCOM",
- "glExtGetProgramBinarySourceQCOM",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtMultiDrawArraysFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glMultiDrawArraysEXT",
- "glMultiDrawElementsEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesMatrixPaletteFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glCurrentPaletteMatrixOES",
- "glLoadPaletteFromModelViewMatrixOES",
- "glMatrixIndexPointerOES",
- "glWeightPointerOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtSeparateShaderObjectsFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glUseProgramStagesEXT",
- "glActiveShaderProgramEXT",
- "glCreateShaderProgramvEXT",
- "glBindProgramPipelineEXT",
- "glDeleteProgramPipelinesEXT",
- "glGenProgramPipelinesEXT",
- "glIsProgramPipelineEXT",
- "glProgramParameteriEXT",
- "glGetProgramPipelineivEXT",
- "glProgramUniform1iEXT",
- "glProgramUniform2iEXT",
- "glProgramUniform3iEXT",
- "glProgramUniform4iEXT",
- "glProgramUniform1fEXT",
- "glProgramUniform2fEXT",
- "glProgramUniform3fEXT",
- "glProgramUniform4fEXT",
- "glProgramUniform1ivEXT",
- "glProgramUniform2ivEXT",
- "glProgramUniform3ivEXT",
- "glProgramUniform4ivEXT",
- "glProgramUniform1fvEXT",
- "glProgramUniform2fvEXT",
- "glProgramUniform3fvEXT",
- "glProgramUniform4fvEXT",
- "glProgramUniformMatrix2fvEXT",
- "glProgramUniformMatrix3fvEXT",
- "glProgramUniformMatrix4fvEXT",
- "glValidateProgramPipelineEXT",
- "glGetProgramPipelineInfoLogEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getAngleTranslatedShaderSourceFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glGetTranslatedShaderSourceANGLE",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getNvFramebufferMultisampleFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glRenderbufferStorageMultisampleNV",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getNvDrawBuffersFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glDrawBuffersNV",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesEglImageFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glEGLImageTargetTexture2DOES",
- "glEGLImageTargetRenderbufferStorageOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getKhrWaitSyncFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglWaitSyncKHR",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getNvSystemTimeFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglGetSystemTimeFrequencyNV",
- "eglGetSystemTimeNV",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtRobustnessFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glGetGraphicsResetStatusEXT",
- "glReadnPixelsEXT",
- "glGetnUniformfvEXT",
- "glGetnUniformivEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getKhrImageFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglCreateImageKHR",
- "eglDestroyImageKHR",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getNvDrawInstancedFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glDrawArraysInstancedNV",
- "glDrawElementsInstancedNV",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getImgUserClipPlaneFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glClipPlanefIMG",
- "glClipPlanexIMG",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesQueryMatrixFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glQueryMatrixxOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getNvCoverageSampleFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glCoverageMaskNV",
- "glCoverageOperationNV",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtDisjointTimerQueryFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glGenQueriesEXT",
- "glDeleteQueriesEXT",
- "glIsQueryEXT",
- "glBeginQueryEXT",
- "glEndQueryEXT",
- "glQueryCounterEXT",
- "glGetQueryivEXT",
- "glGetQueryObjectivEXT",
- "glGetQueryObjectuivEXT",
- "glGetQueryObjecti64vEXT",
- "glGetQueryObjectui64vEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesVertexArrayObjectFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glBindVertexArrayOES",
- "glDeleteVertexArraysOES",
- "glGenVertexArraysOES",
- "glIsVertexArrayOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getKhrReusableSyncFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglCreateSyncKHR",
- "eglDestroySyncKHR",
- "eglClientWaitSyncKHR",
- "eglSignalSyncKHR",
- "eglGetSyncAttribKHR",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtDebugLabelFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glLabelObjectEXT",
- "glGetObjectLabelEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtMapBufferRangeFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glMapBufferRangeEXT",
- "glFlushMappedBufferRangeEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getAngleFramebufferMultisampleFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glRenderbufferStorageMultisampleANGLE",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getKhrStreamCrossProcessFdFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglGetStreamFileDescriptorKHR",
- "eglCreateStreamFromFileDescriptorKHR",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtTextureStorageFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glTexStorage1DEXT",
- "glTexStorage2DEXT",
- "glTexStorage3DEXT",
- "glTextureStorage1DEXT",
- "glTextureStorage2DEXT",
- "glTextureStorage3DEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getKhrStreamFifoFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglQueryStreamTimeKHR",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesMapbufferFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glMapBufferOES",
- "glUnmapBufferOES",
- "glGetBufferPointervOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getNvPostSubBufferFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglPostSubBufferNV",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesTextureCubeMapFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glTexGenfOES",
- "glTexGenfvOES",
- "glTexGeniOES",
- "glTexGenivOES",
- "glTexGenxOES",
- "glTexGenxvOES",
- "glGetTexGenfvOES",
- "glGetTexGenivOES",
- "glGetTexGenxvOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getKhrStreamProducerEglsurfaceFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglCreateStreamProducerSurfaceKHR",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesBlendEquationSeparateFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glBlendEquationSeparateOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtDrawBuffersFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glDrawBuffersEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesFramebufferObjectFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glIsRenderbufferOES",
- "glBindRenderbufferOES",
- "glDeleteRenderbuffersOES",
- "glGenRenderbuffersOES",
- "glRenderbufferStorageOES",
- "glGetRenderbufferParameterivOES",
- "glIsFramebufferOES",
- "glBindFramebufferOES",
- "glDeleteFramebuffersOES",
- "glGenFramebuffersOES",
- "glCheckFramebufferStatusOES",
- "glFramebufferRenderbufferOES",
- "glFramebufferTexture2DOES",
- "glGetFramebufferAttachmentParameterivOES",
- "glGenerateMipmapOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtDebugMarkerFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glInsertEventMarkerEXT",
- "glPushGroupMarkerEXT",
- "glPopGroupMarkerEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtMultisampledRenderToTextureFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glRenderbufferStorageMultisampleEXT",
- "glFramebufferTexture2DMultisampleEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtDiscardFramebufferFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glDiscardFramebufferEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesFixedPointFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glAlphaFuncxOES",
- "glClearColorxOES",
- "glClearDepthxOES",
- "glClipPlanexOES",
- "glColor4xOES",
- "glDepthRangexOES",
- "glFogxOES",
- "glFogxvOES",
- "glFrustumxOES",
- "glGetClipPlanexOES",
- "glGetFixedvOES",
- "glGetLightxvOES",
- "glGetMaterialxvOES",
- "glGetTexEnvxvOES",
- "glGetTexParameterxvOES",
- "glLightModelxOES",
- "glLightModelxvOES",
- "glLightxOES",
- "glLightxvOES",
- "glLineWidthxOES",
- "glLoadMatrixxOES",
- "glMaterialxOES",
- "glMaterialxvOES",
- "glMultMatrixxOES",
- "glMultiTexCoord4xOES",
- "glNormal3xOES",
- "glOrthoxOES",
- "glPointParameterxOES",
- "glPointParameterxvOES",
- "glPointSizexOES",
- "glPolygonOffsetxOES",
- "glRotatexOES",
- "glSampleCoveragexOES",
- "glScalexOES",
- "glTexEnvxOES",
- "glTexEnvxvOES",
- "glTexParameterxOES",
- "glTexParameterxvOES",
- "glTranslatexOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getImgMultisampledRenderToTextureFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glRenderbufferStorageMultisampleIMG",
- "glFramebufferTexture2DMultisampleIMG",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesGetProgramBinaryFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glGetProgramBinaryOES",
- "glProgramBinaryOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getAppleFramebufferMultisampleFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glRenderbufferStorageMultisampleAPPLE",
- "glResolveMultisampleFramebufferAPPLE",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getAppleCopyTextureLevelsFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glCopyTextureLevelsAPPLE",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtMultiviewDrawBuffersFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glReadBufferIndexedEXT",
- "glDrawBuffersIndexedEXT",
- "glGetIntegeri_vEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesBlendFuncSeparateFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glBlendFuncSeparateOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getQcomExtendedGetFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glExtGetTexturesQCOM",
- "glExtGetBuffersQCOM",
- "glExtGetRenderbuffersQCOM",
- "glExtGetFramebuffersQCOM",
- "glExtGetTexLevelParameterivQCOM",
- "glExtTexObjectStateOverrideiQCOM",
- "glExtGetTexSubImageQCOM",
- "glExtGetBufferPointervQCOM",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getNvFramebufferBlitFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glBlitFramebufferNV",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getAndroidBlobCacheFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglSetBlobCacheFuncsANDROID",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getAngleFramebufferBlitFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glBlitFramebufferANGLE",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesTexture3DFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glTexImage3DOES",
- "glTexSubImage3DOES",
- "glCopyTexSubImage3DOES",
- "glCompressedTexImage3DOES",
- "glCompressedTexSubImage3DOES",
- "glFramebufferTexture3DOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getKhrDebugFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glDebugMessageControlKHR",
- "glDebugMessageInsertKHR",
- "glDebugMessageCallbackKHR",
- "glGetDebugMessageLogKHR",
- "glPushDebugGroupKHR",
- "glPopDebugGroupKHR",
- "glObjectLabelKHR",
- "glGetObjectLabelKHR",
- "glObjectPtrLabelKHR",
- "glGetObjectPtrLabelKHR",
- "glGetPointervKHR",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getQcomAlphaTestFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glAlphaFuncQCOM",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getHiClientpixmapFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglCreatePixmapSurfaceHI",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getKhrStreamFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglCreateStreamKHR",
- "eglDestroyStreamKHR",
- "eglStreamAttribKHR",
- "eglQueryStreamKHR",
- "eglQueryStreamu64KHR",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getOesDrawTextureFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glDrawTexsOES",
- "glDrawTexiOES",
- "glDrawTexxOES",
- "glDrawTexsvOES",
- "glDrawTexivOES",
- "glDrawTexxvOES",
- "glDrawTexfOES",
- "glDrawTexfvOES",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtOcclusionQueryBooleanFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glGenQueriesEXT",
- "glDeleteQueriesEXT",
- "glIsQueryEXT",
- "glBeginQueryEXT",
- "glEndQueryEXT",
- "glGetQueryivEXT",
- "glGetQueryObjectuivEXT",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getAngleQuerySurfacePointerFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglQuerySurfacePointerANGLE",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getNvReadBufferFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glReadBufferNV",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getNvInstancedArraysFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glVertexAttribDivisorNV",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getAngleInstancedArraysFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glDrawArraysInstancedANGLE",
- "glDrawElementsInstancedANGLE",
- "glVertexAttribDivisorANGLE",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getAmdPerformanceMonitorFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glGetPerfMonitorGroupsAMD",
- "glGetPerfMonitorCountersAMD",
- "glGetPerfMonitorGroupStringAMD",
- "glGetPerfMonitorCounterStringAMD",
- "glGetPerfMonitorCounterInfoAMD",
- "glGenPerfMonitorsAMD",
- "glDeletePerfMonitorsAMD",
- "glSelectPerfMonitorCountersAMD",
- "glBeginPerfMonitorAMD",
- "glEndPerfMonitorAMD",
- "glGetPerfMonitorCounterDataAMD",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getAndroidNativeFenceSyncFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglDupNativeFenceFDANDROID",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getAppleSyncFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glFenceSyncAPPLE",
- "glIsSyncAPPLE",
- "glDeleteSyncAPPLE",
- "glClientWaitSyncAPPLE",
- "glWaitSyncAPPLE",
- "glGetInteger64vAPPLE",
- "glGetSyncivAPPLE",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getNvSyncFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "eglCreateFenceSyncNV",
- "eglDestroySyncNV",
- "eglFenceNV",
- "eglClientWaitSyncNV",
- "eglSignalSyncNV",
- "eglGetSyncAttribNV",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getQcomDriverControlFuncStrs (void)
-{
- static const char* funcs[] =
- {
- "glGetDriverControlsQCOM",
- "glGetDriverControlStringQCOM",
- "glEnableDriverControlQCOM",
- "glDisableDriverControlQCOM",
- DE_NULL
- };
-
- return funcs;
-}
-
-const char** getExtensionFuncStrs (const std::string& extensionName)
-{
- if (extensionName == "EGL_KHR_lock_surface")
- return getKhrLockSurfaceFuncStrs();
- else if (extensionName == "GL_OES_single_precision")
- return getOesSinglePrecisionFuncStrs();
- else if (extensionName == "GL_QCOM_tiled_rendering")
- return getQcomTiledRenderingFuncStrs();
- else if (extensionName == "EGL_NV_native_query")
- return getNvNativeQueryFuncStrs();
- else if (extensionName == "EGL_MESA_drm_image")
- return getMesaDrmImageFuncStrs();
- else if (extensionName == "GL_NV_fence")
- return getNvFenceFuncStrs();
- else if (extensionName == "GL_OES_blend_subtract")
- return getOesBlendSubtractFuncStrs();
- else if (extensionName == "EGL_KHR_stream_consumer_gltexture")
- return getKhrStreamConsumerGltextureFuncStrs();
- else if (extensionName == "GL_QCOM_extended_get2")
- return getQcomExtendedGet2FuncStrs();
- else if (extensionName == "GL_EXT_multi_draw_arrays")
- return getExtMultiDrawArraysFuncStrs();
- else if (extensionName == "GL_OES_matrix_palette")
- return getOesMatrixPaletteFuncStrs();
- else if (extensionName == "GL_EXT_separate_shader_objects")
- return getExtSeparateShaderObjectsFuncStrs();
- else if (extensionName == "GL_ANGLE_translated_shader_source")
- return getAngleTranslatedShaderSourceFuncStrs();
- else if (extensionName == "GL_NV_framebuffer_multisample")
- return getNvFramebufferMultisampleFuncStrs();
- else if (extensionName == "GL_NV_draw_buffers")
- return getNvDrawBuffersFuncStrs();
- else if (extensionName == "GL_OES_EGL_image")
- return getOesEglImageFuncStrs();
- else if (extensionName == "EGL_KHR_wait_sync")
- return getKhrWaitSyncFuncStrs();
- else if (extensionName == "EGL_NV_system_time")
- return getNvSystemTimeFuncStrs();
- else if (extensionName == "GL_EXT_robustness")
- return getExtRobustnessFuncStrs();
- else if (extensionName == "EGL_KHR_image")
- return getKhrImageFuncStrs();
- else if (extensionName == "GL_NV_draw_instanced")
- return getNvDrawInstancedFuncStrs();
- else if (extensionName == "GL_IMG_user_clip_plane")
- return getImgUserClipPlaneFuncStrs();
- else if (extensionName == "GL_OES_query_matrix")
- return getOesQueryMatrixFuncStrs();
- else if (extensionName == "GL_NV_coverage_sample")
- return getNvCoverageSampleFuncStrs();
- else if (extensionName == "GL_EXT_disjoint_timer_query")
- return getExtDisjointTimerQueryFuncStrs();
- else if (extensionName == "GL_OES_vertex_array_object")
- return getOesVertexArrayObjectFuncStrs();
- else if (extensionName == "EGL_KHR_reusable_sync")
- return getKhrReusableSyncFuncStrs();
- else if (extensionName == "GL_EXT_debug_label")
- return getExtDebugLabelFuncStrs();
- else if (extensionName == "GL_EXT_map_buffer_range")
- return getExtMapBufferRangeFuncStrs();
- else if (extensionName == "GL_ANGLE_framebuffer_multisample")
- return getAngleFramebufferMultisampleFuncStrs();
- else if (extensionName == "EGL_KHR_stream_cross_process_fd")
- return getKhrStreamCrossProcessFdFuncStrs();
- else if (extensionName == "GL_EXT_texture_storage")
- return getExtTextureStorageFuncStrs();
- else if (extensionName == "EGL_KHR_stream_fifo")
- return getKhrStreamFifoFuncStrs();
- else if (extensionName == "GL_OES_mapbuffer")
- return getOesMapbufferFuncStrs();
- else if (extensionName == "EGL_NV_post_sub_buffer")
- return getNvPostSubBufferFuncStrs();
- else if (extensionName == "GL_OES_texture_cube_map")
- return getOesTextureCubeMapFuncStrs();
- else if (extensionName == "EGL_KHR_stream_producer_eglsurface")
- return getKhrStreamProducerEglsurfaceFuncStrs();
- else if (extensionName == "GL_OES_blend_equation_separate")
- return getOesBlendEquationSeparateFuncStrs();
- else if (extensionName == "GL_EXT_draw_buffers")
- return getExtDrawBuffersFuncStrs();
- else if (extensionName == "GL_OES_framebuffer_object")
- return getOesFramebufferObjectFuncStrs();
- else if (extensionName == "GL_EXT_debug_marker")
- return getExtDebugMarkerFuncStrs();
- else if (extensionName == "GL_EXT_multisampled_render_to_texture")
- return getExtMultisampledRenderToTextureFuncStrs();
- else if (extensionName == "GL_EXT_discard_framebuffer")
- return getExtDiscardFramebufferFuncStrs();
- else if (extensionName == "GL_OES_fixed_point")
- return getOesFixedPointFuncStrs();
- else if (extensionName == "GL_IMG_multisampled_render_to_texture")
- return getImgMultisampledRenderToTextureFuncStrs();
- else if (extensionName == "GL_OES_get_program_binary")
- return getOesGetProgramBinaryFuncStrs();
- else if (extensionName == "GL_APPLE_framebuffer_multisample")
- return getAppleFramebufferMultisampleFuncStrs();
- else if (extensionName == "GL_APPLE_copy_texture_levels")
- return getAppleCopyTextureLevelsFuncStrs();
- else if (extensionName == "GL_EXT_multiview_draw_buffers")
- return getExtMultiviewDrawBuffersFuncStrs();
- else if (extensionName == "GL_OES_blend_func_separate")
- return getOesBlendFuncSeparateFuncStrs();
- else if (extensionName == "GL_QCOM_extended_get")
- return getQcomExtendedGetFuncStrs();
- else if (extensionName == "GL_NV_framebuffer_blit")
- return getNvFramebufferBlitFuncStrs();
- else if (extensionName == "EGL_ANDROID_blob_cache")
- return getAndroidBlobCacheFuncStrs();
- else if (extensionName == "GL_ANGLE_framebuffer_blit")
- return getAngleFramebufferBlitFuncStrs();
- else if (extensionName == "GL_OES_texture_3D")
- return getOesTexture3DFuncStrs();
- else if (extensionName == "GL_KHR_debug")
- return getKhrDebugFuncStrs();
- else if (extensionName == "GL_QCOM_alpha_test")
- return getQcomAlphaTestFuncStrs();
- else if (extensionName == "EGL_HI_clientpixmap")
- return getHiClientpixmapFuncStrs();
- else if (extensionName == "EGL_KHR_stream")
- return getKhrStreamFuncStrs();
- else if (extensionName == "GL_OES_draw_texture")
- return getOesDrawTextureFuncStrs();
- else if (extensionName == "GL_EXT_occlusion_query_boolean")
- return getExtOcclusionQueryBooleanFuncStrs();
- else if (extensionName == "EGL_ANGLE_query_surface_pointer")
- return getAngleQuerySurfacePointerFuncStrs();
- else if (extensionName == "GL_NV_read_buffer")
- return getNvReadBufferFuncStrs();
- else if (extensionName == "GL_NV_instanced_arrays")
- return getNvInstancedArraysFuncStrs();
- else if (extensionName == "GL_ANGLE_instanced_arrays")
- return getAngleInstancedArraysFuncStrs();
- else if (extensionName == "GL_AMD_performance_monitor")
- return getAmdPerformanceMonitorFuncStrs();
- else if (extensionName == "EGL_ANDROID_native_fence_sync")
- return getAndroidNativeFenceSyncFuncStrs();
- else if (extensionName == "GL_APPLE_sync")
- return getAppleSyncFuncStrs();
- else if (extensionName == "EGL_NV_sync")
- return getNvSyncFuncStrs();
- else if (extensionName == "GL_QCOM_driver_control")
- return getQcomDriverControlFuncStrs();
- else
- return 0;
-}
-
-const char** getExtensionStrs (void)
-{
- static const char* extensions[] =
- {
- "EGL_KHR_config_attribs",
- "EGL_KHR_lock_surface",
- "EGL_KHR_image",
- "EGL_KHR_vg_parent_image",
- "EGL_KHR_gl_texture_2D_image",
- "EGL_KHR_gl_texture_cubemap_image",
- "EGL_KHR_gl_texture_3D_image",
- "EGL_KHR_gl_renderbuffer_image",
- "EGL_KHR_reusable_sync",
- "EGL_KHR_image_base",
- "EGL_KHR_image_pixmap",
- "EGL_IMG_context_priority",
- "EGL_KHR_lock_surface2",
- "EGL_NV_coverage_sample",
- "EGL_NV_depth_nonlinear",
- "EGL_NV_sync",
- "EGL_KHR_fence_sync",
- "EGL_HI_clientpixmap",
- "EGL_HI_colorformats",
- "EGL_MESA_drm_image",
- "EGL_NV_post_sub_buffer",
- "EGL_ANGLE_query_surface_pointer",
- "EGL_ANGLE_surface_d3d_texture_2d_share_handle",
- "EGL_NV_coverage_sample_resolve",
- "EGL_NV_system_time",
- "EGL_KHR_stream",
- "EGL_KHR_stream_consumer_gltexture",
- "EGL_KHR_stream_producer_eglsurface",
- "EGL_KHR_stream_producer_aldatalocator",
- "EGL_KHR_stream_fifo",
- "EGL_EXT_create_context_robustness",
- "EGL_ANGLE_d3d_share_handle_client_buffer",
- "EGL_KHR_create_context",
- "EGL_KHR_surfaceless_context",
- "EGL_KHR_stream_cross_process_fd",
- "EGL_EXT_multiview_window",
- "EGL_KHR_wait_sync",
- "EGL_NV_post_convert_rounding",
- "EGL_NV_native_query",
- "EGL_NV_3dvision_surface",
- "EGL_ANDROID_framebuffer_target",
- "EGL_ANDROID_blob_cache",
- "EGL_ANDROID_image_native_buffer",
- "EGL_ANDROID_native_fence_sync",
- "EGL_ANDROID_recordable",
- "EGL_EXT_buffer_age",
- "EGL_EXT_image_dma_buf_import",
- "EGL_ARM_pixmap_multisample_discard",
- "GL_APIENTRYP",
- "GL_OES_blend_equation_separate",
- "GL_OES_blend_func_separate",
- "GL_OES_blend_subtract",
- "GL_OES_compressed_ETC1_RGB8_texture",
- "GL_OES_depth24",
- "GL_OES_depth32",
- "GL_OES_draw_texture",
- "GL_OES_EGL_image",
- "GL_OES_EGL_image_external",
- "GL_OES_element_index_uint",
- "GL_OES_fixed_point",
- "GL_OES_framebuffer_object",
- "GL_OES_mapbuffer",
- "GL_OES_matrix_get",
- "GL_OES_matrix_palette",
- "GL_OES_packed_depth_stencil",
- "GL_OES_rgb8_rgba8",
- "GL_OES_stencil1",
- "GL_OES_stencil4",
- "GL_OES_stencil8",
- "GL_OES_stencil_wrap",
- "GL_OES_texture_cube_map",
- "GL_OES_texture_mirrored_repeat",
- "GL_OES_vertex_array_object",
- "GL_AMD_compressed_3DC_texture",
- "GL_AMD_compressed_ATC_texture",
- "GL_APPLE_framebuffer_multisample",
- "GL_APPLE_sync",
- "GL_APPLE_texture_format_BGRA8888",
- "GL_APPLE_texture_max_level",
- "GL_EXT_blend_minmax",
- "GL_EXT_discard_framebuffer",
- "GL_EXT_map_buffer_range",
- "GL_EXT_multisampled_render_to_texture",
- "GL_EXT_read_format_bgra",
- "GL_EXT_robustness",
- "GL_EXT_sRGB",
- "GL_EXT_texture_compression_dxt1",
- "GL_EXT_texture_filter_anisotropic",
- "GL_EXT_texture_format_BGRA8888",
- "GL_EXT_texture_lod_bias",
- "GL_EXT_texture_storage",
- "GL_IMG_read_format",
- "GL_IMG_texture_compression_pvrtc",
- "GL_IMG_texture_env_enhanced_fixed_function",
- "GL_IMG_user_clip_plane",
- "GL_IMG_multisampled_render_to_texture",
- "GL_NV_fence",
- "GL_QCOM_extended_get",
- "GL_QCOM_perfmon_global_mode",
- "GL_QCOM_writeonly_rendering",
- "GL_QCOM_tiled_rendering",
- "GL_OES_byte_coordinates",
- "GL_OES_extended_matrix_palette",
- "GL_OES_fbo_render_mipmap",
- "GL_OES_required_internalformat",
- "GL_OES_query_matrix",
- "GL_OES_single_precision",
- "GL_OES_texture_env_crossbar",
- "GL_APPLE_copy_texture_levels",
- "GL_APPLE_texture_2D_limited_npot",
- "GL_ARM_rgba8",
- "GL_EXT_multi_draw_arrays",
- "GL_QCOM_driver_control",
- "GL_QCOM_extended_get2",
- "GL_OES_compressed_paletted_texture",
- "GL_OES_get_program_binary",
- "GL_OES_standard_derivatives",
- "GL_OES_surfaceless_context",
- "GL_OES_texture_3D",
- "GL_OES_texture_half_float",
- "GL_OES_vertex_type_10_10_10_2",
- "GL_KHR_debug",
- "GL_KHR_texture_compression_astc_ldr",
- "GL_AMD_performance_monitor",
- "GL_AMD_program_binary_Z400",
- "GL_ANGLE_depth_texture",
- "GL_ANGLE_framebuffer_blit",
- "GL_ANGLE_framebuffer_multisample",
- "GL_ANGLE_instanced_arrays",
- "GL_ANGLE_pack_reverse_row_order",
- "GL_ANGLE_program_binary",
- "GL_ANGLE_texture_compression_dxt3",
- "GL_ANGLE_texture_compression_dxt5",
- "GL_ANGLE_texture_usage",
- "GL_ANGLE_translated_shader_source",
- "GL_APPLE_rgb_422",
- "GL_ARM_mali_program_binary",
- "GL_ARM_mali_shader_binary",
- "GL_EXT_color_buffer_half_float",
- "GL_EXT_debug_label",
- "GL_EXT_disjoint_timer_query",
- "GL_EXT_draw_buffers",
- "GL_EXT_multiview_draw_buffers",
- "GL_EXT_occlusion_query_boolean",
- "GL_EXT_separate_shader_objects",
- "GL_EXT_shader_framebuffer_fetch",
- "GL_EXT_shadow_samplers",
- "GL_EXT_texture_rg",
- "GL_EXT_texture_type_2_10_10_10_REV",
- "GL_EXT_unpack_subimage",
- "GL_DMP_shader_binary",
- "GL_FJ_shader_binary_GCCSO",
- "GL_IMG_program_binary",
- "GL_IMG_shader_binary",
- "GL_IMG_texture_compression_pvrtc2",
- "GL_NV_coverage_sample",
- "GL_NV_depth_nonlinear",
- "GL_NV_draw_buffers",
- "GL_NV_fbo_color_attachments",
- "GL_NV_framebuffer_blit",
- "GL_NV_framebuffer_multisample",
- "GL_NV_instanced_arrays",
- "GL_NV_read_buffer",
- "GL_NV_shadow_samplers_array",
- "GL_NV_shadow_samplers_cube",
- "GL_NV_sRGB_formats",
- "GL_NV_texture_border_clamp",
- "GL_QCOM_alpha_test",
- "GL_QCOM_binning_control",
- "GL_VIV_shader_binary",
- "GL_OES_depth_texture",
- "GL_OES_fragment_precision_high",
- "GL_OES_texture_float",
- "GL_OES_texture_float_linear",
- "GL_OES_texture_half_float_linear",
- "GL_OES_texture_npot",
- "GL_OES_vertex_half_float",
- "GL_EXT_debug_marker",
- "GL_EXT_shader_texture_lod",
- "GL_NV_draw_instanced",
- "GL_NV_generate_mipmap_sRGB",
- "GL_NV_read_buffer_front",
- "GL_NV_read_depth",
- "GL_NV_read_depth_stencil",
- "GL_NV_read_stencil",
- "GL_NV_texture_compression_s3tc_update",
- "GL_NV_texture_npot_2D_mipmap",
- DE_NULL
- };
-
- return extensions;
-}
+static const char* s_EGL14[] =
+{
+ "eglBindAPI",
+ "eglBindTexImage",
+ "eglChooseConfig",
+ "eglCopyBuffers",
+ "eglCreateContext",
+ "eglCreatePbufferFromClientBuffer",
+ "eglCreatePbufferSurface",
+ "eglCreatePixmapSurface",
+ "eglCreateWindowSurface",
+ "eglDestroyContext",
+ "eglDestroySurface",
+ "eglGetConfigAttrib",
+ "eglGetConfigs",
+ "eglGetCurrentContext",
+ "eglGetCurrentDisplay",
+ "eglGetCurrentSurface",
+ "eglGetDisplay",
+ "eglGetError",
+ "eglGetProcAddress",
+ "eglInitialize",
+ "eglMakeCurrent",
+ "eglQueryAPI",
+ "eglQueryContext",
+ "eglQueryString",
+ "eglQuerySurface",
+ "eglReleaseTexImage",
+ "eglReleaseThread",
+ "eglSurfaceAttrib",
+ "eglSwapBuffers",
+ "eglSwapInterval",
+ "eglTerminate",
+ "eglWaitClient",
+ "eglWaitGL",
+ "eglWaitNative",
+};
+
+static const char* s_GLES10[] =
+{
+ "glActiveTexture",
+ "glAlphaFunc",
+ "glAlphaFuncx",
+ "glBindBuffer",
+ "glBindTexture",
+ "glBlendFunc",
+ "glBufferData",
+ "glBufferSubData",
+ "glClear",
+ "glClearColor",
+ "glClearColorx",
+ "glClearDepthf",
+ "glClearDepthx",
+ "glClearStencil",
+ "glClientActiveTexture",
+ "glClipPlanef",
+ "glClipPlanex",
+ "glColor4f",
+ "glColor4ub",
+ "glColor4x",
+ "glColorMask",
+ "glColorPointer",
+ "glCompressedTexImage2D",
+ "glCompressedTexSubImage2D",
+ "glCopyTexImage2D",
+ "glCopyTexSubImage2D",
+ "glCullFace",
+ "glDeleteBuffers",
+ "glDeleteTextures",
+ "glDepthFunc",
+ "glDepthMask",
+ "glDepthRangef",
+ "glDepthRangex",
+ "glDisable",
+ "glDisableClientState",
+ "glDrawArrays",
+ "glDrawElements",
+ "glEnable",
+ "glEnableClientState",
+ "glFinish",
+ "glFlush",
+ "glFogf",
+ "glFogfv",
+ "glFogx",
+ "glFogxv",
+ "glFrontFace",
+ "glFrustumf",
+ "glFrustumx",
+ "glGenBuffers",
+ "glGenTextures",
+ "glGetBooleanv",
+ "glGetBufferParameteriv",
+ "glGetClipPlanef",
+ "glGetClipPlanex",
+ "glGetError",
+ "glGetFixedv",
+ "glGetFloatv",
+ "glGetIntegerv",
+ "glGetLightfv",
+ "glGetLightxv",
+ "glGetMaterialfv",
+ "glGetMaterialxv",
+ "glGetPointerv",
+ "glGetString",
+ "glGetTexEnvfv",
+ "glGetTexEnviv",
+ "glGetTexEnvxv",
+ "glGetTexParameterfv",
+ "glGetTexParameteriv",
+ "glGetTexParameterxv",
+ "glHint",
+ "glIsBuffer",
+ "glIsEnabled",
+ "glIsTexture",
+ "glLightModelf",
+ "glLightModelfv",
+ "glLightModelx",
+ "glLightModelxv",
+ "glLightf",
+ "glLightfv",
+ "glLightx",
+ "glLightxv",
+ "glLineWidth",
+ "glLineWidthx",
+ "glLoadIdentity",
+ "glLoadMatrixf",
+ "glLoadMatrixx",
+ "glLogicOp",
+ "glMaterialf",
+ "glMaterialfv",
+ "glMaterialx",
+ "glMaterialxv",
+ "glMatrixMode",
+ "glMultMatrixf",
+ "glMultMatrixx",
+ "glMultiTexCoord4f",
+ "glMultiTexCoord4x",
+ "glNormal3f",
+ "glNormal3x",
+ "glNormalPointer",
+ "glOrthof",
+ "glOrthox",
+ "glPixelStorei",
+ "glPointParameterf",
+ "glPointParameterfv",
+ "glPointParameterx",
+ "glPointParameterxv",
+ "glPointSize",
+ "glPointSizex",
+ "glPolygonOffset",
+ "glPolygonOffsetx",
+ "glPopMatrix",
+ "glPushMatrix",
+ "glReadPixels",
+ "glRotatef",
+ "glRotatex",
+ "glSampleCoverage",
+ "glSampleCoveragex",
+ "glScalef",
+ "glScalex",
+ "glScissor",
+ "glShadeModel",
+ "glStencilFunc",
+ "glStencilMask",
+ "glStencilOp",
+ "glTexCoordPointer",
+ "glTexEnvf",
+ "glTexEnvfv",
+ "glTexEnvi",
+ "glTexEnviv",
+ "glTexEnvx",
+ "glTexEnvxv",
+ "glTexImage2D",
+ "glTexParameterf",
+ "glTexParameterfv",
+ "glTexParameteri",
+ "glTexParameteriv",
+ "glTexParameterx",
+ "glTexParameterxv",
+ "glTexSubImage2D",
+ "glTranslatef",
+ "glTranslatex",
+ "glVertexPointer",
+ "glViewport",
+};
+
+static const char* s_GLES20[] =
+{
+ "glActiveTexture",
+ "glAttachShader",
+ "glBindAttribLocation",
+ "glBindBuffer",
+ "glBindFramebuffer",
+ "glBindRenderbuffer",
+ "glBindTexture",
+ "glBlendColor",
+ "glBlendEquation",
+ "glBlendEquationSeparate",
+ "glBlendFunc",
+ "glBlendFuncSeparate",
+ "glBufferData",
+ "glBufferSubData",
+ "glCheckFramebufferStatus",
+ "glClear",
+ "glClearColor",
+ "glClearDepthf",
+ "glClearStencil",
+ "glColorMask",
+ "glCompileShader",
+ "glCompressedTexImage2D",
+ "glCompressedTexSubImage2D",
+ "glCopyTexImage2D",
+ "glCopyTexSubImage2D",
+ "glCreateProgram",
+ "glCreateShader",
+ "glCullFace",
+ "glDeleteBuffers",
+ "glDeleteFramebuffers",
+ "glDeleteProgram",
+ "glDeleteRenderbuffers",
+ "glDeleteShader",
+ "glDeleteTextures",
+ "glDepthFunc",
+ "glDepthMask",
+ "glDepthRangef",
+ "glDetachShader",
+ "glDisable",
+ "glDisableVertexAttribArray",
+ "glDrawArrays",
+ "glDrawElements",
+ "glEnable",
+ "glEnableVertexAttribArray",
+ "glFinish",
+ "glFlush",
+ "glFramebufferRenderbuffer",
+ "glFramebufferTexture2D",
+ "glFrontFace",
+ "glGenBuffers",
+ "glGenFramebuffers",
+ "glGenRenderbuffers",
+ "glGenTextures",
+ "glGenerateMipmap",
+ "glGetActiveAttrib",
+ "glGetActiveUniform",
+ "glGetAttachedShaders",
+ "glGetAttribLocation",
+ "glGetBooleanv",
+ "glGetBufferParameteriv",
+ "glGetError",
+ "glGetFloatv",
+ "glGetFramebufferAttachmentParameteriv",
+ "glGetIntegerv",
+ "glGetProgramInfoLog",
+ "glGetProgramiv",
+ "glGetRenderbufferParameteriv",
+ "glGetShaderInfoLog",
+ "glGetShaderPrecisionFormat",
+ "glGetShaderSource",
+ "glGetShaderiv",
+ "glGetString",
+ "glGetTexParameterfv",
+ "glGetTexParameteriv",
+ "glGetUniformLocation",
+ "glGetUniformfv",
+ "glGetUniformiv",
+ "glGetVertexAttribPointerv",
+ "glGetVertexAttribfv",
+ "glGetVertexAttribiv",
+ "glHint",
+ "glIsBuffer",
+ "glIsEnabled",
+ "glIsFramebuffer",
+ "glIsProgram",
+ "glIsRenderbuffer",
+ "glIsShader",
+ "glIsTexture",
+ "glLineWidth",
+ "glLinkProgram",
+ "glPixelStorei",
+ "glPolygonOffset",
+ "glReadPixels",
+ "glReleaseShaderCompiler",
+ "glRenderbufferStorage",
+ "glSampleCoverage",
+ "glScissor",
+ "glShaderBinary",
+ "glShaderSource",
+ "glStencilFunc",
+ "glStencilFuncSeparate",
+ "glStencilMask",
+ "glStencilMaskSeparate",
+ "glStencilOp",
+ "glStencilOpSeparate",
+ "glTexImage2D",
+ "glTexParameterf",
+ "glTexParameterfv",
+ "glTexParameteri",
+ "glTexParameteriv",
+ "glTexSubImage2D",
+ "glUniform1f",
+ "glUniform1fv",
+ "glUniform1i",
+ "glUniform1iv",
+ "glUniform2f",
+ "glUniform2fv",
+ "glUniform2i",
+ "glUniform2iv",
+ "glUniform3f",
+ "glUniform3fv",
+ "glUniform3i",
+ "glUniform3iv",
+ "glUniform4f",
+ "glUniform4fv",
+ "glUniform4i",
+ "glUniform4iv",
+ "glUniformMatrix2fv",
+ "glUniformMatrix3fv",
+ "glUniformMatrix4fv",
+ "glUseProgram",
+ "glValidateProgram",
+ "glVertexAttrib1f",
+ "glVertexAttrib1fv",
+ "glVertexAttrib2f",
+ "glVertexAttrib2fv",
+ "glVertexAttrib3f",
+ "glVertexAttrib3fv",
+ "glVertexAttrib4f",
+ "glVertexAttrib4fv",
+ "glVertexAttribPointer",
+ "glViewport",
+};
+
+static const char* s_GLES30[] =
+{
+ "glBeginQuery",
+ "glBeginTransformFeedback",
+ "glBindBufferBase",
+ "glBindBufferRange",
+ "glBindSampler",
+ "glBindTransformFeedback",
+ "glBindVertexArray",
+ "glBlitFramebuffer",
+ "glClearBufferfi",
+ "glClearBufferfv",
+ "glClearBufferiv",
+ "glClearBufferuiv",
+ "glClientWaitSync",
+ "glCompressedTexImage3D",
+ "glCompressedTexSubImage3D",
+ "glCopyBufferSubData",
+ "glCopyTexSubImage3D",
+ "glDeleteQueries",
+ "glDeleteSamplers",
+ "glDeleteSync",
+ "glDeleteTransformFeedbacks",
+ "glDeleteVertexArrays",
+ "glDrawArraysInstanced",
+ "glDrawBuffers",
+ "glDrawElementsInstanced",
+ "glDrawRangeElements",
+ "glEndQuery",
+ "glEndTransformFeedback",
+ "glFenceSync",
+ "glFlushMappedBufferRange",
+ "glFramebufferTextureLayer",
+ "glGenQueries",
+ "glGenSamplers",
+ "glGenTransformFeedbacks",
+ "glGenVertexArrays",
+ "glGetActiveUniformBlockName",
+ "glGetActiveUniformBlockiv",
+ "glGetActiveUniformsiv",
+ "glGetBufferParameteri64v",
+ "glGetBufferPointerv",
+ "glGetFragDataLocation",
+ "glGetInteger64i_v",
+ "glGetInteger64v",
+ "glGetIntegeri_v",
+ "glGetInternalformativ",
+ "glGetProgramBinary",
+ "glGetQueryObjectuiv",
+ "glGetQueryiv",
+ "glGetSamplerParameterfv",
+ "glGetSamplerParameteriv",
+ "glGetStringi",
+ "glGetSynciv",
+ "glGetTransformFeedbackVarying",
+ "glGetUniformBlockIndex",
+ "glGetUniformIndices",
+ "glGetUniformuiv",
+ "glGetVertexAttribIiv",
+ "glGetVertexAttribIuiv",
+ "glInvalidateFramebuffer",
+ "glInvalidateSubFramebuffer",
+ "glIsQuery",
+ "glIsSampler",
+ "glIsSync",
+ "glIsTransformFeedback",
+ "glIsVertexArray",
+ "glMapBufferRange",
+ "glPauseTransformFeedback",
+ "glProgramBinary",
+ "glProgramParameteri",
+ "glReadBuffer",
+ "glRenderbufferStorageMultisample",
+ "glResumeTransformFeedback",
+ "glSamplerParameterf",
+ "glSamplerParameterfv",
+ "glSamplerParameteri",
+ "glSamplerParameteriv",
+ "glTexImage3D",
+ "glTexStorage2D",
+ "glTexStorage3D",
+ "glTexSubImage3D",
+ "glTransformFeedbackVaryings",
+ "glUniform1ui",
+ "glUniform1uiv",
+ "glUniform2ui",
+ "glUniform2uiv",
+ "glUniform3ui",
+ "glUniform3uiv",
+ "glUniform4ui",
+ "glUniform4uiv",
+ "glUniformBlockBinding",
+ "glUniformMatrix2x3fv",
+ "glUniformMatrix2x4fv",
+ "glUniformMatrix3x2fv",
+ "glUniformMatrix3x4fv",
+ "glUniformMatrix4x2fv",
+ "glUniformMatrix4x3fv",
+ "glUnmapBuffer",
+ "glVertexAttribDivisor",
+ "glVertexAttribI4i",
+ "glVertexAttribI4iv",
+ "glVertexAttribI4ui",
+ "glVertexAttribI4uiv",
+ "glVertexAttribIPointer",
+ "glWaitSync",
+};
+
+static const char* s_EGL_ANDROID_blob_cache[] =
+{
+ "eglSetBlobCacheFuncsANDROID",
+};
+
+static const char* s_EGL_ANDROID_native_fence_sync[] =
+{
+ "eglDupNativeFenceFDANDROID",
+};
+
+static const char* s_EGL_ANGLE_query_surface_pointer[] =
+{
+ "eglQuerySurfacePointerANGLE",
+};
+
+static const char* s_EGL_EXT_device_base[] =
+{
+ "eglQueryDeviceAttribEXT",
+ "eglQueryDeviceStringEXT",
+ "eglQueryDevicesEXT",
+ "eglQueryDisplayAttribEXT",
+};
+
+static const char* s_EGL_EXT_output_base[] =
+{
+ "eglGetOutputLayersEXT",
+ "eglGetOutputPortsEXT",
+ "eglOutputLayerAttribEXT",
+ "eglOutputPortAttribEXT",
+ "eglQueryOutputLayerAttribEXT",
+ "eglQueryOutputLayerStringEXT",
+ "eglQueryOutputPortAttribEXT",
+ "eglQueryOutputPortStringEXT",
+};
+
+static const char* s_EGL_EXT_platform_base[] =
+{
+ "eglCreatePlatformPixmapSurfaceEXT",
+ "eglCreatePlatformWindowSurfaceEXT",
+ "eglGetPlatformDisplayEXT",
+};
+
+static const char* s_EGL_EXT_stream_consumer_egloutput[] =
+{
+ "eglStreamConsumerOutputEXT",
+};
+
+static const char* s_EGL_EXT_swap_buffers_with_damage[] =
+{
+ "eglSwapBuffersWithDamageEXT",
+};
+
+static const char* s_EGL_HI_clientpixmap[] =
+{
+ "eglCreatePixmapSurfaceHI",
+};
+
+static const char* s_EGL_KHR_cl_event2[] =
+{
+ "eglCreateSync64KHR",
+};
+
+static const char* s_EGL_KHR_image[] =
+{
+ "eglCreateImageKHR",
+ "eglDestroyImageKHR",
+};
+
+static const char* s_EGL_KHR_image_base[] =
+{
+ "eglCreateImageKHR",
+ "eglDestroyImageKHR",
+};
+
+static const char* s_EGL_KHR_lock_surface[] =
+{
+ "eglLockSurfaceKHR",
+ "eglUnlockSurfaceKHR",
+};
+
+static const char* s_EGL_KHR_lock_surface3[] =
+{
+ "eglLockSurfaceKHR",
+ "eglQuerySurface64KHR",
+ "eglUnlockSurfaceKHR",
+};
+
+static const char* s_EGL_KHR_reusable_sync[] =
+{
+ "eglClientWaitSyncKHR",
+ "eglCreateSyncKHR",
+ "eglDestroySyncKHR",
+ "eglGetSyncAttribKHR",
+ "eglSignalSyncKHR",
+};
+
+static const char* s_EGL_KHR_stream[] =
+{
+ "eglCreateStreamKHR",
+ "eglDestroyStreamKHR",
+ "eglQueryStreamKHR",
+ "eglQueryStreamu64KHR",
+ "eglStreamAttribKHR",
+};
+
+static const char* s_EGL_KHR_stream_consumer_gltexture[] =
+{
+ "eglStreamConsumerAcquireKHR",
+ "eglStreamConsumerGLTextureExternalKHR",
+ "eglStreamConsumerReleaseKHR",
+};
+
+static const char* s_EGL_KHR_stream_cross_process_fd[] =
+{
+ "eglCreateStreamFromFileDescriptorKHR",
+ "eglGetStreamFileDescriptorKHR",
+};
+
+static const char* s_EGL_KHR_stream_fifo[] =
+{
+ "eglQueryStreamTimeKHR",
+};
+
+static const char* s_EGL_KHR_stream_producer_eglsurface[] =
+{
+ "eglCreateStreamProducerSurfaceKHR",
+};
+
+static const char* s_EGL_KHR_wait_sync[] =
+{
+ "eglWaitSyncKHR",
+};
+
+static const char* s_EGL_MESA_drm_image[] =
+{
+ "eglCreateDRMImageMESA",
+ "eglExportDRMImageMESA",
+};
+
+static const char* s_EGL_NOK_swap_region[] =
+{
+ "eglSwapBuffersRegionNOK",
+};
+
+static const char* s_EGL_NOK_swap_region2[] =
+{
+ "eglSwapBuffersRegion2NOK",
+};
+
+static const char* s_EGL_NV_native_query[] =
+{
+ "eglQueryNativeDisplayNV",
+ "eglQueryNativePixmapNV",
+ "eglQueryNativeWindowNV",
+};
+
+static const char* s_EGL_NV_post_sub_buffer[] =
+{
+ "eglPostSubBufferNV",
+};
+
+static const char* s_EGL_NV_stream_sync[] =
+{
+ "eglCreateStreamSyncNV",
+};
+
+static const char* s_EGL_NV_sync[] =
+{
+ "eglClientWaitSyncNV",
+ "eglCreateFenceSyncNV",
+ "eglDestroySyncNV",
+ "eglFenceNV",
+ "eglGetSyncAttribNV",
+ "eglSignalSyncNV",
+};
+
+static const char* s_EGL_NV_system_time[] =
+{
+ "eglGetSystemTimeFrequencyNV",
+ "eglGetSystemTimeNV",
+};
+
+static const char* s_GL_APPLE_copy_texture_levels[] =
+{
+ "glCopyTextureLevelsAPPLE",
+};
+
+static const char* s_GL_APPLE_framebuffer_multisample[] =
+{
+ "glRenderbufferStorageMultisampleAPPLE",
+ "glResolveMultisampleFramebufferAPPLE",
+};
+
+static const char* s_GL_APPLE_sync[] =
+{
+ "glClientWaitSyncAPPLE",
+ "glDeleteSyncAPPLE",
+ "glFenceSyncAPPLE",
+ "glGetInteger64vAPPLE",
+ "glGetSyncivAPPLE",
+ "glIsSyncAPPLE",
+ "glWaitSyncAPPLE",
+};
+
+static const char* s_GL_EXT_discard_framebuffer[] =
+{
+ "glDiscardFramebufferEXT",
+};
+
+static const char* s_GL_EXT_map_buffer_range[] =
+{
+ "glFlushMappedBufferRangeEXT",
+ "glMapBufferRangeEXT",
+};
+
+static const char* s_GL_EXT_multi_draw_arrays[] =
+{
+ "glMultiDrawArraysEXT",
+ "glMultiDrawElementsEXT",
+};
+
+static const char* s_GL_EXT_multisampled_render_to_texture[] =
+{
+ "glFramebufferTexture2DMultisampleEXT",
+ "glRenderbufferStorageMultisampleEXT",
+};
+
+static const char* s_GL_EXT_robustness[] =
+{
+ "glGetGraphicsResetStatusEXT",
+ "glGetnUniformfvEXT",
+ "glGetnUniformivEXT",
+ "glReadnPixelsEXT",
+};
+
+static const char* s_GL_EXT_texture_storage[] =
+{
+ "glTexStorage1DEXT",
+ "glTexStorage2DEXT",
+ "glTexStorage3DEXT",
+ "glTextureStorage1DEXT",
+ "glTextureStorage2DEXT",
+ "glTextureStorage3DEXT",
+};
+
+static const char* s_GL_IMG_multisampled_render_to_texture[] =
+{
+ "glFramebufferTexture2DMultisampleIMG",
+ "glRenderbufferStorageMultisampleIMG",
+};
+
+static const char* s_GL_IMG_user_clip_plane[] =
+{
+ "glClipPlanefIMG",
+ "glClipPlanexIMG",
+};
+
+static const char* s_GL_NV_fence[] =
+{
+ "glDeleteFencesNV",
+ "glFinishFenceNV",
+ "glGenFencesNV",
+ "glGetFenceivNV",
+ "glIsFenceNV",
+ "glSetFenceNV",
+ "glTestFenceNV",
+};
+
+static const char* s_GL_OES_EGL_image[] =
+{
+ "glEGLImageTargetRenderbufferStorageOES",
+ "glEGLImageTargetTexture2DOES",
+};
+
+static const char* s_GL_OES_blend_equation_separate[] =
+{
+ "glBlendEquationSeparateOES",
+};
+
+static const char* s_GL_OES_blend_func_separate[] =
+{
+ "glBlendFuncSeparateOES",
+};
+
+static const char* s_GL_OES_blend_subtract[] =
+{
+ "glBlendEquationOES",
+};
+
+static const char* s_GL_OES_draw_texture[] =
+{
+ "glDrawTexfOES",
+ "glDrawTexfvOES",
+ "glDrawTexiOES",
+ "glDrawTexivOES",
+ "glDrawTexsOES",
+ "glDrawTexsvOES",
+ "glDrawTexxOES",
+ "glDrawTexxvOES",
+};
+
+static const char* s_GL_OES_fixed_point[] =
+{
+ "glAlphaFuncxOES",
+ "glClearColorxOES",
+ "glClearDepthxOES",
+ "glClipPlanexOES",
+ "glColor4xOES",
+ "glDepthRangexOES",
+ "glFogxOES",
+ "glFogxvOES",
+ "glFrustumxOES",
+ "glGetClipPlanexOES",
+ "glGetFixedvOES",
+ "glGetLightxvOES",
+ "glGetMaterialxvOES",
+ "glGetTexEnvxvOES",
+ "glGetTexParameterxvOES",
+ "glLightModelxOES",
+ "glLightModelxvOES",
+ "glLightxOES",
+ "glLightxvOES",
+ "glLineWidthxOES",
+ "glLoadMatrixxOES",
+ "glMaterialxOES",
+ "glMaterialxvOES",
+ "glMultMatrixxOES",
+ "glMultiTexCoord4xOES",
+ "glNormal3xOES",
+ "glOrthoxOES",
+ "glPointParameterxOES",
+ "glPointParameterxvOES",
+ "glPointSizexOES",
+ "glPolygonOffsetxOES",
+ "glRotatexOES",
+ "glSampleCoverageOES",
+ "glSampleCoveragexOES",
+ "glScalexOES",
+ "glTexEnvxOES",
+ "glTexEnvxvOES",
+ "glTexParameterxOES",
+ "glTexParameterxvOES",
+ "glTranslatexOES",
+};
+
+static const char* s_GL_OES_framebuffer_object[] =
+{
+ "glBindFramebufferOES",
+ "glBindRenderbufferOES",
+ "glCheckFramebufferStatusOES",
+ "glDeleteFramebuffersOES",
+ "glDeleteRenderbuffersOES",
+ "glFramebufferRenderbufferOES",
+ "glFramebufferTexture2DOES",
+ "glGenFramebuffersOES",
+ "glGenRenderbuffersOES",
+ "glGenerateMipmapOES",
+ "glGetFramebufferAttachmentParameterivOES",
+ "glGetRenderbufferParameterivOES",
+ "glIsFramebufferOES",
+ "glIsRenderbufferOES",
+ "glRenderbufferStorageOES",
+};
+
+static const char* s_GL_OES_mapbuffer[] =
+{
+ "glGetBufferPointervOES",
+ "glMapBufferOES",
+ "glUnmapBufferOES",
+};
+
+static const char* s_GL_OES_matrix_palette[] =
+{
+ "glCurrentPaletteMatrixOES",
+ "glLoadPaletteFromModelViewMatrixOES",
+ "glMatrixIndexPointerOES",
+ "glWeightPointerOES",
+};
+
+static const char* s_GL_OES_point_size_array[] =
+{
+ "glPointSizePointerOES",
+};
+
+static const char* s_GL_OES_query_matrix[] =
+{
+ "glQueryMatrixxOES",
+};
+
+static const char* s_GL_OES_single_precision[] =
+{
+ "glClearDepthfOES",
+ "glClipPlanefOES",
+ "glDepthRangefOES",
+ "glFrustumfOES",
+ "glGetClipPlanefOES",
+ "glOrthofOES",
+};
+
+static const char* s_GL_OES_texture_cube_map[] =
+{
+ "glGetTexGenfvOES",
+ "glGetTexGenivOES",
+ "glGetTexGenxvOES",
+ "glTexGenfOES",
+ "glTexGenfvOES",
+ "glTexGeniOES",
+ "glTexGenivOES",
+ "glTexGenxOES",
+ "glTexGenxvOES",
+};
+
+static const char* s_GL_OES_vertex_array_object[] =
+{
+ "glBindVertexArrayOES",
+ "glDeleteVertexArraysOES",
+ "glGenVertexArraysOES",
+ "glIsVertexArrayOES",
+};
+
+static const char* s_GL_QCOM_driver_control[] =
+{
+ "glDisableDriverControlQCOM",
+ "glEnableDriverControlQCOM",
+ "glGetDriverControlStringQCOM",
+ "glGetDriverControlsQCOM",
+};
+
+static const char* s_GL_QCOM_extended_get[] =
+{
+ "glExtGetBufferPointervQCOM",
+ "glExtGetBuffersQCOM",
+ "glExtGetFramebuffersQCOM",
+ "glExtGetRenderbuffersQCOM",
+ "glExtGetTexLevelParameterivQCOM",
+ "glExtGetTexSubImageQCOM",
+ "glExtGetTexturesQCOM",
+ "glExtTexObjectStateOverrideiQCOM",
+};
+
+static const char* s_GL_QCOM_extended_get2[] =
+{
+ "glExtGetProgramBinarySourceQCOM",
+ "glExtGetProgramsQCOM",
+ "glExtGetShadersQCOM",
+ "glExtIsProgramBinaryQCOM",
+};
+
+static const char* s_GL_QCOM_tiled_rendering[] =
+{
+ "glEndTilingQCOM",
+ "glStartTilingQCOM",
+};
+
+static const char* s_GL_AMD_performance_monitor[] =
+{
+ "glBeginPerfMonitorAMD",
+ "glDeletePerfMonitorsAMD",
+ "glEndPerfMonitorAMD",
+ "glGenPerfMonitorsAMD",
+ "glGetPerfMonitorCounterDataAMD",
+ "glGetPerfMonitorCounterInfoAMD",
+ "glGetPerfMonitorCounterStringAMD",
+ "glGetPerfMonitorCountersAMD",
+ "glGetPerfMonitorGroupStringAMD",
+ "glGetPerfMonitorGroupsAMD",
+ "glSelectPerfMonitorCountersAMD",
+};
+
+static const char* s_GL_ANGLE_framebuffer_blit[] =
+{
+ "glBlitFramebufferANGLE",
+};
+
+static const char* s_GL_ANGLE_framebuffer_multisample[] =
+{
+ "glRenderbufferStorageMultisampleANGLE",
+};
+
+static const char* s_GL_ANGLE_instanced_arrays[] =
+{
+ "glDrawArraysInstancedANGLE",
+ "glDrawElementsInstancedANGLE",
+ "glVertexAttribDivisorANGLE",
+};
+
+static const char* s_GL_ANGLE_translated_shader_source[] =
+{
+ "glGetTranslatedShaderSourceANGLE",
+};
+
+static const char* s_GL_EXT_copy_image[] =
+{
+ "glCopyImageSubDataEXT",
+};
+
+static const char* s_GL_EXT_debug_label[] =
+{
+ "glGetObjectLabelEXT",
+ "glLabelObjectEXT",
+};
+
+static const char* s_GL_EXT_debug_marker[] =
+{
+ "glInsertEventMarkerEXT",
+ "glPopGroupMarkerEXT",
+ "glPushGroupMarkerEXT",
+};
+
+static const char* s_GL_EXT_disjoint_timer_query[] =
+{
+ "glBeginQueryEXT",
+ "glDeleteQueriesEXT",
+ "glEndQueryEXT",
+ "glGenQueriesEXT",
+ "glGetQueryObjecti64vEXT",
+ "glGetQueryObjectivEXT",
+ "glGetQueryObjectui64vEXT",
+ "glGetQueryObjectuivEXT",
+ "glGetQueryivEXT",
+ "glIsQueryEXT",
+ "glQueryCounterEXT",
+};
+
+static const char* s_GL_EXT_draw_buffers[] =
+{
+ "glDrawBuffersEXT",
+};
+
+static const char* s_GL_EXT_draw_buffers_indexed[] =
+{
+ "glBlendEquationSeparateiEXT",
+ "glBlendEquationiEXT",
+ "glBlendFuncSeparateiEXT",
+ "glBlendFunciEXT",
+ "glColorMaskiEXT",
+ "glDisableiEXT",
+ "glEnableiEXT",
+ "glIsEnablediEXT",
+};
+
+static const char* s_GL_EXT_draw_instanced[] =
+{
+ "glDrawArraysInstancedEXT",
+ "glDrawElementsInstancedEXT",
+};
+
+static const char* s_GL_EXT_geometry_shader[] =
+{
+ "glFramebufferTextureEXT",
+};
+
+static const char* s_GL_EXT_instanced_arrays[] =
+{
+ "glDrawArraysInstancedEXT",
+ "glDrawElementsInstancedEXT",
+ "glVertexAttribDivisorEXT",
+};
+
+static const char* s_GL_EXT_multiview_draw_buffers[] =
+{
+ "glDrawBuffersIndexedEXT",
+ "glGetIntegeri_vEXT",
+ "glReadBufferIndexedEXT",
+};
+
+static const char* s_GL_EXT_occlusion_query_boolean[] =
+{
+ "glBeginQueryEXT",
+ "glDeleteQueriesEXT",
+ "glEndQueryEXT",
+ "glGenQueriesEXT",
+ "glGetQueryObjectuivEXT",
+ "glGetQueryivEXT",
+ "glIsQueryEXT",
+};
+
+static const char* s_GL_EXT_primitive_bounding_box[] =
+{
+ "glPrimitiveBoundingBoxEXT",
+};
+
+static const char* s_GL_EXT_separate_shader_objects[] =
+{
+ "glActiveShaderProgramEXT",
+ "glBindProgramPipelineEXT",
+ "glCreateShaderProgramvEXT",
+ "glDeleteProgramPipelinesEXT",
+ "glGenProgramPipelinesEXT",
+ "glGetProgramPipelineInfoLogEXT",
+ "glGetProgramPipelineivEXT",
+ "glIsProgramPipelineEXT",
+ "glProgramParameteriEXT",
+ "glProgramUniform1fEXT",
+ "glProgramUniform1fvEXT",
+ "glProgramUniform1iEXT",
+ "glProgramUniform1ivEXT",
+ "glProgramUniform1uiEXT",
+ "glProgramUniform1uivEXT",
+ "glProgramUniform2fEXT",
+ "glProgramUniform2fvEXT",
+ "glProgramUniform2iEXT",
+ "glProgramUniform2ivEXT",
+ "glProgramUniform2uiEXT",
+ "glProgramUniform2uivEXT",
+ "glProgramUniform3fEXT",
+ "glProgramUniform3fvEXT",
+ "glProgramUniform3iEXT",
+ "glProgramUniform3ivEXT",
+ "glProgramUniform3uiEXT",
+ "glProgramUniform3uivEXT",
+ "glProgramUniform4fEXT",
+ "glProgramUniform4fvEXT",
+ "glProgramUniform4iEXT",
+ "glProgramUniform4ivEXT",
+ "glProgramUniform4uiEXT",
+ "glProgramUniform4uivEXT",
+ "glProgramUniformMatrix2fvEXT",
+ "glProgramUniformMatrix2x3fvEXT",
+ "glProgramUniformMatrix2x4fvEXT",
+ "glProgramUniformMatrix3fvEXT",
+ "glProgramUniformMatrix3x2fvEXT",
+ "glProgramUniformMatrix3x4fvEXT",
+ "glProgramUniformMatrix4fvEXT",
+ "glProgramUniformMatrix4x2fvEXT",
+ "glProgramUniformMatrix4x3fvEXT",
+ "glUseProgramStagesEXT",
+ "glValidateProgramPipelineEXT",
+};
+
+static const char* s_GL_EXT_tessellation_shader[] =
+{
+ "glPatchParameteriEXT",
+};
+
+static const char* s_GL_EXT_texture_border_clamp[] =
+{
+ "glGetSamplerParameterIivEXT",
+ "glGetSamplerParameterIuivEXT",
+ "glGetTexParameterIivEXT",
+ "glGetTexParameterIuivEXT",
+ "glSamplerParameterIivEXT",
+ "glSamplerParameterIuivEXT",
+ "glTexParameterIivEXT",
+ "glTexParameterIuivEXT",
+};
+
+static const char* s_GL_EXT_texture_buffer[] =
+{
+ "glTexBufferEXT",
+ "glTexBufferRangeEXT",
+};
+
+static const char* s_GL_EXT_texture_view[] =
+{
+ "glTextureViewEXT",
+};
+
+static const char* s_GL_INTEL_performance_query[] =
+{
+ "glBeginPerfQueryINTEL",
+ "glCreatePerfQueryINTEL",
+ "glDeletePerfQueryINTEL",
+ "glEndPerfQueryINTEL",
+ "glGetFirstPerfQueryIdINTEL",
+ "glGetNextPerfQueryIdINTEL",
+ "glGetPerfCounterInfoINTEL",
+ "glGetPerfQueryDataINTEL",
+ "glGetPerfQueryIdByNameINTEL",
+ "glGetPerfQueryInfoINTEL",
+};
+
+static const char* s_GL_KHR_blend_equation_advanced[] =
+{
+ "glBlendBarrierKHR",
+};
+
+static const char* s_GL_KHR_debug[] =
+{
+ "glDebugMessageCallbackKHR",
+ "glDebugMessageControlKHR",
+ "glDebugMessageInsertKHR",
+ "glGetDebugMessageLogKHR",
+ "glGetObjectLabelKHR",
+ "glGetObjectPtrLabelKHR",
+ "glGetPointervKHR",
+ "glObjectLabelKHR",
+ "glObjectPtrLabelKHR",
+ "glPopDebugGroupKHR",
+ "glPushDebugGroupKHR",
+};
+
+static const char* s_GL_KHR_robustness[] =
+{
+ "glGetGraphicsResetStatusKHR",
+ "glGetnUniformfvKHR",
+ "glGetnUniformivKHR",
+ "glGetnUniformuivKHR",
+ "glReadnPixelsKHR",
+};
+
+static const char* s_GL_NV_blend_equation_advanced[] =
+{
+ "glBlendBarrierNV",
+ "glBlendParameteriNV",
+};
+
+static const char* s_GL_NV_copy_buffer[] =
+{
+ "glCopyBufferSubDataNV",
+};
+
+static const char* s_GL_NV_coverage_sample[] =
+{
+ "glCoverageMaskNV",
+ "glCoverageOperationNV",
+};
+
+static const char* s_GL_NV_draw_buffers[] =
+{
+ "glDrawBuffersNV",
+};
+
+static const char* s_GL_NV_draw_instanced[] =
+{
+ "glDrawArraysInstancedNV",
+ "glDrawElementsInstancedNV",
+};
+
+static const char* s_GL_NV_framebuffer_blit[] =
+{
+ "glBlitFramebufferNV",
+};
+
+static const char* s_GL_NV_framebuffer_multisample[] =
+{
+ "glRenderbufferStorageMultisampleNV",
+};
+
+static const char* s_GL_NV_instanced_arrays[] =
+{
+ "glVertexAttribDivisorNV",
+};
+
+static const char* s_GL_NV_internalformat_sample_query[] =
+{
+ "glGetInternalformatSampleivNV",
+};
+
+static const char* s_GL_NV_non_square_matrices[] =
+{
+ "glUniformMatrix2x3fvNV",
+ "glUniformMatrix2x4fvNV",
+ "glUniformMatrix3x2fvNV",
+ "glUniformMatrix3x4fvNV",
+ "glUniformMatrix4x2fvNV",
+ "glUniformMatrix4x3fvNV",
+};
+
+static const char* s_GL_NV_read_buffer[] =
+{
+ "glReadBufferNV",
+};
+
+static const char* s_GL_OES_get_program_binary[] =
+{
+ "glGetProgramBinaryOES",
+ "glProgramBinaryOES",
+};
+
+static const char* s_GL_OES_sample_shading[] =
+{
+ "glMinSampleShadingOES",
+};
+
+static const char* s_GL_OES_texture_3D[] =
+{
+ "glCompressedTexImage3DOES",
+ "glCompressedTexSubImage3DOES",
+ "glCopyTexSubImage3DOES",
+ "glFramebufferTexture3DOES",
+ "glTexImage3DOES",
+ "glTexSubImage3DOES",
+};
+
+static const char* s_GL_OES_texture_storage_multisample_2d_array[] =
+{
+ "glTexStorage3DMultisampleOES",
+};
+
+static const char* s_GL_QCOM_alpha_test[] =
+{
+ "glAlphaFuncQCOM",
+};
+
+static const struct
+{
+ const char* name;
+ const int numFunctions;
+ const char* const* functions;
+} s_extensions[] =
+{
+ { "EGL_ANDROID_blob_cache", DE_LENGTH_OF_ARRAY(s_EGL_ANDROID_blob_cache), s_EGL_ANDROID_blob_cache },
+ { "EGL_ANDROID_native_fence_sync", DE_LENGTH_OF_ARRAY(s_EGL_ANDROID_native_fence_sync), s_EGL_ANDROID_native_fence_sync },
+ { "EGL_ANGLE_query_surface_pointer", DE_LENGTH_OF_ARRAY(s_EGL_ANGLE_query_surface_pointer), s_EGL_ANGLE_query_surface_pointer },
+ { "EGL_EXT_device_base", DE_LENGTH_OF_ARRAY(s_EGL_EXT_device_base), s_EGL_EXT_device_base },
+ { "EGL_EXT_output_base", DE_LENGTH_OF_ARRAY(s_EGL_EXT_output_base), s_EGL_EXT_output_base },
+ { "EGL_EXT_platform_base", DE_LENGTH_OF_ARRAY(s_EGL_EXT_platform_base), s_EGL_EXT_platform_base },
+ { "EGL_EXT_stream_consumer_egloutput", DE_LENGTH_OF_ARRAY(s_EGL_EXT_stream_consumer_egloutput), s_EGL_EXT_stream_consumer_egloutput },
+ { "EGL_EXT_swap_buffers_with_damage", DE_LENGTH_OF_ARRAY(s_EGL_EXT_swap_buffers_with_damage), s_EGL_EXT_swap_buffers_with_damage },
+ { "EGL_HI_clientpixmap", DE_LENGTH_OF_ARRAY(s_EGL_HI_clientpixmap), s_EGL_HI_clientpixmap },
+ { "EGL_KHR_cl_event2", DE_LENGTH_OF_ARRAY(s_EGL_KHR_cl_event2), s_EGL_KHR_cl_event2 },
+ { "EGL_KHR_image", DE_LENGTH_OF_ARRAY(s_EGL_KHR_image), s_EGL_KHR_image },
+ { "EGL_KHR_image_base", DE_LENGTH_OF_ARRAY(s_EGL_KHR_image_base), s_EGL_KHR_image_base },
+ { "EGL_KHR_lock_surface", DE_LENGTH_OF_ARRAY(s_EGL_KHR_lock_surface), s_EGL_KHR_lock_surface },
+ { "EGL_KHR_lock_surface3", DE_LENGTH_OF_ARRAY(s_EGL_KHR_lock_surface3), s_EGL_KHR_lock_surface3 },
+ { "EGL_KHR_reusable_sync", DE_LENGTH_OF_ARRAY(s_EGL_KHR_reusable_sync), s_EGL_KHR_reusable_sync },
+ { "EGL_KHR_stream", DE_LENGTH_OF_ARRAY(s_EGL_KHR_stream), s_EGL_KHR_stream },
+ { "EGL_KHR_stream_consumer_gltexture", DE_LENGTH_OF_ARRAY(s_EGL_KHR_stream_consumer_gltexture), s_EGL_KHR_stream_consumer_gltexture },
+ { "EGL_KHR_stream_cross_process_fd", DE_LENGTH_OF_ARRAY(s_EGL_KHR_stream_cross_process_fd), s_EGL_KHR_stream_cross_process_fd },
+ { "EGL_KHR_stream_fifo", DE_LENGTH_OF_ARRAY(s_EGL_KHR_stream_fifo), s_EGL_KHR_stream_fifo },
+ { "EGL_KHR_stream_producer_eglsurface", DE_LENGTH_OF_ARRAY(s_EGL_KHR_stream_producer_eglsurface), s_EGL_KHR_stream_producer_eglsurface },
+ { "EGL_KHR_wait_sync", DE_LENGTH_OF_ARRAY(s_EGL_KHR_wait_sync), s_EGL_KHR_wait_sync },
+ { "EGL_MESA_drm_image", DE_LENGTH_OF_ARRAY(s_EGL_MESA_drm_image), s_EGL_MESA_drm_image },
+ { "EGL_NOK_swap_region", DE_LENGTH_OF_ARRAY(s_EGL_NOK_swap_region), s_EGL_NOK_swap_region },
+ { "EGL_NOK_swap_region2", DE_LENGTH_OF_ARRAY(s_EGL_NOK_swap_region2), s_EGL_NOK_swap_region2 },
+ { "EGL_NV_native_query", DE_LENGTH_OF_ARRAY(s_EGL_NV_native_query), s_EGL_NV_native_query },
+ { "EGL_NV_post_sub_buffer", DE_LENGTH_OF_ARRAY(s_EGL_NV_post_sub_buffer), s_EGL_NV_post_sub_buffer },
+ { "EGL_NV_stream_sync", DE_LENGTH_OF_ARRAY(s_EGL_NV_stream_sync), s_EGL_NV_stream_sync },
+ { "EGL_NV_sync", DE_LENGTH_OF_ARRAY(s_EGL_NV_sync), s_EGL_NV_sync },
+ { "EGL_NV_system_time", DE_LENGTH_OF_ARRAY(s_EGL_NV_system_time), s_EGL_NV_system_time },
+ { "GL_APPLE_copy_texture_levels", DE_LENGTH_OF_ARRAY(s_GL_APPLE_copy_texture_levels), s_GL_APPLE_copy_texture_levels },
+ { "GL_APPLE_framebuffer_multisample", DE_LENGTH_OF_ARRAY(s_GL_APPLE_framebuffer_multisample), s_GL_APPLE_framebuffer_multisample },
+ { "GL_APPLE_sync", DE_LENGTH_OF_ARRAY(s_GL_APPLE_sync), s_GL_APPLE_sync },
+ { "GL_EXT_discard_framebuffer", DE_LENGTH_OF_ARRAY(s_GL_EXT_discard_framebuffer), s_GL_EXT_discard_framebuffer },
+ { "GL_EXT_map_buffer_range", DE_LENGTH_OF_ARRAY(s_GL_EXT_map_buffer_range), s_GL_EXT_map_buffer_range },
+ { "GL_EXT_multi_draw_arrays", DE_LENGTH_OF_ARRAY(s_GL_EXT_multi_draw_arrays), s_GL_EXT_multi_draw_arrays },
+ { "GL_EXT_multisampled_render_to_texture", DE_LENGTH_OF_ARRAY(s_GL_EXT_multisampled_render_to_texture), s_GL_EXT_multisampled_render_to_texture },
+ { "GL_EXT_robustness", DE_LENGTH_OF_ARRAY(s_GL_EXT_robustness), s_GL_EXT_robustness },
+ { "GL_EXT_texture_storage", DE_LENGTH_OF_ARRAY(s_GL_EXT_texture_storage), s_GL_EXT_texture_storage },
+ { "GL_IMG_multisampled_render_to_texture", DE_LENGTH_OF_ARRAY(s_GL_IMG_multisampled_render_to_texture), s_GL_IMG_multisampled_render_to_texture },
+ { "GL_IMG_user_clip_plane", DE_LENGTH_OF_ARRAY(s_GL_IMG_user_clip_plane), s_GL_IMG_user_clip_plane },
+ { "GL_NV_fence", DE_LENGTH_OF_ARRAY(s_GL_NV_fence), s_GL_NV_fence },
+ { "GL_OES_EGL_image", DE_LENGTH_OF_ARRAY(s_GL_OES_EGL_image), s_GL_OES_EGL_image },
+ { "GL_OES_blend_equation_separate", DE_LENGTH_OF_ARRAY(s_GL_OES_blend_equation_separate), s_GL_OES_blend_equation_separate },
+ { "GL_OES_blend_func_separate", DE_LENGTH_OF_ARRAY(s_GL_OES_blend_func_separate), s_GL_OES_blend_func_separate },
+ { "GL_OES_blend_subtract", DE_LENGTH_OF_ARRAY(s_GL_OES_blend_subtract), s_GL_OES_blend_subtract },
+ { "GL_OES_draw_texture", DE_LENGTH_OF_ARRAY(s_GL_OES_draw_texture), s_GL_OES_draw_texture },
+ { "GL_OES_fixed_point", DE_LENGTH_OF_ARRAY(s_GL_OES_fixed_point), s_GL_OES_fixed_point },
+ { "GL_OES_framebuffer_object", DE_LENGTH_OF_ARRAY(s_GL_OES_framebuffer_object), s_GL_OES_framebuffer_object },
+ { "GL_OES_mapbuffer", DE_LENGTH_OF_ARRAY(s_GL_OES_mapbuffer), s_GL_OES_mapbuffer },
+ { "GL_OES_matrix_palette", DE_LENGTH_OF_ARRAY(s_GL_OES_matrix_palette), s_GL_OES_matrix_palette },
+ { "GL_OES_point_size_array", DE_LENGTH_OF_ARRAY(s_GL_OES_point_size_array), s_GL_OES_point_size_array },
+ { "GL_OES_query_matrix", DE_LENGTH_OF_ARRAY(s_GL_OES_query_matrix), s_GL_OES_query_matrix },
+ { "GL_OES_single_precision", DE_LENGTH_OF_ARRAY(s_GL_OES_single_precision), s_GL_OES_single_precision },
+ { "GL_OES_texture_cube_map", DE_LENGTH_OF_ARRAY(s_GL_OES_texture_cube_map), s_GL_OES_texture_cube_map },
+ { "GL_OES_vertex_array_object", DE_LENGTH_OF_ARRAY(s_GL_OES_vertex_array_object), s_GL_OES_vertex_array_object },
+ { "GL_QCOM_driver_control", DE_LENGTH_OF_ARRAY(s_GL_QCOM_driver_control), s_GL_QCOM_driver_control },
+ { "GL_QCOM_extended_get", DE_LENGTH_OF_ARRAY(s_GL_QCOM_extended_get), s_GL_QCOM_extended_get },
+ { "GL_QCOM_extended_get2", DE_LENGTH_OF_ARRAY(s_GL_QCOM_extended_get2), s_GL_QCOM_extended_get2 },
+ { "GL_QCOM_tiled_rendering", DE_LENGTH_OF_ARRAY(s_GL_QCOM_tiled_rendering), s_GL_QCOM_tiled_rendering },
+ { "GL_AMD_performance_monitor", DE_LENGTH_OF_ARRAY(s_GL_AMD_performance_monitor), s_GL_AMD_performance_monitor },
+ { "GL_ANGLE_framebuffer_blit", DE_LENGTH_OF_ARRAY(s_GL_ANGLE_framebuffer_blit), s_GL_ANGLE_framebuffer_blit },
+ { "GL_ANGLE_framebuffer_multisample", DE_LENGTH_OF_ARRAY(s_GL_ANGLE_framebuffer_multisample), s_GL_ANGLE_framebuffer_multisample },
+ { "GL_ANGLE_instanced_arrays", DE_LENGTH_OF_ARRAY(s_GL_ANGLE_instanced_arrays), s_GL_ANGLE_instanced_arrays },
+ { "GL_ANGLE_translated_shader_source", DE_LENGTH_OF_ARRAY(s_GL_ANGLE_translated_shader_source), s_GL_ANGLE_translated_shader_source },
+ { "GL_EXT_copy_image", DE_LENGTH_OF_ARRAY(s_GL_EXT_copy_image), s_GL_EXT_copy_image },
+ { "GL_EXT_debug_label", DE_LENGTH_OF_ARRAY(s_GL_EXT_debug_label), s_GL_EXT_debug_label },
+ { "GL_EXT_debug_marker", DE_LENGTH_OF_ARRAY(s_GL_EXT_debug_marker), s_GL_EXT_debug_marker },
+ { "GL_EXT_disjoint_timer_query", DE_LENGTH_OF_ARRAY(s_GL_EXT_disjoint_timer_query), s_GL_EXT_disjoint_timer_query },
+ { "GL_EXT_draw_buffers", DE_LENGTH_OF_ARRAY(s_GL_EXT_draw_buffers), s_GL_EXT_draw_buffers },
+ { "GL_EXT_draw_buffers_indexed", DE_LENGTH_OF_ARRAY(s_GL_EXT_draw_buffers_indexed), s_GL_EXT_draw_buffers_indexed },
+ { "GL_EXT_draw_instanced", DE_LENGTH_OF_ARRAY(s_GL_EXT_draw_instanced), s_GL_EXT_draw_instanced },
+ { "GL_EXT_geometry_shader", DE_LENGTH_OF_ARRAY(s_GL_EXT_geometry_shader), s_GL_EXT_geometry_shader },
+ { "GL_EXT_instanced_arrays", DE_LENGTH_OF_ARRAY(s_GL_EXT_instanced_arrays), s_GL_EXT_instanced_arrays },
+ { "GL_EXT_multiview_draw_buffers", DE_LENGTH_OF_ARRAY(s_GL_EXT_multiview_draw_buffers), s_GL_EXT_multiview_draw_buffers },
+ { "GL_EXT_occlusion_query_boolean", DE_LENGTH_OF_ARRAY(s_GL_EXT_occlusion_query_boolean), s_GL_EXT_occlusion_query_boolean },
+ { "GL_EXT_primitive_bounding_box", DE_LENGTH_OF_ARRAY(s_GL_EXT_primitive_bounding_box), s_GL_EXT_primitive_bounding_box },
+ { "GL_EXT_separate_shader_objects", DE_LENGTH_OF_ARRAY(s_GL_EXT_separate_shader_objects), s_GL_EXT_separate_shader_objects },
+ { "GL_EXT_tessellation_shader", DE_LENGTH_OF_ARRAY(s_GL_EXT_tessellation_shader), s_GL_EXT_tessellation_shader },
+ { "GL_EXT_texture_border_clamp", DE_LENGTH_OF_ARRAY(s_GL_EXT_texture_border_clamp), s_GL_EXT_texture_border_clamp },
+ { "GL_EXT_texture_buffer", DE_LENGTH_OF_ARRAY(s_GL_EXT_texture_buffer), s_GL_EXT_texture_buffer },
+ { "GL_EXT_texture_view", DE_LENGTH_OF_ARRAY(s_GL_EXT_texture_view), s_GL_EXT_texture_view },
+ { "GL_INTEL_performance_query", DE_LENGTH_OF_ARRAY(s_GL_INTEL_performance_query), s_GL_INTEL_performance_query },
+ { "GL_KHR_blend_equation_advanced", DE_LENGTH_OF_ARRAY(s_GL_KHR_blend_equation_advanced), s_GL_KHR_blend_equation_advanced },
+ { "GL_KHR_debug", DE_LENGTH_OF_ARRAY(s_GL_KHR_debug), s_GL_KHR_debug },
+ { "GL_KHR_robustness", DE_LENGTH_OF_ARRAY(s_GL_KHR_robustness), s_GL_KHR_robustness },
+ { "GL_NV_blend_equation_advanced", DE_LENGTH_OF_ARRAY(s_GL_NV_blend_equation_advanced), s_GL_NV_blend_equation_advanced },
+ { "GL_NV_copy_buffer", DE_LENGTH_OF_ARRAY(s_GL_NV_copy_buffer), s_GL_NV_copy_buffer },
+ { "GL_NV_coverage_sample", DE_LENGTH_OF_ARRAY(s_GL_NV_coverage_sample), s_GL_NV_coverage_sample },
+ { "GL_NV_draw_buffers", DE_LENGTH_OF_ARRAY(s_GL_NV_draw_buffers), s_GL_NV_draw_buffers },
+ { "GL_NV_draw_instanced", DE_LENGTH_OF_ARRAY(s_GL_NV_draw_instanced), s_GL_NV_draw_instanced },
+ { "GL_NV_framebuffer_blit", DE_LENGTH_OF_ARRAY(s_GL_NV_framebuffer_blit), s_GL_NV_framebuffer_blit },
+ { "GL_NV_framebuffer_multisample", DE_LENGTH_OF_ARRAY(s_GL_NV_framebuffer_multisample), s_GL_NV_framebuffer_multisample },
+ { "GL_NV_instanced_arrays", DE_LENGTH_OF_ARRAY(s_GL_NV_instanced_arrays), s_GL_NV_instanced_arrays },
+ { "GL_NV_internalformat_sample_query", DE_LENGTH_OF_ARRAY(s_GL_NV_internalformat_sample_query), s_GL_NV_internalformat_sample_query },
+ { "GL_NV_non_square_matrices", DE_LENGTH_OF_ARRAY(s_GL_NV_non_square_matrices), s_GL_NV_non_square_matrices },
+ { "GL_NV_read_buffer", DE_LENGTH_OF_ARRAY(s_GL_NV_read_buffer), s_GL_NV_read_buffer },
+ { "GL_OES_get_program_binary", DE_LENGTH_OF_ARRAY(s_GL_OES_get_program_binary), s_GL_OES_get_program_binary },
+ { "GL_OES_sample_shading", DE_LENGTH_OF_ARRAY(s_GL_OES_sample_shading), s_GL_OES_sample_shading },
+ { "GL_OES_texture_3D", DE_LENGTH_OF_ARRAY(s_GL_OES_texture_3D), s_GL_OES_texture_3D },
+ { "GL_OES_texture_storage_multisample_2d_array", DE_LENGTH_OF_ARRAY(s_GL_OES_texture_storage_multisample_2d_array), s_GL_OES_texture_storage_multisample_2d_array },
+ { "GL_QCOM_alpha_test", DE_LENGTH_OF_ARRAY(s_GL_QCOM_alpha_test), s_GL_QCOM_alpha_test },
+};
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from common import getEGLRegistry, getInterface, getDefaultInterface
+
+import str_util
+import call_log_wrapper
+import proc_address_tests
+
+def gen ():
+ registry = getEGLRegistry()
+ iface = getDefaultInterface()
+ noExtIface = getInterface(registry, 'egl', '1.4')
+
+ str_util.gen(iface)
+ call_log_wrapper.gen(noExtIface)
+ proc_address_tests.gen()
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import os
+import string
+
+from common import *
+from khr_util.format import indentLines
+
+def genCommandList(iface, renderCommand, directory, filename, align=False):
+ lines = map(renderCommand, iface.commands)
+ if align:
+ lines = indentLines(lines)
+ writeInlFile(os.path.join(directory, filename), lines)
+
+class LogSpec:
+ def __init__ (self, argInPrints, argOutPrints = {}, returnPrint = None):
+ self.argInPrints = argInPrints
+ self.argOutPrints = argOutPrints
+ self.returnPrint = returnPrint
+
+def enum (group):
+ return lambda name: "get%sStr(%s)" % (group, name)
+
+def pointer (size):
+ return lambda name: "getPointerStr(%s, %s)" % (name, size)
+
+def enumPointer (group, size):
+ return lambda name: "getEnumPointerStr(%s, %s, get%sName)" % (name, size, group)
+
+def configAttrib (attribNdx):
+ return lambda name: "getConfigAttribValueStr(param%d, %s)" % (attribNdx, name)
+
+# Special rules for printing call arguments
+CALL_LOG_SPECS = {
+ "eglBindAPI": LogSpec({0: enum("API")}),
+ "eglChooseConfig": LogSpec({1: lambda n: "getConfigAttribListStr(%s)" % n}, argOutPrints = {2: pointer("(num_config && returnValue) ? deMin32(config_size, *num_config) : 0"), 4: lambda n: "(%s ? de::toString(*%s) : \"NULL\")" % (n, n)}),
+ "eglCreateContext": LogSpec({3: lambda n: "getContextAttribListStr(%s)" % n}),
+ "eglCreatePbufferSurface": LogSpec({2: lambda n: "getSurfaceAttribListStr(%s)" % n}),
+ "eglCreatePixmapSurface": LogSpec({3: lambda n: "getSurfaceAttribListStr(%s)" % n}),
+ "eglCreateWindowSurface": LogSpec({3: lambda n: "getSurfaceAttribListStr(%s)" % n}),
+ "eglGetError": LogSpec({}, returnPrint = enum("Error")),
+ "eglGetConfigAttrib": LogSpec({2: enum("ConfigAttrib")}, argOutPrints = {3: lambda n: "getConfigAttribValuePointerStr(attribute, %s)" % n}),
+ "eglGetCurrentSurface": LogSpec({0: enum("SurfaceTarget")}),
+ "eglGetProcAddress": LogSpec({}, returnPrint = lambda n: "tcu::toHex(%s)" % (n)),
+ "eglQueryAPI": LogSpec({}, returnPrint = enum("API")),
+ "eglQueryContext": LogSpec({2: enum("ContextAttrib")}, argOutPrints = {3: lambda n: "getContextAttribValuePointerStr(attribute, %s)" % n}),
+ "eglQuerySurface": LogSpec({2: enum("SurfaceAttrib")}, argOutPrints = {3: lambda n: "getSurfaceAttribValuePointerStr(attribute, %s)" % n}),
+ "eglSurfaceAttrib": LogSpec({2: enum("SurfaceAttrib"), 3: lambda n: "getSurfaceAttribValueStr(attribute, %s)" % n}),
+}
+
+def eglwPrefix(string):
+ # \note Not used for now
+ return string
+
+def prefixedParams(command):
+ if len(command.params) > 0:
+ return ", ".join(eglwPrefix(param.declaration) for param in command.params)
+ else:
+ return "void"
+
+def commandLogWrapperMemberDecl (command):
+ return "%s\t%s\t(%s);" % (eglwPrefix(command.type), command.name, prefixedParams(command))
+
+def getVarDefaultPrint (type, varName):
+ if re.match(r'^const +char *\*$', type):
+ return "getStringStr(%s)" % varName
+ elif re.match(r'(EGLenum|EGLConfig|EGLSurface|EGLClientBuffer|EGLNativeDisplayType|EGLNativeWindowType|EGLNativePixmapType|\*)$', type):
+ return "toHex(%s)" % varName
+ elif type == 'EGLBoolean':
+ return "getBooleanStr(%s)" % varName
+ else:
+ return varName
+
+def commandLogWrapperMemberDef (command):
+ src = ""
+ try:
+ logSpec = CALL_LOG_SPECS[command.name]
+ except KeyError:
+ logSpec = None
+
+ src += "\n"
+ src += "%s CallLogWrapper::%s (%s)\n{\n" % (eglwPrefix(command.type), command.name, ", ".join(eglwPrefix(p.declaration) for p in command.params))
+
+ # Append paramemetrs
+ callPrintItems = ["\"%s(\"" % command.name]
+ for paramNdx, param in enumerate(command.params):
+ if paramNdx > 0:
+ callPrintItems.append("\", \"")
+
+ if logSpec and paramNdx in logSpec.argInPrints:
+ callPrintItems.append(logSpec.argInPrints[paramNdx](param.name))
+ else:
+ callPrintItems.append(getVarDefaultPrint(param.type, param.name))
+
+ callPrintItems += ["\");\"", "TestLog::EndMessage"]
+
+ src += "\tif (m_enableLog)\n"
+ src += "\t\tm_log << TestLog::Message << %s;\n" % " << ".join(callPrintItems)
+
+ callStr = "::%s(%s)" % (command.name, ", ".join([p.name for p in command.params]))
+
+ isVoid = command.type == 'void'
+ if isVoid:
+ src += "\t%s;\n" % callStr
+ else:
+ src += "\t%s returnValue = %s;\n" % (eglwPrefix(command.type), callStr)
+
+ if logSpec and len(logSpec.argOutPrints) > 0:
+ # Print values returned in pointers
+ src += "\tif (m_enableLog)\n\t{\n"
+
+ for paramNdx, param in enumerate(command.params):
+ if paramNdx in logSpec.argOutPrints:
+ src += "\t\tm_log << TestLog::Message << \"// %s = \" << %s << TestLog::EndMessage;\n" % (param.name, logSpec.argOutPrints[paramNdx](param.name))
+
+ src += "\t}\n"
+
+ if not isVoid:
+ # Print return value
+ returnPrint = getVarDefaultPrint(command.type, "returnValue")
+ if logSpec and logSpec.returnPrint:
+ returnPrint = logSpec.returnPrint("returnValue")
+
+ src += "\tif (m_enableLog)\n"
+ src += "\t\tm_log << TestLog::Message << \"// \" << %s << \" returned\" << TestLog::EndMessage;\n" % returnPrint
+ src += "\treturn returnValue;\n"
+
+ src += "}"
+ return src
+
+def gen (iface):
+ genCommandList(iface, commandLogWrapperMemberDecl, EGL_DIR, "egluCallLogWrapperApi.inl", True)
+ genCommandList(iface, commandLogWrapperMemberDef, EGL_DIR, "egluCallLogWrapper.inl", False)
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import os
+import re
+import sys
+
+def registerPaths():
+ sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+
+registerPaths()
+
+import khr_util.format
+import khr_util.registry
+import khr_util.registry_cache
+
+SCRIPTS_DIR = os.path.dirname(__file__)
+EGL_DIR = os.path.normpath(os.path.join(SCRIPTS_DIR, "..", "..", "framework", "egl"))
+
+EGL_SOURCE = khr_util.registry_cache.RegistrySource(
+ "egl.xml",
+ 28861,
+ "0e7e6381c4e518f915450fe5080c9b1307cbf3548999a74e2b7676de7b5e5a30")
+
+EXTENSIONS = [
+ "EGL_KHR_create_context",
+ "EGL_KHR_lock_surface"
+]
+
+def getEGLRegistry ():
+ return khr_util.registry_cache.getRegistry(EGL_SOURCE)
+
+def getInterface (registry, api, version=None, profile=None, **kwargs):
+ spec = khr_util.registry.spec(registry, api, version, profile, **kwargs)
+ return khr_util.registry.createInterface(registry, spec, api)
+
+def getDefaultInterface ():
+ return getInterface(getEGLRegistry(), 'egl', '1.4', extensionNames = EXTENSIONS)
+
+INL_HEADER = khr_util.format.genInlHeader("Khronos EGL API description (egl.xml)", EGL_SOURCE.getRevision())
+
+def writeInlFile (filename, source):
+ khr_util.format.writeInlFile(filename, INL_HEADER, source)
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import os
+import string
+
+from common import *
+from opengl.src_util import getGLRegistry
+from itertools import chain
+
+import khr_util.registry
+from khr_util.format import indentLines
+
+def toCamelCase (extName):
+ return "".join([x.title() for x in extName.split("_")])
+
+def makeStringList (name, strings):
+ yield ""
+ yield "static const char* s_%s[] =" % name
+ yield "{"
+
+ for entry in strings:
+ yield "\t\"%s\"," % (entry)
+
+ yield "};"
+
+def makeFunctionList (name, iface):
+ return makeStringList(name, [command.name for command in iface.commands])
+
+def makeExtensionList (extensions):
+ for name, iface in extensions:
+ for line in makeFunctionList(name, iface):
+ yield line
+
+ yield ""
+ yield "static const struct"
+ yield "{"
+ yield "\tconst char*\t\t\tname;"
+ yield "\tconst int\t\t\tnumFunctions;"
+ yield "\tconst char* const*\tfunctions;"
+ yield "} s_extensions[] ="
+ yield "{"
+
+ entries = []
+ for name, iface in extensions:
+ entries.append("\t{ \"%s\",\tDE_LENGTH_OF_ARRAY(s_%s),\ts_%s\t}," % (name, name, name))
+
+ for line in indentLines(entries):
+ yield line
+
+ yield "};"
+
+def getExtensionList (registry, api):
+ exts = []
+
+ for extension in registry.extensions:
+ if not khr_util.registry.extensionSupports(extension, api):
+ continue
+
+ spec = khr_util.registry.InterfaceSpec()
+ spec.addExtension(extension, api)
+ iface = khr_util.registry.createInterface(registry, spec, api)
+
+ if len(iface.commands) == 0:
+ continue
+
+ exts.append((khr_util.registry.getExtensionName(extension),
+ iface))
+
+ return exts
+
+def uniqueExtensions (extensions):
+ res = []
+ seen = set()
+
+ for name, iface in extensions:
+ if not name in seen:
+ res.append((name, iface))
+ seen.add(name)
+
+ return res
+
+def getInterfaceExactVersion (registry, api, version):
+ spec = khr_util.registry.InterfaceSpec()
+
+ def check (v): return v == version
+
+ for feature in registry.getFeatures(api, check):
+ spec.addFeature(feature, api)
+
+ return khr_util.registry.createInterface(registry, spec, api)
+
+def gen ():
+ eglRegistry = getEGLRegistry()
+ eglCoreIface = getInterface(eglRegistry, 'egl', '1.4')
+ eglExtensions = getExtensionList(eglRegistry, 'egl')
+
+ glRegistry = getGLRegistry()
+ gles1Extensions = getExtensionList(glRegistry, 'gles1')
+ gles2Extensions = getExtensionList(glRegistry, 'gles2')
+ gles10CoreIface = getInterface(glRegistry, 'gles1', '1.0')
+ gles20CoreIface = getInterface(glRegistry, 'gles2', '2.0')
+ gles30CoreIface = getInterfaceExactVersion(glRegistry, 'gles2', '3.0')
+# gles31CoreIface = getInterfaceExactVersion(glRegistry, 'gles2', '3.1')
+
+ allExtensions = eglExtensions + uniqueExtensions(gles1Extensions + gles2Extensions)
+
+ writeInlFile(os.path.normpath(os.path.join(SCRIPTS_DIR, "..", "..", "modules", "egl", "teglGetProcAddressTests.inl")),
+ chain(makeFunctionList ("EGL14", eglCoreIface),
+ makeFunctionList ("GLES10", gles10CoreIface),
+ makeFunctionList ("GLES20", gles20CoreIface),
+ makeFunctionList ("GLES30", gles30CoreIface),
+# makeFunctionList ("GLES31", gles31CoreIface),
+ makeExtensionList (allExtensions)))
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import os
+import string
+
+from common import *
+from khr_util.format import indentLines
+from khr_util.gen_str_util import addValuePrefix, genStrUtilProtos, genStrUtilImpls
+
+# Bitfield mapping
+BITFIELD_GROUPS = [
+ ("APIBits", [
+ "OPENGL_BIT",
+ "OPENGL_ES_BIT",
+ "OPENGL_ES2_BIT",
+ "OPENGL_ES3_BIT_KHR",
+ "OPENVG_BIT"
+ ]),
+ ("SurfaceBits", [
+ "PBUFFER_BIT",
+ "PIXMAP_BIT",
+ "WINDOW_BIT",
+ "MULTISAMPLE_RESOLVE_BOX_BIT",
+ "SWAP_BEHAVIOR_PRESERVED_BIT",
+ "VG_ALPHA_FORMAT_PRE_BIT",
+ "VG_COLORSPACE_LINEAR_BIT",
+ "LOCK_SURFACE_BIT_KHR",
+ "OPTIMAL_FORMAT_BIT_KHR"
+ ])
+]
+
+# Enum mapping
+ENUM_GROUPS = [
+ ("Boolean", ["TRUE", "FALSE"]),
+ ("BoolDontCare", ["TRUE", "FALSE", "DONT_CARE"]),
+ ("API", ["OPENGL_API", "OPENGL_ES_API", "OPENVG_API"]),
+ ("Error", [
+ "SUCCESS",
+ "NOT_INITIALIZED",
+ "BAD_ACCESS",
+ "BAD_ALLOC",
+ "BAD_ATTRIBUTE",
+ "BAD_CONFIG",
+ "BAD_CONTEXT",
+ "BAD_CURRENT_SURFACE",
+ "BAD_DISPLAY",
+ "BAD_MATCH",
+ "BAD_NATIVE_PIXMAP",
+ "BAD_NATIVE_WINDOW",
+ "BAD_PARAMETER",
+ "BAD_SURFACE",
+ "CONTEXT_LOST"
+ ]),
+ ("ContextAttrib", [
+ "CONFIG_ID",
+ "CONTEXT_CLIENT_TYPE",
+ "CONTEXT_CLIENT_VERSION",
+ "RENDER_BUFFER"
+ ]),
+ ("ConfigAttrib", [
+ "BUFFER_SIZE",
+ "RED_SIZE",
+ "GREEN_SIZE",
+ "BLUE_SIZE",
+ "LUMINANCE_SIZE",
+ "ALPHA_SIZE",
+ "ALPHA_MASK_SIZE",
+ "BIND_TO_TEXTURE_RGB",
+ "BIND_TO_TEXTURE_RGBA",
+ "COLOR_BUFFER_TYPE",
+ "CONFIG_CAVEAT",
+ "CONFIG_ID",
+ "CONFORMANT",
+ "DEPTH_SIZE",
+ "LEVEL",
+ "MATCH_NATIVE_PIXMAP",
+ "MAX_SWAP_INTERVAL",
+ "MIN_SWAP_INTERVAL",
+ "NATIVE_RENDERABLE",
+ "NATIVE_VISUAL_TYPE",
+ "RENDERABLE_TYPE",
+ "SAMPLE_BUFFERS",
+ "SAMPLES",
+ "STENCIL_SIZE",
+ "SURFACE_TYPE",
+ "TRANSPARENT_TYPE",
+ "TRANSPARENT_RED_VALUE",
+ "TRANSPARENT_GREEN_VALUE",
+ "TRANSPARENT_BLUE_VALUE"
+ ]),
+ ("SurfaceAttrib", [
+ "CONFIG_ID",
+ "WIDTH",
+ "HEIGHT",
+ "HORIZONTAL_RESOLUTION",
+ "VERTICAL_RESOLUTION",
+ "LARGEST_PBUFFER",
+ "MIPMAP_TEXTURE",
+ "MIPMAP_LEVEL",
+ "MULTISAMPLE_RESOLVE",
+ "PIXEL_ASPECT_RATIO",
+ "RENDER_BUFFER",
+ "SWAP_BEHAVIOR",
+ "TEXTURE_FORMAT",
+ "TEXTURE_TARGET",
+ "VG_ALPHA_FORMAT",
+ "VG_COLORSPACE"
+ ]),
+ ("SurfaceTarget", ["READ", "DRAW"]),
+
+ # ConfigAttrib values
+ ("ColorBufferType", ["RGB_BUFFER", "LUMINANCE_BUFFER"]),
+ ("ConfigCaveat", ["NONE", "SLOW_CONFIG", "NON_CONFORMANT_CONFIG"]),
+ ("TransparentType", ["NONE", "TRANSPARENT_RGB"]),
+
+ # SurfaceAttrib values
+ ("MultisampleResolve", ["MULTISAMPLE_RESOLVE_DEFAULT", "MULTISAMPLE_RESOLVE_BOX"]),
+ ("RenderBuffer", ["SINGLE_BUFFER", "BACK_BUFFER"]),
+ ("SwapBehavior", ["BUFFER_DESTROYED", "BUFFER_PRESERVED"]),
+ ("TextureFormat", ["NO_TEXTURE", "TEXTURE_RGB", "TEXTURE_RGBA"]),
+ ("TextureTarget", ["NO_TEXTURE", "TEXTURE_2D"]),
+ ("VGAlphaFormat", ["VG_ALPHA_FORMAT_NONPRE", "VG_ALPHA_FORMAT_PRE"]),
+ ("VGColorspace", ["VG_COLORSPACE_sRGB", "VG_COLORSPACE_LINEAR"])
+]
+
+def gen (iface):
+ enumGroups = addValuePrefix(ENUM_GROUPS, "EGL_")
+ bitfieldGroups = addValuePrefix(BITFIELD_GROUPS, "EGL_")
+ prototypeFile = os.path.join(EGL_DIR, "egluStrUtilPrototypes.inl")
+ implFile = os.path.join(EGL_DIR, "egluStrUtil.inl")
+
+ writeInlFile(prototypeFile, indentLines(genStrUtilProtos(iface, enumGroups, bitfieldGroups)))
+ writeInlFile(implFile, genStrUtilImpls(iface, enumGroups, bitfieldGroups))
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import egl
+
+def gen ():
+ egl.gen()
+
+if __name__ == "__main__":
+ gen()
--- /dev/null
+# -*- coding: utf-8 -*-
+__all__ = ['format', 'registry', 'registry_cache', 'gen_str_util']
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from itertools import chain
+
+INL_HEADER_TMPL = """\
+/* WARNING: This is auto-generated file. Do not modify, since changes will
+ * be lost! Modify the generating script instead.
+ *
+ * Generated from {registryName} revision {revision}.
+ */\
+"""
+
+def genInlHeader (registryName, revision):
+ return INL_HEADER_TMPL.format(
+ registryName = registryName,
+ revision = str(revision))
+
+def genInlHeaderForSource (registrySource):
+ return genInlHeaderForSource(registrySource.getFilename(), registrySource.getRevision())
+
+def nextMod (val, mod):
+ if val % mod == 0:
+ return val + mod
+ else:
+ return int(val/mod)*mod + mod
+
+def indentLines (lines):
+ tabSize = 4
+
+ # Split into columns
+ lineColumns = [line.split("\t") for line in lines if line is not None]
+ if len(lineColumns) == 0:
+ return
+
+ numColumns = max(len(line) for line in lineColumns)
+
+ # Figure out max length per column
+ columnLengths = [nextMod(max(len(line[ndx]) for line in lineColumns if len(line) > ndx), tabSize) for ndx in range(numColumns)]
+
+ for line in lineColumns:
+ indented = []
+ for columnNdx, col in enumerate(line[:-1]):
+ colLen = len(col)
+ while colLen < columnLengths[columnNdx]:
+ col += "\t"
+ colLen = nextMod(colLen, tabSize)
+ indented.append(col)
+
+ # Append last col
+ indented.append(line[-1])
+ yield "".join(indented)
+
+def writeLines (filename, lines):
+ with open(filename, 'wb') as f:
+ for line in lines:
+ if line is not None:
+ f.write(line)
+ f.write('\n')
+ print filename
+
+def writeInlFile (filename, header, source):
+ writeLines(filename, chain([header], source))
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from itertools import chain
+from format import indentLines
+
+def isValueDefined (definitions, value):
+ return value in definitions
+
+def allValuesUndefined (definitions, values):
+ for value in values:
+ if isValueDefined(definitions, value):
+ return False
+ return True
+
+def anyValueDefined (definitions, values):
+ return not allValuesUndefined(definitions, values)
+
+def makeDefSet (iface):
+ return set(enum.name for enum in iface.enums) | \
+ set(enum.alias for enum in iface.enums if enum.alias != None)
+
+def genStrUtilProtos (iface, enumGroups, bitfieldGroups):
+ definitions = makeDefSet(iface)
+
+ def genNameProtos ():
+ for groupName, values in enumGroups:
+ if anyValueDefined(definitions, values):
+ yield "const char*\tget%sName\t(int value);" % groupName
+ else:
+ print "Warning: Empty value set for %s, skipping" % groupName
+
+ def genBitfieldProtos ():
+ for groupName, values in bitfieldGroups:
+ if anyValueDefined(definitions, values):
+ yield "tcu::Format::Bitfield<16>\tget%sStr\t(int value);" % groupName
+ else:
+ print "Warning: Empty value set for %s, skipping" % groupName
+
+ def genStrImpl ():
+ for groupName, values in enumGroups:
+ if anyValueDefined(definitions, values):
+ yield "inline tcu::Format::Enum\tget%sStr\t(int value)\t{ return tcu::Format::Enum(get%sName,\tvalue); }" % (groupName, groupName)
+
+ return chain(genNameProtos(), genBitfieldProtos(), genStrImpl())
+
+def genEnumStrImpl (groupName, values, definitions):
+ if allValuesUndefined(definitions, values):
+ return
+
+ yield ""
+ yield "const char* get%sName (int value)" % groupName
+ yield "{"
+ yield "\tswitch (value)"
+ yield "\t{"
+
+ def genCases ():
+ for value in values:
+ if isValueDefined(definitions, value):
+ yield "case %s:\treturn \"%s\";" % (value, value)
+ else:
+ print "Warning: %s not defined, skipping" % value
+ yield "default:\treturn DE_NULL;"
+
+ for caseLine in indentLines(genCases()):
+ yield "\t\t" + caseLine
+
+ yield "\t}"
+ yield "}"
+
+def genBitfieldStrImpl (groupName, values, definitions):
+ if allValuesUndefined(definitions, values):
+ return
+
+ yield ""
+ yield "tcu::Format::Bitfield<16> get%sStr (int value)" % groupName
+ yield "{"
+ yield "\tstatic const tcu::Format::BitDesc s_desc[] ="
+ yield "\t{"
+
+ def genFields ():
+ for value in values:
+ if isValueDefined(definitions, value):
+ yield "tcu::Format::BitDesc(%s,\t\"%s\")," % (value, value)
+ else:
+ print "Warning: %s not defined, skipping" % value
+
+ for fieldLine in indentLines(genFields()):
+ yield "\t\t" + fieldLine
+
+ yield "\t};"
+ yield "\treturn tcu::Format::Bitfield<16>(value, &s_desc[0], &s_desc[DE_LENGTH_OF_ARRAY(s_desc)]);"
+ yield "}"
+
+def genStrUtilImpls (iface, enumGroups, bitfieldGroups):
+ definitions = makeDefSet(iface)
+
+ for groupName, values in enumGroups:
+ for line in genEnumStrImpl(groupName, values, definitions):
+ yield line
+ for groupName, values in bitfieldGroups:
+ for line in genBitfieldStrImpl(groupName, values, definitions):
+ yield line
+
+def addValuePrefix (groups, prefix):
+ return [(groupName, [prefix + value for value in values]) for groupName, values in groups]
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import sys, logging, re
+from lxml import etree
+from collections import OrderedDict
+from functools import wraps, partial
+
+log = logging.getLogger(__name__)
+
+debug = log.debug
+info = log.info
+warning = log.warning
+
+def warnElem(elem, fmt, *args):
+ warning('%s:%d, %s %s: ' + fmt, elem.base, elem.sourceline, elem.tag, elem.get('name') or '', *args)
+
+class Object(object):
+ def __init__(self, **kwargs):
+ self.__dict__.update(kwargs)
+
+class Located(Object):
+ location = None
+
+class Group(Located): pass
+class Enum(Located): pass
+class Enums(Located):
+ name = None
+ comment = None
+ enums = None
+
+class Type(Located):
+ location = None
+ name=None
+ definition=None
+ api=None
+ requires=None
+
+def makeObject(cls, elem, **kwargs):
+ kwargs.setdefault('name', elem.get('name'))
+ kwargs.setdefault('comment', elem.get('comment'))
+ kwargs['location'] = (elem.base, elem.sourceline)
+ return cls(**kwargs)
+
+def parseEnum(eEnum):
+ return makeObject(
+ Enum, eEnum,
+ value=eEnum.get('value'),
+ type=eEnum.get('type'),
+ alias=eEnum.get('alias'))
+
+class Param(Located): pass
+
+class Command(Located):
+ name=None
+ declaration=None
+ type=None
+ ptype=None
+ group=None
+ params=None
+ alias=None
+
+class Interface(Object): pass
+
+class Index:
+ def __init__(self, items=[], **kwargs):
+ self.index = {}
+ self.items = []
+ self.__dict__.update(kwargs)
+ self.update(items)
+
+ def append(self, item):
+ keys = self.getkeys(item)
+ for key in keys:
+ self[key] = item
+ self.items.append(item)
+
+ def update(self, items):
+ for item in items:
+ self.append(item)
+
+ def __iter__(self):
+ return iter(self.items)
+
+ def nextkey(self, key):
+ raise KeyError
+
+ def getkeys(self, item):
+ return []
+
+ def __contains__(self, key):
+ return key in self.index
+
+ def __setitem__(self, key, item):
+ if key in self.index:
+ self.duplicateKey(key, item)
+ else:
+ self.index[key] = item
+
+ def duplicateKey(self, key, item):
+ warning("Duplicate %s: %r", type(item).__name__.lower(), key)
+
+ def __getitem__(self, key):
+ try:
+ while True:
+ try:
+ return self.index[key]
+ except KeyError:
+ pass
+ key = self.nextkey(key)
+ except KeyError:
+ item = self.missingKey(key)
+ self.append(item)
+ return item
+
+ def missingKey(self, key):
+ raise KeyError(key)
+
+ def __len__(self):
+ return len(self.items)
+
+class ElemNameIndex(Index):
+ def getkeys(self, item):
+ return [item.get('name')]
+
+ def duplicateKey(self, key, item):
+ warnElem(item, "Duplicate key: %s", key)
+
+class CommandIndex(Index):
+ def getkeys(self, item):
+ return [item.findtext('proto/name'), item.findtext('alias')]
+
+class NameApiIndex(Index):
+ def getkeys(self, item):
+ return [(item.get('name'), item.get('api'))]
+
+ def nextkey(self, key):
+ if len(key) == 2 and key[1] is not None:
+ return key[0], None
+ raise KeyError
+
+ def duplicateKey(self, key, item):
+ warnElem(item, "Duplicate key: %s", key)
+
+class TypeIndex(NameApiIndex):
+ def getkeys(self, item):
+ return [(item.get('name') or item.findtext('name'), item.get('api'))]
+
+class EnumIndex(NameApiIndex):
+ def getkeys(self, item):
+ name, api, alias = (item.get(attrib) for attrib in ['name', 'api', 'alias'])
+ return [(name, api)] + ([(alias, api)] if alias is not None else [])
+
+ def duplicateKey(self, (name, api), item):
+ if name == item.get('alias'):
+ warnElem(item, "Alias already present: %s", name)
+ else:
+ warnElem(item, "Already present")
+
+class Registry:
+ def __init__(self, eRegistry):
+ self.types = TypeIndex(eRegistry.findall('types/type'))
+ self.groups = ElemNameIndex(eRegistry.findall('groups/group'))
+ self.enums = EnumIndex(eRegistry.findall('enums/enum'))
+ for eEnum in self.enums:
+ groupName = eEnum.get('group')
+ if groupName is not None:
+ self.groups[groupName] = eEnum
+ self.commands = CommandIndex(eRegistry.findall('commands/command'))
+ self.features = ElemNameIndex(eRegistry.findall('feature'))
+ self.apis = {}
+ for eFeature in self.features:
+ self.apis.setdefault(eFeature.get('api'), []).append(eFeature)
+ for apiFeatures in self.apis.itervalues():
+ apiFeatures.sort(key=lambda eFeature: eFeature.get('number'))
+ self.extensions = ElemNameIndex(eRegistry.findall('extensions/extension'))
+ self.element = eRegistry
+
+ def getFeatures(self, api, checkVersion=None):
+ return [eFeature for eFeature in self.apis[api]
+ if checkVersion is None or checkVersion(eFeature.get('number'))]
+
+class NameIndex(Index):
+ createMissing = None
+ kind = "item"
+
+ def getkeys(self, item):
+ return [item.name]
+
+ def missingKey(self, key):
+ if self.createMissing:
+ warning("Reference to implicit %s: %r", self.kind, key)
+ return self.createMissing(name=key)
+ else:
+ raise KeyError
+
+def matchApi(api1, api2):
+ return api1 is None or api2 is None or api1 == api2
+
+class Interface(Object):
+ pass
+
+def extractAlias(eCommand):
+ aliases = eCommand.xpath('alias/@name')
+ return aliases[0] if aliases else None
+
+def getExtensionName(eExtension):
+ return eExtension.get('name')
+
+def extensionSupports(eExtension, api, profile=None):
+ if api == 'gl' and profile == 'core':
+ needSupport = 'glcore'
+ else:
+ needSupport = api
+ supporteds = eExtension.get('supported').split('|')
+ return needSupport in supporteds
+
+class InterfaceSpec(Object):
+ def __init__(self):
+ self.enums = set()
+ self.types = set()
+ self.commands = set()
+
+ def addComponent(self, eComponent):
+ if eComponent.tag == 'require':
+ def modify(items, item): items.add(item)
+ else:
+ assert eComponent.tag == 'remove'
+ def modify(items, item):
+ try:
+ items.remove(item)
+ except KeyError:
+ warning("Tried to remove absent item: %s", item)
+ for typeName in eComponent.xpath('type/@name'):
+ modify(self.types, typeName)
+ for enumName in eComponent.xpath('enum/@name'):
+ modify(self.enums, enumName)
+ for commandName in eComponent.xpath('command/@name'):
+ modify(self.commands, commandName)
+
+ def addComponents(self, elem, api, profile=None):
+ for eComponent in elem.xpath('require|remove'):
+ cApi = eComponent.get('api')
+ cProfile = eComponent.get('profile')
+ if (matchApi(api, eComponent.get('api')) and
+ matchApi(profile, eComponent.get('profile'))):
+ self.addComponent(eComponent)
+
+ def addFeature(self, eFeature, api=None, profile=None, force=False):
+ info('Feature %s', eFeature.get('name'))
+ if not matchApi(api, eFeature.get('api')):
+ if not force: return
+ warnElem(eFeature, 'API %s is not supported', api)
+ self.addComponents(eFeature, api, profile)
+
+ def addExtension(self, eExtension, api=None, profile=None, force=False):
+ if not extensionSupports(eExtension, api, profile):
+ if not force: return
+ warnElem(eExtension, '%s is not supported in API %s' % (getExtensionName(eExtension), api))
+ self.addComponents(eExtension, api, profile)
+
+def createInterface(registry, spec, api=None):
+ def parseType(eType):
+ # todo: apientry
+ #requires = eType.get('requires')
+ #if requires is not None:
+ # types[requires]
+ return makeObject(
+ Type, eType,
+ name=eType.get('name') or eType.findtext('name'),
+ definition=''.join(eType.xpath('.//text()')),
+ api=eType.get('api'),
+ requires=eType.get('requires'))
+
+ def createType(name):
+ info('Add type %s', name)
+ try:
+ return parseType(registry.types[name, api])
+ except KeyError:
+ return Type(name=name)
+
+ def createEnum(enumName):
+ info('Add enum %s', enumName)
+ return parseEnum(registry.enums[enumName, api])
+
+ def extractPtype(elem):
+ ePtype = elem.find('ptype')
+ if ePtype is None:
+ return None
+ return types[ePtype.text]
+
+ def extractGroup(elem):
+ groupName = elem.get('group')
+ if groupName is None:
+ return None
+ return groups[groupName]
+
+ def parseParam(eParam):
+ return makeObject(
+ Param, eParam,
+ name=eParam.get('name') or eParam.findtext('name'),
+ declaration=''.join(eParam.xpath('.//text()')).strip(),
+ type=''.join(eParam.xpath('(.|ptype)/text()')).strip(),
+ ptype=extractPtype(eParam),
+ group=extractGroup(eParam))
+
+ def createCommand(commandName):
+ info('Add command %s', commandName)
+ eCmd = registry.commands[commandName]
+ eProto = eCmd.find('proto')
+ return makeObject(
+ Command, eCmd,
+ name=eCmd.findtext('proto/name'),
+ declaration=''.join(eProto.xpath('.//text()')).strip(),
+ type=''.join(eProto.xpath('(.|ptype)/text()')).strip(),
+ ptype=extractPtype(eProto),
+ group=extractGroup(eProto),
+ alias=extractAlias(eCmd),
+ params=NameIndex(map(parseParam, eCmd.findall('param'))))
+
+ def createGroup(name):
+ info('Add group %s', name)
+ try:
+ eGroup = registry.groups[name]
+ except KeyError:
+ return Group(name=name)
+ return makeObject(
+ Group, eGroup,
+ # Missing enums are often from exotic extensions. Don't create dummy entries,
+ # just filter them out.
+ enums=NameIndex(enums[name] for name in eGroup.xpath('enum/@name')
+ if name in enums))
+
+ def sortedIndex(items):
+ return NameIndex(sorted(items, key=lambda item: item.location))
+
+ groups = NameIndex(createMissing=createGroup, kind="group")
+ types = NameIndex(map(createType, spec.types),
+ createMissing=createType, kind="type")
+ enums = NameIndex(map(createEnum, spec.enums),
+ createMissing=Enum, kind="enum")
+ commands = NameIndex(map(createCommand, spec.commands),
+ createMissing=Command, kind="command")
+
+ # This is a mess because the registry contains alias chains whose
+ # midpoints might not be included in the interface even though
+ # endpoints are.
+ for command in commands:
+ alias = command.alias
+ aliasCommand = None
+ while alias is not None:
+ aliasCommand = registry.commands[alias]
+ alias = extractAlias(aliasCommand)
+ command.alias = None
+ if aliasCommand is not None:
+ name = aliasCommand.findtext('proto/name')
+ if name in commands:
+ command.alias = commands[name]
+
+ return Interface(
+ types=sortedIndex(types),
+ enums=sortedIndex(enums),
+ groups=sortedIndex(groups),
+ commands=sortedIndex(commands))
+
+
+def spec(registry, api, version=None, profile=None, extensionNames=[], protects=[], force=False):
+ available = set(protects)
+ spec = InterfaceSpec()
+
+ if version is None or version is False:
+ def check(v): return False
+ elif version is True:
+ def check(v): return True
+ else:
+ def check(v): return v <= version
+
+ for eFeature in registry.getFeatures(api, check):
+ spec.addFeature(eFeature, api, profile, force)
+
+ for extName in extensionNames:
+ eExtension = registry.extensions[extName]
+ protect = eExtension.get('protect')
+ if protect is not None and protect not in available:
+ warnElem(eExtension, "Unavailable dependency %s", protect)
+ if not force:
+ continue
+ spec.addExtension(eExtension, api, profile, force)
+ available.add(extName)
+
+ return spec
+
+def interface(registry, api, **kwargs):
+ s = spec(registry, api, **kwargs)
+ return createInterface(registry, s, api)
+
+def parse(path):
+ return Registry(etree.parse(path))
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import os
+import urllib2
+import hashlib
+
+import registry
+
+BASE_URL = ""
+
+class RegistrySource:
+ def __init__(self, filename, revision, checksum):
+ self.filename = filename
+ self.revision = revision
+ self.checksum = checksum
+
+ def __hash__(self):
+ return hash((self.filename, self.revision, self.checksum))
+
+ def __eq__(self, other):
+ return (self.filename, self.revision, self.checksum) == (other.filename, other.revision, other.checksum)
+
+ def getFilename (self):
+ return self.filename
+
+ def getCacheFilename (self):
+ return "r%d-%s" % (self.revision, self.filename)
+
+ def getChecksum (self):
+ return self.checksum
+
+ def getRevision (self):
+ return self.revision
+
+ def getSourceUrl (self):
+ return "https://cvs.khronos.org/svn/repos/ogl/trunk/doc/registry/public/api/%s?r=%d" % (self.filename, self.revision)
+
+def computeChecksum (data):
+ return hashlib.sha256(data).hexdigest()
+
+def fetchUrl (url):
+ req = urllib2.urlopen(url)
+ data = req.read()
+ return data
+
+def fetchFile (dstPath, url, checksum):
+ def writeFile (filename, data):
+ f = open(filename, 'wb')
+ f.write(data)
+ f.close()
+
+ if not os.path.exists(os.path.dirname(dstPath)):
+ os.makedirs(os.path.dirname(dstPath))
+
+ print "Fetching %s" % url
+ data = fetchUrl(url)
+ gotChecksum = computeChecksum(data)
+
+ if checksum != gotChecksum:
+ raise Exception("Checksum mismatch, exepected %s, got %s" % (checksum, gotChecksum))
+
+ writeFile(dstPath, data)
+
+def checkFile (filename, checksum):
+ def readFile (filename):
+ f = open(filename, 'rb')
+ data = f.read()
+ f.close()
+ return data
+
+ if os.path.exists(filename):
+ return computeChecksum(readFile(filename)) == checksum
+ else:
+ return False
+
+g_registryCache = {}
+
+def getRegistry (source):
+ global g_registryCache
+
+ if source in g_registryCache:
+ return g_registryCache[source]
+
+ cacheDir = os.path.join(os.path.dirname(__file__), "cache")
+ cachePath = os.path.join(cacheDir, source.getCacheFilename())
+
+ if not checkFile(cachePath, source.checksum):
+ fetchFile(cachePath, source.getSourceUrl(), source.getChecksum())
+
+ parsedReg = registry.parse(cachePath)
+
+ g_registryCache[source] = parsedReg
+
+ return parsedReg
import os
import string
+# TODO remove
+import sys
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+
from src_util import *
+from khr_util.gen_str_util import addValuePrefix, genStrUtilProtos, genStrUtilImpls
# Bitfield mapping
BITFIELD_GROUPS = [
# EnableCap EnumGroups are also GettableState EnumGroups
[x for x in ENUM_GROUPS if x[0]=="GettableState"][0][1].extend([x for x in ENUM_GROUPS if x[0]=="EnableCap"][0][1])
-def isValueDefined (definitions, value):
- return ("GL_" + value) in definitions
-
-def allValuesUndefined (definitions, values):
- for value in values:
- if isValueDefined(definitions, value):
- return False
- return True
-
-def anyValueDefined (definitions, values):
- return not allValuesUndefined(definitions, values)
-
-def writeStrUtilPrototypes (enumGroups, bitfieldGroups, definitions, dstFile):
- def genNameProtos ():
- for groupName, values in enumGroups:
- if anyValueDefined(definitions, values):
- yield "const char*\tget%sName\t(int value);" % groupName
- else:
- print "Warning: Empty value set for %s, skipping" % groupName
-
- def genBitfieldProtos ():
- for groupName, values in bitfieldGroups:
- if anyValueDefined(definitions, values):
- yield "tcu::Format::Bitfield<16>\tget%sStr\t(int value);" % groupName
- else:
- print "Warning: Empty value set for %s, skipping" % groupName
-
- def genStrImpl ():
- for groupName, values in enumGroups:
- if anyValueDefined(definitions, values):
- yield "inline tcu::Format::Enum\tget%sStr\t(int value)\t{ return tcu::Format::Enum(get%sName,\tvalue); }" % (groupName, groupName)
-
- writeInlFile(dstFile, indentLines(chain(genNameProtos(), genBitfieldProtos(), genStrImpl())))
-
-def genEnumStrImplementation (groupName, values, definitions):
- if allValuesUndefined(definitions, values):
- return
-
- yield ""
- yield "const char* get%sName (int value)" % groupName
- yield "{"
- yield "\tswitch (value)"
- yield "\t{"
-
- def genCases ():
- for value in values:
- if isValueDefined(definitions, value):
- yield "case GL_%s:\treturn \"GL_%s\";" % (value, value)
- else:
- print "Warning: %s not defined, skipping" % value
- yield "default:\treturn DE_NULL;"
-
- for caseLine in indentLines(genCases()):
- yield "\t\t" + caseLine
-
- yield "\t}"
- yield "}"
-
-def genBitfieldStrImplementation (groupName, values, definitions):
- if allValuesUndefined(definitions, values):
- return
-
- yield ""
- yield "tcu::Format::Bitfield<16> get%sStr (int value)" % groupName
- yield "{"
- yield "\tstatic const tcu::Format::BitDesc s_desc[] ="
- yield "\t{"
-
- def genFields ():
- for value in values:
- if isValueDefined(definitions, value):
- yield "tcu::Format::BitDesc(GL_%s,\t\"GL_%s\")," % (value, value)
- else:
- print "Warning: %s not defined, skipping" % value
-
- for fieldLine in indentLines(genFields()):
- yield "\t\t" + fieldLine
-
- yield "\t};"
- yield "\treturn tcu::Format::Bitfield<16>(value, &s_desc[0], &s_desc[DE_LENGTH_OF_ARRAY(s_desc)]);"
- yield "}"
-
-def genStrUtilImplementations (enumGroups, bitfieldGroups, definitions):
- for groupName, values in enumGroups:
- for line in genEnumStrImplementation(groupName, values, definitions):
- yield line
- for groupName, values in bitfieldGroups:
- for line in genBitfieldStrImplementation(groupName, values, definitions):
- yield line
-
-def writeStrUtilImplementations (enumGroups, bitfieldGroups, definitions, dstFile):
- writeInlFile(dstFile, genStrUtilImplementations(enumGroups, bitfieldGroups, definitions))
-
def genStrUtil (iface):
- definitions = set(enum.name for enum in iface.enums)
- writeStrUtilPrototypes(ENUM_GROUPS, BITFIELD_GROUPS, definitions, os.path.join(OPENGL_DIR, "gluStrUtilPrototypes.inl"))
- writeStrUtilImplementations(ENUM_GROUPS, BITFIELD_GROUPS, definitions, os.path.join(OPENGL_DIR, "gluStrUtil.inl"))
+ enumGroups = addValuePrefix(ENUM_GROUPS, "GL_")
+ bitfieldGroups = addValuePrefix(BITFIELD_GROUPS, "GL_")
+ prototypeFile = os.path.join(OPENGL_DIR, "gluStrUtilPrototypes.inl")
+ implFile = os.path.join(OPENGL_DIR, "gluStrUtil.inl")
+
+ writeInlFile(prototypeFile, indentLines(genStrUtilProtos(iface, enumGroups, bitfieldGroups)))
+ writeInlFile(implFile, genStrUtilImpls(iface, enumGroups, bitfieldGroups))
if __name__ == "__main__":
genStrUtil(getHybridInterface())
+++ /dev/null
-#!/usr/bin/env python
-
-import sys, logging, re
-from lxml import etree
-from collections import OrderedDict
-from functools import wraps, partial
-
-log = logging.getLogger(__name__)
-
-debug = log.debug
-info = log.info
-warning = log.warning
-
-def warnElem(elem, fmt, *args):
- warning('%s:%d, %s %s: ' + fmt, elem.base, elem.sourceline, elem.tag, elem.get('name') or '', *args)
-
-class Object(object):
- def __init__(self, **kwargs):
- self.__dict__.update(kwargs)
-
-class Located(Object):
- location = None
-
-class Group(Located): pass
-class Enum(Located): pass
-class Enums(Located):
- name = None
- comment = None
- enums = None
-
-class Type(Located):
- location = None
- name=None
- definition=None
- api=None
- requires=None
-
-def makeObject(cls, elem, **kwargs):
- kwargs.setdefault('name', elem.get('name'))
- kwargs.setdefault('comment', elem.get('comment'))
- kwargs['location'] = (elem.base, elem.sourceline)
- return cls(**kwargs)
-
-def parseEnum(eEnum):
- return makeObject(
- Enum, eEnum,
- value=eEnum.get('value'),
- type=eEnum.get('type'),
- alias=eEnum.get('alias'))
-
-class Param(Located): pass
-
-class Command(Located):
- name=None
- declaration=None
- type=None
- ptype=None
- group=None
- params=None
- alias=None
-
-class Interface(Object): pass
-
-class Index:
- def __init__(self, items=[], **kwargs):
- self.index = {}
- self.items = []
- self.__dict__.update(kwargs)
- self.update(items)
-
- def append(self, item):
- keys = self.getkeys(item)
- for key in keys:
- self[key] = item
- self.items.append(item)
-
- def update(self, items):
- for item in items:
- self.append(item)
-
- def __iter__(self):
- return iter(self.items)
-
- def nextkey(self, key):
- raise KeyError
-
- def getkeys(self, item):
- return []
-
- def __contains__(self, key):
- return key in self.index
-
- def __setitem__(self, key, item):
- if key in self.index:
- self.duplicateKey(key, item)
- else:
- self.index[key] = item
-
- def duplicateKey(self, key, item):
- warning("Duplicate %s: %r", type(item).__name__.lower(), key)
-
- def __getitem__(self, key):
- try:
- while True:
- try:
- return self.index[key]
- except KeyError:
- pass
- key = self.nextkey(key)
- except KeyError:
- item = self.missingKey(key)
- self.append(item)
- return item
-
- def missingKey(self, key):
- raise KeyError(key)
-
- def __len__(self):
- return len(self.items)
-
-class ElemNameIndex(Index):
- def getkeys(self, item):
- return [item.get('name')]
-
- def duplicateKey(self, key, item):
- warnElem(item, "Duplicate key: %s", key)
-
-class CommandIndex(Index):
- def getkeys(self, item):
- return [item.findtext('proto/name'), item.findtext('alias')]
-
-class NameApiIndex(Index):
- def getkeys(self, item):
- return [(item.get('name'), item.get('api'))]
-
- def nextkey(self, key):
- if len(key) == 2 and key[1] is not None:
- return key[0], None
- raise KeyError
-
- def duplicateKey(self, key, item):
- warnElem(item, "Duplicate key: %s", key)
-
-class TypeIndex(NameApiIndex):
- def getkeys(self, item):
- return [(item.get('name') or item.findtext('name'), item.get('api'))]
-
-class EnumIndex(NameApiIndex):
- def getkeys(self, item):
- name, api, alias = (item.get(attrib) for attrib in ['name', 'api', 'alias'])
- return [(name, api)] + ([(alias, api)] if alias is not None else [])
-
- def duplicateKey(self, (name, api), item):
- if name == item.get('alias'):
- warnElem(item, "Alias already present: %s", name)
- else:
- warnElem(item, "Already present")
-
-class Registry:
- def __init__(self, eRegistry):
- self.types = TypeIndex(eRegistry.findall('types/type'))
- self.groups = ElemNameIndex(eRegistry.findall('groups/group'))
- self.enums = EnumIndex(eRegistry.findall('enums/enum'))
- for eEnum in self.enums:
- groupName = eEnum.get('group')
- if groupName is not None:
- self.groups[groupName] = eEnum
- self.commands = CommandIndex(eRegistry.findall('commands/command'))
- self.features = ElemNameIndex(eRegistry.findall('feature'))
- self.apis = {}
- for eFeature in self.features:
- self.apis.setdefault(eFeature.get('api'), []).append(eFeature)
- for apiFeatures in self.apis.itervalues():
- apiFeatures.sort(key=lambda eFeature: eFeature.get('number'))
- self.extensions = ElemNameIndex(eRegistry.findall('extensions/extension'))
- self.element = eRegistry
-
- def getFeatures(self, api, checkVersion=None):
- return [eFeature for eFeature in self.apis[api]
- if checkVersion is None or checkVersion(eFeature.get('number'))]
-
-class NameIndex(Index):
- createMissing = None
- kind = "item"
-
- def getkeys(self, item):
- return [item.name]
-
- def missingKey(self, key):
- if self.createMissing:
- warning("Reference to implicit %s: %r", self.kind, key)
- return self.createMissing(name=key)
- else:
- raise KeyError
-
-def matchApi(api1, api2):
- return api1 is None or api2 is None or api1 == api2
-
-class Interface(Object):
- pass
-
-def extractAlias(eCommand):
- aliases = eCommand.xpath('alias/@name')
- return aliases[0] if aliases else None
-
-class InterfaceSpec(Object):
- def __init__(self):
- self.enums = set()
- self.types = set()
- self.commands = set()
-
- def addComponent(self, eComponent):
- if eComponent.tag == 'require':
- def modify(items, item): items.add(item)
- else:
- assert eComponent.tag == 'remove'
- def modify(items, item):
- try:
- items.remove(item)
- except KeyError:
- warning("Tried to remove absent item: %s", item)
- for typeName in eComponent.xpath('type/@name'):
- modify(self.types, typeName)
- for enumName in eComponent.xpath('enum/@name'):
- modify(self.enums, enumName)
- for commandName in eComponent.xpath('command/@name'):
- modify(self.commands, commandName)
-
- def addComponents(self, elem, api, profile=None):
- for eComponent in elem.xpath('require|remove'):
- cApi = eComponent.get('api')
- cProfile = eComponent.get('profile')
- if (matchApi(api, eComponent.get('api')) and
- matchApi(profile, eComponent.get('profile'))):
- self.addComponent(eComponent)
-
- def addFeature(self, eFeature, api=None, profile=None, force=False):
- info('Feature %s', eFeature.get('name'))
- if not matchApi(api, eFeature.get('api')):
- if not force: return
- warnElem(eFeature, 'API %s is not supported', api)
- self.addComponents(eFeature, api, profile)
-
- def addExtension(self, eExtension, api=None, profile=None, force=False):
- if api == 'gl' and profile == 'core':
- needSupport = 'glcore'
- else:
- needSupport = api
- supporteds = eExtension.get('supported').split('|')
- if needSupport not in supporteds:
- if not force: return
- warnElem(eExtension, 'API %s is not supported', needSupport)
- self.addComponents(eExtension, api, profile)
-
-def createInterface(registry, spec, api=None):
- def parseType(eType):
- # todo: apientry
- #requires = eType.get('requires')
- #if requires is not None:
- # types[requires]
- return makeObject(
- Type, eType,
- name=eType.get('name') or eType.findtext('name'),
- definition=''.join(eType.xpath('.//text()')),
- api=eType.get('api'),
- requires=eType.get('requires'))
-
- def createType(name):
- info('Add type %s', name)
- try:
- return parseType(registry.types[name, api])
- except KeyError:
- return Type(name=name)
-
- def createEnum(enumName):
- info('Add enum %s', enumName)
- return parseEnum(registry.enums[enumName, api])
-
- def extractPtype(elem):
- ePtype = elem.find('ptype')
- if ePtype is None:
- return None
- return types[ePtype.text]
-
- def extractGroup(elem):
- groupName = elem.get('group')
- if groupName is None:
- return None
- return groups[groupName]
-
- def parseParam(eParam):
- return makeObject(
- Param, eParam,
- name=eParam.get('name') or eParam.findtext('name'),
- declaration=''.join(eParam.xpath('.//text()')).strip(),
- type=''.join(eParam.xpath('(.|ptype)/text()')).strip(),
- ptype=extractPtype(eParam),
- group=extractGroup(eParam))
-
- def createCommand(commandName):
- info('Add command %s', commandName)
- eCmd = registry.commands[commandName]
- eProto = eCmd.find('proto')
- return makeObject(
- Command, eCmd,
- name=eCmd.findtext('proto/name'),
- declaration=''.join(eProto.xpath('.//text()')).strip(),
- type=''.join(eProto.xpath('(.|ptype)/text()')).strip(),
- ptype=extractPtype(eProto),
- group=extractGroup(eProto),
- alias=extractAlias(eCmd),
- params=NameIndex(map(parseParam, eCmd.findall('param'))))
-
- def createGroup(name):
- info('Add group %s', name)
- try:
- eGroup = registry.groups[name]
- except KeyError:
- return Group(name=name)
- return makeObject(
- Group, eGroup,
- # Missing enums are often from exotic extensions. Don't create dummy entries,
- # just filter them out.
- enums=NameIndex(enums[name] for name in eGroup.xpath('enum/@name')
- if name in enums))
-
- def sortedIndex(items):
- return NameIndex(sorted(items, key=lambda item: item.location))
-
- groups = NameIndex(createMissing=createGroup, kind="group")
- types = NameIndex(map(createType, spec.types),
- createMissing=createType, kind="type")
- enums = NameIndex(map(createEnum, spec.enums),
- createMissing=Enum, kind="enum")
- commands = NameIndex(map(createCommand, spec.commands),
- createMissing=Command, kind="command")
-
- # This is a mess because the registry contains alias chains whose
- # midpoints might not be included in the interface even though
- # endpoints are.
- for command in commands:
- alias = command.alias
- aliasCommand = None
- while alias is not None:
- aliasCommand = registry.commands[alias]
- alias = extractAlias(aliasCommand)
- command.alias = None
- if aliasCommand is not None:
- name = aliasCommand.findtext('proto/name')
- if name in commands:
- command.alias = commands[name]
-
- return Interface(
- types=sortedIndex(types),
- enums=sortedIndex(enums),
- groups=sortedIndex(groups),
- commands=sortedIndex(commands))
-
-
-def spec(registry, api, version=None, profile=None, extensionNames=[], protects=[], force=False):
- available = set(protects)
- spec = InterfaceSpec()
-
- if version is None or version is False:
- def check(v): return False
- elif version is True:
- def check(v): return True
- else:
- def check(v): return v <= version
-
- for eFeature in registry.getFeatures(api, check):
- spec.addFeature(eFeature, api, profile, force)
-
- for extName in extensionNames:
- eExtension = registry.extensions[extName]
- protect = eExtension.get('protect')
- if protect is not None and protect not in available:
- warnElem(eExtension, "Unavailable dependency %s", protect)
- if not force:
- continue
- spec.addExtension(eExtension, api, profile, force)
- available.add(extName)
-
- return spec
-
-def interface(registry, api, **kwargs):
- s = spec(registry, api, **kwargs)
- return createInterface(registry, s, api)
-
-def parse(path):
- return Registry(etree.parse(path))
import os
import re
-import urllib2
-import hashlib
-import khronos_registry
+import sys
-from itertools import chain
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+
+import khr_util.format
+import khr_util.registry
+import khr_util.registry_cache
SCRIPTS_DIR = os.path.dirname(__file__)
OPENGL_DIR = os.path.normpath(os.path.join(SCRIPTS_DIR, "..", "..", "framework", "opengl"))
EGL_DIR = os.path.normpath(os.path.join(SCRIPTS_DIR, "..", "..", "framework", "egl"))
-OPENGL_IN_DIR = os.path.join(SCRIPTS_DIR, "src")
OPENGL_INC_DIR = os.path.join(OPENGL_DIR, "wrapper")
-GL_XML = os.path.join(OPENGL_IN_DIR, "gl.xml")
-OPENGL_ENUMS_IN = os.path.join(OPENGL_IN_DIR, "glEnums.in")
-OPENGL_FUNCS_IN = os.path.join(OPENGL_IN_DIR, "glFunctions.in")
-OPENGL_ES_FUNCS_IN = os.path.join(OPENGL_IN_DIR, "esFunctions.in")
-SRC_URL = "https://cvs.khronos.org/svn/repos/ogl/trunk/doc/registry/public/api/gl.xml"
-SRC_REVISION = 28861
-SRC_CHECKSUM = "65564395098c82ec9d18cc19100357cb11d99f7baf1d99133bb543ffca7a0f0e"
+GL_SOURCE = khr_util.registry_cache.RegistrySource(
+ "gl.xml",
+ 28861,
+ "65564395098c82ec9d18cc19100357cb11d99f7baf1d99133bb543ffca7a0f0e")
EXTENSIONS = [
'GL_KHR_texture_compression_astc_ldr',
'GL_OES_sample_shading',
]
-gl_registry = None
-
def getGLRegistry ():
- global gl_registry
- if gl_registry is None:
- updateSrc()
- gl_registry = khronos_registry.parse(GL_XML)
- return gl_registry
+ return khr_util.registry_cache.getRegistry(GL_SOURCE)
# return the name of a core command corresponding to an extension command.
# Ideally this should be done using the alias attribute of commands, but dEQP
registry = getGLRegistry()
glFeatures = registry.getFeatures('gl')
esFeatures = registry.getFeatures('gles2')
- spec = khronos_registry.InterfaceSpec()
+ spec = khr_util.registry.InterfaceSpec()
for feature in registry.getFeatures('gl'):
spec.addFeature(feature, 'gl', 'core')
if coreName != commandName and coreName in spec.commands:
spec.commands.remove(commandName)
- return khronos_registry.createInterface(registry, spec, 'gles2')
+ return khr_util.registry.createInterface(registry, spec, 'gles2')
def getInterface (registry, api, version=None, profile=None, **kwargs):
- spec = khronos_registry.spec(registry, api, version, profile, **kwargs)
+ spec = khr_util.registry.spec(registry, api, version, profile, **kwargs)
if api == 'gl' and profile == 'core' and version < "3.2":
gl32 = registry.features['GL_VERSION_3_2']
for eRemove in gl32.xpath('remove'):
spec.addComponent(eRemove)
- return khronos_registry.createInterface(registry, spec, api)
+ return khr_util.registry.createInterface(registry, spec, api)
def getVersionToken (api, version):
prefixes = { 'gles2': "ES", 'gl': "GL" }
else:
return "%c%s" % (funcName[2].lower(), funcName[3:])
-INL_HEADER = """\
-/* WARNING: This is auto-generated file. Do not modify, since changes will
- * be lost! Modify the generating script instead.
- *
- * Generated from Khronos GL API description (gl.xml) revision {REVISION}.
- */\
-""".replace("{REVISION}", str(SRC_REVISION))
-
-SRC_HEADER = """\
-#ifndef {INCLUDE_GUARD}
-#define {INCLUDE_GUARD}
-/*-------------------------------------------------------------------------
- * drawElements Quality Program OpenGL Utilities
- * ---------------------------------------------
- *
- * Copyright 2014 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- *//*!
- * \\file
- * \\brief {DESCRIPTION}
- *
- * WARNING: This is auto-generated file. Do not modify, since changes will
- * be lost! Modify the generating script instead.
- *//*--------------------------------------------------------------------*/
-
-#ifndef _DEDEFS_H
-# include "deDefs.h"
-#endif
-#ifndef _GLTYPES_H
-# include "glTypes.h"
-#endif
-
-DE_BEGIN_EXTERN_C
-
-"""
-
-SRC_FOOTER = """
-
-DE_END_EXTERN_C
-
-#endif /* {INCLUDE_GUARD} */
-"""[1:]
-
-def nextMod (val, mod):
- if val % mod == 0:
- return val + mod
- else:
- return int(val/mod)*mod + mod
-
-def indentLines (lines):
- tabSize = 4
-
- # Split into columns
- lineColumns = [line.split("\t") for line in lines if line is not None]
- if len(lineColumns) == 0:
- return
-
- numColumns = max(len(line) for line in lineColumns)
-
- # Figure out max length per column
- columnLengths = [nextMod(max(len(line[ndx]) for line in lineColumns if len(line) > ndx), tabSize) for ndx in range(numColumns)]
-
- for line in lineColumns:
- indented = []
- for columnNdx, col in enumerate(line[:-1]):
- colLen = len(col)
- while colLen < columnLengths[columnNdx]:
- col += "\t"
- colLen = nextMod(colLen, tabSize)
- indented.append(col)
-
- # Append last col
- indented.append(line[-1])
- yield "".join(indented)
-
def normalizeConstant(constant):
value = int(constant, base=0)
if value >= 1 << 63:
def commandArgs(command):
return ", ".join(param.name for param in command.params)
-def getIncludeGuardName (filename):
- filename = filename.upper()
- filename = filename.replace('.', '_')
- return "_%s" % filename
-
-def writeFile (filename, lines):
- with open(filename, 'wb') as f:
- for line in lines:
- if line is not None:
- f.write(line)
- f.write('\n')
- print filename
-
-def writeSrcFile (filename, description, source):
- includeGuard = getIncludeGuardName(os.path.basename(filename))
-
- header = SRC_HEADER.format(INCLUDE_GUARD=includeGuard, DESCRIPTION=description)
- footer = SRC_FOOTER.format(INCLUDE_GUARD=includeGuard)
- writeFile(filename, chain([header], lines, [footer]))
+INL_HEADER = khr_util.format.genInlHeader("Khronos GL API description (gl.xml)", GL_SOURCE.getRevision())
def writeInlFile (filename, source):
- includeGuard = getIncludeGuardName(os.path.basename(filename))
- writeFile(filename, chain([INL_HEADER], source))
-
-def computeChecksum (data):
- return hashlib.sha256(data).hexdigest()
-
-def fetchUrl (url):
- req = urllib2.urlopen(url)
- data = req.read()
- return data
-
-def fetchSrc ():
- def writeFile (filename, data):
- f = open(filename, 'wb')
- f.write(data)
- f.close()
-
- if not os.path.exists(os.path.dirname(GL_XML)):
- os.makedirs(os.path.dirname(GL_XML))
-
- fullUrl = "%s?r=%d" % (SRC_URL, SRC_REVISION)
-
- print "Fetching %s" % fullUrl
- data = fetchUrl(fullUrl)
- checksum = computeChecksum(data)
-
- if checksum != SRC_CHECKSUM:
- raise Exception("Checksum mismatch, exepected %s, got %s" % (SRC_CHECKSUM, checksum))
-
- writeFile(GL_XML, data)
-
-def checkSrc ():
- def readFile (filename):
- f = open(filename, 'rb')
- data = f.read()
- f.close()
- return data
-
- if os.path.exists(GL_XML):
- return computeChecksum(readFile(GL_XML)) == SRC_CHECKSUM
- else:
- return False
+ khr_util.format.writeInlFile(filename, INL_HEADER, source)
-def updateSrc ():
- if not checkSrc():
- fetchSrc()
+# Aliases from khr_util.common
+indentLines = khr_util.format.indentLines
message("*** Using X11 EGL/GLX target")
set(DEQP_TARGET_NAME "X11 EGL/GLX")
-set(DEQP_RUNTIME_LINK ON)
+set(DEQP_RUNTIME_LINK OFF)
set(DEQP_SUPPORT_GLES2 ON)
set(DEQP_SUPPORT_GLES3 ON)
set(DEQP_SUPPORT_OPENGL ON)
message(FATAL_ERROR "X11 development package not found")
endif ()
-set(DEQP_PLATFORM_LIBRARIES ${X11_LIBRARIES})
+find_library(EGL_LIBRARY EGL)
+if (NOT EGL_LIBRARY)
+ message(FATAL_ERROR "EGL library not found")
+endif()
+
+set(DEQP_EGL_LIBRARIES ${EGL_LIBRARY})
+set(DEQP_PLATFORM_LIBRARIES ${X11_LIBRARIES})
+
include_directories(${X11_INCLUDE_DIR})
projects / platform / upstream / VK-GL-CTS.git / commitdiff