Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(31)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: ui/gfx/gl/generate_bindings.py

Issue 10392068: ui: Move gl/ directory out of gfx/, up to ui/. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: fix mac_rel Created 8 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « ui/gfx/gl/egl_util.cc ('k') | ui/gfx/gl/gl.gyp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: ui/gfx/gl/generate_bindings.py
diff --git a/ui/gfx/gl/generate_bindings.py b/ui/gfx/gl/generate_bindings.py
deleted file mode 100755
index b01fea7687ecbd08930a3dc0069c87b89992158b..0000000000000000000000000000000000000000
--- a/ui/gfx/gl/generate_bindings.py
+++ /dev/null
@@ -1,1531 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2012 The Chromium Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""code generator for GL/GLES extension wrangler."""
-
-import os
-import collections
-import re
-import sys
-
-GL_FUNCTIONS = [
-{ 'return_type': 'void',
- 'names': ['glActiveTexture'],
- 'arguments': 'GLenum texture', },
-{ 'return_type': 'void',
- 'names': ['glAttachShader'],
- 'arguments': 'GLuint program, GLuint shader', },
-{ 'return_type': 'void',
- 'names': ['glBeginQuery'],
- 'arguments': 'GLenum target, GLuint id', },
-{ 'return_type': 'void',
- 'names': ['glBeginQueryARB', 'glBeginQueryEXT'],
- 'arguments': 'GLenum target, GLuint id', },
-{ 'return_type': 'void',
- 'names': ['glBindAttribLocation'],
- 'arguments': 'GLuint program, GLuint index, const char* name', },
-{ 'return_type': 'void',
- 'names': ['glBindBuffer'],
- 'arguments': 'GLenum target, GLuint buffer', },
-{ 'return_type': 'void',
- 'names': ['glBindFragDataLocation'],
- 'arguments': 'GLuint program, GLuint colorNumber, const char* name', },
-{ 'return_type': 'void',
- 'names': ['glBindFragDataLocationIndexed'],
- 'arguments':
- 'GLuint program, GLuint colorNumber, GLuint index, const char* name', },
-{ 'return_type': 'void',
- 'names': ['glBindFramebufferEXT', 'glBindFramebuffer'],
- 'arguments': 'GLenum target, GLuint framebuffer', },
-{ 'return_type': 'void',
- 'names': ['glBindRenderbufferEXT', 'glBindRenderbuffer'],
- 'arguments': 'GLenum target, GLuint renderbuffer', },
-{ 'return_type': 'void',
- 'names': ['glBindTexture'],
- 'arguments': 'GLenum target, GLuint texture', },
-{ 'return_type': 'void',
- 'names': ['glBlendColor'],
- 'arguments': 'GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha', },
-{ 'return_type': 'void',
- 'names': ['glBlendEquation'],
- 'arguments': ' GLenum mode ', },
-{ 'return_type': 'void',
- 'names': ['glBlendEquationSeparate'],
- 'arguments': 'GLenum modeRGB, GLenum modeAlpha', },
-{ 'return_type': 'void',
- 'names': ['glBlendFunc'],
- 'arguments': 'GLenum sfactor, GLenum dfactor', },
-{ 'return_type': 'void',
- 'names': ['glBlendFuncSeparate'],
- 'arguments':
- 'GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha', },
-{ 'return_type': 'void',
- 'names': ['glBlitFramebufferEXT', 'glBlitFramebuffer'],
- 'arguments': 'GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, '
- 'GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, '
- 'GLbitfield mask, GLenum filter', },
-{ 'return_type': 'void',
- 'names': ['glBlitFramebufferANGLE', 'glBlitFramebuffer'],
- 'arguments': 'GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, '
- 'GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, '
- 'GLbitfield mask, GLenum filter', },
-{ 'return_type': 'void',
- 'names': ['glBufferData'],
- 'arguments': 'GLenum target, GLsizei size, const void* data, GLenum usage', },
-{ 'return_type': 'void',
- 'names': ['glBufferSubData'],
- 'arguments': 'GLenum target, GLint offset, GLsizei size, const void* data', },
-{ 'return_type': 'GLenum',
- 'names': ['glCheckFramebufferStatusEXT',
- 'glCheckFramebufferStatus'],
- 'arguments': 'GLenum target',
- 'logging_code': """
- GL_SERVICE_LOG("GL_RESULT: " << GLES2Util::GetStringEnum(result));
-""", },
-{ 'return_type': 'void',
- 'names': ['glClear'],
- 'arguments': 'GLbitfield mask', },
-{ 'return_type': 'void',
- 'names': ['glClearColor'],
- 'arguments': 'GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha', },
-{ 'return_type': 'void',
- 'names': ['glClearDepth'],
- 'arguments': 'GLclampd depth', },
-{ 'return_type': 'void',
- 'names': ['glClearDepthf'],
- 'arguments': 'GLclampf depth', },
-{ 'return_type': 'void',
- 'names': ['glClearStencil'],
- 'arguments': 'GLint s', },
-{ 'return_type': 'void',
- 'names': ['glColorMask'],
- 'arguments':
- 'GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha', },
-{ 'return_type': 'void',
- 'names': ['glCompileShader'],
- 'arguments': 'GLuint shader', },
-{ 'return_type': 'void',
- 'names': ['glCompressedTexImage2D'],
- 'arguments':
- 'GLenum target, GLint level, GLenum internalformat, GLsizei width, '
- 'GLsizei height, GLint border, GLsizei imageSize, const void* data', },
-{ 'return_type': 'void',
- 'names': ['glCompressedTexSubImage2D'],
- 'arguments':
- 'GLenum target, GLint level, GLint xoffset, GLint yoffset, '
- 'GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, '
- 'const void* data', },
-{ 'return_type': 'void',
- 'names': ['glCopyTexImage2D'],
- 'arguments':
- 'GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, '
- 'GLsizei width, GLsizei height, GLint border', },
-{ 'return_type': 'void',
- 'names': ['glCopyTexSubImage2D'],
- 'arguments':
- 'GLenum target, GLint level, GLint xoffset, '
- 'GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height', },
-{ 'return_type': 'GLuint',
- 'names': ['glCreateProgram'],
- 'arguments': 'void', },
-{ 'return_type': 'GLuint',
- 'names': ['glCreateShader'],
- 'arguments': 'GLenum type', },
-{ 'return_type': 'void',
- 'names': ['glCullFace'],
- 'arguments': 'GLenum mode', },
-{ 'return_type': 'void',
- 'names': ['glDeleteBuffersARB', 'glDeleteBuffers'],
- 'arguments': 'GLsizei n, const GLuint* buffers', },
-{ 'return_type': 'void',
- 'names': ['glDeleteFramebuffersEXT', 'glDeleteFramebuffers'],
- 'arguments': 'GLsizei n, const GLuint* framebuffers', },
-{ 'return_type': 'void',
- 'names': ['glDeleteProgram'],
- 'arguments': 'GLuint program', },
-{ 'return_type': 'void',
- 'names': ['glDeleteQueries'],
- 'arguments': 'GLsizei n, const GLuint* ids', },
-{ 'return_type': 'void',
- 'names': ['glDeleteQueriesARB', 'glDeleteQueriesEXT'],
- 'arguments': 'GLsizei n, const GLuint* ids', },
-{ 'return_type': 'void',
- 'names': ['glDeleteRenderbuffersEXT', 'glDeleteRenderbuffers'],
- 'arguments': 'GLsizei n, const GLuint* renderbuffers', },
-{ 'return_type': 'void',
- 'names': ['glDeleteShader'],
- 'arguments': 'GLuint shader', },
-{ 'return_type': 'void',
- 'names': ['glDeleteTextures'],
- 'arguments': 'GLsizei n, const GLuint* textures', },
-{ 'return_type': 'void',
- 'names': ['glDepthFunc'],
- 'arguments': 'GLenum func', },
-{ 'return_type': 'void',
- 'names': ['glDepthMask'],
- 'arguments': 'GLboolean flag', },
-{ 'return_type': 'void',
- 'names': ['glDepthRange'],
- 'arguments': 'GLclampd zNear, GLclampd zFar', },
-{ 'return_type': 'void',
- 'names': ['glDepthRangef'],
- 'arguments': 'GLclampf zNear, GLclampf zFar', },
-{ 'return_type': 'void',
- 'names': ['glDetachShader'],
- 'arguments': 'GLuint program, GLuint shader', },
-{ 'return_type': 'void',
- 'names': ['glDisable'],
- 'arguments': 'GLenum cap', },
-{ 'return_type': 'void',
- 'names': ['glDisableVertexAttribArray'],
- 'arguments': 'GLuint index', },
-{ 'return_type': 'void',
- 'names': ['glDrawArrays'],
- 'arguments': 'GLenum mode, GLint first, GLsizei count', },
-{ 'return_type': 'void',
- 'names': ['glDrawBuffer'],
- 'arguments': 'GLenum mode', },
-{ 'return_type': 'void',
- 'names': ['glDrawBuffersARB'],
- 'arguments': 'GLsizei n, const GLenum* bufs', },
-{ 'return_type': 'void',
- 'names': ['glDrawElements'],
- 'arguments':
- 'GLenum mode, GLsizei count, GLenum type, const void* indices', },
-{ 'return_type': 'void',
- 'names': ['glEGLImageTargetTexture2DOES'],
- 'arguments': 'GLenum target, GLeglImageOES image', },
-{ 'return_type': 'void',
- 'names': ['glEGLImageTargetRenderbufferStorageOES'],
- 'arguments': 'GLenum target, GLeglImageOES image', },
-{ 'return_type': 'void',
- 'names': ['glEnable'],
- 'arguments': 'GLenum cap', },
-{ 'return_type': 'void',
- 'names': ['glEnableVertexAttribArray'],
- 'arguments': 'GLuint index', },
-{ 'return_type': 'void',
- 'names': ['glEndQuery'],
- 'arguments': 'GLenum target', },
-{ 'return_type': 'void',
- 'names': ['glEndQueryARB', 'glEndQueryEXT'],
- 'arguments': 'GLenum target', },
-{ 'return_type': 'void',
- 'names': ['glFinish'],
- 'arguments': 'void', },
-{ 'return_type': 'void',
- 'names': ['glFlush'],
- 'arguments': 'void', },
-{ 'return_type': 'void',
- 'names': ['glFramebufferRenderbufferEXT', 'glFramebufferRenderbuffer'],
- 'arguments': \
- 'GLenum target, GLenum attachment, GLenum renderbuffertarget, '
- 'GLuint renderbuffer', },
-{ 'return_type': 'void',
- 'names': ['glFramebufferTexture2DEXT', 'glFramebufferTexture2D'],
- 'arguments':
- 'GLenum target, GLenum attachment, GLenum textarget, GLuint texture, '
- 'GLint level', },
-{ 'return_type': 'void',
- 'names': ['glFrontFace'],
- 'arguments': 'GLenum mode', },
-{ 'return_type': 'void',
- 'names': ['glGenBuffersARB', 'glGenBuffers'],
- 'arguments': 'GLsizei n, GLuint* buffers', },
-{ 'return_type': 'void',
- 'names': ['glGenQueries'],
- 'arguments': 'GLsizei n, GLuint* ids', },
-{ 'return_type': 'void',
- 'names': ['glGenQueriesARB', 'glGenQueriesEXT'],
- 'arguments': 'GLsizei n, GLuint* ids', },
-{ 'return_type': 'void',
- 'names': ['glGenerateMipmapEXT', 'glGenerateMipmap'],
- 'arguments': 'GLenum target', },
-{ 'return_type': 'void',
- 'names': ['glGenFramebuffersEXT', 'glGenFramebuffers'],
- 'arguments': 'GLsizei n, GLuint* framebuffers', },
-{ 'return_type': 'void',
- 'names': ['glGenRenderbuffersEXT', 'glGenRenderbuffers'],
- 'arguments': 'GLsizei n, GLuint* renderbuffers', },
-{ 'return_type': 'void',
- 'names': ['glGenTextures'],
- 'arguments': 'GLsizei n, GLuint* textures', },
-{ 'return_type': 'void',
- 'names': ['glGetActiveAttrib'],
- 'arguments':
- 'GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, '
- 'GLint* size, GLenum* type, char* name', },
-{ 'return_type': 'void',
- 'names': ['glGetActiveUniform'],
- 'arguments':
- 'GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, '
- 'GLint* size, GLenum* type, char* name', },
-{ 'return_type': 'void',
- 'names': ['glGetAttachedShaders'],
- 'arguments':
- 'GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders', },
-{ 'return_type': 'GLint',
- 'names': ['glGetAttribLocation'],
- 'arguments': 'GLuint program, const char* name', },
-{ 'return_type': 'void',
- 'names': ['glGetBooleanv'],
- 'arguments': 'GLenum pname, GLboolean* params', },
-{ 'return_type': 'void',
- 'names': ['glGetBufferParameteriv'],
- 'arguments': 'GLenum target, GLenum pname, GLint* params', },
-{ 'return_type': 'GLenum',
- 'names': ['glGetError'],
- 'arguments': 'void',
- 'logging_code': """
- GL_SERVICE_LOG("GL_RESULT: " << GLES2Util::GetStringError(result));
-""", },
-{ 'return_type': 'void',
- 'names': ['glGetFloatv'],
- 'arguments': 'GLenum pname, GLfloat* params', },
-{ 'return_type': 'void',
- 'names': ['glGetFramebufferAttachmentParameterivEXT',
- 'glGetFramebufferAttachmentParameteriv'],
- 'arguments': 'GLenum target, '
- 'GLenum attachment, GLenum pname, GLint* params', },
-{ 'return_type': 'GLenum',
- 'names': ['glGetGraphicsResetStatusARB'],
- 'arguments': 'void', },
-{ 'return_type': 'void',
- 'names': ['glGetIntegerv'],
- 'arguments': 'GLenum pname, GLint* params', },
-{ 'return_type': 'void',
- 'names': ['glGetProgramiv'],
- 'arguments': 'GLuint program, GLenum pname, GLint* params', },
-{ 'return_type': 'void',
- 'names': ['glGetProgramInfoLog'],
- 'arguments':
- 'GLuint program, GLsizei bufsize, GLsizei* length, char* infolog', },
-{ 'return_type': 'void',
- 'names': ['glGetQueryiv'],
- 'arguments': 'GLenum target, GLenum pname, GLint* params', },
-{ 'return_type': 'void',
- 'names': ['glGetQueryivARB', 'glGetQueryivEXT'],
- 'arguments': 'GLenum target, GLenum pname, GLint* params', },
-{ 'return_type': 'void',
- 'names': ['glGetQueryObjecti64v'],
- 'arguments': 'GLuint id, GLenum pname, GLint64* params', },
-{ 'return_type': 'void',
- 'names': ['glGetQueryObjectiv'],
- 'arguments': 'GLuint id, GLenum pname, GLint* params', },
-{ 'return_type': 'void',
- 'names': ['glGetQueryObjectui64v'],
- 'arguments': 'GLuint id, GLenum pname, GLuint64* params', },
-{ 'return_type': 'void',
- 'names': ['glGetQueryObjectuiv'],
- 'arguments': 'GLuint id, GLenum pname, GLuint* params', },
-{ 'return_type': 'void',
- 'names': ['glGetQueryObjectuivARB', 'glGetQueryObjectuivEXT'],
- 'arguments': 'GLuint id, GLenum pname, GLuint* params', },
-{ 'return_type': 'void',
- 'names': ['glGetRenderbufferParameterivEXT', 'glGetRenderbufferParameteriv'],
- 'arguments': 'GLenum target, GLenum pname, GLint* params', },
-{ 'return_type': 'void',
- 'names': ['glGetShaderiv'],
- 'arguments': 'GLuint shader, GLenum pname, GLint* params', },
-{ 'return_type': 'void',
- 'names': ['glGetShaderInfoLog'],
- 'arguments':
- 'GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog', },
-{ 'return_type': 'void',
- 'names': ['glGetShaderPrecisionFormat'],
- 'arguments': 'GLenum shadertype, GLenum precisiontype, '
- 'GLint* range, GLint* precision', },
-{ 'return_type': 'void',
- 'names': ['glGetShaderSource'],
- 'arguments':
- 'GLuint shader, GLsizei bufsize, GLsizei* length, char* source', },
-{ 'return_type': 'const GLubyte*',
- 'names': ['glGetString'],
- 'arguments': 'GLenum name', },
-{ 'return_type': 'void',
- 'names': ['glGetTexLevelParameterfv'],
- 'arguments': 'GLenum target, GLint level, GLenum pname, GLfloat* params', },
-{ 'return_type': 'void',
- 'names': ['glGetTexLevelParameteriv'],
- 'arguments': 'GLenum target, GLint level, GLenum pname, GLint* params', },
-{ 'return_type': 'void',
- 'names': ['glGetTexParameterfv'],
- 'arguments': 'GLenum target, GLenum pname, GLfloat* params', },
-{ 'return_type': 'void',
- 'names': ['glGetTexParameteriv'],
- 'arguments': 'GLenum target, GLenum pname, GLint* params', },
-{ 'return_type': 'void',
- 'names': ['glGetTranslatedShaderSourceANGLE'],
- 'arguments':
- 'GLuint shader, GLsizei bufsize, GLsizei* length, char* source', },
-{ 'return_type': 'void',
- 'names': ['glGetUniformfv'],
- 'arguments': 'GLuint program, GLint location, GLfloat* params', },
-{ 'return_type': 'void',
- 'names': ['glGetUniformiv'],
- 'arguments': 'GLuint program, GLint location, GLint* params', },
-{ 'return_type': 'GLint',
- 'names': ['glGetUniformLocation'],
- 'arguments': 'GLuint program, const char* name', },
-{ 'return_type': 'void',
- 'names': ['glGetVertexAttribfv'],
- 'arguments': 'GLuint index, GLenum pname, GLfloat* params', },
-{ 'return_type': 'void',
- 'names': ['glGetVertexAttribiv'],
- 'arguments': 'GLuint index, GLenum pname, GLint* params', },
-{ 'return_type': 'void',
- 'names': ['glGetVertexAttribPointerv'],
- 'arguments': 'GLuint index, GLenum pname, void** pointer', },
-{ 'return_type': 'void',
- 'names': ['glHint'],
- 'arguments': 'GLenum target, GLenum mode', },
-{ 'return_type': 'GLboolean',
- 'names': ['glIsBuffer'],
- 'arguments': 'GLuint buffer', },
-{ 'return_type': 'GLboolean',
- 'names': ['glIsEnabled'],
- 'arguments': 'GLenum cap', },
-{ 'return_type': 'GLboolean',
- 'names': ['glIsFramebufferEXT', 'glIsFramebuffer'],
- 'arguments': 'GLuint framebuffer', },
-{ 'return_type': 'GLboolean',
- 'names': ['glIsProgram'],
- 'arguments': 'GLuint program', },
-{ 'return_type': 'GLboolean',
- 'names': ['glIsQueryARB', 'glIsQueryEXT'],
- 'arguments': 'GLuint query', },
-{ 'return_type': 'GLboolean',
- 'names': ['glIsRenderbufferEXT', 'glIsRenderbuffer'],
- 'arguments': 'GLuint renderbuffer', },
-{ 'return_type': 'GLboolean',
- 'names': ['glIsShader'],
- 'arguments': 'GLuint shader', },
-{ 'return_type': 'GLboolean',
- 'names': ['glIsTexture'],
- 'arguments': 'GLuint texture', },
-{ 'return_type': 'void',
- 'names': ['glLineWidth'],
- 'arguments': 'GLfloat width', },
-{ 'return_type': 'void',
- 'names': ['glLinkProgram'],
- 'arguments': 'GLuint program', },
-{ 'return_type': 'void*',
- 'names': ['glMapBuffer', 'glMapBufferOES'],
- 'arguments': 'GLenum target, GLenum access', },
-{ 'return_type': 'void',
- 'names': ['glPixelStorei'],
- 'arguments': 'GLenum pname, GLint param', },
-{ 'return_type': 'void',
- 'names': ['glPolygonOffset'],
- 'arguments': 'GLfloat factor, GLfloat units', },
-{ 'return_type': 'void',
- 'names': ['glQueryCounter'],
- 'arguments': 'GLuint id, GLenum target', },
-{ 'return_type': 'void',
- 'names': ['glReadBuffer'],
- 'arguments': 'GLenum src', },
-{ 'return_type': 'void',
- 'names': ['glReadPixels'],
- 'arguments':
- 'GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, '
- 'GLenum type, void* pixels', },
-{ 'return_type': 'void',
- 'names': ['glReleaseShaderCompiler'],
- 'arguments': 'void', },
-{ 'return_type': 'void',
- 'names': ['glRenderbufferStorageMultisampleEXT',
- 'glRenderbufferStorageMultisample'],
- 'arguments': 'GLenum target, GLsizei samples, GLenum internalformat, '
- 'GLsizei width, GLsizei height', },
-{ 'return_type': 'void',
- 'names': ['glRenderbufferStorageMultisampleANGLE',
- 'glRenderbufferStorageMultisample'],
- 'arguments': 'GLenum target, GLsizei samples, GLenum internalformat, '
- 'GLsizei width, GLsizei height', },
-{ 'return_type': 'void',
- 'names': ['glRenderbufferStorageEXT', 'glRenderbufferStorage'],
- 'arguments':
- 'GLenum target, GLenum internalformat, GLsizei width, GLsizei height', },
-{ 'return_type': 'void',
- 'names': ['glSampleCoverage'],
- 'arguments': 'GLclampf value, GLboolean invert', },
-{ 'return_type': 'void',
- 'names': ['glScissor'],
- 'arguments': 'GLint x, GLint y, GLsizei width, GLsizei height', },
-{ 'return_type': 'void',
- 'names': ['glShaderBinary'],
- 'arguments': 'GLsizei n, const GLuint* shaders, GLenum binaryformat, '
- 'const void* binary, GLsizei length', },
-{ 'return_type': 'void',
- 'names': ['glShaderSource'],
- 'arguments':
- 'GLuint shader, GLsizei count, const char** str, const GLint* length',
- 'logging_code': """
- GL_SERVICE_LOG_CODE_BLOCK({
- for (GLsizei ii = 0; ii < count; ++ii) {
- if (str[ii]) {
- if (length && length[ii] >= 0) {
- std::string source(str[ii], length[ii]);
- GL_SERVICE_LOG(" " << ii << ": ---\\n" << source << "\\n---");
- } else {
- GL_SERVICE_LOG(" " << ii << ": ---\\n" << str[ii] << "\\n---");
- }
- } else {
- GL_SERVICE_LOG(" " << ii << ": NULL");
- }
- }
- });
-""", },
-{ 'return_type': 'void',
- 'names': ['glStencilFunc'],
- 'arguments': 'GLenum func, GLint ref, GLuint mask', },
-{ 'return_type': 'void',
- 'names': ['glStencilFuncSeparate'],
- 'arguments': 'GLenum face, GLenum func, GLint ref, GLuint mask', },
-{ 'return_type': 'void',
- 'names': ['glStencilMask'],
- 'arguments': 'GLuint mask', },
-{ 'return_type': 'void',
- 'names': ['glStencilMaskSeparate'],
- 'arguments': 'GLenum face, GLuint mask', },
-{ 'return_type': 'void',
- 'names': ['glStencilOp'],
- 'arguments': 'GLenum fail, GLenum zfail, GLenum zpass', },
-{ 'return_type': 'void',
- 'names': ['glStencilOpSeparate'],
- 'arguments': 'GLenum face, GLenum fail, GLenum zfail, GLenum zpass', },
-{ 'return_type': 'void',
- 'names': ['glTexImage2D'],
- 'arguments':
- 'GLenum target, GLint level, GLint internalformat, GLsizei width, '
- 'GLsizei height, GLint border, GLenum format, GLenum type, '
- 'const void* pixels', },
-{ 'return_type': 'void',
- 'names': ['glTexParameterf'],
- 'arguments': 'GLenum target, GLenum pname, GLfloat param', },
-{ 'return_type': 'void',
- 'names': ['glTexParameterfv'],
- 'arguments': 'GLenum target, GLenum pname, const GLfloat* params', },
-{ 'return_type': 'void',
- 'names': ['glTexParameteri'],
- 'arguments': 'GLenum target, GLenum pname, GLint param', },
-{ 'return_type': 'void',
- 'names': ['glTexParameteriv'],
- 'arguments': 'GLenum target, GLenum pname, const GLint* params', },
-{ 'return_type': 'void',
- 'names': ['glTexStorage2DEXT'],
- 'arguments': 'GLenum target, GLsizei levels, GLenum internalformat, '
- 'GLsizei width, GLsizei height', },
-{ 'return_type': 'void',
- 'names': ['glTexSubImage2D'],
- 'arguments':
- 'GLenum target, GLint level, GLint xoffset, GLint yoffset, '
- 'GLsizei width, GLsizei height, GLenum format, GLenum type, '
- 'const void* pixels', },
-{ 'return_type': 'void',
- 'names': ['glUniform1f'],
- 'arguments': 'GLint location, GLfloat x', },
-{ 'return_type': 'void',
- 'names': ['glUniform1fv'],
- 'arguments': 'GLint location, GLsizei count, const GLfloat* v', },
-{ 'return_type': 'void',
- 'names': ['glUniform1i'],
- 'arguments': 'GLint location, GLint x', },
-{ 'return_type': 'void',
- 'names': ['glUniform1iv'],
- 'arguments': 'GLint location, GLsizei count, const GLint* v', },
-{ 'return_type': 'void',
- 'names': ['glUniform2f'],
- 'arguments': 'GLint location, GLfloat x, GLfloat y', },
-{ 'return_type': 'void',
- 'names': ['glUniform2fv'],
- 'arguments': 'GLint location, GLsizei count, const GLfloat* v', },
-{ 'return_type': 'void',
- 'names': ['glUniform2i'],
- 'arguments': 'GLint location, GLint x, GLint y', },
-{ 'return_type': 'void',
- 'names': ['glUniform2iv'],
- 'arguments': 'GLint location, GLsizei count, const GLint* v', },
-{ 'return_type': 'void',
- 'names': ['glUniform3f'],
- 'arguments': 'GLint location, GLfloat x, GLfloat y, GLfloat z', },
-{ 'return_type': 'void',
- 'names': ['glUniform3fv'],
- 'arguments': 'GLint location, GLsizei count, const GLfloat* v', },
-{ 'return_type': 'void',
- 'names': ['glUniform3i'],
- 'arguments': 'GLint location, GLint x, GLint y, GLint z', },
-{ 'return_type': 'void',
- 'names': ['glUniform3iv'],
- 'arguments': 'GLint location, GLsizei count, const GLint* v', },
-{ 'return_type': 'void',
- 'names': ['glUniform4f'],
- 'arguments': 'GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w', },
-{ 'return_type': 'void',
- 'names': ['glUniform4fv'],
- 'arguments': 'GLint location, GLsizei count, const GLfloat* v', },
-{ 'return_type': 'void',
- 'names': ['glUniform4i'],
- 'arguments': 'GLint location, GLint x, GLint y, GLint z, GLint w', },
-{ 'return_type': 'void',
- 'names': ['glUniform4iv'],
- 'arguments': 'GLint location, GLsizei count, const GLint* v', },
-{ 'return_type': 'void',
- 'names': ['glUniformMatrix2fv'],
- 'arguments': 'GLint location, GLsizei count, '
- 'GLboolean transpose, const GLfloat* value', },
-{ 'return_type': 'void',
- 'names': ['glUniformMatrix3fv'],
- 'arguments': 'GLint location, GLsizei count, '
- 'GLboolean transpose, const GLfloat* value', },
-{ 'return_type': 'void',
- 'names': ['glUniformMatrix4fv'],
- 'arguments': 'GLint location, GLsizei count, '
- 'GLboolean transpose, const GLfloat* value', },
-{ 'return_type': 'GLboolean',
- 'names': ['glUnmapBuffer', 'glUnmapBufferOES'],
- 'arguments': 'GLenum target', },
-{ 'return_type': 'void',
- 'names': ['glUseProgram'],
- 'arguments': 'GLuint program', },
-{ 'return_type': 'void',
- 'names': ['glValidateProgram'],
- 'arguments': 'GLuint program', },
-{ 'return_type': 'void',
- 'names': ['glVertexAttrib1f'],
- 'arguments': 'GLuint indx, GLfloat x', },
-{ 'return_type': 'void',
- 'names': ['glVertexAttrib1fv'],
- 'arguments': 'GLuint indx, const GLfloat* values', },
-{ 'return_type': 'void',
- 'names': ['glVertexAttrib2f'],
- 'arguments': 'GLuint indx, GLfloat x, GLfloat y', },
-{ 'return_type': 'void',
- 'names': ['glVertexAttrib2fv'],
- 'arguments': 'GLuint indx, const GLfloat* values', },
-{ 'return_type': 'void',
- 'names': ['glVertexAttrib3f'],
- 'arguments': 'GLuint indx, GLfloat x, GLfloat y, GLfloat z', },
-{ 'return_type': 'void',
- 'names': ['glVertexAttrib3fv'],
- 'arguments': 'GLuint indx, const GLfloat* values', },
-{ 'return_type': 'void',
- 'names': ['glVertexAttrib4f'],
- 'arguments': 'GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w', },
-{ 'return_type': 'void',
- 'names': ['glVertexAttrib4fv'],
- 'arguments': 'GLuint indx, const GLfloat* values', },
-{ 'return_type': 'void',
- 'names': ['glVertexAttribPointer'],
- 'arguments': 'GLuint indx, GLint size, GLenum type, GLboolean normalized, '
- 'GLsizei stride, const void* ptr', },
-{ 'return_type': 'void',
- 'names': ['glViewport'],
- 'arguments': 'GLint x, GLint y, GLsizei width, GLsizei height', },
-{ 'return_type': 'void',
- 'names': ['glGenFencesNV'],
- 'arguments': 'GLsizei n, GLuint* fences', },
-{ 'return_type': 'void',
- 'names': ['glDeleteFencesNV'],
- 'arguments': 'GLsizei n, const GLuint* fences', },
-{ 'return_type': 'void',
- 'names': ['glSetFenceNV'],
- 'arguments': 'GLuint fence, GLenum condition', },
-{ 'return_type': 'GLboolean',
- 'names': ['glTestFenceNV'],
- 'arguments': 'GLuint fence', },
-{ 'return_type': 'void',
- 'names': ['glFinishFenceNV'],
- 'arguments': 'GLuint fence', },
-{ 'return_type': 'GLboolean',
- 'names': ['glIsFenceNV'],
- 'arguments': 'GLuint fence', },
-{ 'return_type': 'void',
- 'names': ['glGetFenceivNV'],
- 'arguments': 'GLuint fence, GLenum pname, GLint* params', },
-{ 'return_type': 'GLsync',
- 'names': ['glFenceSync'],
- 'arguments': 'GLenum condition, GLbitfield flags', },
-{ 'return_type': 'void',
- 'names': ['glDeleteSync'],
- 'arguments': 'GLsync sync', },
-{ 'return_type': 'void',
- 'names': ['glGetSynciv'],
- 'arguments':
- 'GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length,'
- 'GLint* values', },
-{ 'return_type': 'void',
- 'names': ['glDrawArraysInstancedANGLE', 'glDrawArraysInstancedARB'],
- 'arguments': 'GLenum mode, GLint first, GLsizei count, GLsizei primcount', },
-{ 'return_type': 'void',
- 'names': ['glDrawElementsInstancedANGLE', 'glDrawElementsInstancedARB'],
- 'arguments':
- 'GLenum mode, GLsizei count, GLenum type, const void* indices, '
- 'GLsizei primcount', },
-{ 'return_type': 'void',
- 'names': ['glVertexAttribDivisorANGLE', 'glVertexAttribDivisorARB'],
- 'arguments':
- 'GLuint index, GLuint divisor', },
-]
-
-OSMESA_FUNCTIONS = [
-{ 'return_type': 'OSMesaContext',
- 'names': ['OSMesaCreateContext'],
- 'arguments': 'GLenum format, OSMesaContext sharelist', },
-{ 'return_type': 'OSMesaContext',
- 'names': ['OSMesaCreateContextExt'],
- 'arguments':
- 'GLenum format, GLint depthBits, GLint stencilBits, GLint accumBits, '
- 'OSMesaContext sharelist', },
-{ 'return_type': 'void',
- 'names': ['OSMesaDestroyContext'],
- 'arguments': 'OSMesaContext ctx', },
-{ 'return_type': 'GLboolean',
- 'names': ['OSMesaMakeCurrent'],
- 'arguments': 'OSMesaContext ctx, void* buffer, GLenum type, GLsizei width, '
- 'GLsizei height', },
-{ 'return_type': 'OSMesaContext',
- 'names': ['OSMesaGetCurrentContext'],
- 'arguments': 'void', },
-{ 'return_type': 'void',
- 'names': ['OSMesaPixelStore'],
- 'arguments': 'GLint pname, GLint value', },
-{ 'return_type': 'void',
- 'names': ['OSMesaGetIntegerv'],
- 'arguments': 'GLint pname, GLint* value', },
-{ 'return_type': 'GLboolean',
- 'names': ['OSMesaGetDepthBuffer'],
- 'arguments':
- 'OSMesaContext c, GLint* width, GLint* height, GLint* bytesPerValue, '
- 'void** buffer', },
-{ 'return_type': 'GLboolean',
- 'names': ['OSMesaGetColorBuffer'],
- 'arguments': 'OSMesaContext c, GLint* width, GLint* height, GLint* format, '
- 'void** buffer', },
-{ 'return_type': 'OSMESAproc',
- 'names': ['OSMesaGetProcAddress'],
- 'arguments': 'const char* funcName', },
-{ 'return_type': 'void',
- 'names': ['OSMesaColorClamp'],
- 'arguments': 'GLboolean enable', },
-]
-
-EGL_FUNCTIONS = [
-{ 'return_type': 'EGLint',
- 'names': ['eglGetError'],
- 'arguments': 'void', },
-{ 'return_type': 'EGLDisplay',
- 'names': ['eglGetDisplay'],
- 'arguments': 'EGLNativeDisplayType display_id', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglInitialize'],
- 'arguments': 'EGLDisplay dpy, EGLint* major, EGLint* minor', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglTerminate'],
- 'arguments': 'EGLDisplay dpy', },
-{ 'return_type': 'const char*',
- 'names': ['eglQueryString'],
- 'arguments': 'EGLDisplay dpy, EGLint name', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglGetConfigs'],
- 'arguments': 'EGLDisplay dpy, EGLConfig* configs, EGLint config_size, '
- 'EGLint* num_config', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglChooseConfig'],
- 'arguments': 'EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, '
- 'EGLint config_size, EGLint* num_config', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglGetConfigAttrib'],
- 'arguments':
- 'EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value', },
-{ 'return_type': 'EGLImageKHR',
- 'names': ['eglCreateImageKHR'],
- 'arguments':
- 'EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, '
- 'const EGLint* attrib_list',
- 'other_extensions': ['EGL_KHR_image_base'] },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglDestroyImageKHR'],
- 'arguments': 'EGLDisplay dpy, EGLImageKHR image',
- 'other_extensions': ['EGL_KHR_image_base'] },
-{ 'return_type': 'EGLSurface',
- 'names': ['eglCreateWindowSurface'],
- 'arguments': 'EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, '
- 'const EGLint* attrib_list', },
-{ 'return_type': 'EGLSurface',
- 'names': ['eglCreatePbufferSurface'],
- 'arguments': 'EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list', },
-{ 'return_type': 'EGLSurface',
- 'names': ['eglCreatePixmapSurface'],
- 'arguments': 'EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, '
- 'const EGLint* attrib_list', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglDestroySurface'],
- 'arguments': 'EGLDisplay dpy, EGLSurface surface', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglQuerySurface'],
- 'arguments':
- 'EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint* value', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglBindAPI'],
- 'arguments': 'EGLenum api', },
-{ 'return_type': 'EGLenum',
- 'names': ['eglQueryAPI'],
- 'arguments': 'void', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglWaitClient'],
- 'arguments': 'void', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglReleaseThread'],
- 'arguments': 'void', },
-{ 'return_type': 'EGLSurface',
- 'names': ['eglCreatePbufferFromClientBuffer'],
- 'arguments':
- 'EGLDisplay dpy, EGLenum buftype, void* buffer, EGLConfig config, '
- 'const EGLint* attrib_list', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglSurfaceAttrib'],
- 'arguments':
- 'EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglBindTexImage'],
- 'arguments': 'EGLDisplay dpy, EGLSurface surface, EGLint buffer', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglReleaseTexImage'],
- 'arguments': 'EGLDisplay dpy, EGLSurface surface, EGLint buffer', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglSwapInterval'],
- 'arguments': 'EGLDisplay dpy, EGLint interval', },
-{ 'return_type': 'EGLContext',
- 'names': ['eglCreateContext'],
- 'arguments': 'EGLDisplay dpy, EGLConfig config, EGLContext share_context, '
- 'const EGLint* attrib_list', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglDestroyContext'],
- 'arguments': 'EGLDisplay dpy, EGLContext ctx', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglMakeCurrent'],
- 'arguments':
- 'EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx', },
-{ 'return_type': 'EGLContext',
- 'names': ['eglGetCurrentContext'],
- 'arguments': 'void', },
-{ 'return_type': 'EGLSurface',
- 'names': ['eglGetCurrentSurface'],
- 'arguments': 'EGLint readdraw', },
-{ 'return_type': 'EGLDisplay',
- 'names': ['eglGetCurrentDisplay'],
- 'arguments': 'void', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglQueryContext'],
- 'arguments':
- 'EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglWaitGL'],
- 'arguments': 'void', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglWaitNative'],
- 'arguments': 'EGLint engine', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglSwapBuffers'],
- 'arguments': 'EGLDisplay dpy, EGLSurface surface', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglCopyBuffers'],
- 'arguments':
- 'EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target', },
-{ 'return_type': '__eglMustCastToProperFunctionPointerType',
- 'names': ['eglGetProcAddress'],
- 'arguments': 'const char* procname', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglPostSubBufferNV'],
- 'arguments': 'EGLDisplay dpy, EGLSurface surface, '
- 'EGLint x, EGLint y, EGLint width, EGLint height', },
-{ 'return_type': 'EGLBoolean',
- 'names': ['eglQuerySurfacePointerANGLE'],
- 'arguments':
- 'EGLDisplay dpy, EGLSurface surface, EGLint attribute, void** value', },
-]
-
-WGL_FUNCTIONS = [
-{ 'return_type': 'HGLRC',
- 'names': ['wglCreateContext'],
- 'arguments': 'HDC hdc', },
-{ 'return_type': 'HGLRC',
- 'names': ['wglCreateLayerContext'],
- 'arguments': 'HDC hdc, int iLayerPlane', },
-{ 'return_type': 'BOOL',
- 'names': ['wglCopyContext'],
- 'arguments': 'HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask', },
-{ 'return_type': 'BOOL',
- 'names': ['wglDeleteContext'],
- 'arguments': 'HGLRC hglrc', },
-{ 'return_type': 'HGLRC',
- 'names': ['wglGetCurrentContext'],
- 'arguments': '', },
-{ 'return_type': 'HDC',
- 'names': ['wglGetCurrentDC'],
- 'arguments': '', },
-{ 'return_type': 'BOOL',
- 'names': ['wglMakeCurrent'],
- 'arguments': 'HDC hdc, HGLRC hglrc', },
-{ 'return_type': 'BOOL',
- 'names': ['wglShareLists'],
- 'arguments': 'HGLRC hglrc1, HGLRC hglrc2', },
-{ 'return_type': 'BOOL',
- 'names': ['wglSwapIntervalEXT'],
- 'arguments': 'int interval', },
-{ 'return_type': 'BOOL',
- 'names': ['wglSwapLayerBuffers'],
- 'arguments': 'HDC hdc, UINT fuPlanes', },
-{ 'return_type': 'const char*',
- 'names': ['wglGetExtensionsStringARB'],
- 'arguments': 'HDC hDC', },
-{ 'return_type': 'const char*',
- 'names': ['wglGetExtensionsStringEXT'],
- 'arguments': '', },
-{ 'return_type': 'BOOL',
- 'names': ['wglChoosePixelFormatARB'],
- 'arguments':
- 'HDC dc, const int* int_attrib_list, const float* float_attrib_list, '
- 'UINT max_formats, int* formats, UINT* num_formats', },
-{ 'return_type': 'HPBUFFERARB',
- 'names': ['wglCreatePbufferARB'],
- 'arguments': 'HDC hDC, int iPixelFormat, int iWidth, int iHeight, '
- 'const int* piAttribList', },
-{ 'return_type': 'HDC',
- 'names': ['wglGetPbufferDCARB'],
- 'arguments': 'HPBUFFERARB hPbuffer', },
-{ 'return_type': 'int',
- 'names': ['wglReleasePbufferDCARB'],
- 'arguments': 'HPBUFFERARB hPbuffer, HDC hDC', },
-{ 'return_type': 'BOOL',
- 'names': ['wglDestroyPbufferARB'],
- 'arguments': 'HPBUFFERARB hPbuffer', },
-{ 'return_type': 'BOOL',
- 'names': ['wglQueryPbufferARB'],
- 'arguments': 'HPBUFFERARB hPbuffer, int iAttribute, int* piValue', },
-]
-
-GLX_FUNCTIONS = [
-{ 'return_type': 'XVisualInfo*',
- 'names': ['glXChooseVisual'],
- 'arguments': 'Display* dpy, int screen, int* attribList', },
-{ 'return_type': 'void',
- 'names': ['glXCopySubBufferMESA'],
- 'arguments': 'Display* dpy, GLXDrawable drawable, '
- 'int x, int y, int width, int height', },
-{ 'return_type': 'GLXContext',
- 'names': ['glXCreateContext'],
- 'arguments':
- 'Display* dpy, XVisualInfo* vis, GLXContext shareList, int direct', },
-{ 'return_type': 'void',
- 'names': ['glXBindTexImageEXT'],
- 'arguments':
- 'Display* dpy, GLXDrawable drawable, int buffer, int* attribList', },
-{ 'return_type': 'void',
- 'names': ['glXReleaseTexImageEXT'],
- 'arguments': 'Display* dpy, GLXDrawable drawable, int buffer', },
-{ 'return_type': 'void',
- 'names': ['glXDestroyContext'],
- 'arguments': 'Display* dpy, GLXContext ctx', },
-{ 'return_type': 'int',
- 'names': ['glXMakeCurrent'],
- 'arguments': 'Display* dpy, GLXDrawable drawable, GLXContext ctx', },
-{ 'return_type': 'void',
- 'names': ['glXCopyContext'],
- 'arguments':
- 'Display* dpy, GLXContext src, GLXContext dst, unsigned long mask', },
-{ 'return_type': 'void',
- 'names': ['glXSwapBuffers'],
- 'arguments': 'Display* dpy, GLXDrawable drawable', },
-{ 'return_type': 'GLXPixmap',
- 'names': ['glXCreateGLXPixmap'],
- 'arguments': 'Display* dpy, XVisualInfo* visual, Pixmap pixmap', },
-{ 'return_type': 'void',
- 'names': ['glXDestroyGLXPixmap'],
- 'arguments': 'Display* dpy, GLXPixmap pixmap', },
-{ 'return_type': 'int',
- 'names': ['glXQueryExtension'],
- 'arguments': 'Display* dpy, int* errorb, int* event', },
-{ 'return_type': 'int',
- 'names': ['glXQueryVersion'],
- 'arguments': 'Display* dpy, int* maj, int* min', },
-{ 'return_type': 'int',
- 'names': ['glXIsDirect'],
- 'arguments': 'Display* dpy, GLXContext ctx', },
-{ 'return_type': 'int',
- 'names': ['glXGetConfig'],
- 'arguments': 'Display* dpy, XVisualInfo* visual, int attrib, int* value', },
-{ 'return_type': 'GLXContext',
- 'names': ['glXGetCurrentContext'],
- 'arguments': 'void', },
-{ 'return_type': 'GLXDrawable',
- 'names': ['glXGetCurrentDrawable'],
- 'arguments': 'void', },
-{ 'return_type': 'void',
- 'names': ['glXWaitGL'],
- 'arguments': 'void', },
-{ 'return_type': 'void',
- 'names': ['glXWaitX'],
- 'arguments': 'void', },
-{ 'return_type': 'void',
- 'names': ['glXUseXFont'],
- 'arguments': 'Font font, int first, int count, int list', },
-{ 'return_type': 'const char*',
- 'names': ['glXQueryExtensionsString'],
- 'arguments': 'Display* dpy, int screen', },
-{ 'return_type': 'const char*',
- 'names': ['glXQueryServerString'],
- 'arguments': 'Display* dpy, int screen, int name', },
-{ 'return_type': 'const char*',
- 'names': ['glXGetClientString'],
- 'arguments': 'Display* dpy, int name', },
-{ 'return_type': 'Display*',
- 'names': ['glXGetCurrentDisplay'],
- 'arguments': 'void', },
-{ 'return_type': 'GLXFBConfig*',
- 'names': ['glXChooseFBConfig'],
- 'arguments':
- 'Display* dpy, int screen, const int* attribList, int* nitems', },
-{ 'return_type': 'int',
- 'names': ['glXGetFBConfigAttrib'],
- 'arguments': 'Display* dpy, GLXFBConfig config, int attribute, int* value', },
-{ 'return_type': 'GLXFBConfig*',
- 'names': ['glXGetFBConfigs'],
- 'arguments': 'Display* dpy, int screen, int* nelements', },
-{ 'return_type': 'XVisualInfo*',
- 'names': ['glXGetVisualFromFBConfig'],
- 'arguments': 'Display* dpy, GLXFBConfig config', },
-{ 'return_type': 'GLXWindow',
- 'names': ['glXCreateWindow'],
- 'arguments':
- 'Display* dpy, GLXFBConfig config, Window win, const int* attribList', },
-{ 'return_type': 'void',
- 'names': ['glXDestroyWindow'],
- 'arguments': 'Display* dpy, GLXWindow window', },
-{ 'return_type': 'GLXPixmap',
- 'names': ['glXCreatePixmap'],
- 'arguments': 'Display* dpy, GLXFBConfig config, '
- 'Pixmap pixmap, const int* attribList', },
-{ 'return_type': 'void',
- 'names': ['glXDestroyPixmap'],
- 'arguments': 'Display* dpy, GLXPixmap pixmap', },
-{ 'return_type': 'GLXPbuffer',
- 'names': ['glXCreatePbuffer'],
- 'arguments': 'Display* dpy, GLXFBConfig config, const int* attribList', },
-{ 'return_type': 'void',
- 'names': ['glXDestroyPbuffer'],
- 'arguments': 'Display* dpy, GLXPbuffer pbuf', },
-{ 'return_type': 'void',
- 'names': ['glXQueryDrawable'],
- 'arguments':
- 'Display* dpy, GLXDrawable draw, int attribute, unsigned int* value', },
-{ 'return_type': 'GLXContext',
- 'names': ['glXCreateNewContext'],
- 'arguments': 'Display* dpy, GLXFBConfig config, int renderType, '
- 'GLXContext shareList, int direct', },
-{ 'return_type': 'int',
- 'names': ['glXMakeContextCurrent'],
- 'arguments':
- 'Display* dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx', },
-{ 'return_type': 'GLXDrawable',
- 'names': ['glXGetCurrentReadDrawable'],
- 'arguments': 'void', },
-{ 'return_type': 'int',
- 'names': ['glXQueryContext'],
- 'arguments': 'Display* dpy, GLXContext ctx, int attribute, int* value', },
-{ 'return_type': 'void',
- 'names': ['glXSelectEvent'],
- 'arguments': 'Display* dpy, GLXDrawable drawable, unsigned long mask', },
-{ 'return_type': 'void',
- 'names': ['glXGetSelectedEvent'],
- 'arguments': 'Display* dpy, GLXDrawable drawable, unsigned long* mask', },
-{ 'return_type': 'void',
- 'names': ['glXSwapIntervalEXT'],
- 'arguments': 'Display* dpy, GLXDrawable drawable, int interval', },
-{ 'return_type': 'GLXFBConfig',
- 'names': ['glXGetFBConfigFromVisualSGIX'],
- 'arguments': 'Display* dpy, XVisualInfo* visualInfo', },
-{ 'return_type': 'GLXContext',
- 'names': ['glXCreateContextAttribsARB'],
- 'arguments':
- 'Display* dpy, GLXFBConfig config, GLXContext share_context, int direct, '
- 'const int* attrib_list', },
-]
-
-FUNCTION_SETS = [
- [GL_FUNCTIONS, 'gl', ['../../../third_party/mesa/MesaLib/include/GL/glext.h',
- '../../../third_party/khronos/GLES2/gl2ext.h'], []],
- [OSMESA_FUNCTIONS, 'osmesa', [], []],
- [EGL_FUNCTIONS, 'egl', ['../../../third_party/khronos/EGL/eglext.h'],
- [
- 'EGL_ANGLE_d3d_share_handle_client_buffer',
- ],
- ],
- [WGL_FUNCTIONS, 'wgl', [
- '../../../third_party/mesa/MesaLib/include/GL/wglext.h'], []],
- [GLX_FUNCTIONS, 'glx', [
- '../../../third_party/mesa/MesaLib/include/GL/glxext.h'], []],
-]
-
-def GenerateHeader(file, functions, set_name, used_extension_functions):
- """Generates gl_binding_autogen_x.h"""
-
- # Write file header.
- file.write('// Copyright (c) 2011 The Chromium Authors. All rights reserved.\n')
- file.write('// Use of this source code is governed by a BSD-style license that can be\n')
- file.write('// found in the LICENSE file.\n')
- file.write('\n')
- file.write('// This file is automatically generated.\n')
- file.write('\n')
- file.write('#ifndef UI_GFX_GL_GL_BINDINGS_AUTOGEN_%s_H_\n' % set_name.upper())
- file.write('#define UI_GFX_GL_GL_BINDINGS_AUTOGEN_%s_H_\n' % set_name.upper())
-
- # Write prototype for initialization function.
- file.write('\n')
- file.write('namespace gfx {\n')
- file.write('\n')
- file.write('class GLContext;\n')
- file.write('\n')
- file.write('void InitializeGLBindings%s();\n' % set_name.upper())
- file.write('void InitializeGLExtensionBindings%s(GLContext* context);\n' %
- set_name.upper())
- file.write('void InitializeDebugGLBindings%s();\n' % set_name.upper())
- file.write('void ClearGLBindings%s();\n' % set_name.upper())
-
- # Write typedefs for function pointer types. Always use the GL name for the
- # typedef.
- file.write('\n')
- for func in functions:
- file.write('typedef %s (GL_BINDING_CALL *%sProc)(%s);\n' %
- (func['return_type'], func['names'][0], func['arguments']))
-
- # Write declarations for booleans indicating which extensions are available.
- file.write('\n')
- for extension, ext_functions in used_extension_functions:
- file.write('GL_EXPORT extern bool g_%s;\n' % extension)
-
- # Write declarations for function pointers. Always use the GL name for the
- # declaration.
- file.write('\n')
- for func in functions:
- file.write('GL_EXPORT extern %sProc g_%s;\n' %
- (func['names'][0], func['names'][0]))
- file.write('\n')
- file.write( '} // namespace gfx\n')
-
- # Write macros to invoke function pointers. Always use the GL name for the
- # macro.
- file.write('\n')
- for func in functions:
- file.write('#define %s ::gfx::g_%s\n' %
- (func['names'][0], func['names'][0]))
-
- file.write('\n')
- file.write('#endif // UI_GFX_GL_GL_BINDINGS_AUTOGEN_%s_H_\n' %
- set_name.upper())
-
-
-def GenerateSource(file, functions, set_name, used_extension_functions):
- """Generates gl_binding_autogen_x.cc"""
-
- # Write file header.
- file.write('// Copyright (c) 2011 The Chromium Authors. All rights reserved.\n')
- file.write('// Use of this source code is governed by a BSD-style license that can be\n')
- file.write('// found in the LICENSE file.\n')
- file.write('\n')
- file.write('// This file is automatically generated.\n')
- file.write('\n')
- file.write('#include <string>\n')
- file.write('#include "gpu/command_buffer/common/gles2_cmd_utils.h"\n')
- file.write('#include "ui/gfx/gl/gl_bindings.h"\n')
- file.write('#include "ui/gfx/gl/gl_context.h"\n')
- file.write('#include "ui/gfx/gl/gl_implementation.h"\n')
-
- # Write definitions for booleans indicating which extensions are available.
- file.write('\n')
- file.write('using gpu::gles2::GLES2Util;\n')
- file.write('\n')
- file.write('namespace gfx {\n')
- file.write('\n')
- for extension, ext_functions in used_extension_functions:
- file.write('bool g_%s;\n' % extension)
-
- # Write definitions of function pointers.
- file.write('\n')
- file.write('static bool g_debugBindingsInitialized;\n')
- file.write('static void UpdateDebugGLExtensionBindings();\n')
- file.write('\n')
- for func in functions:
- file.write('%sProc g_%s;\n' % (func['names'][0], func['names'][0]))
-
- file.write('\n')
- for func in functions:
- file.write('static %sProc g_debug_%s;\n' %
- (func['names'][0], func['names'][0]))
-
- # Write function to initialize the core function pointers. The code assumes
- # any non-NULL pointer returned by GetGLCoreProcAddress() is valid, although
- # it may be overwritten by an extension function pointer later.
- file.write('\n')
- file.write('void InitializeGLBindings%s() {\n' % set_name.upper())
- for func in functions:
- first_name = func['names'][0]
- for i, name in enumerate(func['names']):
- if i:
- file.write(' if (!g_%s)\n ' % first_name)
- file.write(
- ' g_%s = reinterpret_cast<%sProc>(GetGLCoreProcAddress("%s"));\n' %
- (first_name, first_name, name))
- file.write('}\n')
- file.write('\n')
-
- # Write function to initialize the extension function pointers. This function
- # uses a current context to query which extensions are actually supported.
- file.write('void InitializeGLExtensionBindings%s(GLContext* context) {\n' %
- set_name.upper())
- file.write(' DCHECK(context && context->IsCurrent(NULL));\n')
- for extension, ext_functions in used_extension_functions:
- file.write(' g_%s = context->HasExtension("%s");\n' %
- (extension, extension))
- file.write(' if (g_%s) {\n' %
- (extension))
- queried_entry_points = set()
- for entry_point_name, function_name in ext_functions:
- # Replace the pointer unconditionally unless this extension has several
- # alternatives for the same entry point (e.g.,
- # GL_ARB_blend_func_extended).
- if entry_point_name in queried_entry_points:
- file.write(' if (!g_%s)\n ' % entry_point_name)
- file.write(
- ' g_%s = reinterpret_cast<%sProc>(GetGLProcAddress("%s"));\n' %
- (entry_point_name, entry_point_name, function_name))
- queried_entry_points.add(entry_point_name)
- file.write(' }\n')
- file.write(' if (g_debugBindingsInitialized)\n')
- file.write(' UpdateDebugGLExtensionBindings();\n')
- file.write('}\n')
- file.write('\n')
-
- # Write logging wrappers for each function.
- file.write('extern "C" {\n')
- for func in functions:
- names = func['names']
- return_type = func['return_type']
- arguments = func['arguments']
- file.write('\n')
- file.write('static %s GL_BINDING_CALL Debug_%s(%s) {\n' %
- (return_type, names[0], arguments))
- argument_names = re.sub(
- r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', arguments)
- argument_names = re.sub(
- r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', argument_names)
- log_argument_names = re.sub(
- r'const char\* ([a-zA-Z0-9_]+)', r'CONSTCHAR_\1', arguments)
- log_argument_names = re.sub(
- r'(const )?[a-zA-Z0-9_]+\* ([a-zA-Z0-9_]+)',
- r'CONSTVOID_\2', log_argument_names)
- log_argument_names = re.sub(
- r'(?<!E)GLenum ([a-zA-Z0-9_]+)', r'GLenum_\1', log_argument_names)
- log_argument_names = re.sub(
- r'(?<!E)GLboolean ([a-zA-Z0-9_]+)', r'GLboolean_\1', log_argument_names)
- log_argument_names = re.sub(
- r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2',
- log_argument_names)
- log_argument_names = re.sub(
- r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2',
- log_argument_names)
- log_argument_names = re.sub(
- r'CONSTVOID_([a-zA-Z0-9_]+)',
- r'static_cast<const void*>(\1)', log_argument_names);
- log_argument_names = re.sub(
- r'CONSTCHAR_([a-zA-Z0-9_]+)', r'\1', log_argument_names);
- log_argument_names = re.sub(
- r'GLenum_([a-zA-Z0-9_]+)', r'GLES2Util::GetStringEnum(\1)',
- log_argument_names)
- log_argument_names = re.sub(
- r'GLboolean_([a-zA-Z0-9_]+)', r'GLES2Util::GetStringBool(\1)',
- log_argument_names)
- log_argument_names = log_argument_names.replace(',', ' << ", " <<')
- if argument_names == 'void' or argument_names == '':
- argument_names = ''
- log_argument_names = ''
- else:
- log_argument_names = " << " + log_argument_names
- function_name = names[0]
- if return_type == 'void':
- file.write(' GL_SERVICE_LOG("%s" << "(" %s << ")");\n' %
- (function_name, log_argument_names))
- file.write(' g_debug_%s(%s);\n' %
- (function_name, argument_names))
- if 'logging_code' in func:
- file.write("%s\n" % func['logging_code'])
- else:
- file.write(' GL_SERVICE_LOG("%s" << "(" %s << ")");\n' %
- (function_name, log_argument_names))
- file.write(' %s result = g_debug_%s(%s);\n' %
- (return_type, function_name, argument_names))
- if 'logging_code' in func:
- file.write("%s\n" % func['logging_code'])
- else:
- file.write(' GL_SERVICE_LOG("GL_RESULT: " << result);\n');
- file.write(' return result;\n')
- file.write('}\n')
- file.write('} // extern "C"\n')
-
- # Write function to initialize the debug function pointers.
- file.write('\n')
- file.write('void InitializeDebugGLBindings%s() {\n' % set_name.upper())
- for func in functions:
- first_name = func['names'][0]
- file.write(' if (!g_debug_%s) {\n' % first_name)
- file.write(' g_debug_%s = g_%s;\n' % (first_name, first_name))
- file.write(' g_%s = Debug_%s;\n' % (first_name, first_name))
- file.write(' }\n')
- file.write(' g_debugBindingsInitialized = true;\n')
- file.write('}\n')
-
- # Write function to update the debug function pointers to extension functions
- # after the extensions have been initialized.
- file.write('\n')
- file.write('static void UpdateDebugGLExtensionBindings() {\n')
- for extension, ext_functions in used_extension_functions:
- for name, _ in ext_functions:
- file.write(' if (g_debug_%s != g_%s &&\n' % (name, name))
- file.write(' g_%s != Debug_%s) {\n' % (name, name))
- file.write(' g_debug_%s = g_%s;\n' % (name, name))
- file.write(' g_%s = Debug_%s;\n' % (name, name))
- file.write(' }\n')
- file.write('}\n')
-
- # Write function to clear all function pointers.
- file.write('\n')
- file.write('void ClearGLBindings%s() {\n' % set_name.upper())
- # Clear the availability of GL extensions.
- for extension, ext_functions in used_extension_functions:
- file.write(' g_%s = false;\n' % extension)
- # Clear GL bindings.
- file.write('\n')
- for func in functions:
- file.write(' g_%s = NULL;\n' % func['names'][0])
- # Clear debug GL bindings.
- file.write('\n')
- for func in functions:
- file.write(' g_debug_%s = NULL;\n' % func['names'][0])
- file.write(' g_debugBindingsInitialized = false;\n')
- file.write('}\n')
-
- file.write('\n')
- file.write('} // namespace gfx\n')
-
-
-def GenerateMockSource(file, functions):
- """Generates functions that invoke a mock GLInterface"""
-
- file.write('// Copyright (c) 2011 The Chromium Authors. All rights reserved.\n')
- file.write('// Use of this source code is governed by a BSD-style license that can be\n')
- file.write('// found in the LICENSE file.\n')
- file.write('\n')
- file.write('// This file is automatically generated.\n')
- file.write('\n')
- file.write('#include <string.h>\n')
- file.write('\n')
- file.write('#include "ui/gfx/gl/gl_interface.h"\n')
-
- file.write('\n')
- file.write('namespace gfx {\n')
-
- # Write function that trampoline into the GLInterface.
- for func in functions:
- file.write('\n')
- file.write('%s GL_BINDING_CALL Mock_%s(%s) {\n' %
- (func['return_type'], func['names'][0], func['arguments']))
- argument_names = re.sub(r'(const )?[a-zA-Z0-9]+\** ([a-zA-Z0-9]+)', r'\2',
- func['arguments'])
- if argument_names == 'void':
- argument_names = ''
- function_name = func['names'][0][2:]
- if func['return_type'] == 'void':
- file.write(' GLInterface::GetGLInterface()->%s(%s);\n' %
- (function_name, argument_names))
- else:
- file.write(' return GLInterface::GetGLInterface()->%s(%s);\n' %
- (function_name, argument_names))
- file.write('}\n')
-
- # Write an 'invalid' function to catch code calling through uninitialized
- # function pointers or trying to interpret the return value of
- # GLProcAddress().
- file.write('\n')
- file.write('static void MockInvalidFunction() {\n')
- file.write(' NOTREACHED();\n')
- file.write('}\n')
-
- # Write a function to lookup a mock GL function based on its name.
- file.write('\n')
- file.write('void* GL_BINDING_CALL GetMockGLProcAddress(const char* name) {\n')
- for func in functions:
- first_name = func['names'][0]
- file.write(' if (strcmp(name, "%s") == 0)\n' % first_name)
- file.write(' return reinterpret_cast<void*>(Mock_%s);\n' % first_name)
- # Always return a non-NULL pointer like some EGL implementations do.
- file.write(' return reinterpret_cast<void*>(&MockInvalidFunction);\n')
- file.write('}\n');
-
- file.write('\n')
- file.write('} // namespace gfx\n')
-
-
-def ParseExtensionFunctionsFromHeader(header_file):
- """Parse a C extension header file and return a map from extension names to
- a list of functions.
-
- Args:
- header_file: Line-iterable C header file.
- Returns:
- Map of extension name => functions.
- """
- extension_start = re.compile(r'#define ([A-Z]+_[A-Z]+_[a-zA-Z]\w+) 1')
- extension_function = re.compile(r'.+\s+([a-z]+\w+)\s*\(.+\);')
- typedef = re.compile(r'typedef .*')
- macro_start = re.compile(r'^#(if|ifdef|ifndef).*')
- macro_end = re.compile(r'^#endif.*')
- macro_depth = 0
- current_extension = None
- current_extension_depth = 0
- extensions = collections.defaultdict(lambda: [])
- for line in header_file:
- if macro_start.match(line):
- macro_depth += 1
- elif macro_end.match(line):
- macro_depth -= 1
- if macro_depth < current_extension_depth:
- current_extension = None
- match = extension_start.match(line)
- if match:
- current_extension = match.group(1)
- current_extension_depth = macro_depth
- assert current_extension not in extensions, \
- "Duplicate extension: " + current_extension
- match = extension_function.match(line)
- if match and current_extension and not typedef.match(line):
- extensions[current_extension].append(match.group(1))
- return extensions
-
-
-def GetExtensionFunctions(extension_headers):
- """Parse extension functions from a list of header files.
-
- Args:
- extension_headers: List of header file names.
- Returns:
- Map of extension name => list of functions.
- """
- extensions = {}
- for header in extension_headers:
- extensions.update(ParseExtensionFunctionsFromHeader(open(header)))
- return extensions
-
-
-def GetFunctionToExtensionMap(extensions):
- """Construct map from a function names to extensions which define the
- function.
-
- Args:
- extensions: Map of extension name => functions.
- Returns:
- Map of function name => extension name.
- """
- function_to_extensions = {}
- for extension, functions in extensions.items():
- for function in functions:
- if not function in function_to_extensions:
- function_to_extensions[function] = []
- function_to_extensions[function].append(extension)
- return function_to_extensions
-
-
-def LooksLikeExtensionFunction(function):
- """Heuristic to see if a function name is consistent with extension function
- naming."""
- vendor = re.match(r'\w+?([A-Z][A-Z]+)$', function)
- return vendor is not None and not vendor.group(1) in ['GL', 'API', 'DC']
-
-
-def GetUsedExtensionFunctions(functions, extension_headers, extra_extensions):
- """Determine which functions belong to extensions.
-
- Args:
- functions: List of (return type, function names, arguments).
- extension_headers: List of header file names.
- Returns:
- List of (extension name, [function name alternatives]) sorted with least
- preferred extensions first.
- """
- # Parse known extensions.
- extensions = GetExtensionFunctions(extension_headers)
- functions_to_extensions = GetFunctionToExtensionMap(extensions)
-
- # Collect all used extension functions.
- used_extension_functions = collections.defaultdict(lambda: [])
- for func in functions:
- for name in func['names']:
- # Make sure we know about all extension functions.
- if (LooksLikeExtensionFunction(name) and
- not name in functions_to_extensions):
- raise RuntimeError('%s looks like an extension function but does not '
- 'belong to any of the known extensions.' % name)
- if name in functions_to_extensions:
- extensions = functions_to_extensions[name][:]
- if 'other_extensions' in func:
- extensions.extend(func['other_extensions'])
- for extension in extensions:
- used_extension_functions[extension].append((func['names'][0], name))
-
- # Add extensions that do not have any functions.
- used_extension_functions.update(dict(
- [(e, []) for e in extra_extensions if e not in used_extension_functions]))
-
- def ExtensionSortKey(name):
- # Prefer ratified extensions and EXTs.
- preferences = ['_ARB_', '_OES_', '_EXT_', '']
- for i, category in enumerate(preferences):
- if category in name:
- return -i
- used_extension_functions = sorted(used_extension_functions.items(),
- key = lambda item: ExtensionSortKey(item[0]))
- return used_extension_functions
-
-
-def main(argv):
- """This is the main function."""
-
- if len(argv) >= 1:
- dir = argv[0]
- else:
- dir = '.'
-
- for [functions, set_name, extension_headers, extensions] in FUNCTION_SETS:
- used_extension_functions = GetUsedExtensionFunctions(
- functions, extension_headers, extensions)
-
- header_file = open(
- os.path.join(dir, 'gl_bindings_autogen_%s.h' % set_name), 'wb')
- GenerateHeader(header_file, functions, set_name, used_extension_functions)
- header_file.close()
-
- source_file = open(
- os.path.join(dir, 'gl_bindings_autogen_%s.cc' % set_name), 'wb')
- GenerateSource(source_file, functions, set_name, used_extension_functions)
- source_file.close()
-
- source_file = open(os.path.join(dir, 'gl_bindings_autogen_mock.cc'), 'wb')
- GenerateMockSource(source_file, GL_FUNCTIONS)
- source_file.close()
- return 0
-
-
-if __name__ == '__main__':
- sys.exit(main(sys.argv[1:]))
« no previous file with comments | « ui/gfx/gl/egl_util.cc ('k') | ui/gfx/gl/gl.gyp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698