From a017863963f9194666b813f6ef88130288a5fc50 Mon Sep 17 00:00:00 2001 From: Pyry Haulos Date: Fri, 21 Nov 2014 14:56:21 -0800 Subject: [PATCH] Generate EGL framework .inl files from Khronos XML registry This change adds support for producing auto-generated parts of the EGL framework from official Khronos XML API description. The change comes with some refactoring of opengl generator scripts as common code is moved to scripts/khr_util. Bug: 18273960 Change-Id: I4da9a1a5fae02854e3de3facfc93b325e3087502 --- framework/egl/egluCallLogWrapper.hpp | 2 +- framework/egl/egluCallLogWrapper.inl | 310 +- ...ApiPrototypes.inl => egluCallLogWrapperApi.inl} | 65 +- framework/egl/egluStrUtil.inl | 10 +- framework/egl/egluStrUtilPrototypes.inl | 85 +- modules/egl/teglGetProcAddressTests.cpp | 105 +- modules/egl/teglGetProcAddressTests.inl | 3068 +++++++++----------- scripts/egl/__init__.py | 16 + scripts/egl/call_log_wrapper.py | 133 + scripts/egl/common.py | 42 + scripts/egl/proc_address_tests.py | 113 + scripts/egl/str_util.py | 133 + scripts/gen_egl.py | 9 + scripts/khr_util/.gitignore | 1 + scripts/khr_util/__init__.py | 2 + scripts/khr_util/format.py | 62 + scripts/khr_util/gen_str_util.py | 105 + scripts/khr_util/registry.py | 397 +++ scripts/khr_util/registry_cache.py | 94 + scripts/opengl/.gitignore | 1 - scripts/opengl/__init__.py | 0 scripts/opengl/gen_str_util.py | 108 +- scripts/opengl/khronos_registry.py | 391 --- scripts/opengl/src_util.py | 193 +- targets/x11_egl_glx/x11_egl_glx.cmake | 11 +- 25 files changed, 2779 insertions(+), 2677 deletions(-) rename framework/egl/{egluApiPrototypes.inl => egluCallLogWrapperApi.inl} (60%) create mode 100644 scripts/egl/__init__.py create mode 100644 scripts/egl/call_log_wrapper.py create mode 100644 scripts/egl/common.py create mode 100644 scripts/egl/proc_address_tests.py create mode 100644 scripts/egl/str_util.py create mode 100644 scripts/gen_egl.py create mode 100644 scripts/khr_util/.gitignore create mode 100644 scripts/khr_util/__init__.py create mode 100644 scripts/khr_util/format.py create mode 100644 scripts/khr_util/gen_str_util.py create mode 100644 scripts/khr_util/registry.py create mode 100644 scripts/khr_util/registry_cache.py delete mode 100644 scripts/opengl/.gitignore create mode 100644 scripts/opengl/__init__.py delete mode 100644 scripts/opengl/khronos_registry.py diff --git a/framework/egl/egluCallLogWrapper.hpp b/framework/egl/egluCallLogWrapper.hpp index 10d1c03..825ae38 100644 --- a/framework/egl/egluCallLogWrapper.hpp +++ b/framework/egl/egluCallLogWrapper.hpp @@ -37,7 +37,7 @@ public: ~CallLogWrapper (void); // EGL API is exposed as member functions -#include "egluApiPrototypes.inl" +#include "egluCallLogWrapperApi.inl" void enableLogging (bool enable) { m_enableLog = enable; } diff --git a/framework/egl/egluCallLogWrapper.inl b/framework/egl/egluCallLogWrapper.inl index 8c25e39..ee613a8 100644 --- a/framework/egl/egluCallLogWrapper.inl +++ b/framework/egl/egluCallLogWrapper.inl @@ -1,360 +1,362 @@ -/* 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; } diff --git a/framework/egl/egluApiPrototypes.inl b/framework/egl/egluCallLogWrapperApi.inl similarity index 60% rename from framework/egl/egluApiPrototypes.inl rename to framework/egl/egluCallLogWrapperApi.inl index 866ed5d..605c907 100644 --- a/framework/egl/egluApiPrototypes.inl +++ b/framework/egl/egluCallLogWrapperApi.inl @@ -1,38 +1,39 @@ -/* 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); diff --git a/framework/egl/egluStrUtil.inl b/framework/egl/egluStrUtil.inl index 8ed6321..693e147 100644 --- a/framework/egl/egluStrUtil.inl +++ b/framework/egl/egluStrUtil.inl @@ -1,5 +1,7 @@ -/* 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) @@ -250,7 +252,7 @@ tcu::Format::Bitfield<16> getAPIBitsStr (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)]); } @@ -267,7 +269,7 @@ tcu::Format::Bitfield<16> getSurfaceBitsStr (int value) 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)]); } diff --git a/framework/egl/egluStrUtilPrototypes.inl b/framework/egl/egluStrUtilPrototypes.inl index 155053b..232b9d2 100644 --- a/framework/egl/egluStrUtilPrototypes.inl +++ b/framework/egl/egluStrUtilPrototypes.inl @@ -1,44 +1,43 @@ -/* 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); } diff --git a/modules/egl/teglGetProcAddressTests.cpp b/modules/egl/teglGetProcAddressTests.cpp index b341289..565a1a9 100644 --- a/modules/egl/teglGetProcAddressTests.cpp +++ b/modules/egl/teglGetProcAddressTests.cpp @@ -27,17 +27,10 @@ #include "egluStrUtil.hpp" #include "tcuTestLog.hpp" -#include -#include -#include -#include - #if !defined(EGL_OPENGL_ES3_BIT_KHR) # define EGL_OPENGL_ES3_BIT_KHR 0x0040 #endif -using tcu::TestLog; - namespace deqp { namespace egl @@ -46,47 +39,49 @@ namespace egl namespace { +using tcu::TestLog; + // Function name strings generated from API headers #include "teglGetProcAddressTests.inl" -std::vector makeStringVector (const char** cStrArray) +struct FunctionNames { - std::vector 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 getExtensionNames (void) -{ - return makeStringVector(getExtensionStrs()); -} - -std::vector 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(); + DE_ASSERT(false); + return FunctionNames(0, DE_NULL); } -std::vector 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(); + return FunctionNames(0, DE_NULL); } } // anonymous @@ -161,21 +156,21 @@ public: void executeTest (void) { - TestLog& log = m_testCtx.getLog(); - bool supported = isSupported(m_extName); - const std::vector 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::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) @@ -195,9 +190,8 @@ private: 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) { } @@ -226,9 +220,10 @@ public: 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; @@ -239,12 +234,12 @@ public: log << TestLog::Message << TestLog::EndMessage; } - for (std::vector::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)) @@ -261,8 +256,7 @@ public: } private: - const std::vector m_funcNames; - const EGLint m_apiBit; + const EGLint m_apiBit; }; GetProcAddressTests::GetProcAddressTests (EglTestContext& eglTestCtx) @@ -281,17 +275,10 @@ void GetProcAddressTests::init (void) tcu::TestCaseGroup* extensionsGroup = new tcu::TestCaseGroup(m_testCtx, "extension", "Test EGL extensions"); addChild(extensionsGroup); - const std::vector extNames = getExtensionNames(); - - for (std::vector::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 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]); @@ -305,7 +292,7 @@ void GetProcAddressTests::init (void) 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)); diff --git a/modules/egl/teglGetProcAddressTests.inl b/modules/egl/teglGetProcAddressTests.inl index 7f0cda2..810d1a6 100644 --- a/modules/egl/teglGetProcAddressTests.inl +++ b/modules/egl/teglGetProcAddressTests.inl @@ -1,1722 +1,1350 @@ -/* 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 }, +}; diff --git a/scripts/egl/__init__.py b/scripts/egl/__init__.py new file mode 100644 index 0000000..c0c86d7 --- /dev/null +++ b/scripts/egl/__init__.py @@ -0,0 +1,16 @@ +# -*- 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() diff --git a/scripts/egl/call_log_wrapper.py b/scripts/egl/call_log_wrapper.py new file mode 100644 index 0000000..9233db0 --- /dev/null +++ b/scripts/egl/call_log_wrapper.py @@ -0,0 +1,133 @@ +# -*- 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) diff --git a/scripts/egl/common.py b/scripts/egl/common.py new file mode 100644 index 0000000..fa573cb --- /dev/null +++ b/scripts/egl/common.py @@ -0,0 +1,42 @@ +# -*- 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) diff --git a/scripts/egl/proc_address_tests.py b/scripts/egl/proc_address_tests.py new file mode 100644 index 0000000..c3fce49 --- /dev/null +++ b/scripts/egl/proc_address_tests.py @@ -0,0 +1,113 @@ +# -*- 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))) diff --git a/scripts/egl/str_util.py b/scripts/egl/str_util.py new file mode 100644 index 0000000..7e5e4f4 --- /dev/null +++ b/scripts/egl/str_util.py @@ -0,0 +1,133 @@ +# -*- 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)) diff --git a/scripts/gen_egl.py b/scripts/gen_egl.py new file mode 100644 index 0000000..23aa200 --- /dev/null +++ b/scripts/gen_egl.py @@ -0,0 +1,9 @@ +# -*- coding: utf-8 -*- + +import egl + +def gen (): + egl.gen() + +if __name__ == "__main__": + gen() diff --git a/scripts/khr_util/.gitignore b/scripts/khr_util/.gitignore new file mode 100644 index 0000000..06cf653 --- /dev/null +++ b/scripts/khr_util/.gitignore @@ -0,0 +1 @@ +cache diff --git a/scripts/khr_util/__init__.py b/scripts/khr_util/__init__.py new file mode 100644 index 0000000..439591b --- /dev/null +++ b/scripts/khr_util/__init__.py @@ -0,0 +1,2 @@ +# -*- coding: utf-8 -*- +__all__ = ['format', 'registry', 'registry_cache', 'gen_str_util'] diff --git a/scripts/khr_util/format.py b/scripts/khr_util/format.py new file mode 100644 index 0000000..903aac6 --- /dev/null +++ b/scripts/khr_util/format.py @@ -0,0 +1,62 @@ +# -*- 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)) diff --git a/scripts/khr_util/gen_str_util.py b/scripts/khr_util/gen_str_util.py new file mode 100644 index 0000000..4c4d43a --- /dev/null +++ b/scripts/khr_util/gen_str_util.py @@ -0,0 +1,105 @@ +# -*- 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] diff --git a/scripts/khr_util/registry.py b/scripts/khr_util/registry.py new file mode 100644 index 0000000..d6eda71 --- /dev/null +++ b/scripts/khr_util/registry.py @@ -0,0 +1,397 @@ +# -*- 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)) diff --git a/scripts/khr_util/registry_cache.py b/scripts/khr_util/registry_cache.py new file mode 100644 index 0000000..45de4f0 --- /dev/null +++ b/scripts/khr_util/registry_cache.py @@ -0,0 +1,94 @@ +# -*- 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 diff --git a/scripts/opengl/.gitignore b/scripts/opengl/.gitignore deleted file mode 100644 index 85de9cf..0000000 --- a/scripts/opengl/.gitignore +++ /dev/null @@ -1 +0,0 @@ -src diff --git a/scripts/opengl/__init__.py b/scripts/opengl/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/scripts/opengl/gen_str_util.py b/scripts/opengl/gen_str_util.py index 78e1dbd..c452450 100644 --- a/scripts/opengl/gen_str_util.py +++ b/scripts/opengl/gen_str_util.py @@ -3,7 +3,12 @@ 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 = [ @@ -780,103 +785,14 @@ ENUM_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()) diff --git a/scripts/opengl/khronos_registry.py b/scripts/opengl/khronos_registry.py deleted file mode 100644 index a65d864..0000000 --- a/scripts/opengl/khronos_registry.py +++ /dev/null @@ -1,391 +0,0 @@ -#!/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)) diff --git a/scripts/opengl/src_util.py b/scripts/opengl/src_util.py index cdb505b..e2fdb4e 100644 --- a/scripts/opengl/src_util.py +++ b/scripts/opengl/src_util.py @@ -2,25 +2,23 @@ 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', @@ -39,14 +37,8 @@ EXTENSIONS = [ '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 @@ -60,7 +52,7 @@ def getHybridInterface (): 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') @@ -80,15 +72,15 @@ def getHybridInterface (): 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" } @@ -124,93 +116,6 @@ def getFunctionMemberName (funcName): 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: @@ -232,70 +137,10 @@ def commandParams(command): 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 diff --git a/targets/x11_egl_glx/x11_egl_glx.cmake b/targets/x11_egl_glx/x11_egl_glx.cmake index 438b85f..3772922 100644 --- a/targets/x11_egl_glx/x11_egl_glx.cmake +++ b/targets/x11_egl_glx/x11_egl_glx.cmake @@ -1,7 +1,7 @@ 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) @@ -16,5 +16,12 @@ if (NOT X11_FOUND) 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}) -- 2.7.4