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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: ui/gl/gl_bindings_autogen_gl1.cc

Issue 2629633003: Refactor GL bindings so there is no global GLApi or DriverGL. (Closed)
Patch Set: rebase Created 3 years, 11 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/gl/gl_bindings_autogen_gl0.cc ('k') | ui/gl/gl_bindings_autogen_gl2.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: ui/gl/gl_bindings_autogen_gl1.cc
diff --git a/ui/gl/gl_bindings_autogen_gl1.cc b/ui/gl/gl_bindings_autogen_gl1.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6b1c4cdf3d99ff95f1cc4cd58c6abf3bd7813cdc
--- /dev/null
+++ b/ui/gl/gl_bindings_autogen_gl1.cc
@@ -0,0 +1,2587 @@
+// Copyright 2016 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.
+//
+// This file is auto-generated from
+// ui/gl/generate_bindings.py
+// It's formatted by clang-format using chromium coding style:
+// clang-format -i -style=chromium filename
+// DO NOT EDIT!
+
+#include <string>
+
+#include "base/trace_event/trace_event.h"
+#include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_context.h"
+#include "ui/gl/gl_enums.h"
+#include "ui/gl/gl_gl_api_implementation.h"
+#include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_version_info.h"
+
+namespace gl {
+
+void GLApiBase::glActiveTextureFn(GLenum texture) {
+ driver_->fn.glActiveTextureFn(texture);
+}
+
+void GLApiBase::glApplyFramebufferAttachmentCMAAINTELFn(void) {
+ driver_->fn.glApplyFramebufferAttachmentCMAAINTELFn();
+}
+
+void GLApiBase::glAttachShaderFn(GLuint program, GLuint shader) {
+ driver_->fn.glAttachShaderFn(program, shader);
+}
+
+void GLApiBase::glBeginQueryFn(GLenum target, GLuint id) {
+ driver_->fn.glBeginQueryFn(target, id);
+}
+
+void GLApiBase::glBeginTransformFeedbackFn(GLenum primitiveMode) {
+ driver_->fn.glBeginTransformFeedbackFn(primitiveMode);
+}
+
+void GLApiBase::glBindAttribLocationFn(GLuint program,
+ GLuint index,
+ const char* name) {
+ driver_->fn.glBindAttribLocationFn(program, index, name);
+}
+
+void GLApiBase::glBindBufferFn(GLenum target, GLuint buffer) {
+ driver_->fn.glBindBufferFn(target, buffer);
+}
+
+void GLApiBase::glBindBufferBaseFn(GLenum target, GLuint index, GLuint buffer) {
+ driver_->fn.glBindBufferBaseFn(target, index, buffer);
+}
+
+void GLApiBase::glBindBufferRangeFn(GLenum target,
+ GLuint index,
+ GLuint buffer,
+ GLintptr offset,
+ GLsizeiptr size) {
+ driver_->fn.glBindBufferRangeFn(target, index, buffer, offset, size);
+}
+
+void GLApiBase::glBindFragDataLocationFn(GLuint program,
+ GLuint colorNumber,
+ const char* name) {
+ driver_->fn.glBindFragDataLocationFn(program, colorNumber, name);
+}
+
+void GLApiBase::glBindFragDataLocationIndexedFn(GLuint program,
+ GLuint colorNumber,
+ GLuint index,
+ const char* name) {
+ driver_->fn.glBindFragDataLocationIndexedFn(program, colorNumber, index,
+ name);
+}
+
+void GLApiBase::glBindFramebufferEXTFn(GLenum target, GLuint framebuffer) {
+ driver_->fn.glBindFramebufferEXTFn(target, framebuffer);
+}
+
+void GLApiBase::glBindImageTextureEXTFn(GLuint index,
+ GLuint texture,
+ GLint level,
+ GLboolean layered,
+ GLint layer,
+ GLenum access,
+ GLint format) {
+ driver_->fn.glBindImageTextureEXTFn(index, texture, level, layered, layer,
+ access, format);
+}
+
+void GLApiBase::glBindRenderbufferEXTFn(GLenum target, GLuint renderbuffer) {
+ driver_->fn.glBindRenderbufferEXTFn(target, renderbuffer);
+}
+
+void GLApiBase::glBindSamplerFn(GLuint unit, GLuint sampler) {
+ driver_->fn.glBindSamplerFn(unit, sampler);
+}
+
+void GLApiBase::glBindTextureFn(GLenum target, GLuint texture) {
+ driver_->fn.glBindTextureFn(target, texture);
+}
+
+void GLApiBase::glBindTransformFeedbackFn(GLenum target, GLuint id) {
+ driver_->fn.glBindTransformFeedbackFn(target, id);
+}
+
+void GLApiBase::glBindUniformLocationCHROMIUMFn(GLuint program,
+ GLint location,
+ const char* name) {
+ driver_->fn.glBindUniformLocationCHROMIUMFn(program, location, name);
+}
+
+void GLApiBase::glBindVertexArrayOESFn(GLuint array) {
+ driver_->fn.glBindVertexArrayOESFn(array);
+}
+
+void GLApiBase::glBlendBarrierKHRFn(void) {
+ driver_->fn.glBlendBarrierKHRFn();
+}
+
+void GLApiBase::glBlendColorFn(GLclampf red,
+ GLclampf green,
+ GLclampf blue,
+ GLclampf alpha) {
+ driver_->fn.glBlendColorFn(red, green, blue, alpha);
+}
+
+void GLApiBase::glBlendEquationFn(GLenum mode) {
+ driver_->fn.glBlendEquationFn(mode);
+}
+
+void GLApiBase::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) {
+ driver_->fn.glBlendEquationSeparateFn(modeRGB, modeAlpha);
+}
+
+void GLApiBase::glBlendFuncFn(GLenum sfactor, GLenum dfactor) {
+ driver_->fn.glBlendFuncFn(sfactor, dfactor);
+}
+
+void GLApiBase::glBlendFuncSeparateFn(GLenum srcRGB,
+ GLenum dstRGB,
+ GLenum srcAlpha,
+ GLenum dstAlpha) {
+ driver_->fn.glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha, dstAlpha);
+}
+
+void GLApiBase::glBlitFramebufferFn(GLint srcX0,
+ GLint srcY0,
+ GLint srcX1,
+ GLint srcY1,
+ GLint dstX0,
+ GLint dstY0,
+ GLint dstX1,
+ GLint dstY1,
+ GLbitfield mask,
+ GLenum filter) {
+ driver_->fn.glBlitFramebufferFn(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+ dstX1, dstY1, mask, filter);
+}
+
+void GLApiBase::glBlitFramebufferANGLEFn(GLint srcX0,
+ GLint srcY0,
+ GLint srcX1,
+ GLint srcY1,
+ GLint dstX0,
+ GLint dstY0,
+ GLint dstX1,
+ GLint dstY1,
+ GLbitfield mask,
+ GLenum filter) {
+ driver_->fn.glBlitFramebufferANGLEFn(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+ dstX1, dstY1, mask, filter);
+}
+
+void GLApiBase::glBlitFramebufferEXTFn(GLint srcX0,
+ GLint srcY0,
+ GLint srcX1,
+ GLint srcY1,
+ GLint dstX0,
+ GLint dstY0,
+ GLint dstX1,
+ GLint dstY1,
+ GLbitfield mask,
+ GLenum filter) {
+ driver_->fn.glBlitFramebufferEXTFn(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+ dstX1, dstY1, mask, filter);
+}
+
+void GLApiBase::glBufferDataFn(GLenum target,
+ GLsizeiptr size,
+ const void* data,
+ GLenum usage) {
+ driver_->fn.glBufferDataFn(target, size, data, usage);
+}
+
+void GLApiBase::glBufferSubDataFn(GLenum target,
+ GLintptr offset,
+ GLsizeiptr size,
+ const void* data) {
+ driver_->fn.glBufferSubDataFn(target, offset, size, data);
+}
+
+GLenum GLApiBase::glCheckFramebufferStatusEXTFn(GLenum target) {
+ return driver_->fn.glCheckFramebufferStatusEXTFn(target);
+}
+
+void GLApiBase::glClearFn(GLbitfield mask) {
+ driver_->fn.glClearFn(mask);
+}
+
+void GLApiBase::glClearBufferfiFn(GLenum buffer,
+ GLint drawbuffer,
+ const GLfloat depth,
+ GLint stencil) {
+ driver_->fn.glClearBufferfiFn(buffer, drawbuffer, depth, stencil);
+}
+
+void GLApiBase::glClearBufferfvFn(GLenum buffer,
+ GLint drawbuffer,
+ const GLfloat* value) {
+ driver_->fn.glClearBufferfvFn(buffer, drawbuffer, value);
+}
+
+void GLApiBase::glClearBufferivFn(GLenum buffer,
+ GLint drawbuffer,
+ const GLint* value) {
+ driver_->fn.glClearBufferivFn(buffer, drawbuffer, value);
+}
+
+void GLApiBase::glClearBufferuivFn(GLenum buffer,
+ GLint drawbuffer,
+ const GLuint* value) {
+ driver_->fn.glClearBufferuivFn(buffer, drawbuffer, value);
+}
+
+void GLApiBase::glClearColorFn(GLclampf red,
+ GLclampf green,
+ GLclampf blue,
+ GLclampf alpha) {
+ driver_->fn.glClearColorFn(red, green, blue, alpha);
+}
+
+void GLApiBase::glClearDepthFn(GLclampd depth) {
+ driver_->fn.glClearDepthFn(depth);
+}
+
+void GLApiBase::glClearDepthfFn(GLclampf depth) {
+ driver_->fn.glClearDepthfFn(depth);
+}
+
+void GLApiBase::glClearStencilFn(GLint s) {
+ driver_->fn.glClearStencilFn(s);
+}
+
+GLenum GLApiBase::glClientWaitSyncFn(GLsync sync,
+ GLbitfield flags,
+ GLuint64 timeout) {
+ return driver_->fn.glClientWaitSyncFn(sync, flags, timeout);
+}
+
+void GLApiBase::glColorMaskFn(GLboolean red,
+ GLboolean green,
+ GLboolean blue,
+ GLboolean alpha) {
+ driver_->fn.glColorMaskFn(red, green, blue, alpha);
+}
+
+void GLApiBase::glCompileShaderFn(GLuint shader) {
+ driver_->fn.glCompileShaderFn(shader);
+}
+
+void GLApiBase::glCompressedCopyTextureCHROMIUMFn(GLuint sourceId,
+ GLuint destId) {
+ driver_->fn.glCompressedCopyTextureCHROMIUMFn(sourceId, destId);
+}
+
+void GLApiBase::glCompressedTexImage2DFn(GLenum target,
+ GLint level,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLint border,
+ GLsizei imageSize,
+ const void* data) {
+ driver_->fn.glCompressedTexImage2DFn(target, level, internalformat, width,
+ height, border, imageSize, data);
+}
+
+void GLApiBase::glCompressedTexImage3DFn(GLenum target,
+ GLint level,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ GLint border,
+ GLsizei imageSize,
+ const void* data) {
+ driver_->fn.glCompressedTexImage3DFn(target, level, internalformat, width,
+ height, depth, border, imageSize, data);
+}
+
+void GLApiBase::glCompressedTexSubImage2DFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLsizei imageSize,
+ const void* data) {
+ driver_->fn.glCompressedTexSubImage2DFn(
+ target, level, xoffset, yoffset, width, height, format, imageSize, data);
+}
+
+void GLApiBase::glCompressedTexSubImage3DFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLint zoffset,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ GLenum format,
+ GLsizei imageSize,
+ const void* data) {
+ driver_->fn.glCompressedTexSubImage3DFn(target, level, xoffset, yoffset,
+ zoffset, width, height, depth, format,
+ imageSize, data);
+}
+
+void GLApiBase::glCopyBufferSubDataFn(GLenum readTarget,
+ GLenum writeTarget,
+ GLintptr readOffset,
+ GLintptr writeOffset,
+ GLsizeiptr size) {
+ driver_->fn.glCopyBufferSubDataFn(readTarget, writeTarget, readOffset,
+ writeOffset, size);
+}
+
+void GLApiBase::glCopySubTextureCHROMIUMFn(GLuint sourceId,
+ GLuint destId,
+ GLint xoffset,
+ GLint yoffset,
+ GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height,
+ GLboolean unpackFlipY,
+ GLboolean unpackPremultiplyAlpha,
+ GLboolean unpackUnmultiplyAlpha) {
+ driver_->fn.glCopySubTextureCHROMIUMFn(
+ sourceId, destId, xoffset, yoffset, x, y, width, height, unpackFlipY,
+ unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+}
+
+void GLApiBase::glCopyTexImage2DFn(GLenum target,
+ GLint level,
+ GLenum internalformat,
+ GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height,
+ GLint border) {
+ driver_->fn.glCopyTexImage2DFn(target, level, internalformat, x, y, width,
+ height, border);
+}
+
+void GLApiBase::glCopyTexSubImage2DFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height) {
+ driver_->fn.glCopyTexSubImage2DFn(target, level, xoffset, yoffset, x, y,
+ width, height);
+}
+
+void GLApiBase::glCopyTexSubImage3DFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLint zoffset,
+ GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height) {
+ driver_->fn.glCopyTexSubImage3DFn(target, level, xoffset, yoffset, zoffset, x,
+ y, width, height);
+}
+
+void GLApiBase::glCopyTextureCHROMIUMFn(GLuint sourceId,
+ GLuint destId,
+ GLint internalFormat,
+ GLenum destType,
+ GLboolean unpackFlipY,
+ GLboolean unpackPremultiplyAlpha,
+ GLboolean unpackUnmultiplyAlpha) {
+ driver_->fn.glCopyTextureCHROMIUMFn(
+ sourceId, destId, internalFormat, destType, unpackFlipY,
+ unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+}
+
+void GLApiBase::glCoverageModulationNVFn(GLenum components) {
+ driver_->fn.glCoverageModulationNVFn(components);
+}
+
+void GLApiBase::glCoverFillPathInstancedNVFn(GLsizei numPaths,
+ GLenum pathNameType,
+ const void* paths,
+ GLuint pathBase,
+ GLenum coverMode,
+ GLenum transformType,
+ const GLfloat* transformValues) {
+ driver_->fn.glCoverFillPathInstancedNVFn(numPaths, pathNameType, paths,
+ pathBase, coverMode, transformType,
+ transformValues);
+}
+
+void GLApiBase::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
+ driver_->fn.glCoverFillPathNVFn(path, coverMode);
+}
+
+void GLApiBase::glCoverStrokePathInstancedNVFn(GLsizei numPaths,
+ GLenum pathNameType,
+ const void* paths,
+ GLuint pathBase,
+ GLenum coverMode,
+ GLenum transformType,
+ const GLfloat* transformValues) {
+ driver_->fn.glCoverStrokePathInstancedNVFn(numPaths, pathNameType, paths,
+ pathBase, coverMode, transformType,
+ transformValues);
+}
+
+void GLApiBase::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
+ driver_->fn.glCoverStrokePathNVFn(name, coverMode);
+}
+
+GLuint GLApiBase::glCreateProgramFn(void) {
+ return driver_->fn.glCreateProgramFn();
+}
+
+GLuint GLApiBase::glCreateShaderFn(GLenum type) {
+ return driver_->fn.glCreateShaderFn(type);
+}
+
+void GLApiBase::glCullFaceFn(GLenum mode) {
+ driver_->fn.glCullFaceFn(mode);
+}
+
+void GLApiBase::glDebugMessageCallbackFn(GLDEBUGPROC callback,
+ const void* userParam) {
+ driver_->fn.glDebugMessageCallbackFn(callback, userParam);
+}
+
+void GLApiBase::glDebugMessageControlFn(GLenum source,
+ GLenum type,
+ GLenum severity,
+ GLsizei count,
+ const GLuint* ids,
+ GLboolean enabled) {
+ driver_->fn.glDebugMessageControlFn(source, type, severity, count, ids,
+ enabled);
+}
+
+void GLApiBase::glDebugMessageInsertFn(GLenum source,
+ GLenum type,
+ GLuint id,
+ GLenum severity,
+ GLsizei length,
+ const char* buf) {
+ driver_->fn.glDebugMessageInsertFn(source, type, id, severity, length, buf);
+}
+
+void GLApiBase::glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) {
+ driver_->fn.glDeleteBuffersARBFn(n, buffers);
+}
+
+void GLApiBase::glDeleteFencesAPPLEFn(GLsizei n, const GLuint* fences) {
+ driver_->fn.glDeleteFencesAPPLEFn(n, fences);
+}
+
+void GLApiBase::glDeleteFencesNVFn(GLsizei n, const GLuint* fences) {
+ driver_->fn.glDeleteFencesNVFn(n, fences);
+}
+
+void GLApiBase::glDeleteFramebuffersEXTFn(GLsizei n,
+ const GLuint* framebuffers) {
+ driver_->fn.glDeleteFramebuffersEXTFn(n, framebuffers);
+}
+
+void GLApiBase::glDeletePathsNVFn(GLuint path, GLsizei range) {
+ driver_->fn.glDeletePathsNVFn(path, range);
+}
+
+void GLApiBase::glDeleteProgramFn(GLuint program) {
+ driver_->fn.glDeleteProgramFn(program);
+}
+
+void GLApiBase::glDeleteQueriesFn(GLsizei n, const GLuint* ids) {
+ driver_->fn.glDeleteQueriesFn(n, ids);
+}
+
+void GLApiBase::glDeleteRenderbuffersEXTFn(GLsizei n,
+ const GLuint* renderbuffers) {
+ driver_->fn.glDeleteRenderbuffersEXTFn(n, renderbuffers);
+}
+
+void GLApiBase::glDeleteSamplersFn(GLsizei n, const GLuint* samplers) {
+ driver_->fn.glDeleteSamplersFn(n, samplers);
+}
+
+void GLApiBase::glDeleteShaderFn(GLuint shader) {
+ driver_->fn.glDeleteShaderFn(shader);
+}
+
+void GLApiBase::glDeleteSyncFn(GLsync sync) {
+ driver_->fn.glDeleteSyncFn(sync);
+}
+
+void GLApiBase::glDeleteTexturesFn(GLsizei n, const GLuint* textures) {
+ driver_->fn.glDeleteTexturesFn(n, textures);
+}
+
+void GLApiBase::glDeleteTransformFeedbacksFn(GLsizei n, const GLuint* ids) {
+ driver_->fn.glDeleteTransformFeedbacksFn(n, ids);
+}
+
+void GLApiBase::glDeleteVertexArraysOESFn(GLsizei n, const GLuint* arrays) {
+ driver_->fn.glDeleteVertexArraysOESFn(n, arrays);
+}
+
+void GLApiBase::glDepthFuncFn(GLenum func) {
+ driver_->fn.glDepthFuncFn(func);
+}
+
+void GLApiBase::glDepthMaskFn(GLboolean flag) {
+ driver_->fn.glDepthMaskFn(flag);
+}
+
+void GLApiBase::glDepthRangeFn(GLclampd zNear, GLclampd zFar) {
+ driver_->fn.glDepthRangeFn(zNear, zFar);
+}
+
+void GLApiBase::glDepthRangefFn(GLclampf zNear, GLclampf zFar) {
+ driver_->fn.glDepthRangefFn(zNear, zFar);
+}
+
+void GLApiBase::glDetachShaderFn(GLuint program, GLuint shader) {
+ driver_->fn.glDetachShaderFn(program, shader);
+}
+
+void GLApiBase::glDisableFn(GLenum cap) {
+ driver_->fn.glDisableFn(cap);
+}
+
+void GLApiBase::glDisableVertexAttribArrayFn(GLuint index) {
+ driver_->fn.glDisableVertexAttribArrayFn(index);
+}
+
+void GLApiBase::glDiscardFramebufferEXTFn(GLenum target,
+ GLsizei numAttachments,
+ const GLenum* attachments) {
+ driver_->fn.glDiscardFramebufferEXTFn(target, numAttachments, attachments);
+}
+
+void GLApiBase::glDrawArraysFn(GLenum mode, GLint first, GLsizei count) {
+ driver_->fn.glDrawArraysFn(mode, first, count);
+}
+
+void GLApiBase::glDrawArraysInstancedANGLEFn(GLenum mode,
+ GLint first,
+ GLsizei count,
+ GLsizei primcount) {
+ driver_->fn.glDrawArraysInstancedANGLEFn(mode, first, count, primcount);
+}
+
+void GLApiBase::glDrawBufferFn(GLenum mode) {
+ driver_->fn.glDrawBufferFn(mode);
+}
+
+void GLApiBase::glDrawBuffersARBFn(GLsizei n, const GLenum* bufs) {
+ driver_->fn.glDrawBuffersARBFn(n, bufs);
+}
+
+void GLApiBase::glDrawElementsFn(GLenum mode,
+ GLsizei count,
+ GLenum type,
+ const void* indices) {
+ driver_->fn.glDrawElementsFn(mode, count, type, indices);
+}
+
+void GLApiBase::glDrawElementsInstancedANGLEFn(GLenum mode,
+ GLsizei count,
+ GLenum type,
+ const void* indices,
+ GLsizei primcount) {
+ driver_->fn.glDrawElementsInstancedANGLEFn(mode, count, type, indices,
+ primcount);
+}
+
+void GLApiBase::glDrawRangeElementsFn(GLenum mode,
+ GLuint start,
+ GLuint end,
+ GLsizei count,
+ GLenum type,
+ const void* indices) {
+ driver_->fn.glDrawRangeElementsFn(mode, start, end, count, type, indices);
+}
+
+void GLApiBase::glEGLImageTargetRenderbufferStorageOESFn(GLenum target,
+ GLeglImageOES image) {
+ driver_->fn.glEGLImageTargetRenderbufferStorageOESFn(target, image);
+}
+
+void GLApiBase::glEGLImageTargetTexture2DOESFn(GLenum target,
+ GLeglImageOES image) {
+ driver_->fn.glEGLImageTargetTexture2DOESFn(target, image);
+}
+
+void GLApiBase::glEnableFn(GLenum cap) {
+ driver_->fn.glEnableFn(cap);
+}
+
+void GLApiBase::glEnableVertexAttribArrayFn(GLuint index) {
+ driver_->fn.glEnableVertexAttribArrayFn(index);
+}
+
+void GLApiBase::glEndQueryFn(GLenum target) {
+ driver_->fn.glEndQueryFn(target);
+}
+
+void GLApiBase::glEndTransformFeedbackFn(void) {
+ driver_->fn.glEndTransformFeedbackFn();
+}
+
+GLsync GLApiBase::glFenceSyncFn(GLenum condition, GLbitfield flags) {
+ return driver_->fn.glFenceSyncFn(condition, flags);
+}
+
+void GLApiBase::glFinishFn(void) {
+ driver_->fn.glFinishFn();
+}
+
+void GLApiBase::glFinishFenceAPPLEFn(GLuint fence) {
+ driver_->fn.glFinishFenceAPPLEFn(fence);
+}
+
+void GLApiBase::glFinishFenceNVFn(GLuint fence) {
+ driver_->fn.glFinishFenceNVFn(fence);
+}
+
+void GLApiBase::glFlushFn(void) {
+ driver_->fn.glFlushFn();
+}
+
+void GLApiBase::glFlushMappedBufferRangeFn(GLenum target,
+ GLintptr offset,
+ GLsizeiptr length) {
+ driver_->fn.glFlushMappedBufferRangeFn(target, offset, length);
+}
+
+void GLApiBase::glFramebufferRenderbufferEXTFn(GLenum target,
+ GLenum attachment,
+ GLenum renderbuffertarget,
+ GLuint renderbuffer) {
+ driver_->fn.glFramebufferRenderbufferEXTFn(target, attachment,
+ renderbuffertarget, renderbuffer);
+}
+
+void GLApiBase::glFramebufferTexture2DEXTFn(GLenum target,
+ GLenum attachment,
+ GLenum textarget,
+ GLuint texture,
+ GLint level) {
+ driver_->fn.glFramebufferTexture2DEXTFn(target, attachment, textarget,
+ texture, level);
+}
+
+void GLApiBase::glFramebufferTexture2DMultisampleEXTFn(GLenum target,
+ GLenum attachment,
+ GLenum textarget,
+ GLuint texture,
+ GLint level,
+ GLsizei samples) {
+ driver_->fn.glFramebufferTexture2DMultisampleEXTFn(
+ target, attachment, textarget, texture, level, samples);
+}
+
+void GLApiBase::glFramebufferTexture2DMultisampleIMGFn(GLenum target,
+ GLenum attachment,
+ GLenum textarget,
+ GLuint texture,
+ GLint level,
+ GLsizei samples) {
+ driver_->fn.glFramebufferTexture2DMultisampleIMGFn(
+ target, attachment, textarget, texture, level, samples);
+}
+
+void GLApiBase::glFramebufferTextureLayerFn(GLenum target,
+ GLenum attachment,
+ GLuint texture,
+ GLint level,
+ GLint layer) {
+ driver_->fn.glFramebufferTextureLayerFn(target, attachment, texture, level,
+ layer);
+}
+
+void GLApiBase::glFrontFaceFn(GLenum mode) {
+ driver_->fn.glFrontFaceFn(mode);
+}
+
+void GLApiBase::glGenBuffersARBFn(GLsizei n, GLuint* buffers) {
+ driver_->fn.glGenBuffersARBFn(n, buffers);
+}
+
+void GLApiBase::glGenerateMipmapEXTFn(GLenum target) {
+ driver_->fn.glGenerateMipmapEXTFn(target);
+}
+
+void GLApiBase::glGenFencesAPPLEFn(GLsizei n, GLuint* fences) {
+ driver_->fn.glGenFencesAPPLEFn(n, fences);
+}
+
+void GLApiBase::glGenFencesNVFn(GLsizei n, GLuint* fences) {
+ driver_->fn.glGenFencesNVFn(n, fences);
+}
+
+void GLApiBase::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
+ driver_->fn.glGenFramebuffersEXTFn(n, framebuffers);
+}
+
+GLuint GLApiBase::glGenPathsNVFn(GLsizei range) {
+ return driver_->fn.glGenPathsNVFn(range);
+}
+
+void GLApiBase::glGenQueriesFn(GLsizei n, GLuint* ids) {
+ driver_->fn.glGenQueriesFn(n, ids);
+}
+
+void GLApiBase::glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) {
+ driver_->fn.glGenRenderbuffersEXTFn(n, renderbuffers);
+}
+
+void GLApiBase::glGenSamplersFn(GLsizei n, GLuint* samplers) {
+ driver_->fn.glGenSamplersFn(n, samplers);
+}
+
+void GLApiBase::glGenTexturesFn(GLsizei n, GLuint* textures) {
+ driver_->fn.glGenTexturesFn(n, textures);
+}
+
+void GLApiBase::glGenTransformFeedbacksFn(GLsizei n, GLuint* ids) {
+ driver_->fn.glGenTransformFeedbacksFn(n, ids);
+}
+
+void GLApiBase::glGenVertexArraysOESFn(GLsizei n, GLuint* arrays) {
+ driver_->fn.glGenVertexArraysOESFn(n, arrays);
+}
+
+void GLApiBase::glGetActiveAttribFn(GLuint program,
+ GLuint index,
+ GLsizei bufsize,
+ GLsizei* length,
+ GLint* size,
+ GLenum* type,
+ char* name) {
+ driver_->fn.glGetActiveAttribFn(program, index, bufsize, length, size, type,
+ name);
+}
+
+void GLApiBase::glGetActiveUniformFn(GLuint program,
+ GLuint index,
+ GLsizei bufsize,
+ GLsizei* length,
+ GLint* size,
+ GLenum* type,
+ char* name) {
+ driver_->fn.glGetActiveUniformFn(program, index, bufsize, length, size, type,
+ name);
+}
+
+void GLApiBase::glGetActiveUniformBlockivFn(GLuint program,
+ GLuint uniformBlockIndex,
+ GLenum pname,
+ GLint* params) {
+ driver_->fn.glGetActiveUniformBlockivFn(program, uniformBlockIndex, pname,
+ params);
+}
+
+void GLApiBase::glGetActiveUniformBlockivRobustANGLEFn(GLuint program,
+ GLuint uniformBlockIndex,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetActiveUniformBlockivRobustANGLEFn(
+ program, uniformBlockIndex, pname, bufSize, length, params);
+}
+
+void GLApiBase::glGetActiveUniformBlockNameFn(GLuint program,
+ GLuint uniformBlockIndex,
+ GLsizei bufSize,
+ GLsizei* length,
+ char* uniformBlockName) {
+ driver_->fn.glGetActiveUniformBlockNameFn(program, uniformBlockIndex, bufSize,
+ length, uniformBlockName);
+}
+
+void GLApiBase::glGetActiveUniformsivFn(GLuint program,
+ GLsizei uniformCount,
+ const GLuint* uniformIndices,
+ GLenum pname,
+ GLint* params) {
+ driver_->fn.glGetActiveUniformsivFn(program, uniformCount, uniformIndices,
+ pname, params);
+}
+
+void GLApiBase::glGetAttachedShadersFn(GLuint program,
+ GLsizei maxcount,
+ GLsizei* count,
+ GLuint* shaders) {
+ driver_->fn.glGetAttachedShadersFn(program, maxcount, count, shaders);
+}
+
+GLint GLApiBase::glGetAttribLocationFn(GLuint program, const char* name) {
+ return driver_->fn.glGetAttribLocationFn(program, name);
+}
+
+void GLApiBase::glGetBooleani_vRobustANGLEFn(GLenum target,
+ GLuint index,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLboolean* data) {
+ driver_->fn.glGetBooleani_vRobustANGLEFn(target, index, bufSize, length,
+ data);
+}
+
+void GLApiBase::glGetBooleanvFn(GLenum pname, GLboolean* params) {
+ driver_->fn.glGetBooleanvFn(pname, params);
+}
+
+void GLApiBase::glGetBooleanvRobustANGLEFn(GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLboolean* data) {
+ driver_->fn.glGetBooleanvRobustANGLEFn(pname, bufSize, length, data);
+}
+
+void GLApiBase::glGetBufferParameteri64vRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint64* params) {
+ driver_->fn.glGetBufferParameteri64vRobustANGLEFn(target, pname, bufSize,
+ length, params);
+}
+
+void GLApiBase::glGetBufferParameterivFn(GLenum target,
+ GLenum pname,
+ GLint* params) {
+ driver_->fn.glGetBufferParameterivFn(target, pname, params);
+}
+
+void GLApiBase::glGetBufferParameterivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetBufferParameterivRobustANGLEFn(target, pname, bufSize,
+ length, params);
+}
+
+void GLApiBase::glGetBufferPointervRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ void** params) {
+ driver_->fn.glGetBufferPointervRobustANGLEFn(target, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetDebugMessageLogFn(GLuint count,
+ GLsizei bufSize,
+ GLenum* sources,
+ GLenum* types,
+ GLuint* ids,
+ GLenum* severities,
+ GLsizei* lengths,
+ char* messageLog) {
+ driver_->fn.glGetDebugMessageLogFn(count, bufSize, sources, types, ids,
+ severities, lengths, messageLog);
+}
+
+GLenum GLApiBase::glGetErrorFn(void) {
+ return driver_->fn.glGetErrorFn();
+}
+
+void GLApiBase::glGetFenceivNVFn(GLuint fence, GLenum pname, GLint* params) {
+ driver_->fn.glGetFenceivNVFn(fence, pname, params);
+}
+
+void GLApiBase::glGetFloatvFn(GLenum pname, GLfloat* params) {
+ driver_->fn.glGetFloatvFn(pname, params);
+}
+
+void GLApiBase::glGetFloatvRobustANGLEFn(GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* data) {
+ driver_->fn.glGetFloatvRobustANGLEFn(pname, bufSize, length, data);
+}
+
+GLint GLApiBase::glGetFragDataIndexFn(GLuint program, const char* name) {
+ return driver_->fn.glGetFragDataIndexFn(program, name);
+}
+
+GLint GLApiBase::glGetFragDataLocationFn(GLuint program, const char* name) {
+ return driver_->fn.glGetFragDataLocationFn(program, name);
+}
+
+void GLApiBase::glGetFramebufferAttachmentParameterivEXTFn(GLenum target,
+ GLenum attachment,
+ GLenum pname,
+ GLint* params) {
+ driver_->fn.glGetFramebufferAttachmentParameterivEXTFn(target, attachment,
+ pname, params);
+}
+
+void GLApiBase::glGetFramebufferAttachmentParameterivRobustANGLEFn(
+ GLenum target,
+ GLenum attachment,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetFramebufferAttachmentParameterivRobustANGLEFn(
+ target, attachment, pname, bufSize, length, params);
+}
+
+void GLApiBase::glGetFramebufferParameterivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetFramebufferParameterivRobustANGLEFn(target, pname, bufSize,
+ length, params);
+}
+
+GLenum GLApiBase::glGetGraphicsResetStatusARBFn(void) {
+ return driver_->fn.glGetGraphicsResetStatusARBFn();
+}
+
+void GLApiBase::glGetInteger64i_vFn(GLenum target,
+ GLuint index,
+ GLint64* data) {
+ driver_->fn.glGetInteger64i_vFn(target, index, data);
+}
+
+void GLApiBase::glGetInteger64i_vRobustANGLEFn(GLenum target,
+ GLuint index,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint64* data) {
+ driver_->fn.glGetInteger64i_vRobustANGLEFn(target, index, bufSize, length,
+ data);
+}
+
+void GLApiBase::glGetInteger64vFn(GLenum pname, GLint64* params) {
+ driver_->fn.glGetInteger64vFn(pname, params);
+}
+
+void GLApiBase::glGetInteger64vRobustANGLEFn(GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint64* data) {
+ driver_->fn.glGetInteger64vRobustANGLEFn(pname, bufSize, length, data);
+}
+
+void GLApiBase::glGetIntegeri_vFn(GLenum target, GLuint index, GLint* data) {
+ driver_->fn.glGetIntegeri_vFn(target, index, data);
+}
+
+void GLApiBase::glGetIntegeri_vRobustANGLEFn(GLenum target,
+ GLuint index,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* data) {
+ driver_->fn.glGetIntegeri_vRobustANGLEFn(target, index, bufSize, length,
+ data);
+}
+
+void GLApiBase::glGetIntegervFn(GLenum pname, GLint* params) {
+ driver_->fn.glGetIntegervFn(pname, params);
+}
+
+void GLApiBase::glGetIntegervRobustANGLEFn(GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* data) {
+ driver_->fn.glGetIntegervRobustANGLEFn(pname, bufSize, length, data);
+}
+
+void GLApiBase::glGetInternalformativFn(GLenum target,
+ GLenum internalformat,
+ GLenum pname,
+ GLsizei bufSize,
+ GLint* params) {
+ driver_->fn.glGetInternalformativFn(target, internalformat, pname, bufSize,
+ params);
+}
+
+void GLApiBase::glGetInternalformativRobustANGLEFn(GLenum target,
+ GLenum internalformat,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetInternalformativRobustANGLEFn(target, internalformat, pname,
+ bufSize, length, params);
+}
+
+void GLApiBase::glGetMultisamplefvRobustANGLEFn(GLenum pname,
+ GLuint index,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* val) {
+ driver_->fn.glGetMultisamplefvRobustANGLEFn(pname, index, bufSize, length,
+ val);
+}
+
+void GLApiBase::glGetnUniformfvRobustANGLEFn(GLuint program,
+ GLint location,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* params) {
+ driver_->fn.glGetnUniformfvRobustANGLEFn(program, location, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetnUniformivRobustANGLEFn(GLuint program,
+ GLint location,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetnUniformivRobustANGLEFn(program, location, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetnUniformuivRobustANGLEFn(GLuint program,
+ GLint location,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint* params) {
+ driver_->fn.glGetnUniformuivRobustANGLEFn(program, location, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetObjectLabelFn(GLenum identifier,
+ GLuint name,
+ GLsizei bufSize,
+ GLsizei* length,
+ char* label) {
+ driver_->fn.glGetObjectLabelFn(identifier, name, bufSize, length, label);
+}
+
+void GLApiBase::glGetObjectPtrLabelFn(void* ptr,
+ GLsizei bufSize,
+ GLsizei* length,
+ char* label) {
+ driver_->fn.glGetObjectPtrLabelFn(ptr, bufSize, length, label);
+}
+
+void GLApiBase::glGetPointervFn(GLenum pname, void** params) {
+ driver_->fn.glGetPointervFn(pname, params);
+}
+
+void GLApiBase::glGetPointervRobustANGLERobustANGLEFn(GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ void** params) {
+ driver_->fn.glGetPointervRobustANGLERobustANGLEFn(pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetProgramBinaryFn(GLuint program,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLenum* binaryFormat,
+ GLvoid* binary) {
+ driver_->fn.glGetProgramBinaryFn(program, bufSize, length, binaryFormat,
+ binary);
+}
+
+void GLApiBase::glGetProgramInfoLogFn(GLuint program,
+ GLsizei bufsize,
+ GLsizei* length,
+ char* infolog) {
+ driver_->fn.glGetProgramInfoLogFn(program, bufsize, length, infolog);
+}
+
+void GLApiBase::glGetProgramInterfaceivFn(GLuint program,
+ GLenum programInterface,
+ GLenum pname,
+ GLint* params) {
+ driver_->fn.glGetProgramInterfaceivFn(program, programInterface, pname,
+ params);
+}
+
+void GLApiBase::glGetProgramInterfaceivRobustANGLEFn(GLuint program,
+ GLenum programInterface,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetProgramInterfaceivRobustANGLEFn(
+ program, programInterface, pname, bufSize, length, params);
+}
+
+void GLApiBase::glGetProgramivFn(GLuint program, GLenum pname, GLint* params) {
+ driver_->fn.glGetProgramivFn(program, pname, params);
+}
+
+void GLApiBase::glGetProgramivRobustANGLEFn(GLuint program,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetProgramivRobustANGLEFn(program, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetProgramResourceivFn(GLuint program,
+ GLenum programInterface,
+ GLuint index,
+ GLsizei propCount,
+ const GLenum* props,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetProgramResourceivFn(program, programInterface, index,
+ propCount, props, bufSize, length,
+ params);
+}
+
+GLint GLApiBase::glGetProgramResourceLocationFn(GLuint program,
+ GLenum programInterface,
+ const char* name) {
+ return driver_->fn.glGetProgramResourceLocationFn(program, programInterface,
+ name);
+}
+
+void GLApiBase::glGetProgramResourceNameFn(GLuint program,
+ GLenum programInterface,
+ GLuint index,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLchar* name) {
+ driver_->fn.glGetProgramResourceNameFn(program, programInterface, index,
+ bufSize, length, name);
+}
+
+void GLApiBase::glGetQueryivFn(GLenum target, GLenum pname, GLint* params) {
+ driver_->fn.glGetQueryivFn(target, pname, params);
+}
+
+void GLApiBase::glGetQueryivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetQueryivRobustANGLEFn(target, pname, bufSize, length, params);
+}
+
+void GLApiBase::glGetQueryObjecti64vFn(GLuint id,
+ GLenum pname,
+ GLint64* params) {
+ driver_->fn.glGetQueryObjecti64vFn(id, pname, params);
+}
+
+void GLApiBase::glGetQueryObjecti64vRobustANGLEFn(GLuint id,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint64* params) {
+ driver_->fn.glGetQueryObjecti64vRobustANGLEFn(id, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetQueryObjectivFn(GLuint id, GLenum pname, GLint* params) {
+ driver_->fn.glGetQueryObjectivFn(id, pname, params);
+}
+
+void GLApiBase::glGetQueryObjectivRobustANGLEFn(GLuint id,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetQueryObjectivRobustANGLEFn(id, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetQueryObjectui64vFn(GLuint id,
+ GLenum pname,
+ GLuint64* params) {
+ driver_->fn.glGetQueryObjectui64vFn(id, pname, params);
+}
+
+void GLApiBase::glGetQueryObjectui64vRobustANGLEFn(GLuint id,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint64* params) {
+ driver_->fn.glGetQueryObjectui64vRobustANGLEFn(id, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetQueryObjectuivFn(GLuint id, GLenum pname, GLuint* params) {
+ driver_->fn.glGetQueryObjectuivFn(id, pname, params);
+}
+
+void GLApiBase::glGetQueryObjectuivRobustANGLEFn(GLuint id,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint* params) {
+ driver_->fn.glGetQueryObjectuivRobustANGLEFn(id, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetRenderbufferParameterivEXTFn(GLenum target,
+ GLenum pname,
+ GLint* params) {
+ driver_->fn.glGetRenderbufferParameterivEXTFn(target, pname, params);
+}
+
+void GLApiBase::glGetRenderbufferParameterivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetRenderbufferParameterivRobustANGLEFn(target, pname, bufSize,
+ length, params);
+}
+
+void GLApiBase::glGetSamplerParameterfvFn(GLuint sampler,
+ GLenum pname,
+ GLfloat* params) {
+ driver_->fn.glGetSamplerParameterfvFn(sampler, pname, params);
+}
+
+void GLApiBase::glGetSamplerParameterfvRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* params) {
+ driver_->fn.glGetSamplerParameterfvRobustANGLEFn(sampler, pname, bufSize,
+ length, params);
+}
+
+void GLApiBase::glGetSamplerParameterIivRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetSamplerParameterIivRobustANGLEFn(sampler, pname, bufSize,
+ length, params);
+}
+
+void GLApiBase::glGetSamplerParameterIuivRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint* params) {
+ driver_->fn.glGetSamplerParameterIuivRobustANGLEFn(sampler, pname, bufSize,
+ length, params);
+}
+
+void GLApiBase::glGetSamplerParameterivFn(GLuint sampler,
+ GLenum pname,
+ GLint* params) {
+ driver_->fn.glGetSamplerParameterivFn(sampler, pname, params);
+}
+
+void GLApiBase::glGetSamplerParameterivRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetSamplerParameterivRobustANGLEFn(sampler, pname, bufSize,
+ length, params);
+}
+
+void GLApiBase::glGetShaderInfoLogFn(GLuint shader,
+ GLsizei bufsize,
+ GLsizei* length,
+ char* infolog) {
+ driver_->fn.glGetShaderInfoLogFn(shader, bufsize, length, infolog);
+}
+
+void GLApiBase::glGetShaderivFn(GLuint shader, GLenum pname, GLint* params) {
+ driver_->fn.glGetShaderivFn(shader, pname, params);
+}
+
+void GLApiBase::glGetShaderivRobustANGLEFn(GLuint shader,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetShaderivRobustANGLEFn(shader, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetShaderPrecisionFormatFn(GLenum shadertype,
+ GLenum precisiontype,
+ GLint* range,
+ GLint* precision) {
+ driver_->fn.glGetShaderPrecisionFormatFn(shadertype, precisiontype, range,
+ precision);
+}
+
+void GLApiBase::glGetShaderSourceFn(GLuint shader,
+ GLsizei bufsize,
+ GLsizei* length,
+ char* source) {
+ driver_->fn.glGetShaderSourceFn(shader, bufsize, length, source);
+}
+
+const GLubyte* GLApiBase::glGetStringFn(GLenum name) {
+ return driver_->fn.glGetStringFn(name);
+}
+
+const GLubyte* GLApiBase::glGetStringiFn(GLenum name, GLuint index) {
+ return driver_->fn.glGetStringiFn(name, index);
+}
+
+void GLApiBase::glGetSyncivFn(GLsync sync,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* values) {
+ driver_->fn.glGetSyncivFn(sync, pname, bufSize, length, values);
+}
+
+void GLApiBase::glGetTexLevelParameterfvFn(GLenum target,
+ GLint level,
+ GLenum pname,
+ GLfloat* params) {
+ driver_->fn.glGetTexLevelParameterfvFn(target, level, pname, params);
+}
+
+void GLApiBase::glGetTexLevelParameterfvRobustANGLEFn(GLenum target,
+ GLint level,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* params) {
+ driver_->fn.glGetTexLevelParameterfvRobustANGLEFn(target, level, pname,
+ bufSize, length, params);
+}
+
+void GLApiBase::glGetTexLevelParameterivFn(GLenum target,
+ GLint level,
+ GLenum pname,
+ GLint* params) {
+ driver_->fn.glGetTexLevelParameterivFn(target, level, pname, params);
+}
+
+void GLApiBase::glGetTexLevelParameterivRobustANGLEFn(GLenum target,
+ GLint level,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetTexLevelParameterivRobustANGLEFn(target, level, pname,
+ bufSize, length, params);
+}
+
+void GLApiBase::glGetTexParameterfvFn(GLenum target,
+ GLenum pname,
+ GLfloat* params) {
+ driver_->fn.glGetTexParameterfvFn(target, pname, params);
+}
+
+void GLApiBase::glGetTexParameterfvRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* params) {
+ driver_->fn.glGetTexParameterfvRobustANGLEFn(target, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetTexParameterIivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetTexParameterIivRobustANGLEFn(target, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetTexParameterIuivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint* params) {
+ driver_->fn.glGetTexParameterIuivRobustANGLEFn(target, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetTexParameterivFn(GLenum target,
+ GLenum pname,
+ GLint* params) {
+ driver_->fn.glGetTexParameterivFn(target, pname, params);
+}
+
+void GLApiBase::glGetTexParameterivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetTexParameterivRobustANGLEFn(target, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetTransformFeedbackVaryingFn(GLuint program,
+ GLuint index,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLsizei* size,
+ GLenum* type,
+ char* name) {
+ driver_->fn.glGetTransformFeedbackVaryingFn(program, index, bufSize, length,
+ size, type, name);
+}
+
+void GLApiBase::glGetTranslatedShaderSourceANGLEFn(GLuint shader,
+ GLsizei bufsize,
+ GLsizei* length,
+ char* source) {
+ driver_->fn.glGetTranslatedShaderSourceANGLEFn(shader, bufsize, length,
+ source);
+}
+
+GLuint GLApiBase::glGetUniformBlockIndexFn(GLuint program,
+ const char* uniformBlockName) {
+ return driver_->fn.glGetUniformBlockIndexFn(program, uniformBlockName);
+}
+
+void GLApiBase::glGetUniformfvFn(GLuint program,
+ GLint location,
+ GLfloat* params) {
+ driver_->fn.glGetUniformfvFn(program, location, params);
+}
+
+void GLApiBase::glGetUniformfvRobustANGLEFn(GLuint program,
+ GLint location,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* params) {
+ driver_->fn.glGetUniformfvRobustANGLEFn(program, location, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetUniformIndicesFn(GLuint program,
+ GLsizei uniformCount,
+ const char* const* uniformNames,
+ GLuint* uniformIndices) {
+ driver_->fn.glGetUniformIndicesFn(program, uniformCount, uniformNames,
+ uniformIndices);
+}
+
+void GLApiBase::glGetUniformivFn(GLuint program,
+ GLint location,
+ GLint* params) {
+ driver_->fn.glGetUniformivFn(program, location, params);
+}
+
+void GLApiBase::glGetUniformivRobustANGLEFn(GLuint program,
+ GLint location,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetUniformivRobustANGLEFn(program, location, bufSize, length,
+ params);
+}
+
+GLint GLApiBase::glGetUniformLocationFn(GLuint program, const char* name) {
+ return driver_->fn.glGetUniformLocationFn(program, name);
+}
+
+void GLApiBase::glGetUniformuivFn(GLuint program,
+ GLint location,
+ GLuint* params) {
+ driver_->fn.glGetUniformuivFn(program, location, params);
+}
+
+void GLApiBase::glGetUniformuivRobustANGLEFn(GLuint program,
+ GLint location,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint* params) {
+ driver_->fn.glGetUniformuivRobustANGLEFn(program, location, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetVertexAttribfvFn(GLuint index,
+ GLenum pname,
+ GLfloat* params) {
+ driver_->fn.glGetVertexAttribfvFn(index, pname, params);
+}
+
+void GLApiBase::glGetVertexAttribfvRobustANGLEFn(GLuint index,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* params) {
+ driver_->fn.glGetVertexAttribfvRobustANGLEFn(index, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetVertexAttribIivRobustANGLEFn(GLuint index,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetVertexAttribIivRobustANGLEFn(index, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetVertexAttribIuivRobustANGLEFn(GLuint index,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint* params) {
+ driver_->fn.glGetVertexAttribIuivRobustANGLEFn(index, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetVertexAttribivFn(GLuint index,
+ GLenum pname,
+ GLint* params) {
+ driver_->fn.glGetVertexAttribivFn(index, pname, params);
+}
+
+void GLApiBase::glGetVertexAttribivRobustANGLEFn(GLuint index,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ driver_->fn.glGetVertexAttribivRobustANGLEFn(index, pname, bufSize, length,
+ params);
+}
+
+void GLApiBase::glGetVertexAttribPointervFn(GLuint index,
+ GLenum pname,
+ void** pointer) {
+ driver_->fn.glGetVertexAttribPointervFn(index, pname, pointer);
+}
+
+void GLApiBase::glGetVertexAttribPointervRobustANGLEFn(GLuint index,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ void** pointer) {
+ driver_->fn.glGetVertexAttribPointervRobustANGLEFn(index, pname, bufSize,
+ length, pointer);
+}
+
+void GLApiBase::glHintFn(GLenum target, GLenum mode) {
+ driver_->fn.glHintFn(target, mode);
+}
+
+void GLApiBase::glInsertEventMarkerEXTFn(GLsizei length, const char* marker) {
+ driver_->fn.glInsertEventMarkerEXTFn(length, marker);
+}
+
+void GLApiBase::glInvalidateFramebufferFn(GLenum target,
+ GLsizei numAttachments,
+ const GLenum* attachments) {
+ driver_->fn.glInvalidateFramebufferFn(target, numAttachments, attachments);
+}
+
+void GLApiBase::glInvalidateSubFramebufferFn(GLenum target,
+ GLsizei numAttachments,
+ const GLenum* attachments,
+ GLint x,
+ GLint y,
+ GLint width,
+ GLint height) {
+ driver_->fn.glInvalidateSubFramebufferFn(target, numAttachments, attachments,
+ x, y, width, height);
+}
+
+GLboolean GLApiBase::glIsBufferFn(GLuint buffer) {
+ return driver_->fn.glIsBufferFn(buffer);
+}
+
+GLboolean GLApiBase::glIsEnabledFn(GLenum cap) {
+ return driver_->fn.glIsEnabledFn(cap);
+}
+
+GLboolean GLApiBase::glIsFenceAPPLEFn(GLuint fence) {
+ return driver_->fn.glIsFenceAPPLEFn(fence);
+}
+
+GLboolean GLApiBase::glIsFenceNVFn(GLuint fence) {
+ return driver_->fn.glIsFenceNVFn(fence);
+}
+
+GLboolean GLApiBase::glIsFramebufferEXTFn(GLuint framebuffer) {
+ return driver_->fn.glIsFramebufferEXTFn(framebuffer);
+}
+
+GLboolean GLApiBase::glIsPathNVFn(GLuint path) {
+ return driver_->fn.glIsPathNVFn(path);
+}
+
+GLboolean GLApiBase::glIsProgramFn(GLuint program) {
+ return driver_->fn.glIsProgramFn(program);
+}
+
+GLboolean GLApiBase::glIsQueryFn(GLuint query) {
+ return driver_->fn.glIsQueryFn(query);
+}
+
+GLboolean GLApiBase::glIsRenderbufferEXTFn(GLuint renderbuffer) {
+ return driver_->fn.glIsRenderbufferEXTFn(renderbuffer);
+}
+
+GLboolean GLApiBase::glIsSamplerFn(GLuint sampler) {
+ return driver_->fn.glIsSamplerFn(sampler);
+}
+
+GLboolean GLApiBase::glIsShaderFn(GLuint shader) {
+ return driver_->fn.glIsShaderFn(shader);
+}
+
+GLboolean GLApiBase::glIsSyncFn(GLsync sync) {
+ return driver_->fn.glIsSyncFn(sync);
+}
+
+GLboolean GLApiBase::glIsTextureFn(GLuint texture) {
+ return driver_->fn.glIsTextureFn(texture);
+}
+
+GLboolean GLApiBase::glIsTransformFeedbackFn(GLuint id) {
+ return driver_->fn.glIsTransformFeedbackFn(id);
+}
+
+GLboolean GLApiBase::glIsVertexArrayOESFn(GLuint array) {
+ return driver_->fn.glIsVertexArrayOESFn(array);
+}
+
+void GLApiBase::glLineWidthFn(GLfloat width) {
+ driver_->fn.glLineWidthFn(width);
+}
+
+void GLApiBase::glLinkProgramFn(GLuint program) {
+ driver_->fn.glLinkProgramFn(program);
+}
+
+void* GLApiBase::glMapBufferFn(GLenum target, GLenum access) {
+ return driver_->fn.glMapBufferFn(target, access);
+}
+
+void* GLApiBase::glMapBufferRangeFn(GLenum target,
+ GLintptr offset,
+ GLsizeiptr length,
+ GLbitfield access) {
+ return driver_->fn.glMapBufferRangeFn(target, offset, length, access);
+}
+
+void GLApiBase::glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) {
+ driver_->fn.glMatrixLoadfEXTFn(matrixMode, m);
+}
+
+void GLApiBase::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
+ driver_->fn.glMatrixLoadIdentityEXTFn(matrixMode);
+}
+
+void GLApiBase::glMemoryBarrierEXTFn(GLbitfield barriers) {
+ driver_->fn.glMemoryBarrierEXTFn(barriers);
+}
+
+void GLApiBase::glObjectLabelFn(GLenum identifier,
+ GLuint name,
+ GLsizei length,
+ const char* label) {
+ driver_->fn.glObjectLabelFn(identifier, name, length, label);
+}
+
+void GLApiBase::glObjectPtrLabelFn(void* ptr,
+ GLsizei length,
+ const char* label) {
+ driver_->fn.glObjectPtrLabelFn(ptr, length, label);
+}
+
+void GLApiBase::glPathCommandsNVFn(GLuint path,
+ GLsizei numCommands,
+ const GLubyte* commands,
+ GLsizei numCoords,
+ GLenum coordType,
+ const GLvoid* coords) {
+ driver_->fn.glPathCommandsNVFn(path, numCommands, commands, numCoords,
+ coordType, coords);
+}
+
+void GLApiBase::glPathParameterfNVFn(GLuint path, GLenum pname, GLfloat value) {
+ driver_->fn.glPathParameterfNVFn(path, pname, value);
+}
+
+void GLApiBase::glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) {
+ driver_->fn.glPathParameteriNVFn(path, pname, value);
+}
+
+void GLApiBase::glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) {
+ driver_->fn.glPathStencilFuncNVFn(func, ref, mask);
+}
+
+void GLApiBase::glPauseTransformFeedbackFn(void) {
+ driver_->fn.glPauseTransformFeedbackFn();
+}
+
+void GLApiBase::glPixelStoreiFn(GLenum pname, GLint param) {
+ driver_->fn.glPixelStoreiFn(pname, param);
+}
+
+void GLApiBase::glPointParameteriFn(GLenum pname, GLint param) {
+ driver_->fn.glPointParameteriFn(pname, param);
+}
+
+void GLApiBase::glPolygonOffsetFn(GLfloat factor, GLfloat units) {
+ driver_->fn.glPolygonOffsetFn(factor, units);
+}
+
+void GLApiBase::glPopDebugGroupFn() {
+ driver_->fn.glPopDebugGroupFn();
+}
+
+void GLApiBase::glPopGroupMarkerEXTFn(void) {
+ driver_->fn.glPopGroupMarkerEXTFn();
+}
+
+void GLApiBase::glPrimitiveRestartIndexFn(GLuint index) {
+ driver_->fn.glPrimitiveRestartIndexFn(index);
+}
+
+void GLApiBase::glProgramBinaryFn(GLuint program,
+ GLenum binaryFormat,
+ const GLvoid* binary,
+ GLsizei length) {
+ driver_->fn.glProgramBinaryFn(program, binaryFormat, binary, length);
+}
+
+void GLApiBase::glProgramParameteriFn(GLuint program,
+ GLenum pname,
+ GLint value) {
+ driver_->fn.glProgramParameteriFn(program, pname, value);
+}
+
+void GLApiBase::glProgramPathFragmentInputGenNVFn(GLuint program,
+ GLint location,
+ GLenum genMode,
+ GLint components,
+ const GLfloat* coeffs) {
+ driver_->fn.glProgramPathFragmentInputGenNVFn(program, location, genMode,
+ components, coeffs);
+}
+
+void GLApiBase::glPushDebugGroupFn(GLenum source,
+ GLuint id,
+ GLsizei length,
+ const char* message) {
+ driver_->fn.glPushDebugGroupFn(source, id, length, message);
+}
+
+void GLApiBase::glPushGroupMarkerEXTFn(GLsizei length, const char* marker) {
+ driver_->fn.glPushGroupMarkerEXTFn(length, marker);
+}
+
+void GLApiBase::glQueryCounterFn(GLuint id, GLenum target) {
+ driver_->fn.glQueryCounterFn(id, target);
+}
+
+void GLApiBase::glReadBufferFn(GLenum src) {
+ driver_->fn.glReadBufferFn(src);
+}
+
+void GLApiBase::glReadnPixelsRobustANGLEFn(GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLenum type,
+ GLsizei bufSize,
+ GLsizei* length,
+ void* data) {
+ driver_->fn.glReadnPixelsRobustANGLEFn(x, y, width, height, format, type,
+ bufSize, length, data);
+}
+
+void GLApiBase::glReadPixelsFn(GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLenum type,
+ void* pixels) {
+ driver_->fn.glReadPixelsFn(x, y, width, height, format, type, pixels);
+}
+
+void GLApiBase::glReadPixelsRobustANGLEFn(GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLenum type,
+ GLsizei bufSize,
+ GLsizei* length,
+ void* pixels) {
+ driver_->fn.glReadPixelsRobustANGLEFn(x, y, width, height, format, type,
+ bufSize, length, pixels);
+}
+
+void GLApiBase::glReleaseShaderCompilerFn(void) {
+ driver_->fn.glReleaseShaderCompilerFn();
+}
+
+void GLApiBase::glRenderbufferStorageEXTFn(GLenum target,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height) {
+ driver_->fn.glRenderbufferStorageEXTFn(target, internalformat, width, height);
+}
+
+void GLApiBase::glRenderbufferStorageMultisampleFn(GLenum target,
+ GLsizei samples,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height) {
+ driver_->fn.glRenderbufferStorageMultisampleFn(target, samples,
+ internalformat, width, height);
+}
+
+void GLApiBase::glRenderbufferStorageMultisampleANGLEFn(GLenum target,
+ GLsizei samples,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height) {
+ driver_->fn.glRenderbufferStorageMultisampleANGLEFn(
+ target, samples, internalformat, width, height);
+}
+
+void GLApiBase::glRenderbufferStorageMultisampleEXTFn(GLenum target,
+ GLsizei samples,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height) {
+ driver_->fn.glRenderbufferStorageMultisampleEXTFn(
+ target, samples, internalformat, width, height);
+}
+
+void GLApiBase::glRenderbufferStorageMultisampleIMGFn(GLenum target,
+ GLsizei samples,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height) {
+ driver_->fn.glRenderbufferStorageMultisampleIMGFn(
+ target, samples, internalformat, width, height);
+}
+
+void GLApiBase::glResumeTransformFeedbackFn(void) {
+ driver_->fn.glResumeTransformFeedbackFn();
+}
+
+void GLApiBase::glSampleCoverageFn(GLclampf value, GLboolean invert) {
+ driver_->fn.glSampleCoverageFn(value, invert);
+}
+
+void GLApiBase::glSamplerParameterfFn(GLuint sampler,
+ GLenum pname,
+ GLfloat param) {
+ driver_->fn.glSamplerParameterfFn(sampler, pname, param);
+}
+
+void GLApiBase::glSamplerParameterfvFn(GLuint sampler,
+ GLenum pname,
+ const GLfloat* params) {
+ driver_->fn.glSamplerParameterfvFn(sampler, pname, params);
+}
+
+void GLApiBase::glSamplerParameterfvRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLfloat* param) {
+ driver_->fn.glSamplerParameterfvRobustANGLEFn(sampler, pname, bufSize, param);
+}
+
+void GLApiBase::glSamplerParameteriFn(GLuint sampler,
+ GLenum pname,
+ GLint param) {
+ driver_->fn.glSamplerParameteriFn(sampler, pname, param);
+}
+
+void GLApiBase::glSamplerParameterIivRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLint* param) {
+ driver_->fn.glSamplerParameterIivRobustANGLEFn(sampler, pname, bufSize,
+ param);
+}
+
+void GLApiBase::glSamplerParameterIuivRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLuint* param) {
+ driver_->fn.glSamplerParameterIuivRobustANGLEFn(sampler, pname, bufSize,
+ param);
+}
+
+void GLApiBase::glSamplerParameterivFn(GLuint sampler,
+ GLenum pname,
+ const GLint* params) {
+ driver_->fn.glSamplerParameterivFn(sampler, pname, params);
+}
+
+void GLApiBase::glSamplerParameterivRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLint* param) {
+ driver_->fn.glSamplerParameterivRobustANGLEFn(sampler, pname, bufSize, param);
+}
+
+void GLApiBase::glScissorFn(GLint x, GLint y, GLsizei width, GLsizei height) {
+ driver_->fn.glScissorFn(x, y, width, height);
+}
+
+void GLApiBase::glSetFenceAPPLEFn(GLuint fence) {
+ driver_->fn.glSetFenceAPPLEFn(fence);
+}
+
+void GLApiBase::glSetFenceNVFn(GLuint fence, GLenum condition) {
+ driver_->fn.glSetFenceNVFn(fence, condition);
+}
+
+void GLApiBase::glShaderBinaryFn(GLsizei n,
+ const GLuint* shaders,
+ GLenum binaryformat,
+ const void* binary,
+ GLsizei length) {
+ driver_->fn.glShaderBinaryFn(n, shaders, binaryformat, binary, length);
+}
+
+void GLApiBase::glShaderSourceFn(GLuint shader,
+ GLsizei count,
+ const char* const* str,
+ const GLint* length) {
+ driver_->fn.glShaderSourceFn(shader, count, str, length);
+}
+
+void GLApiBase::glStencilFillPathInstancedNVFn(GLsizei numPaths,
+ GLenum pathNameType,
+ const void* paths,
+ GLuint pathBase,
+ GLenum fillMode,
+ GLuint mask,
+ GLenum transformType,
+ const GLfloat* transformValues) {
+ driver_->fn.glStencilFillPathInstancedNVFn(numPaths, pathNameType, paths,
+ pathBase, fillMode, mask,
+ transformType, transformValues);
+}
+
+void GLApiBase::glStencilFillPathNVFn(GLuint path,
+ GLenum fillMode,
+ GLuint mask) {
+ driver_->fn.glStencilFillPathNVFn(path, fillMode, mask);
+}
+
+void GLApiBase::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
+ driver_->fn.glStencilFuncFn(func, ref, mask);
+}
+
+void GLApiBase::glStencilFuncSeparateFn(GLenum face,
+ GLenum func,
+ GLint ref,
+ GLuint mask) {
+ driver_->fn.glStencilFuncSeparateFn(face, func, ref, mask);
+}
+
+void GLApiBase::glStencilMaskFn(GLuint mask) {
+ driver_->fn.glStencilMaskFn(mask);
+}
+
+void GLApiBase::glStencilMaskSeparateFn(GLenum face, GLuint mask) {
+ driver_->fn.glStencilMaskSeparateFn(face, mask);
+}
+
+void GLApiBase::glStencilOpFn(GLenum fail, GLenum zfail, GLenum zpass) {
+ driver_->fn.glStencilOpFn(fail, zfail, zpass);
+}
+
+void GLApiBase::glStencilOpSeparateFn(GLenum face,
+ GLenum fail,
+ GLenum zfail,
+ GLenum zpass) {
+ driver_->fn.glStencilOpSeparateFn(face, fail, zfail, zpass);
+}
+
+void GLApiBase::glStencilStrokePathInstancedNVFn(
+ GLsizei numPaths,
+ GLenum pathNameType,
+ const void* paths,
+ GLuint pathBase,
+ GLint ref,
+ GLuint mask,
+ GLenum transformType,
+ const GLfloat* transformValues) {
+ driver_->fn.glStencilStrokePathInstancedNVFn(numPaths, pathNameType, paths,
+ pathBase, ref, mask,
+ transformType, transformValues);
+}
+
+void GLApiBase::glStencilStrokePathNVFn(GLuint path,
+ GLint reference,
+ GLuint mask) {
+ driver_->fn.glStencilStrokePathNVFn(path, reference, mask);
+}
+
+void GLApiBase::glStencilThenCoverFillPathInstancedNVFn(
+ GLsizei numPaths,
+ GLenum pathNameType,
+ const void* paths,
+ GLuint pathBase,
+ GLenum fillMode,
+ GLuint mask,
+ GLenum coverMode,
+ GLenum transformType,
+ const GLfloat* transformValues) {
+ driver_->fn.glStencilThenCoverFillPathInstancedNVFn(
+ numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
+ transformType, transformValues);
+}
+
+void GLApiBase::glStencilThenCoverFillPathNVFn(GLuint path,
+ GLenum fillMode,
+ GLuint mask,
+ GLenum coverMode) {
+ driver_->fn.glStencilThenCoverFillPathNVFn(path, fillMode, mask, coverMode);
+}
+
+void GLApiBase::glStencilThenCoverStrokePathInstancedNVFn(
+ GLsizei numPaths,
+ GLenum pathNameType,
+ const void* paths,
+ GLuint pathBase,
+ GLint ref,
+ GLuint mask,
+ GLenum coverMode,
+ GLenum transformType,
+ const GLfloat* transformValues) {
+ driver_->fn.glStencilThenCoverStrokePathInstancedNVFn(
+ numPaths, pathNameType, paths, pathBase, ref, mask, coverMode,
+ transformType, transformValues);
+}
+
+void GLApiBase::glStencilThenCoverStrokePathNVFn(GLuint path,
+ GLint reference,
+ GLuint mask,
+ GLenum coverMode) {
+ driver_->fn.glStencilThenCoverStrokePathNVFn(path, reference, mask,
+ coverMode);
+}
+
+GLboolean GLApiBase::glTestFenceAPPLEFn(GLuint fence) {
+ return driver_->fn.glTestFenceAPPLEFn(fence);
+}
+
+GLboolean GLApiBase::glTestFenceNVFn(GLuint fence) {
+ return driver_->fn.glTestFenceNVFn(fence);
+}
+
+void GLApiBase::glTexImage2DFn(GLenum target,
+ GLint level,
+ GLint internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLint border,
+ GLenum format,
+ GLenum type,
+ const void* pixels) {
+ driver_->fn.glTexImage2DFn(target, level, internalformat, width, height,
+ border, format, type, pixels);
+}
+
+void GLApiBase::glTexImage2DRobustANGLEFn(GLenum target,
+ GLint level,
+ GLint internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLint border,
+ GLenum format,
+ GLenum type,
+ GLsizei bufSize,
+ const void* pixels) {
+ driver_->fn.glTexImage2DRobustANGLEFn(target, level, internalformat, width,
+ height, border, format, type, bufSize,
+ pixels);
+}
+
+void GLApiBase::glTexImage3DFn(GLenum target,
+ GLint level,
+ GLint internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ GLint border,
+ GLenum format,
+ GLenum type,
+ const void* pixels) {
+ driver_->fn.glTexImage3DFn(target, level, internalformat, width, height,
+ depth, border, format, type, pixels);
+}
+
+void GLApiBase::glTexImage3DRobustANGLEFn(GLenum target,
+ GLint level,
+ GLint internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ GLint border,
+ GLenum format,
+ GLenum type,
+ GLsizei bufSize,
+ const void* pixels) {
+ driver_->fn.glTexImage3DRobustANGLEFn(target, level, internalformat, width,
+ height, depth, border, format, type,
+ bufSize, pixels);
+}
+
+void GLApiBase::glTexParameterfFn(GLenum target, GLenum pname, GLfloat param) {
+ driver_->fn.glTexParameterfFn(target, pname, param);
+}
+
+void GLApiBase::glTexParameterfvFn(GLenum target,
+ GLenum pname,
+ const GLfloat* params) {
+ driver_->fn.glTexParameterfvFn(target, pname, params);
+}
+
+void GLApiBase::glTexParameterfvRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLfloat* params) {
+ driver_->fn.glTexParameterfvRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void GLApiBase::glTexParameteriFn(GLenum target, GLenum pname, GLint param) {
+ driver_->fn.glTexParameteriFn(target, pname, param);
+}
+
+void GLApiBase::glTexParameterIivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLint* params) {
+ driver_->fn.glTexParameterIivRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void GLApiBase::glTexParameterIuivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLuint* params) {
+ driver_->fn.glTexParameterIuivRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void GLApiBase::glTexParameterivFn(GLenum target,
+ GLenum pname,
+ const GLint* params) {
+ driver_->fn.glTexParameterivFn(target, pname, params);
+}
+
+void GLApiBase::glTexParameterivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLint* params) {
+ driver_->fn.glTexParameterivRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void GLApiBase::glTexStorage2DEXTFn(GLenum target,
+ GLsizei levels,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height) {
+ driver_->fn.glTexStorage2DEXTFn(target, levels, internalformat, width,
+ height);
+}
+
+void GLApiBase::glTexStorage3DFn(GLenum target,
+ GLsizei levels,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth) {
+ driver_->fn.glTexStorage3DFn(target, levels, internalformat, width, height,
+ depth);
+}
+
+void GLApiBase::glTexSubImage2DFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLenum type,
+ const void* pixels) {
+ driver_->fn.glTexSubImage2DFn(target, level, xoffset, yoffset, width, height,
+ format, type, pixels);
+}
+
+void GLApiBase::glTexSubImage2DRobustANGLEFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLenum type,
+ GLsizei bufSize,
+ const void* pixels) {
+ driver_->fn.glTexSubImage2DRobustANGLEFn(target, level, xoffset, yoffset,
+ width, height, format, type, bufSize,
+ pixels);
+}
+
+void GLApiBase::glTexSubImage3DFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLint zoffset,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ GLenum format,
+ GLenum type,
+ const void* pixels) {
+ driver_->fn.glTexSubImage3DFn(target, level, xoffset, yoffset, zoffset, width,
+ height, depth, format, type, pixels);
+}
+
+void GLApiBase::glTexSubImage3DRobustANGLEFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLint zoffset,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ GLenum format,
+ GLenum type,
+ GLsizei bufSize,
+ const void* pixels) {
+ driver_->fn.glTexSubImage3DRobustANGLEFn(target, level, xoffset, yoffset,
+ zoffset, width, height, depth,
+ format, type, bufSize, pixels);
+}
+
+void GLApiBase::glTransformFeedbackVaryingsFn(GLuint program,
+ GLsizei count,
+ const char* const* varyings,
+ GLenum bufferMode) {
+ driver_->fn.glTransformFeedbackVaryingsFn(program, count, varyings,
+ bufferMode);
+}
+
+void GLApiBase::glUniform1fFn(GLint location, GLfloat x) {
+ driver_->fn.glUniform1fFn(location, x);
+}
+
+void GLApiBase::glUniform1fvFn(GLint location,
+ GLsizei count,
+ const GLfloat* v) {
+ driver_->fn.glUniform1fvFn(location, count, v);
+}
+
+void GLApiBase::glUniform1iFn(GLint location, GLint x) {
+ driver_->fn.glUniform1iFn(location, x);
+}
+
+void GLApiBase::glUniform1ivFn(GLint location, GLsizei count, const GLint* v) {
+ driver_->fn.glUniform1ivFn(location, count, v);
+}
+
+void GLApiBase::glUniform1uiFn(GLint location, GLuint v0) {
+ driver_->fn.glUniform1uiFn(location, v0);
+}
+
+void GLApiBase::glUniform1uivFn(GLint location,
+ GLsizei count,
+ const GLuint* v) {
+ driver_->fn.glUniform1uivFn(location, count, v);
+}
+
+void GLApiBase::glUniform2fFn(GLint location, GLfloat x, GLfloat y) {
+ driver_->fn.glUniform2fFn(location, x, y);
+}
+
+void GLApiBase::glUniform2fvFn(GLint location,
+ GLsizei count,
+ const GLfloat* v) {
+ driver_->fn.glUniform2fvFn(location, count, v);
+}
+
+void GLApiBase::glUniform2iFn(GLint location, GLint x, GLint y) {
+ driver_->fn.glUniform2iFn(location, x, y);
+}
+
+void GLApiBase::glUniform2ivFn(GLint location, GLsizei count, const GLint* v) {
+ driver_->fn.glUniform2ivFn(location, count, v);
+}
+
+void GLApiBase::glUniform2uiFn(GLint location, GLuint v0, GLuint v1) {
+ driver_->fn.glUniform2uiFn(location, v0, v1);
+}
+
+void GLApiBase::glUniform2uivFn(GLint location,
+ GLsizei count,
+ const GLuint* v) {
+ driver_->fn.glUniform2uivFn(location, count, v);
+}
+
+void GLApiBase::glUniform3fFn(GLint location, GLfloat x, GLfloat y, GLfloat z) {
+ driver_->fn.glUniform3fFn(location, x, y, z);
+}
+
+void GLApiBase::glUniform3fvFn(GLint location,
+ GLsizei count,
+ const GLfloat* v) {
+ driver_->fn.glUniform3fvFn(location, count, v);
+}
+
+void GLApiBase::glUniform3iFn(GLint location, GLint x, GLint y, GLint z) {
+ driver_->fn.glUniform3iFn(location, x, y, z);
+}
+
+void GLApiBase::glUniform3ivFn(GLint location, GLsizei count, const GLint* v) {
+ driver_->fn.glUniform3ivFn(location, count, v);
+}
+
+void GLApiBase::glUniform3uiFn(GLint location,
+ GLuint v0,
+ GLuint v1,
+ GLuint v2) {
+ driver_->fn.glUniform3uiFn(location, v0, v1, v2);
+}
+
+void GLApiBase::glUniform3uivFn(GLint location,
+ GLsizei count,
+ const GLuint* v) {
+ driver_->fn.glUniform3uivFn(location, count, v);
+}
+
+void GLApiBase::glUniform4fFn(GLint location,
+ GLfloat x,
+ GLfloat y,
+ GLfloat z,
+ GLfloat w) {
+ driver_->fn.glUniform4fFn(location, x, y, z, w);
+}
+
+void GLApiBase::glUniform4fvFn(GLint location,
+ GLsizei count,
+ const GLfloat* v) {
+ driver_->fn.glUniform4fvFn(location, count, v);
+}
+
+void GLApiBase::glUniform4iFn(GLint location,
+ GLint x,
+ GLint y,
+ GLint z,
+ GLint w) {
+ driver_->fn.glUniform4iFn(location, x, y, z, w);
+}
+
+void GLApiBase::glUniform4ivFn(GLint location, GLsizei count, const GLint* v) {
+ driver_->fn.glUniform4ivFn(location, count, v);
+}
+
+void GLApiBase::glUniform4uiFn(GLint location,
+ GLuint v0,
+ GLuint v1,
+ GLuint v2,
+ GLuint v3) {
+ driver_->fn.glUniform4uiFn(location, v0, v1, v2, v3);
+}
+
+void GLApiBase::glUniform4uivFn(GLint location,
+ GLsizei count,
+ const GLuint* v) {
+ driver_->fn.glUniform4uivFn(location, count, v);
+}
+
+void GLApiBase::glUniformBlockBindingFn(GLuint program,
+ GLuint uniformBlockIndex,
+ GLuint uniformBlockBinding) {
+ driver_->fn.glUniformBlockBindingFn(program, uniformBlockIndex,
+ uniformBlockBinding);
+}
+
+void GLApiBase::glUniformMatrix2fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ driver_->fn.glUniformMatrix2fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix2x3fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ driver_->fn.glUniformMatrix2x3fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix2x4fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ driver_->fn.glUniformMatrix2x4fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix3fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ driver_->fn.glUniformMatrix3fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix3x2fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ driver_->fn.glUniformMatrix3x2fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix3x4fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ driver_->fn.glUniformMatrix3x4fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix4fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ driver_->fn.glUniformMatrix4fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix4x2fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ driver_->fn.glUniformMatrix4x2fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix4x3fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ driver_->fn.glUniformMatrix4x3fvFn(location, count, transpose, value);
+}
+
+GLboolean GLApiBase::glUnmapBufferFn(GLenum target) {
+ return driver_->fn.glUnmapBufferFn(target);
+}
+
+void GLApiBase::glUseProgramFn(GLuint program) {
+ driver_->fn.glUseProgramFn(program);
+}
+
+void GLApiBase::glValidateProgramFn(GLuint program) {
+ driver_->fn.glValidateProgramFn(program);
+}
+
+void GLApiBase::glVertexAttrib1fFn(GLuint indx, GLfloat x) {
+ driver_->fn.glVertexAttrib1fFn(indx, x);
+}
+
+void GLApiBase::glVertexAttrib1fvFn(GLuint indx, const GLfloat* values) {
+ driver_->fn.glVertexAttrib1fvFn(indx, values);
+}
+
+void GLApiBase::glVertexAttrib2fFn(GLuint indx, GLfloat x, GLfloat y) {
+ driver_->fn.glVertexAttrib2fFn(indx, x, y);
+}
+
+void GLApiBase::glVertexAttrib2fvFn(GLuint indx, const GLfloat* values) {
+ driver_->fn.glVertexAttrib2fvFn(indx, values);
+}
+
+void GLApiBase::glVertexAttrib3fFn(GLuint indx,
+ GLfloat x,
+ GLfloat y,
+ GLfloat z) {
+ driver_->fn.glVertexAttrib3fFn(indx, x, y, z);
+}
+
+void GLApiBase::glVertexAttrib3fvFn(GLuint indx, const GLfloat* values) {
+ driver_->fn.glVertexAttrib3fvFn(indx, values);
+}
+
+void GLApiBase::glVertexAttrib4fFn(GLuint indx,
+ GLfloat x,
+ GLfloat y,
+ GLfloat z,
+ GLfloat w) {
+ driver_->fn.glVertexAttrib4fFn(indx, x, y, z, w);
+}
+
+void GLApiBase::glVertexAttrib4fvFn(GLuint indx, const GLfloat* values) {
+ driver_->fn.glVertexAttrib4fvFn(indx, values);
+}
+
+void GLApiBase::glVertexAttribDivisorANGLEFn(GLuint index, GLuint divisor) {
+ driver_->fn.glVertexAttribDivisorANGLEFn(index, divisor);
+}
+
+void GLApiBase::glVertexAttribI4iFn(GLuint indx,
+ GLint x,
+ GLint y,
+ GLint z,
+ GLint w) {
+ driver_->fn.glVertexAttribI4iFn(indx, x, y, z, w);
+}
+
+void GLApiBase::glVertexAttribI4ivFn(GLuint indx, const GLint* values) {
+ driver_->fn.glVertexAttribI4ivFn(indx, values);
+}
+
+void GLApiBase::glVertexAttribI4uiFn(GLuint indx,
+ GLuint x,
+ GLuint y,
+ GLuint z,
+ GLuint w) {
+ driver_->fn.glVertexAttribI4uiFn(indx, x, y, z, w);
+}
+
+void GLApiBase::glVertexAttribI4uivFn(GLuint indx, const GLuint* values) {
+ driver_->fn.glVertexAttribI4uivFn(indx, values);
+}
+
+void GLApiBase::glVertexAttribIPointerFn(GLuint indx,
+ GLint size,
+ GLenum type,
+ GLsizei stride,
+ const void* ptr) {
+ driver_->fn.glVertexAttribIPointerFn(indx, size, type, stride, ptr);
+}
+
+void GLApiBase::glVertexAttribPointerFn(GLuint indx,
+ GLint size,
+ GLenum type,
+ GLboolean normalized,
+ GLsizei stride,
+ const void* ptr) {
+ driver_->fn.glVertexAttribPointerFn(indx, size, type, normalized, stride,
+ ptr);
+}
+
+void GLApiBase::glViewportFn(GLint x, GLint y, GLsizei width, GLsizei height) {
+ driver_->fn.glViewportFn(x, y, width, height);
+}
+
+GLenum GLApiBase::glWaitSyncFn(GLsync sync,
+ GLbitfield flags,
+ GLuint64 timeout) {
+ return driver_->fn.glWaitSyncFn(sync, flags, timeout);
+}
+
+} // namespace gl
« no previous file with comments | « ui/gl/gl_bindings_autogen_gl0.cc ('k') | ui/gl/gl_bindings_autogen_gl2.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698