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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: ui/gl/gl_bindings_autogen_gl3.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_gl2.cc ('k') | ui/gl/gl_bindings_autogen_gl4.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: ui/gl/gl_bindings_autogen_gl3.cc
diff --git a/ui/gl/gl_bindings_autogen_gl3.cc b/ui/gl/gl_bindings_autogen_gl3.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f290c3e2e77796750be61cc2fd240214ef051508
--- /dev/null
+++ b/ui/gl/gl_bindings_autogen_gl3.cc
@@ -0,0 +1,3040 @@
+// 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 TraceGLApi::glActiveTextureFn(GLenum texture) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glActiveTexture")
+ gl_api_->glActiveTextureFn(texture);
+}
+
+void TraceGLApi::glApplyFramebufferAttachmentCMAAINTELFn(void) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glApplyFramebufferAttachmentCMAAINTEL")
+ gl_api_->glApplyFramebufferAttachmentCMAAINTELFn();
+}
+
+void TraceGLApi::glAttachShaderFn(GLuint program, GLuint shader) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glAttachShader")
+ gl_api_->glAttachShaderFn(program, shader);
+}
+
+void TraceGLApi::glBeginQueryFn(GLenum target, GLuint id) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBeginQuery")
+ gl_api_->glBeginQueryFn(target, id);
+}
+
+void TraceGLApi::glBeginTransformFeedbackFn(GLenum primitiveMode) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBeginTransformFeedback")
+ gl_api_->glBeginTransformFeedbackFn(primitiveMode);
+}
+
+void TraceGLApi::glBindAttribLocationFn(GLuint program,
+ GLuint index,
+ const char* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindAttribLocation")
+ gl_api_->glBindAttribLocationFn(program, index, name);
+}
+
+void TraceGLApi::glBindBufferFn(GLenum target, GLuint buffer) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindBuffer")
+ gl_api_->glBindBufferFn(target, buffer);
+}
+
+void TraceGLApi::glBindBufferBaseFn(GLenum target,
+ GLuint index,
+ GLuint buffer) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindBufferBase")
+ gl_api_->glBindBufferBaseFn(target, index, buffer);
+}
+
+void TraceGLApi::glBindBufferRangeFn(GLenum target,
+ GLuint index,
+ GLuint buffer,
+ GLintptr offset,
+ GLsizeiptr size) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindBufferRange")
+ gl_api_->glBindBufferRangeFn(target, index, buffer, offset, size);
+}
+
+void TraceGLApi::glBindFragDataLocationFn(GLuint program,
+ GLuint colorNumber,
+ const char* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindFragDataLocation")
+ gl_api_->glBindFragDataLocationFn(program, colorNumber, name);
+}
+
+void TraceGLApi::glBindFragDataLocationIndexedFn(GLuint program,
+ GLuint colorNumber,
+ GLuint index,
+ const char* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glBindFragDataLocationIndexed")
+ gl_api_->glBindFragDataLocationIndexedFn(program, colorNumber, index, name);
+}
+
+void TraceGLApi::glBindFramebufferEXTFn(GLenum target, GLuint framebuffer) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindFramebufferEXT")
+ gl_api_->glBindFramebufferEXTFn(target, framebuffer);
+}
+
+void TraceGLApi::glBindImageTextureEXTFn(GLuint index,
+ GLuint texture,
+ GLint level,
+ GLboolean layered,
+ GLint layer,
+ GLenum access,
+ GLint format) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindImageTextureEXT")
+ gl_api_->glBindImageTextureEXTFn(index, texture, level, layered, layer,
+ access, format);
+}
+
+void TraceGLApi::glBindRenderbufferEXTFn(GLenum target, GLuint renderbuffer) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindRenderbufferEXT")
+ gl_api_->glBindRenderbufferEXTFn(target, renderbuffer);
+}
+
+void TraceGLApi::glBindSamplerFn(GLuint unit, GLuint sampler) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindSampler")
+ gl_api_->glBindSamplerFn(unit, sampler);
+}
+
+void TraceGLApi::glBindTextureFn(GLenum target, GLuint texture) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindTexture")
+ gl_api_->glBindTextureFn(target, texture);
+}
+
+void TraceGLApi::glBindTransformFeedbackFn(GLenum target, GLuint id) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindTransformFeedback")
+ gl_api_->glBindTransformFeedbackFn(target, id);
+}
+
+void TraceGLApi::glBindUniformLocationCHROMIUMFn(GLuint program,
+ GLint location,
+ const char* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glBindUniformLocationCHROMIUM")
+ gl_api_->glBindUniformLocationCHROMIUMFn(program, location, name);
+}
+
+void TraceGLApi::glBindVertexArrayOESFn(GLuint array) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindVertexArrayOES")
+ gl_api_->glBindVertexArrayOESFn(array);
+}
+
+void TraceGLApi::glBlendBarrierKHRFn(void) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendBarrierKHR")
+ gl_api_->glBlendBarrierKHRFn();
+}
+
+void TraceGLApi::glBlendColorFn(GLclampf red,
+ GLclampf green,
+ GLclampf blue,
+ GLclampf alpha) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendColor")
+ gl_api_->glBlendColorFn(red, green, blue, alpha);
+}
+
+void TraceGLApi::glBlendEquationFn(GLenum mode) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendEquation")
+ gl_api_->glBlendEquationFn(mode);
+}
+
+void TraceGLApi::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendEquationSeparate")
+ gl_api_->glBlendEquationSeparateFn(modeRGB, modeAlpha);
+}
+
+void TraceGLApi::glBlendFuncFn(GLenum sfactor, GLenum dfactor) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendFunc")
+ gl_api_->glBlendFuncFn(sfactor, dfactor);
+}
+
+void TraceGLApi::glBlendFuncSeparateFn(GLenum srcRGB,
+ GLenum dstRGB,
+ GLenum srcAlpha,
+ GLenum dstAlpha) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendFuncSeparate")
+ gl_api_->glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha, dstAlpha);
+}
+
+void TraceGLApi::glBlitFramebufferFn(GLint srcX0,
+ GLint srcY0,
+ GLint srcX1,
+ GLint srcY1,
+ GLint dstX0,
+ GLint dstY0,
+ GLint dstX1,
+ GLint dstY1,
+ GLbitfield mask,
+ GLenum filter) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlitFramebuffer")
+ gl_api_->glBlitFramebufferFn(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
+ dstY1, mask, filter);
+}
+
+void TraceGLApi::glBlitFramebufferANGLEFn(GLint srcX0,
+ GLint srcY0,
+ GLint srcX1,
+ GLint srcY1,
+ GLint dstX0,
+ GLint dstY0,
+ GLint dstX1,
+ GLint dstY1,
+ GLbitfield mask,
+ GLenum filter) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlitFramebufferANGLE")
+ gl_api_->glBlitFramebufferANGLEFn(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+ dstX1, dstY1, mask, filter);
+}
+
+void TraceGLApi::glBlitFramebufferEXTFn(GLint srcX0,
+ GLint srcY0,
+ GLint srcX1,
+ GLint srcY1,
+ GLint dstX0,
+ GLint dstY0,
+ GLint dstX1,
+ GLint dstY1,
+ GLbitfield mask,
+ GLenum filter) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlitFramebufferEXT")
+ gl_api_->glBlitFramebufferEXTFn(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+ dstX1, dstY1, mask, filter);
+}
+
+void TraceGLApi::glBufferDataFn(GLenum target,
+ GLsizeiptr size,
+ const void* data,
+ GLenum usage) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBufferData")
+ gl_api_->glBufferDataFn(target, size, data, usage);
+}
+
+void TraceGLApi::glBufferSubDataFn(GLenum target,
+ GLintptr offset,
+ GLsizeiptr size,
+ const void* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBufferSubData")
+ gl_api_->glBufferSubDataFn(target, offset, size, data);
+}
+
+GLenum TraceGLApi::glCheckFramebufferStatusEXTFn(GLenum target) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glCheckFramebufferStatusEXT")
+ return gl_api_->glCheckFramebufferStatusEXTFn(target);
+}
+
+void TraceGLApi::glClearFn(GLbitfield mask) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClear")
+ gl_api_->glClearFn(mask);
+}
+
+void TraceGLApi::glClearBufferfiFn(GLenum buffer,
+ GLint drawbuffer,
+ const GLfloat depth,
+ GLint stencil) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClearBufferfi")
+ gl_api_->glClearBufferfiFn(buffer, drawbuffer, depth, stencil);
+}
+
+void TraceGLApi::glClearBufferfvFn(GLenum buffer,
+ GLint drawbuffer,
+ const GLfloat* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClearBufferfv")
+ gl_api_->glClearBufferfvFn(buffer, drawbuffer, value);
+}
+
+void TraceGLApi::glClearBufferivFn(GLenum buffer,
+ GLint drawbuffer,
+ const GLint* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClearBufferiv")
+ gl_api_->glClearBufferivFn(buffer, drawbuffer, value);
+}
+
+void TraceGLApi::glClearBufferuivFn(GLenum buffer,
+ GLint drawbuffer,
+ const GLuint* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClearBufferuiv")
+ gl_api_->glClearBufferuivFn(buffer, drawbuffer, value);
+}
+
+void TraceGLApi::glClearColorFn(GLclampf red,
+ GLclampf green,
+ GLclampf blue,
+ GLclampf alpha) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClearColor")
+ gl_api_->glClearColorFn(red, green, blue, alpha);
+}
+
+void TraceGLApi::glClearDepthFn(GLclampd depth) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClearDepth")
+ gl_api_->glClearDepthFn(depth);
+}
+
+void TraceGLApi::glClearDepthfFn(GLclampf depth) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClearDepthf")
+ gl_api_->glClearDepthfFn(depth);
+}
+
+void TraceGLApi::glClearStencilFn(GLint s) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClearStencil")
+ gl_api_->glClearStencilFn(s);
+}
+
+GLenum TraceGLApi::glClientWaitSyncFn(GLsync sync,
+ GLbitfield flags,
+ GLuint64 timeout) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClientWaitSync")
+ return gl_api_->glClientWaitSyncFn(sync, flags, timeout);
+}
+
+void TraceGLApi::glColorMaskFn(GLboolean red,
+ GLboolean green,
+ GLboolean blue,
+ GLboolean alpha) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glColorMask")
+ gl_api_->glColorMaskFn(red, green, blue, alpha);
+}
+
+void TraceGLApi::glCompileShaderFn(GLuint shader) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCompileShader")
+ gl_api_->glCompileShaderFn(shader);
+}
+
+void TraceGLApi::glCompressedCopyTextureCHROMIUMFn(GLuint sourceId,
+ GLuint destId) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glCompressedCopyTextureCHROMIUM")
+ gl_api_->glCompressedCopyTextureCHROMIUMFn(sourceId, destId);
+}
+
+void TraceGLApi::glCompressedTexImage2DFn(GLenum target,
+ GLint level,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLint border,
+ GLsizei imageSize,
+ const void* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCompressedTexImage2D")
+ gl_api_->glCompressedTexImage2DFn(target, level, internalformat, width,
+ height, border, imageSize, data);
+}
+
+void TraceGLApi::glCompressedTexImage3DFn(GLenum target,
+ GLint level,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ GLint border,
+ GLsizei imageSize,
+ const void* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCompressedTexImage3D")
+ gl_api_->glCompressedTexImage3DFn(target, level, internalformat, width,
+ height, depth, border, imageSize, data);
+}
+
+void TraceGLApi::glCompressedTexSubImage2DFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLsizei imageSize,
+ const void* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCompressedTexSubImage2D")
+ gl_api_->glCompressedTexSubImage2DFn(target, level, xoffset, yoffset, width,
+ height, format, imageSize, data);
+}
+
+void TraceGLApi::glCompressedTexSubImage3DFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLint zoffset,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ GLenum format,
+ GLsizei imageSize,
+ const void* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCompressedTexSubImage3D")
+ gl_api_->glCompressedTexSubImage3DFn(target, level, xoffset, yoffset, zoffset,
+ width, height, depth, format, imageSize,
+ data);
+}
+
+void TraceGLApi::glCopyBufferSubDataFn(GLenum readTarget,
+ GLenum writeTarget,
+ GLintptr readOffset,
+ GLintptr writeOffset,
+ GLsizeiptr size) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCopyBufferSubData")
+ gl_api_->glCopyBufferSubDataFn(readTarget, writeTarget, readOffset,
+ writeOffset, size);
+}
+
+void TraceGLApi::glCopySubTextureCHROMIUMFn(GLuint sourceId,
+ GLuint destId,
+ GLint xoffset,
+ GLint yoffset,
+ GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height,
+ GLboolean unpackFlipY,
+ GLboolean unpackPremultiplyAlpha,
+ GLboolean unpackUnmultiplyAlpha) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCopySubTextureCHROMIUM")
+ gl_api_->glCopySubTextureCHROMIUMFn(
+ sourceId, destId, xoffset, yoffset, x, y, width, height, unpackFlipY,
+ unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+}
+
+void TraceGLApi::glCopyTexImage2DFn(GLenum target,
+ GLint level,
+ GLenum internalformat,
+ GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height,
+ GLint border) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCopyTexImage2D")
+ gl_api_->glCopyTexImage2DFn(target, level, internalformat, x, y, width,
+ height, border);
+}
+
+void TraceGLApi::glCopyTexSubImage2DFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCopyTexSubImage2D")
+ gl_api_->glCopyTexSubImage2DFn(target, level, xoffset, yoffset, x, y, width,
+ height);
+}
+
+void TraceGLApi::glCopyTexSubImage3DFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLint zoffset,
+ GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCopyTexSubImage3D")
+ gl_api_->glCopyTexSubImage3DFn(target, level, xoffset, yoffset, zoffset, x, y,
+ width, height);
+}
+
+void TraceGLApi::glCopyTextureCHROMIUMFn(GLuint sourceId,
+ GLuint destId,
+ GLint internalFormat,
+ GLenum destType,
+ GLboolean unpackFlipY,
+ GLboolean unpackPremultiplyAlpha,
+ GLboolean unpackUnmultiplyAlpha) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCopyTextureCHROMIUM")
+ gl_api_->glCopyTextureCHROMIUMFn(sourceId, destId, internalFormat, destType,
+ unpackFlipY, unpackPremultiplyAlpha,
+ unpackUnmultiplyAlpha);
+}
+
+void TraceGLApi::glCoverageModulationNVFn(GLenum components) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverageModulationNV")
+ gl_api_->glCoverageModulationNVFn(components);
+}
+
+void TraceGLApi::glCoverFillPathInstancedNVFn(GLsizei numPaths,
+ GLenum pathNameType,
+ const void* paths,
+ GLuint pathBase,
+ GLenum coverMode,
+ GLenum transformType,
+ const GLfloat* transformValues) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverFillPathInstancedNV")
+ gl_api_->glCoverFillPathInstancedNVFn(numPaths, pathNameType, paths, pathBase,
+ coverMode, transformType,
+ transformValues);
+}
+
+void TraceGLApi::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverFillPathNV")
+ gl_api_->glCoverFillPathNVFn(path, coverMode);
+}
+
+void TraceGLApi::glCoverStrokePathInstancedNVFn(
+ GLsizei numPaths,
+ GLenum pathNameType,
+ const void* paths,
+ GLuint pathBase,
+ GLenum coverMode,
+ GLenum transformType,
+ const GLfloat* transformValues) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glCoverStrokePathInstancedNV")
+ gl_api_->glCoverStrokePathInstancedNVFn(numPaths, pathNameType, paths,
+ pathBase, coverMode, transformType,
+ transformValues);
+}
+
+void TraceGLApi::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverStrokePathNV")
+ gl_api_->glCoverStrokePathNVFn(name, coverMode);
+}
+
+GLuint TraceGLApi::glCreateProgramFn(void) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCreateProgram")
+ return gl_api_->glCreateProgramFn();
+}
+
+GLuint TraceGLApi::glCreateShaderFn(GLenum type) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCreateShader")
+ return gl_api_->glCreateShaderFn(type);
+}
+
+void TraceGLApi::glCullFaceFn(GLenum mode) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCullFace")
+ gl_api_->glCullFaceFn(mode);
+}
+
+void TraceGLApi::glDebugMessageCallbackFn(GLDEBUGPROC callback,
+ const void* userParam) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDebugMessageCallback")
+ gl_api_->glDebugMessageCallbackFn(callback, userParam);
+}
+
+void TraceGLApi::glDebugMessageControlFn(GLenum source,
+ GLenum type,
+ GLenum severity,
+ GLsizei count,
+ const GLuint* ids,
+ GLboolean enabled) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDebugMessageControl")
+ gl_api_->glDebugMessageControlFn(source, type, severity, count, ids, enabled);
+}
+
+void TraceGLApi::glDebugMessageInsertFn(GLenum source,
+ GLenum type,
+ GLuint id,
+ GLenum severity,
+ GLsizei length,
+ const char* buf) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDebugMessageInsert")
+ gl_api_->glDebugMessageInsertFn(source, type, id, severity, length, buf);
+}
+
+void TraceGLApi::glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteBuffersARB")
+ gl_api_->glDeleteBuffersARBFn(n, buffers);
+}
+
+void TraceGLApi::glDeleteFencesAPPLEFn(GLsizei n, const GLuint* fences) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteFencesAPPLE")
+ gl_api_->glDeleteFencesAPPLEFn(n, fences);
+}
+
+void TraceGLApi::glDeleteFencesNVFn(GLsizei n, const GLuint* fences) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteFencesNV")
+ gl_api_->glDeleteFencesNVFn(n, fences);
+}
+
+void TraceGLApi::glDeleteFramebuffersEXTFn(GLsizei n,
+ const GLuint* framebuffers) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteFramebuffersEXT")
+ gl_api_->glDeleteFramebuffersEXTFn(n, framebuffers);
+}
+
+void TraceGLApi::glDeletePathsNVFn(GLuint path, GLsizei range) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeletePathsNV")
+ gl_api_->glDeletePathsNVFn(path, range);
+}
+
+void TraceGLApi::glDeleteProgramFn(GLuint program) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteProgram")
+ gl_api_->glDeleteProgramFn(program);
+}
+
+void TraceGLApi::glDeleteQueriesFn(GLsizei n, const GLuint* ids) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteQueries")
+ gl_api_->glDeleteQueriesFn(n, ids);
+}
+
+void TraceGLApi::glDeleteRenderbuffersEXTFn(GLsizei n,
+ const GLuint* renderbuffers) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteRenderbuffersEXT")
+ gl_api_->glDeleteRenderbuffersEXTFn(n, renderbuffers);
+}
+
+void TraceGLApi::glDeleteSamplersFn(GLsizei n, const GLuint* samplers) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteSamplers")
+ gl_api_->glDeleteSamplersFn(n, samplers);
+}
+
+void TraceGLApi::glDeleteShaderFn(GLuint shader) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteShader")
+ gl_api_->glDeleteShaderFn(shader);
+}
+
+void TraceGLApi::glDeleteSyncFn(GLsync sync) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteSync")
+ gl_api_->glDeleteSyncFn(sync);
+}
+
+void TraceGLApi::glDeleteTexturesFn(GLsizei n, const GLuint* textures) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteTextures")
+ gl_api_->glDeleteTexturesFn(n, textures);
+}
+
+void TraceGLApi::glDeleteTransformFeedbacksFn(GLsizei n, const GLuint* ids) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteTransformFeedbacks")
+ gl_api_->glDeleteTransformFeedbacksFn(n, ids);
+}
+
+void TraceGLApi::glDeleteVertexArraysOESFn(GLsizei n, const GLuint* arrays) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteVertexArraysOES")
+ gl_api_->glDeleteVertexArraysOESFn(n, arrays);
+}
+
+void TraceGLApi::glDepthFuncFn(GLenum func) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDepthFunc")
+ gl_api_->glDepthFuncFn(func);
+}
+
+void TraceGLApi::glDepthMaskFn(GLboolean flag) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDepthMask")
+ gl_api_->glDepthMaskFn(flag);
+}
+
+void TraceGLApi::glDepthRangeFn(GLclampd zNear, GLclampd zFar) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDepthRange")
+ gl_api_->glDepthRangeFn(zNear, zFar);
+}
+
+void TraceGLApi::glDepthRangefFn(GLclampf zNear, GLclampf zFar) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDepthRangef")
+ gl_api_->glDepthRangefFn(zNear, zFar);
+}
+
+void TraceGLApi::glDetachShaderFn(GLuint program, GLuint shader) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDetachShader")
+ gl_api_->glDetachShaderFn(program, shader);
+}
+
+void TraceGLApi::glDisableFn(GLenum cap) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDisable")
+ gl_api_->glDisableFn(cap);
+}
+
+void TraceGLApi::glDisableVertexAttribArrayFn(GLuint index) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDisableVertexAttribArray")
+ gl_api_->glDisableVertexAttribArrayFn(index);
+}
+
+void TraceGLApi::glDiscardFramebufferEXTFn(GLenum target,
+ GLsizei numAttachments,
+ const GLenum* attachments) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDiscardFramebufferEXT")
+ gl_api_->glDiscardFramebufferEXTFn(target, numAttachments, attachments);
+}
+
+void TraceGLApi::glDrawArraysFn(GLenum mode, GLint first, GLsizei count) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDrawArrays")
+ gl_api_->glDrawArraysFn(mode, first, count);
+}
+
+void TraceGLApi::glDrawArraysInstancedANGLEFn(GLenum mode,
+ GLint first,
+ GLsizei count,
+ GLsizei primcount) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDrawArraysInstancedANGLE")
+ gl_api_->glDrawArraysInstancedANGLEFn(mode, first, count, primcount);
+}
+
+void TraceGLApi::glDrawBufferFn(GLenum mode) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDrawBuffer")
+ gl_api_->glDrawBufferFn(mode);
+}
+
+void TraceGLApi::glDrawBuffersARBFn(GLsizei n, const GLenum* bufs) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDrawBuffersARB")
+ gl_api_->glDrawBuffersARBFn(n, bufs);
+}
+
+void TraceGLApi::glDrawElementsFn(GLenum mode,
+ GLsizei count,
+ GLenum type,
+ const void* indices) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDrawElements")
+ gl_api_->glDrawElementsFn(mode, count, type, indices);
+}
+
+void TraceGLApi::glDrawElementsInstancedANGLEFn(GLenum mode,
+ GLsizei count,
+ GLenum type,
+ const void* indices,
+ GLsizei primcount) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glDrawElementsInstancedANGLE")
+ gl_api_->glDrawElementsInstancedANGLEFn(mode, count, type, indices,
+ primcount);
+}
+
+void TraceGLApi::glDrawRangeElementsFn(GLenum mode,
+ GLuint start,
+ GLuint end,
+ GLsizei count,
+ GLenum type,
+ const void* indices) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDrawRangeElements")
+ gl_api_->glDrawRangeElementsFn(mode, start, end, count, type, indices);
+}
+
+void TraceGLApi::glEGLImageTargetRenderbufferStorageOESFn(GLenum target,
+ GLeglImageOES image) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glEGLImageTargetRenderbufferStorageOES")
+ gl_api_->glEGLImageTargetRenderbufferStorageOESFn(target, image);
+}
+
+void TraceGLApi::glEGLImageTargetTexture2DOESFn(GLenum target,
+ GLeglImageOES image) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glEGLImageTargetTexture2DOES")
+ gl_api_->glEGLImageTargetTexture2DOESFn(target, image);
+}
+
+void TraceGLApi::glEnableFn(GLenum cap) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glEnable")
+ gl_api_->glEnableFn(cap);
+}
+
+void TraceGLApi::glEnableVertexAttribArrayFn(GLuint index) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glEnableVertexAttribArray")
+ gl_api_->glEnableVertexAttribArrayFn(index);
+}
+
+void TraceGLApi::glEndQueryFn(GLenum target) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glEndQuery")
+ gl_api_->glEndQueryFn(target);
+}
+
+void TraceGLApi::glEndTransformFeedbackFn(void) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glEndTransformFeedback")
+ gl_api_->glEndTransformFeedbackFn();
+}
+
+GLsync TraceGLApi::glFenceSyncFn(GLenum condition, GLbitfield flags) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFenceSync")
+ return gl_api_->glFenceSyncFn(condition, flags);
+}
+
+void TraceGLApi::glFinishFn(void) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFinish")
+ gl_api_->glFinishFn();
+}
+
+void TraceGLApi::glFinishFenceAPPLEFn(GLuint fence) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFinishFenceAPPLE")
+ gl_api_->glFinishFenceAPPLEFn(fence);
+}
+
+void TraceGLApi::glFinishFenceNVFn(GLuint fence) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFinishFenceNV")
+ gl_api_->glFinishFenceNVFn(fence);
+}
+
+void TraceGLApi::glFlushFn(void) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFlush")
+ gl_api_->glFlushFn();
+}
+
+void TraceGLApi::glFlushMappedBufferRangeFn(GLenum target,
+ GLintptr offset,
+ GLsizeiptr length) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFlushMappedBufferRange")
+ gl_api_->glFlushMappedBufferRangeFn(target, offset, length);
+}
+
+void TraceGLApi::glFramebufferRenderbufferEXTFn(GLenum target,
+ GLenum attachment,
+ GLenum renderbuffertarget,
+ GLuint renderbuffer) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glFramebufferRenderbufferEXT")
+ gl_api_->glFramebufferRenderbufferEXTFn(target, attachment,
+ renderbuffertarget, renderbuffer);
+}
+
+void TraceGLApi::glFramebufferTexture2DEXTFn(GLenum target,
+ GLenum attachment,
+ GLenum textarget,
+ GLuint texture,
+ GLint level) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFramebufferTexture2DEXT")
+ gl_api_->glFramebufferTexture2DEXTFn(target, attachment, textarget, texture,
+ level);
+}
+
+void TraceGLApi::glFramebufferTexture2DMultisampleEXTFn(GLenum target,
+ GLenum attachment,
+ GLenum textarget,
+ GLuint texture,
+ GLint level,
+ GLsizei samples) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glFramebufferTexture2DMultisampleEXT")
+ gl_api_->glFramebufferTexture2DMultisampleEXTFn(target, attachment, textarget,
+ texture, level, samples);
+}
+
+void TraceGLApi::glFramebufferTexture2DMultisampleIMGFn(GLenum target,
+ GLenum attachment,
+ GLenum textarget,
+ GLuint texture,
+ GLint level,
+ GLsizei samples) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glFramebufferTexture2DMultisampleIMG")
+ gl_api_->glFramebufferTexture2DMultisampleIMGFn(target, attachment, textarget,
+ texture, level, samples);
+}
+
+void TraceGLApi::glFramebufferTextureLayerFn(GLenum target,
+ GLenum attachment,
+ GLuint texture,
+ GLint level,
+ GLint layer) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFramebufferTextureLayer")
+ gl_api_->glFramebufferTextureLayerFn(target, attachment, texture, level,
+ layer);
+}
+
+void TraceGLApi::glFrontFaceFn(GLenum mode) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFrontFace")
+ gl_api_->glFrontFaceFn(mode);
+}
+
+void TraceGLApi::glGenBuffersARBFn(GLsizei n, GLuint* buffers) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenBuffersARB")
+ gl_api_->glGenBuffersARBFn(n, buffers);
+}
+
+void TraceGLApi::glGenerateMipmapEXTFn(GLenum target) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenerateMipmapEXT")
+ gl_api_->glGenerateMipmapEXTFn(target);
+}
+
+void TraceGLApi::glGenFencesAPPLEFn(GLsizei n, GLuint* fences) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenFencesAPPLE")
+ gl_api_->glGenFencesAPPLEFn(n, fences);
+}
+
+void TraceGLApi::glGenFencesNVFn(GLsizei n, GLuint* fences) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenFencesNV")
+ gl_api_->glGenFencesNVFn(n, fences);
+}
+
+void TraceGLApi::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenFramebuffersEXT")
+ gl_api_->glGenFramebuffersEXTFn(n, framebuffers);
+}
+
+GLuint TraceGLApi::glGenPathsNVFn(GLsizei range) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenPathsNV")
+ return gl_api_->glGenPathsNVFn(range);
+}
+
+void TraceGLApi::glGenQueriesFn(GLsizei n, GLuint* ids) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenQueries")
+ gl_api_->glGenQueriesFn(n, ids);
+}
+
+void TraceGLApi::glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenRenderbuffersEXT")
+ gl_api_->glGenRenderbuffersEXTFn(n, renderbuffers);
+}
+
+void TraceGLApi::glGenSamplersFn(GLsizei n, GLuint* samplers) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenSamplers")
+ gl_api_->glGenSamplersFn(n, samplers);
+}
+
+void TraceGLApi::glGenTexturesFn(GLsizei n, GLuint* textures) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenTextures")
+ gl_api_->glGenTexturesFn(n, textures);
+}
+
+void TraceGLApi::glGenTransformFeedbacksFn(GLsizei n, GLuint* ids) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenTransformFeedbacks")
+ gl_api_->glGenTransformFeedbacksFn(n, ids);
+}
+
+void TraceGLApi::glGenVertexArraysOESFn(GLsizei n, GLuint* arrays) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenVertexArraysOES")
+ gl_api_->glGenVertexArraysOESFn(n, arrays);
+}
+
+void TraceGLApi::glGetActiveAttribFn(GLuint program,
+ GLuint index,
+ GLsizei bufsize,
+ GLsizei* length,
+ GLint* size,
+ GLenum* type,
+ char* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetActiveAttrib")
+ gl_api_->glGetActiveAttribFn(program, index, bufsize, length, size, type,
+ name);
+}
+
+void TraceGLApi::glGetActiveUniformFn(GLuint program,
+ GLuint index,
+ GLsizei bufsize,
+ GLsizei* length,
+ GLint* size,
+ GLenum* type,
+ char* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetActiveUniform")
+ gl_api_->glGetActiveUniformFn(program, index, bufsize, length, size, type,
+ name);
+}
+
+void TraceGLApi::glGetActiveUniformBlockivFn(GLuint program,
+ GLuint uniformBlockIndex,
+ GLenum pname,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetActiveUniformBlockiv")
+ gl_api_->glGetActiveUniformBlockivFn(program, uniformBlockIndex, pname,
+ params);
+}
+
+void TraceGLApi::glGetActiveUniformBlockivRobustANGLEFn(
+ GLuint program,
+ GLuint uniformBlockIndex,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetActiveUniformBlockivRobustANGLE")
+ gl_api_->glGetActiveUniformBlockivRobustANGLEFn(
+ program, uniformBlockIndex, pname, bufSize, length, params);
+}
+
+void TraceGLApi::glGetActiveUniformBlockNameFn(GLuint program,
+ GLuint uniformBlockIndex,
+ GLsizei bufSize,
+ GLsizei* length,
+ char* uniformBlockName) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetActiveUniformBlockName")
+ gl_api_->glGetActiveUniformBlockNameFn(program, uniformBlockIndex, bufSize,
+ length, uniformBlockName);
+}
+
+void TraceGLApi::glGetActiveUniformsivFn(GLuint program,
+ GLsizei uniformCount,
+ const GLuint* uniformIndices,
+ GLenum pname,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetActiveUniformsiv")
+ gl_api_->glGetActiveUniformsivFn(program, uniformCount, uniformIndices, pname,
+ params);
+}
+
+void TraceGLApi::glGetAttachedShadersFn(GLuint program,
+ GLsizei maxcount,
+ GLsizei* count,
+ GLuint* shaders) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetAttachedShaders")
+ gl_api_->glGetAttachedShadersFn(program, maxcount, count, shaders);
+}
+
+GLint TraceGLApi::glGetAttribLocationFn(GLuint program, const char* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetAttribLocation")
+ return gl_api_->glGetAttribLocationFn(program, name);
+}
+
+void TraceGLApi::glGetBooleani_vRobustANGLEFn(GLenum target,
+ GLuint index,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLboolean* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetBooleani_vRobustANGLE")
+ gl_api_->glGetBooleani_vRobustANGLEFn(target, index, bufSize, length, data);
+}
+
+void TraceGLApi::glGetBooleanvFn(GLenum pname, GLboolean* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetBooleanv")
+ gl_api_->glGetBooleanvFn(pname, params);
+}
+
+void TraceGLApi::glGetBooleanvRobustANGLEFn(GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLboolean* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetBooleanvRobustANGLE")
+ gl_api_->glGetBooleanvRobustANGLEFn(pname, bufSize, length, data);
+}
+
+void TraceGLApi::glGetBufferParameteri64vRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint64* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetBufferParameteri64vRobustANGLE")
+ gl_api_->glGetBufferParameteri64vRobustANGLEFn(target, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetBufferParameterivFn(GLenum target,
+ GLenum pname,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetBufferParameteriv")
+ gl_api_->glGetBufferParameterivFn(target, pname, params);
+}
+
+void TraceGLApi::glGetBufferParameterivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetBufferParameterivRobustANGLE")
+ gl_api_->glGetBufferParameterivRobustANGLEFn(target, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetBufferPointervRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ void** params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetBufferPointervRobustANGLE")
+ gl_api_->glGetBufferPointervRobustANGLEFn(target, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetDebugMessageLogFn(GLuint count,
+ GLsizei bufSize,
+ GLenum* sources,
+ GLenum* types,
+ GLuint* ids,
+ GLenum* severities,
+ GLsizei* lengths,
+ char* messageLog) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetDebugMessageLog")
+ gl_api_->glGetDebugMessageLogFn(count, bufSize, sources, types, ids,
+ severities, lengths, messageLog);
+}
+
+GLenum TraceGLApi::glGetErrorFn(void) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetError")
+ return gl_api_->glGetErrorFn();
+}
+
+void TraceGLApi::glGetFenceivNVFn(GLuint fence, GLenum pname, GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetFenceivNV")
+ gl_api_->glGetFenceivNVFn(fence, pname, params);
+}
+
+void TraceGLApi::glGetFloatvFn(GLenum pname, GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetFloatv")
+ gl_api_->glGetFloatvFn(pname, params);
+}
+
+void TraceGLApi::glGetFloatvRobustANGLEFn(GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetFloatvRobustANGLE")
+ gl_api_->glGetFloatvRobustANGLEFn(pname, bufSize, length, data);
+}
+
+GLint TraceGLApi::glGetFragDataIndexFn(GLuint program, const char* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetFragDataIndex")
+ return gl_api_->glGetFragDataIndexFn(program, name);
+}
+
+GLint TraceGLApi::glGetFragDataLocationFn(GLuint program, const char* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetFragDataLocation")
+ return gl_api_->glGetFragDataLocationFn(program, name);
+}
+
+void TraceGLApi::glGetFramebufferAttachmentParameterivEXTFn(GLenum target,
+ GLenum attachment,
+ GLenum pname,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetFramebufferAttachmentParameterivEXT")
+ gl_api_->glGetFramebufferAttachmentParameterivEXTFn(target, attachment, pname,
+ params);
+}
+
+void TraceGLApi::glGetFramebufferAttachmentParameterivRobustANGLEFn(
+ GLenum target,
+ GLenum attachment,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetFramebufferAttachmentParameterivRobustANGLE")
+ gl_api_->glGetFramebufferAttachmentParameterivRobustANGLEFn(
+ target, attachment, pname, bufSize, length, params);
+}
+
+void TraceGLApi::glGetFramebufferParameterivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetFramebufferParameterivRobustANGLE")
+ gl_api_->glGetFramebufferParameterivRobustANGLEFn(target, pname, bufSize,
+ length, params);
+}
+
+GLenum TraceGLApi::glGetGraphicsResetStatusARBFn(void) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetGraphicsResetStatusARB")
+ return gl_api_->glGetGraphicsResetStatusARBFn();
+}
+
+void TraceGLApi::glGetInteger64i_vFn(GLenum target,
+ GLuint index,
+ GLint64* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetInteger64i_v")
+ gl_api_->glGetInteger64i_vFn(target, index, data);
+}
+
+void TraceGLApi::glGetInteger64i_vRobustANGLEFn(GLenum target,
+ GLuint index,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint64* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetInteger64i_vRobustANGLE")
+ gl_api_->glGetInteger64i_vRobustANGLEFn(target, index, bufSize, length, data);
+}
+
+void TraceGLApi::glGetInteger64vFn(GLenum pname, GLint64* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetInteger64v")
+ gl_api_->glGetInteger64vFn(pname, params);
+}
+
+void TraceGLApi::glGetInteger64vRobustANGLEFn(GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint64* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetInteger64vRobustANGLE")
+ gl_api_->glGetInteger64vRobustANGLEFn(pname, bufSize, length, data);
+}
+
+void TraceGLApi::glGetIntegeri_vFn(GLenum target, GLuint index, GLint* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetIntegeri_v")
+ gl_api_->glGetIntegeri_vFn(target, index, data);
+}
+
+void TraceGLApi::glGetIntegeri_vRobustANGLEFn(GLenum target,
+ GLuint index,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetIntegeri_vRobustANGLE")
+ gl_api_->glGetIntegeri_vRobustANGLEFn(target, index, bufSize, length, data);
+}
+
+void TraceGLApi::glGetIntegervFn(GLenum pname, GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetIntegerv")
+ gl_api_->glGetIntegervFn(pname, params);
+}
+
+void TraceGLApi::glGetIntegervRobustANGLEFn(GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetIntegervRobustANGLE")
+ gl_api_->glGetIntegervRobustANGLEFn(pname, bufSize, length, data);
+}
+
+void TraceGLApi::glGetInternalformativFn(GLenum target,
+ GLenum internalformat,
+ GLenum pname,
+ GLsizei bufSize,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetInternalformativ")
+ gl_api_->glGetInternalformativFn(target, internalformat, pname, bufSize,
+ params);
+}
+
+void TraceGLApi::glGetInternalformativRobustANGLEFn(GLenum target,
+ GLenum internalformat,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetInternalformativRobustANGLE")
+ gl_api_->glGetInternalformativRobustANGLEFn(target, internalformat, pname,
+ bufSize, length, params);
+}
+
+void TraceGLApi::glGetMultisamplefvRobustANGLEFn(GLenum pname,
+ GLuint index,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* val) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetMultisamplefvRobustANGLE")
+ gl_api_->glGetMultisamplefvRobustANGLEFn(pname, index, bufSize, length, val);
+}
+
+void TraceGLApi::glGetnUniformfvRobustANGLEFn(GLuint program,
+ GLint location,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetnUniformfvRobustANGLE")
+ gl_api_->glGetnUniformfvRobustANGLEFn(program, location, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetnUniformivRobustANGLEFn(GLuint program,
+ GLint location,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetnUniformivRobustANGLE")
+ gl_api_->glGetnUniformivRobustANGLEFn(program, location, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetnUniformuivRobustANGLEFn(GLuint program,
+ GLint location,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetnUniformuivRobustANGLE")
+ gl_api_->glGetnUniformuivRobustANGLEFn(program, location, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetObjectLabelFn(GLenum identifier,
+ GLuint name,
+ GLsizei bufSize,
+ GLsizei* length,
+ char* label) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetObjectLabel")
+ gl_api_->glGetObjectLabelFn(identifier, name, bufSize, length, label);
+}
+
+void TraceGLApi::glGetObjectPtrLabelFn(void* ptr,
+ GLsizei bufSize,
+ GLsizei* length,
+ char* label) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetObjectPtrLabel")
+ gl_api_->glGetObjectPtrLabelFn(ptr, bufSize, length, label);
+}
+
+void TraceGLApi::glGetPointervFn(GLenum pname, void** params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetPointerv")
+ gl_api_->glGetPointervFn(pname, params);
+}
+
+void TraceGLApi::glGetPointervRobustANGLERobustANGLEFn(GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ void** params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetPointervRobustANGLERobustANGLE")
+ gl_api_->glGetPointervRobustANGLERobustANGLEFn(pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetProgramBinaryFn(GLuint program,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLenum* binaryFormat,
+ GLvoid* binary) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetProgramBinary")
+ gl_api_->glGetProgramBinaryFn(program, bufSize, length, binaryFormat, binary);
+}
+
+void TraceGLApi::glGetProgramInfoLogFn(GLuint program,
+ GLsizei bufsize,
+ GLsizei* length,
+ char* infolog) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetProgramInfoLog")
+ gl_api_->glGetProgramInfoLogFn(program, bufsize, length, infolog);
+}
+
+void TraceGLApi::glGetProgramInterfaceivFn(GLuint program,
+ GLenum programInterface,
+ GLenum pname,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetProgramInterfaceiv")
+ gl_api_->glGetProgramInterfaceivFn(program, programInterface, pname, params);
+}
+
+void TraceGLApi::glGetProgramInterfaceivRobustANGLEFn(GLuint program,
+ GLenum programInterface,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetProgramInterfaceivRobustANGLE")
+ gl_api_->glGetProgramInterfaceivRobustANGLEFn(program, programInterface,
+ pname, bufSize, length, params);
+}
+
+void TraceGLApi::glGetProgramivFn(GLuint program, GLenum pname, GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetProgramiv")
+ gl_api_->glGetProgramivFn(program, pname, params);
+}
+
+void TraceGLApi::glGetProgramivRobustANGLEFn(GLuint program,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetProgramivRobustANGLE")
+ gl_api_->glGetProgramivRobustANGLEFn(program, pname, bufSize, length, params);
+}
+
+void TraceGLApi::glGetProgramResourceivFn(GLuint program,
+ GLenum programInterface,
+ GLuint index,
+ GLsizei propCount,
+ const GLenum* props,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetProgramResourceiv")
+ gl_api_->glGetProgramResourceivFn(program, programInterface, index, propCount,
+ props, bufSize, length, params);
+}
+
+GLint TraceGLApi::glGetProgramResourceLocationFn(GLuint program,
+ GLenum programInterface,
+ const char* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetProgramResourceLocation")
+ return gl_api_->glGetProgramResourceLocationFn(program, programInterface,
+ name);
+}
+
+void TraceGLApi::glGetProgramResourceNameFn(GLuint program,
+ GLenum programInterface,
+ GLuint index,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLchar* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetProgramResourceName")
+ gl_api_->glGetProgramResourceNameFn(program, programInterface, index, bufSize,
+ length, name);
+}
+
+void TraceGLApi::glGetQueryivFn(GLenum target, GLenum pname, GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetQueryiv")
+ gl_api_->glGetQueryivFn(target, pname, params);
+}
+
+void TraceGLApi::glGetQueryivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetQueryivRobustANGLE")
+ gl_api_->glGetQueryivRobustANGLEFn(target, pname, bufSize, length, params);
+}
+
+void TraceGLApi::glGetQueryObjecti64vFn(GLuint id,
+ GLenum pname,
+ GLint64* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetQueryObjecti64v")
+ gl_api_->glGetQueryObjecti64vFn(id, pname, params);
+}
+
+void TraceGLApi::glGetQueryObjecti64vRobustANGLEFn(GLuint id,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint64* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetQueryObjecti64vRobustANGLE")
+ gl_api_->glGetQueryObjecti64vRobustANGLEFn(id, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetQueryObjectivFn(GLuint id, GLenum pname, GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetQueryObjectiv")
+ gl_api_->glGetQueryObjectivFn(id, pname, params);
+}
+
+void TraceGLApi::glGetQueryObjectivRobustANGLEFn(GLuint id,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetQueryObjectivRobustANGLE")
+ gl_api_->glGetQueryObjectivRobustANGLEFn(id, pname, bufSize, length, params);
+}
+
+void TraceGLApi::glGetQueryObjectui64vFn(GLuint id,
+ GLenum pname,
+ GLuint64* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetQueryObjectui64v")
+ gl_api_->glGetQueryObjectui64vFn(id, pname, params);
+}
+
+void TraceGLApi::glGetQueryObjectui64vRobustANGLEFn(GLuint id,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint64* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetQueryObjectui64vRobustANGLE")
+ gl_api_->glGetQueryObjectui64vRobustANGLEFn(id, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetQueryObjectuivFn(GLuint id,
+ GLenum pname,
+ GLuint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetQueryObjectuiv")
+ gl_api_->glGetQueryObjectuivFn(id, pname, params);
+}
+
+void TraceGLApi::glGetQueryObjectuivRobustANGLEFn(GLuint id,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetQueryObjectuivRobustANGLE")
+ gl_api_->glGetQueryObjectuivRobustANGLEFn(id, pname, bufSize, length, params);
+}
+
+void TraceGLApi::glGetRenderbufferParameterivEXTFn(GLenum target,
+ GLenum pname,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetRenderbufferParameterivEXT")
+ gl_api_->glGetRenderbufferParameterivEXTFn(target, pname, params);
+}
+
+void TraceGLApi::glGetRenderbufferParameterivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetRenderbufferParameterivRobustANGLE")
+ gl_api_->glGetRenderbufferParameterivRobustANGLEFn(target, pname, bufSize,
+ length, params);
+}
+
+void TraceGLApi::glGetSamplerParameterfvFn(GLuint sampler,
+ GLenum pname,
+ GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetSamplerParameterfv")
+ gl_api_->glGetSamplerParameterfvFn(sampler, pname, params);
+}
+
+void TraceGLApi::glGetSamplerParameterfvRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetSamplerParameterfvRobustANGLE")
+ gl_api_->glGetSamplerParameterfvRobustANGLEFn(sampler, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetSamplerParameterIivRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetSamplerParameterIivRobustANGLE")
+ gl_api_->glGetSamplerParameterIivRobustANGLEFn(sampler, pname, bufSize,
+ length, params);
+}
+
+void TraceGLApi::glGetSamplerParameterIuivRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetSamplerParameterIuivRobustANGLE")
+ gl_api_->glGetSamplerParameterIuivRobustANGLEFn(sampler, pname, bufSize,
+ length, params);
+}
+
+void TraceGLApi::glGetSamplerParameterivFn(GLuint sampler,
+ GLenum pname,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetSamplerParameteriv")
+ gl_api_->glGetSamplerParameterivFn(sampler, pname, params);
+}
+
+void TraceGLApi::glGetSamplerParameterivRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetSamplerParameterivRobustANGLE")
+ gl_api_->glGetSamplerParameterivRobustANGLEFn(sampler, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetShaderInfoLogFn(GLuint shader,
+ GLsizei bufsize,
+ GLsizei* length,
+ char* infolog) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetShaderInfoLog")
+ gl_api_->glGetShaderInfoLogFn(shader, bufsize, length, infolog);
+}
+
+void TraceGLApi::glGetShaderivFn(GLuint shader, GLenum pname, GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetShaderiv")
+ gl_api_->glGetShaderivFn(shader, pname, params);
+}
+
+void TraceGLApi::glGetShaderivRobustANGLEFn(GLuint shader,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetShaderivRobustANGLE")
+ gl_api_->glGetShaderivRobustANGLEFn(shader, pname, bufSize, length, params);
+}
+
+void TraceGLApi::glGetShaderPrecisionFormatFn(GLenum shadertype,
+ GLenum precisiontype,
+ GLint* range,
+ GLint* precision) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetShaderPrecisionFormat")
+ gl_api_->glGetShaderPrecisionFormatFn(shadertype, precisiontype, range,
+ precision);
+}
+
+void TraceGLApi::glGetShaderSourceFn(GLuint shader,
+ GLsizei bufsize,
+ GLsizei* length,
+ char* source) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetShaderSource")
+ gl_api_->glGetShaderSourceFn(shader, bufsize, length, source);
+}
+
+const GLubyte* TraceGLApi::glGetStringFn(GLenum name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetString")
+ return gl_api_->glGetStringFn(name);
+}
+
+const GLubyte* TraceGLApi::glGetStringiFn(GLenum name, GLuint index) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetStringi")
+ return gl_api_->glGetStringiFn(name, index);
+}
+
+void TraceGLApi::glGetSyncivFn(GLsync sync,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* values) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetSynciv")
+ gl_api_->glGetSyncivFn(sync, pname, bufSize, length, values);
+}
+
+void TraceGLApi::glGetTexLevelParameterfvFn(GLenum target,
+ GLint level,
+ GLenum pname,
+ GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetTexLevelParameterfv")
+ gl_api_->glGetTexLevelParameterfvFn(target, level, pname, params);
+}
+
+void TraceGLApi::glGetTexLevelParameterfvRobustANGLEFn(GLenum target,
+ GLint level,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetTexLevelParameterfvRobustANGLE")
+ gl_api_->glGetTexLevelParameterfvRobustANGLEFn(target, level, pname, bufSize,
+ length, params);
+}
+
+void TraceGLApi::glGetTexLevelParameterivFn(GLenum target,
+ GLint level,
+ GLenum pname,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetTexLevelParameteriv")
+ gl_api_->glGetTexLevelParameterivFn(target, level, pname, params);
+}
+
+void TraceGLApi::glGetTexLevelParameterivRobustANGLEFn(GLenum target,
+ GLint level,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetTexLevelParameterivRobustANGLE")
+ gl_api_->glGetTexLevelParameterivRobustANGLEFn(target, level, pname, bufSize,
+ length, params);
+}
+
+void TraceGLApi::glGetTexParameterfvFn(GLenum target,
+ GLenum pname,
+ GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetTexParameterfv")
+ gl_api_->glGetTexParameterfvFn(target, pname, params);
+}
+
+void TraceGLApi::glGetTexParameterfvRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetTexParameterfvRobustANGLE")
+ gl_api_->glGetTexParameterfvRobustANGLEFn(target, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetTexParameterIivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetTexParameterIivRobustANGLE")
+ gl_api_->glGetTexParameterIivRobustANGLEFn(target, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetTexParameterIuivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetTexParameterIuivRobustANGLE")
+ gl_api_->glGetTexParameterIuivRobustANGLEFn(target, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetTexParameterivFn(GLenum target,
+ GLenum pname,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetTexParameteriv")
+ gl_api_->glGetTexParameterivFn(target, pname, params);
+}
+
+void TraceGLApi::glGetTexParameterivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetTexParameterivRobustANGLE")
+ gl_api_->glGetTexParameterivRobustANGLEFn(target, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetTransformFeedbackVaryingFn(GLuint program,
+ GLuint index,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLsizei* size,
+ GLenum* type,
+ char* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetTransformFeedbackVarying")
+ gl_api_->glGetTransformFeedbackVaryingFn(program, index, bufSize, length,
+ size, type, name);
+}
+
+void TraceGLApi::glGetTranslatedShaderSourceANGLEFn(GLuint shader,
+ GLsizei bufsize,
+ GLsizei* length,
+ char* source) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetTranslatedShaderSourceANGLE")
+ gl_api_->glGetTranslatedShaderSourceANGLEFn(shader, bufsize, length, source);
+}
+
+GLuint TraceGLApi::glGetUniformBlockIndexFn(GLuint program,
+ const char* uniformBlockName) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetUniformBlockIndex")
+ return gl_api_->glGetUniformBlockIndexFn(program, uniformBlockName);
+}
+
+void TraceGLApi::glGetUniformfvFn(GLuint program,
+ GLint location,
+ GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetUniformfv")
+ gl_api_->glGetUniformfvFn(program, location, params);
+}
+
+void TraceGLApi::glGetUniformfvRobustANGLEFn(GLuint program,
+ GLint location,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetUniformfvRobustANGLE")
+ gl_api_->glGetUniformfvRobustANGLEFn(program, location, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetUniformIndicesFn(GLuint program,
+ GLsizei uniformCount,
+ const char* const* uniformNames,
+ GLuint* uniformIndices) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetUniformIndices")
+ gl_api_->glGetUniformIndicesFn(program, uniformCount, uniformNames,
+ uniformIndices);
+}
+
+void TraceGLApi::glGetUniformivFn(GLuint program,
+ GLint location,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetUniformiv")
+ gl_api_->glGetUniformivFn(program, location, params);
+}
+
+void TraceGLApi::glGetUniformivRobustANGLEFn(GLuint program,
+ GLint location,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetUniformivRobustANGLE")
+ gl_api_->glGetUniformivRobustANGLEFn(program, location, bufSize, length,
+ params);
+}
+
+GLint TraceGLApi::glGetUniformLocationFn(GLuint program, const char* name) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetUniformLocation")
+ return gl_api_->glGetUniformLocationFn(program, name);
+}
+
+void TraceGLApi::glGetUniformuivFn(GLuint program,
+ GLint location,
+ GLuint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetUniformuiv")
+ gl_api_->glGetUniformuivFn(program, location, params);
+}
+
+void TraceGLApi::glGetUniformuivRobustANGLEFn(GLuint program,
+ GLint location,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetUniformuivRobustANGLE")
+ gl_api_->glGetUniformuivRobustANGLEFn(program, location, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetVertexAttribfvFn(GLuint index,
+ GLenum pname,
+ GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetVertexAttribfv")
+ gl_api_->glGetVertexAttribfvFn(index, pname, params);
+}
+
+void TraceGLApi::glGetVertexAttribfvRobustANGLEFn(GLuint index,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetVertexAttribfvRobustANGLE")
+ gl_api_->glGetVertexAttribfvRobustANGLEFn(index, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetVertexAttribIivRobustANGLEFn(GLuint index,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetVertexAttribIivRobustANGLE")
+ gl_api_->glGetVertexAttribIivRobustANGLEFn(index, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetVertexAttribIuivRobustANGLEFn(GLuint index,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLuint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetVertexAttribIuivRobustANGLE")
+ gl_api_->glGetVertexAttribIuivRobustANGLEFn(index, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetVertexAttribivFn(GLuint index,
+ GLenum pname,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetVertexAttribiv")
+ gl_api_->glGetVertexAttribivFn(index, pname, params);
+}
+
+void TraceGLApi::glGetVertexAttribivRobustANGLEFn(GLuint index,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glGetVertexAttribivRobustANGLE")
+ gl_api_->glGetVertexAttribivRobustANGLEFn(index, pname, bufSize, length,
+ params);
+}
+
+void TraceGLApi::glGetVertexAttribPointervFn(GLuint index,
+ GLenum pname,
+ void** pointer) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetVertexAttribPointerv")
+ gl_api_->glGetVertexAttribPointervFn(index, pname, pointer);
+}
+
+void TraceGLApi::glGetVertexAttribPointervRobustANGLEFn(GLuint index,
+ GLenum pname,
+ GLsizei bufSize,
+ GLsizei* length,
+ void** pointer) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glGetVertexAttribPointervRobustANGLE")
+ gl_api_->glGetVertexAttribPointervRobustANGLEFn(index, pname, bufSize, length,
+ pointer);
+}
+
+void TraceGLApi::glHintFn(GLenum target, GLenum mode) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glHint")
+ gl_api_->glHintFn(target, mode);
+}
+
+void TraceGLApi::glInsertEventMarkerEXTFn(GLsizei length, const char* marker) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glInsertEventMarkerEXT")
+ gl_api_->glInsertEventMarkerEXTFn(length, marker);
+}
+
+void TraceGLApi::glInvalidateFramebufferFn(GLenum target,
+ GLsizei numAttachments,
+ const GLenum* attachments) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glInvalidateFramebuffer")
+ gl_api_->glInvalidateFramebufferFn(target, numAttachments, attachments);
+}
+
+void TraceGLApi::glInvalidateSubFramebufferFn(GLenum target,
+ GLsizei numAttachments,
+ const GLenum* attachments,
+ GLint x,
+ GLint y,
+ GLint width,
+ GLint height) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glInvalidateSubFramebuffer")
+ gl_api_->glInvalidateSubFramebufferFn(target, numAttachments, attachments, x,
+ y, width, height);
+}
+
+GLboolean TraceGLApi::glIsBufferFn(GLuint buffer) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsBuffer")
+ return gl_api_->glIsBufferFn(buffer);
+}
+
+GLboolean TraceGLApi::glIsEnabledFn(GLenum cap) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsEnabled")
+ return gl_api_->glIsEnabledFn(cap);
+}
+
+GLboolean TraceGLApi::glIsFenceAPPLEFn(GLuint fence) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsFenceAPPLE")
+ return gl_api_->glIsFenceAPPLEFn(fence);
+}
+
+GLboolean TraceGLApi::glIsFenceNVFn(GLuint fence) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsFenceNV")
+ return gl_api_->glIsFenceNVFn(fence);
+}
+
+GLboolean TraceGLApi::glIsFramebufferEXTFn(GLuint framebuffer) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsFramebufferEXT")
+ return gl_api_->glIsFramebufferEXTFn(framebuffer);
+}
+
+GLboolean TraceGLApi::glIsPathNVFn(GLuint path) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsPathNV")
+ return gl_api_->glIsPathNVFn(path);
+}
+
+GLboolean TraceGLApi::glIsProgramFn(GLuint program) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsProgram")
+ return gl_api_->glIsProgramFn(program);
+}
+
+GLboolean TraceGLApi::glIsQueryFn(GLuint query) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsQuery")
+ return gl_api_->glIsQueryFn(query);
+}
+
+GLboolean TraceGLApi::glIsRenderbufferEXTFn(GLuint renderbuffer) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsRenderbufferEXT")
+ return gl_api_->glIsRenderbufferEXTFn(renderbuffer);
+}
+
+GLboolean TraceGLApi::glIsSamplerFn(GLuint sampler) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsSampler")
+ return gl_api_->glIsSamplerFn(sampler);
+}
+
+GLboolean TraceGLApi::glIsShaderFn(GLuint shader) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsShader")
+ return gl_api_->glIsShaderFn(shader);
+}
+
+GLboolean TraceGLApi::glIsSyncFn(GLsync sync) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsSync")
+ return gl_api_->glIsSyncFn(sync);
+}
+
+GLboolean TraceGLApi::glIsTextureFn(GLuint texture) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsTexture")
+ return gl_api_->glIsTextureFn(texture);
+}
+
+GLboolean TraceGLApi::glIsTransformFeedbackFn(GLuint id) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsTransformFeedback")
+ return gl_api_->glIsTransformFeedbackFn(id);
+}
+
+GLboolean TraceGLApi::glIsVertexArrayOESFn(GLuint array) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsVertexArrayOES")
+ return gl_api_->glIsVertexArrayOESFn(array);
+}
+
+void TraceGLApi::glLineWidthFn(GLfloat width) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glLineWidth")
+ gl_api_->glLineWidthFn(width);
+}
+
+void TraceGLApi::glLinkProgramFn(GLuint program) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glLinkProgram")
+ gl_api_->glLinkProgramFn(program);
+}
+
+void* TraceGLApi::glMapBufferFn(GLenum target, GLenum access) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glMapBuffer")
+ return gl_api_->glMapBufferFn(target, access);
+}
+
+void* TraceGLApi::glMapBufferRangeFn(GLenum target,
+ GLintptr offset,
+ GLsizeiptr length,
+ GLbitfield access) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glMapBufferRange")
+ return gl_api_->glMapBufferRangeFn(target, offset, length, access);
+}
+
+void TraceGLApi::glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glMatrixLoadfEXT")
+ gl_api_->glMatrixLoadfEXTFn(matrixMode, m);
+}
+
+void TraceGLApi::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glMatrixLoadIdentityEXT")
+ gl_api_->glMatrixLoadIdentityEXTFn(matrixMode);
+}
+
+void TraceGLApi::glMemoryBarrierEXTFn(GLbitfield barriers) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glMemoryBarrierEXT")
+ gl_api_->glMemoryBarrierEXTFn(barriers);
+}
+
+void TraceGLApi::glObjectLabelFn(GLenum identifier,
+ GLuint name,
+ GLsizei length,
+ const char* label) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glObjectLabel")
+ gl_api_->glObjectLabelFn(identifier, name, length, label);
+}
+
+void TraceGLApi::glObjectPtrLabelFn(void* ptr,
+ GLsizei length,
+ const char* label) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glObjectPtrLabel")
+ gl_api_->glObjectPtrLabelFn(ptr, length, label);
+}
+
+void TraceGLApi::glPathCommandsNVFn(GLuint path,
+ GLsizei numCommands,
+ const GLubyte* commands,
+ GLsizei numCoords,
+ GLenum coordType,
+ const GLvoid* coords) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathCommandsNV")
+ gl_api_->glPathCommandsNVFn(path, numCommands, commands, numCoords, coordType,
+ coords);
+}
+
+void TraceGLApi::glPathParameterfNVFn(GLuint path,
+ GLenum pname,
+ GLfloat value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathParameterfNV")
+ gl_api_->glPathParameterfNVFn(path, pname, value);
+}
+
+void TraceGLApi::glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathParameteriNV")
+ gl_api_->glPathParameteriNVFn(path, pname, value);
+}
+
+void TraceGLApi::glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathStencilFuncNV")
+ gl_api_->glPathStencilFuncNVFn(func, ref, mask);
+}
+
+void TraceGLApi::glPauseTransformFeedbackFn(void) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPauseTransformFeedback")
+ gl_api_->glPauseTransformFeedbackFn();
+}
+
+void TraceGLApi::glPixelStoreiFn(GLenum pname, GLint param) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPixelStorei")
+ gl_api_->glPixelStoreiFn(pname, param);
+}
+
+void TraceGLApi::glPointParameteriFn(GLenum pname, GLint param) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPointParameteri")
+ gl_api_->glPointParameteriFn(pname, param);
+}
+
+void TraceGLApi::glPolygonOffsetFn(GLfloat factor, GLfloat units) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPolygonOffset")
+ gl_api_->glPolygonOffsetFn(factor, units);
+}
+
+void TraceGLApi::glPopDebugGroupFn() {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPopDebugGroup")
+ gl_api_->glPopDebugGroupFn();
+}
+
+void TraceGLApi::glPopGroupMarkerEXTFn(void) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPopGroupMarkerEXT")
+ gl_api_->glPopGroupMarkerEXTFn();
+}
+
+void TraceGLApi::glPrimitiveRestartIndexFn(GLuint index) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPrimitiveRestartIndex")
+ gl_api_->glPrimitiveRestartIndexFn(index);
+}
+
+void TraceGLApi::glProgramBinaryFn(GLuint program,
+ GLenum binaryFormat,
+ const GLvoid* binary,
+ GLsizei length) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glProgramBinary")
+ gl_api_->glProgramBinaryFn(program, binaryFormat, binary, length);
+}
+
+void TraceGLApi::glProgramParameteriFn(GLuint program,
+ GLenum pname,
+ GLint value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glProgramParameteri")
+ gl_api_->glProgramParameteriFn(program, pname, value);
+}
+
+void TraceGLApi::glProgramPathFragmentInputGenNVFn(GLuint program,
+ GLint location,
+ GLenum genMode,
+ GLint components,
+ const GLfloat* coeffs) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glProgramPathFragmentInputGenNV")
+ gl_api_->glProgramPathFragmentInputGenNVFn(program, location, genMode,
+ components, coeffs);
+}
+
+void TraceGLApi::glPushDebugGroupFn(GLenum source,
+ GLuint id,
+ GLsizei length,
+ const char* message) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPushDebugGroup")
+ gl_api_->glPushDebugGroupFn(source, id, length, message);
+}
+
+void TraceGLApi::glPushGroupMarkerEXTFn(GLsizei length, const char* marker) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPushGroupMarkerEXT")
+ gl_api_->glPushGroupMarkerEXTFn(length, marker);
+}
+
+void TraceGLApi::glQueryCounterFn(GLuint id, GLenum target) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glQueryCounter")
+ gl_api_->glQueryCounterFn(id, target);
+}
+
+void TraceGLApi::glReadBufferFn(GLenum src) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glReadBuffer")
+ gl_api_->glReadBufferFn(src);
+}
+
+void TraceGLApi::glReadnPixelsRobustANGLEFn(GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLenum type,
+ GLsizei bufSize,
+ GLsizei* length,
+ void* data) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glReadnPixelsRobustANGLE")
+ gl_api_->glReadnPixelsRobustANGLEFn(x, y, width, height, format, type,
+ bufSize, length, data);
+}
+
+void TraceGLApi::glReadPixelsFn(GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLenum type,
+ void* pixels) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glReadPixels")
+ gl_api_->glReadPixelsFn(x, y, width, height, format, type, pixels);
+}
+
+void TraceGLApi::glReadPixelsRobustANGLEFn(GLint x,
+ GLint y,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLenum type,
+ GLsizei bufSize,
+ GLsizei* length,
+ void* pixels) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glReadPixelsRobustANGLE")
+ gl_api_->glReadPixelsRobustANGLEFn(x, y, width, height, format, type, bufSize,
+ length, pixels);
+}
+
+void TraceGLApi::glReleaseShaderCompilerFn(void) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glReleaseShaderCompiler")
+ gl_api_->glReleaseShaderCompilerFn();
+}
+
+void TraceGLApi::glRenderbufferStorageEXTFn(GLenum target,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glRenderbufferStorageEXT")
+ gl_api_->glRenderbufferStorageEXTFn(target, internalformat, width, height);
+}
+
+void TraceGLApi::glRenderbufferStorageMultisampleFn(GLenum target,
+ GLsizei samples,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glRenderbufferStorageMultisample")
+ gl_api_->glRenderbufferStorageMultisampleFn(target, samples, internalformat,
+ width, height);
+}
+
+void TraceGLApi::glRenderbufferStorageMultisampleANGLEFn(GLenum target,
+ GLsizei samples,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glRenderbufferStorageMultisampleANGLE")
+ gl_api_->glRenderbufferStorageMultisampleANGLEFn(
+ target, samples, internalformat, width, height);
+}
+
+void TraceGLApi::glRenderbufferStorageMultisampleEXTFn(GLenum target,
+ GLsizei samples,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glRenderbufferStorageMultisampleEXT")
+ gl_api_->glRenderbufferStorageMultisampleEXTFn(target, samples,
+ internalformat, width, height);
+}
+
+void TraceGLApi::glRenderbufferStorageMultisampleIMGFn(GLenum target,
+ GLsizei samples,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glRenderbufferStorageMultisampleIMG")
+ gl_api_->glRenderbufferStorageMultisampleIMGFn(target, samples,
+ internalformat, width, height);
+}
+
+void TraceGLApi::glResumeTransformFeedbackFn(void) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glResumeTransformFeedback")
+ gl_api_->glResumeTransformFeedbackFn();
+}
+
+void TraceGLApi::glSampleCoverageFn(GLclampf value, GLboolean invert) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glSampleCoverage")
+ gl_api_->glSampleCoverageFn(value, invert);
+}
+
+void TraceGLApi::glSamplerParameterfFn(GLuint sampler,
+ GLenum pname,
+ GLfloat param) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glSamplerParameterf")
+ gl_api_->glSamplerParameterfFn(sampler, pname, param);
+}
+
+void TraceGLApi::glSamplerParameterfvFn(GLuint sampler,
+ GLenum pname,
+ const GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glSamplerParameterfv")
+ gl_api_->glSamplerParameterfvFn(sampler, pname, params);
+}
+
+void TraceGLApi::glSamplerParameterfvRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLfloat* param) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glSamplerParameterfvRobustANGLE")
+ gl_api_->glSamplerParameterfvRobustANGLEFn(sampler, pname, bufSize, param);
+}
+
+void TraceGLApi::glSamplerParameteriFn(GLuint sampler,
+ GLenum pname,
+ GLint param) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glSamplerParameteri")
+ gl_api_->glSamplerParameteriFn(sampler, pname, param);
+}
+
+void TraceGLApi::glSamplerParameterIivRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLint* param) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glSamplerParameterIivRobustANGLE")
+ gl_api_->glSamplerParameterIivRobustANGLEFn(sampler, pname, bufSize, param);
+}
+
+void TraceGLApi::glSamplerParameterIuivRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLuint* param) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glSamplerParameterIuivRobustANGLE")
+ gl_api_->glSamplerParameterIuivRobustANGLEFn(sampler, pname, bufSize, param);
+}
+
+void TraceGLApi::glSamplerParameterivFn(GLuint sampler,
+ GLenum pname,
+ const GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glSamplerParameteriv")
+ gl_api_->glSamplerParameterivFn(sampler, pname, params);
+}
+
+void TraceGLApi::glSamplerParameterivRobustANGLEFn(GLuint sampler,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLint* param) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glSamplerParameterivRobustANGLE")
+ gl_api_->glSamplerParameterivRobustANGLEFn(sampler, pname, bufSize, param);
+}
+
+void TraceGLApi::glScissorFn(GLint x, GLint y, GLsizei width, GLsizei height) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glScissor")
+ gl_api_->glScissorFn(x, y, width, height);
+}
+
+void TraceGLApi::glSetFenceAPPLEFn(GLuint fence) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glSetFenceAPPLE")
+ gl_api_->glSetFenceAPPLEFn(fence);
+}
+
+void TraceGLApi::glSetFenceNVFn(GLuint fence, GLenum condition) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glSetFenceNV")
+ gl_api_->glSetFenceNVFn(fence, condition);
+}
+
+void TraceGLApi::glShaderBinaryFn(GLsizei n,
+ const GLuint* shaders,
+ GLenum binaryformat,
+ const void* binary,
+ GLsizei length) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glShaderBinary")
+ gl_api_->glShaderBinaryFn(n, shaders, binaryformat, binary, length);
+}
+
+void TraceGLApi::glShaderSourceFn(GLuint shader,
+ GLsizei count,
+ const char* const* str,
+ const GLint* length) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glShaderSource")
+ gl_api_->glShaderSourceFn(shader, count, str, length);
+}
+
+void TraceGLApi::glStencilFillPathInstancedNVFn(
+ GLsizei numPaths,
+ GLenum pathNameType,
+ const void* paths,
+ GLuint pathBase,
+ GLenum fillMode,
+ GLuint mask,
+ GLenum transformType,
+ const GLfloat* transformValues) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glStencilFillPathInstancedNV")
+ gl_api_->glStencilFillPathInstancedNVFn(numPaths, pathNameType, paths,
+ pathBase, fillMode, mask,
+ transformType, transformValues);
+}
+
+void TraceGLApi::glStencilFillPathNVFn(GLuint path,
+ GLenum fillMode,
+ GLuint mask) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilFillPathNV")
+ gl_api_->glStencilFillPathNVFn(path, fillMode, mask);
+}
+
+void TraceGLApi::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilFunc")
+ gl_api_->glStencilFuncFn(func, ref, mask);
+}
+
+void TraceGLApi::glStencilFuncSeparateFn(GLenum face,
+ GLenum func,
+ GLint ref,
+ GLuint mask) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilFuncSeparate")
+ gl_api_->glStencilFuncSeparateFn(face, func, ref, mask);
+}
+
+void TraceGLApi::glStencilMaskFn(GLuint mask) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilMask")
+ gl_api_->glStencilMaskFn(mask);
+}
+
+void TraceGLApi::glStencilMaskSeparateFn(GLenum face, GLuint mask) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilMaskSeparate")
+ gl_api_->glStencilMaskSeparateFn(face, mask);
+}
+
+void TraceGLApi::glStencilOpFn(GLenum fail, GLenum zfail, GLenum zpass) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilOp")
+ gl_api_->glStencilOpFn(fail, zfail, zpass);
+}
+
+void TraceGLApi::glStencilOpSeparateFn(GLenum face,
+ GLenum fail,
+ GLenum zfail,
+ GLenum zpass) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilOpSeparate")
+ gl_api_->glStencilOpSeparateFn(face, fail, zfail, zpass);
+}
+
+void TraceGLApi::glStencilStrokePathInstancedNVFn(
+ GLsizei numPaths,
+ GLenum pathNameType,
+ const void* paths,
+ GLuint pathBase,
+ GLint ref,
+ GLuint mask,
+ GLenum transformType,
+ const GLfloat* transformValues) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glStencilStrokePathInstancedNV")
+ gl_api_->glStencilStrokePathInstancedNVFn(numPaths, pathNameType, paths,
+ pathBase, ref, mask, transformType,
+ transformValues);
+}
+
+void TraceGLApi::glStencilStrokePathNVFn(GLuint path,
+ GLint reference,
+ GLuint mask) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilStrokePathNV")
+ gl_api_->glStencilStrokePathNVFn(path, reference, mask);
+}
+
+void TraceGLApi::glStencilThenCoverFillPathInstancedNVFn(
+ GLsizei numPaths,
+ GLenum pathNameType,
+ const void* paths,
+ GLuint pathBase,
+ GLenum fillMode,
+ GLuint mask,
+ GLenum coverMode,
+ GLenum transformType,
+ const GLfloat* transformValues) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glStencilThenCoverFillPathInstancedNV")
+ gl_api_->glStencilThenCoverFillPathInstancedNVFn(
+ numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
+ transformType, transformValues);
+}
+
+void TraceGLApi::glStencilThenCoverFillPathNVFn(GLuint path,
+ GLenum fillMode,
+ GLuint mask,
+ GLenum coverMode) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glStencilThenCoverFillPathNV")
+ gl_api_->glStencilThenCoverFillPathNVFn(path, fillMode, mask, coverMode);
+}
+
+void TraceGLApi::glStencilThenCoverStrokePathInstancedNVFn(
+ GLsizei numPaths,
+ GLenum pathNameType,
+ const void* paths,
+ GLuint pathBase,
+ GLint ref,
+ GLuint mask,
+ GLenum coverMode,
+ GLenum transformType,
+ const GLfloat* transformValues) {
+ TRACE_EVENT_BINARY_EFFICIENT0(
+ "gpu", "TraceGLAPI::glStencilThenCoverStrokePathInstancedNV")
+ gl_api_->glStencilThenCoverStrokePathInstancedNVFn(
+ numPaths, pathNameType, paths, pathBase, ref, mask, coverMode,
+ transformType, transformValues);
+}
+
+void TraceGLApi::glStencilThenCoverStrokePathNVFn(GLuint path,
+ GLint reference,
+ GLuint mask,
+ GLenum coverMode) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glStencilThenCoverStrokePathNV")
+ gl_api_->glStencilThenCoverStrokePathNVFn(path, reference, mask, coverMode);
+}
+
+GLboolean TraceGLApi::glTestFenceAPPLEFn(GLuint fence) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTestFenceAPPLE")
+ return gl_api_->glTestFenceAPPLEFn(fence);
+}
+
+GLboolean TraceGLApi::glTestFenceNVFn(GLuint fence) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTestFenceNV")
+ return gl_api_->glTestFenceNVFn(fence);
+}
+
+void TraceGLApi::glTexImage2DFn(GLenum target,
+ GLint level,
+ GLint internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLint border,
+ GLenum format,
+ GLenum type,
+ const void* pixels) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexImage2D")
+ gl_api_->glTexImage2DFn(target, level, internalformat, width, height, border,
+ format, type, pixels);
+}
+
+void TraceGLApi::glTexImage2DRobustANGLEFn(GLenum target,
+ GLint level,
+ GLint internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLint border,
+ GLenum format,
+ GLenum type,
+ GLsizei bufSize,
+ const void* pixels) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexImage2DRobustANGLE")
+ gl_api_->glTexImage2DRobustANGLEFn(target, level, internalformat, width,
+ height, border, format, type, bufSize,
+ pixels);
+}
+
+void TraceGLApi::glTexImage3DFn(GLenum target,
+ GLint level,
+ GLint internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ GLint border,
+ GLenum format,
+ GLenum type,
+ const void* pixels) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexImage3D")
+ gl_api_->glTexImage3DFn(target, level, internalformat, width, height, depth,
+ border, format, type, pixels);
+}
+
+void TraceGLApi::glTexImage3DRobustANGLEFn(GLenum target,
+ GLint level,
+ GLint internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ GLint border,
+ GLenum format,
+ GLenum type,
+ GLsizei bufSize,
+ const void* pixels) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexImage3DRobustANGLE")
+ gl_api_->glTexImage3DRobustANGLEFn(target, level, internalformat, width,
+ height, depth, border, format, type,
+ bufSize, pixels);
+}
+
+void TraceGLApi::glTexParameterfFn(GLenum target, GLenum pname, GLfloat param) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexParameterf")
+ gl_api_->glTexParameterfFn(target, pname, param);
+}
+
+void TraceGLApi::glTexParameterfvFn(GLenum target,
+ GLenum pname,
+ const GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexParameterfv")
+ gl_api_->glTexParameterfvFn(target, pname, params);
+}
+
+void TraceGLApi::glTexParameterfvRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLfloat* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glTexParameterfvRobustANGLE")
+ gl_api_->glTexParameterfvRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void TraceGLApi::glTexParameteriFn(GLenum target, GLenum pname, GLint param) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexParameteri")
+ gl_api_->glTexParameteriFn(target, pname, param);
+}
+
+void TraceGLApi::glTexParameterIivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glTexParameterIivRobustANGLE")
+ gl_api_->glTexParameterIivRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void TraceGLApi::glTexParameterIuivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLuint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glTexParameterIuivRobustANGLE")
+ gl_api_->glTexParameterIuivRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void TraceGLApi::glTexParameterivFn(GLenum target,
+ GLenum pname,
+ const GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexParameteriv")
+ gl_api_->glTexParameterivFn(target, pname, params);
+}
+
+void TraceGLApi::glTexParameterivRobustANGLEFn(GLenum target,
+ GLenum pname,
+ GLsizei bufSize,
+ const GLint* params) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glTexParameterivRobustANGLE")
+ gl_api_->glTexParameterivRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void TraceGLApi::glTexStorage2DEXTFn(GLenum target,
+ GLsizei levels,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexStorage2DEXT")
+ gl_api_->glTexStorage2DEXTFn(target, levels, internalformat, width, height);
+}
+
+void TraceGLApi::glTexStorage3DFn(GLenum target,
+ GLsizei levels,
+ GLenum internalformat,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexStorage3D")
+ gl_api_->glTexStorage3DFn(target, levels, internalformat, width, height,
+ depth);
+}
+
+void TraceGLApi::glTexSubImage2DFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLenum type,
+ const void* pixels) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexSubImage2D")
+ gl_api_->glTexSubImage2DFn(target, level, xoffset, yoffset, width, height,
+ format, type, pixels);
+}
+
+void TraceGLApi::glTexSubImage2DRobustANGLEFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLsizei width,
+ GLsizei height,
+ GLenum format,
+ GLenum type,
+ GLsizei bufSize,
+ const void* pixels) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexSubImage2DRobustANGLE")
+ gl_api_->glTexSubImage2DRobustANGLEFn(target, level, xoffset, yoffset, width,
+ height, format, type, bufSize, pixels);
+}
+
+void TraceGLApi::glTexSubImage3DFn(GLenum target,
+ GLint level,
+ GLint xoffset,
+ GLint yoffset,
+ GLint zoffset,
+ GLsizei width,
+ GLsizei height,
+ GLsizei depth,
+ GLenum format,
+ GLenum type,
+ const void* pixels) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexSubImage3D")
+ gl_api_->glTexSubImage3DFn(target, level, xoffset, yoffset, zoffset, width,
+ height, depth, format, type, pixels);
+}
+
+void TraceGLApi::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) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexSubImage3DRobustANGLE")
+ gl_api_->glTexSubImage3DRobustANGLEFn(target, level, xoffset, yoffset,
+ zoffset, width, height, depth, format,
+ type, bufSize, pixels);
+}
+
+void TraceGLApi::glTransformFeedbackVaryingsFn(GLuint program,
+ GLsizei count,
+ const char* const* varyings,
+ GLenum bufferMode) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu",
+ "TraceGLAPI::glTransformFeedbackVaryings")
+ gl_api_->glTransformFeedbackVaryingsFn(program, count, varyings, bufferMode);
+}
+
+void TraceGLApi::glUniform1fFn(GLint location, GLfloat x) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform1f")
+ gl_api_->glUniform1fFn(location, x);
+}
+
+void TraceGLApi::glUniform1fvFn(GLint location,
+ GLsizei count,
+ const GLfloat* v) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform1fv")
+ gl_api_->glUniform1fvFn(location, count, v);
+}
+
+void TraceGLApi::glUniform1iFn(GLint location, GLint x) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform1i")
+ gl_api_->glUniform1iFn(location, x);
+}
+
+void TraceGLApi::glUniform1ivFn(GLint location, GLsizei count, const GLint* v) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform1iv")
+ gl_api_->glUniform1ivFn(location, count, v);
+}
+
+void TraceGLApi::glUniform1uiFn(GLint location, GLuint v0) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform1ui")
+ gl_api_->glUniform1uiFn(location, v0);
+}
+
+void TraceGLApi::glUniform1uivFn(GLint location,
+ GLsizei count,
+ const GLuint* v) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform1uiv")
+ gl_api_->glUniform1uivFn(location, count, v);
+}
+
+void TraceGLApi::glUniform2fFn(GLint location, GLfloat x, GLfloat y) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform2f")
+ gl_api_->glUniform2fFn(location, x, y);
+}
+
+void TraceGLApi::glUniform2fvFn(GLint location,
+ GLsizei count,
+ const GLfloat* v) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform2fv")
+ gl_api_->glUniform2fvFn(location, count, v);
+}
+
+void TraceGLApi::glUniform2iFn(GLint location, GLint x, GLint y) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform2i")
+ gl_api_->glUniform2iFn(location, x, y);
+}
+
+void TraceGLApi::glUniform2ivFn(GLint location, GLsizei count, const GLint* v) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform2iv")
+ gl_api_->glUniform2ivFn(location, count, v);
+}
+
+void TraceGLApi::glUniform2uiFn(GLint location, GLuint v0, GLuint v1) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform2ui")
+ gl_api_->glUniform2uiFn(location, v0, v1);
+}
+
+void TraceGLApi::glUniform2uivFn(GLint location,
+ GLsizei count,
+ const GLuint* v) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform2uiv")
+ gl_api_->glUniform2uivFn(location, count, v);
+}
+
+void TraceGLApi::glUniform3fFn(GLint location,
+ GLfloat x,
+ GLfloat y,
+ GLfloat z) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform3f")
+ gl_api_->glUniform3fFn(location, x, y, z);
+}
+
+void TraceGLApi::glUniform3fvFn(GLint location,
+ GLsizei count,
+ const GLfloat* v) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform3fv")
+ gl_api_->glUniform3fvFn(location, count, v);
+}
+
+void TraceGLApi::glUniform3iFn(GLint location, GLint x, GLint y, GLint z) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform3i")
+ gl_api_->glUniform3iFn(location, x, y, z);
+}
+
+void TraceGLApi::glUniform3ivFn(GLint location, GLsizei count, const GLint* v) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform3iv")
+ gl_api_->glUniform3ivFn(location, count, v);
+}
+
+void TraceGLApi::glUniform3uiFn(GLint location,
+ GLuint v0,
+ GLuint v1,
+ GLuint v2) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform3ui")
+ gl_api_->glUniform3uiFn(location, v0, v1, v2);
+}
+
+void TraceGLApi::glUniform3uivFn(GLint location,
+ GLsizei count,
+ const GLuint* v) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform3uiv")
+ gl_api_->glUniform3uivFn(location, count, v);
+}
+
+void TraceGLApi::glUniform4fFn(GLint location,
+ GLfloat x,
+ GLfloat y,
+ GLfloat z,
+ GLfloat w) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform4f")
+ gl_api_->glUniform4fFn(location, x, y, z, w);
+}
+
+void TraceGLApi::glUniform4fvFn(GLint location,
+ GLsizei count,
+ const GLfloat* v) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform4fv")
+ gl_api_->glUniform4fvFn(location, count, v);
+}
+
+void TraceGLApi::glUniform4iFn(GLint location,
+ GLint x,
+ GLint y,
+ GLint z,
+ GLint w) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform4i")
+ gl_api_->glUniform4iFn(location, x, y, z, w);
+}
+
+void TraceGLApi::glUniform4ivFn(GLint location, GLsizei count, const GLint* v) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform4iv")
+ gl_api_->glUniform4ivFn(location, count, v);
+}
+
+void TraceGLApi::glUniform4uiFn(GLint location,
+ GLuint v0,
+ GLuint v1,
+ GLuint v2,
+ GLuint v3) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform4ui")
+ gl_api_->glUniform4uiFn(location, v0, v1, v2, v3);
+}
+
+void TraceGLApi::glUniform4uivFn(GLint location,
+ GLsizei count,
+ const GLuint* v) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform4uiv")
+ gl_api_->glUniform4uivFn(location, count, v);
+}
+
+void TraceGLApi::glUniformBlockBindingFn(GLuint program,
+ GLuint uniformBlockIndex,
+ GLuint uniformBlockBinding) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniformBlockBinding")
+ gl_api_->glUniformBlockBindingFn(program, uniformBlockIndex,
+ uniformBlockBinding);
+}
+
+void TraceGLApi::glUniformMatrix2fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniformMatrix2fv")
+ gl_api_->glUniformMatrix2fvFn(location, count, transpose, value);
+}
+
+void TraceGLApi::glUniformMatrix2x3fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniformMatrix2x3fv")
+ gl_api_->glUniformMatrix2x3fvFn(location, count, transpose, value);
+}
+
+void TraceGLApi::glUniformMatrix2x4fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniformMatrix2x4fv")
+ gl_api_->glUniformMatrix2x4fvFn(location, count, transpose, value);
+}
+
+void TraceGLApi::glUniformMatrix3fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniformMatrix3fv")
+ gl_api_->glUniformMatrix3fvFn(location, count, transpose, value);
+}
+
+void TraceGLApi::glUniformMatrix3x2fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniformMatrix3x2fv")
+ gl_api_->glUniformMatrix3x2fvFn(location, count, transpose, value);
+}
+
+void TraceGLApi::glUniformMatrix3x4fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniformMatrix3x4fv")
+ gl_api_->glUniformMatrix3x4fvFn(location, count, transpose, value);
+}
+
+void TraceGLApi::glUniformMatrix4fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniformMatrix4fv")
+ gl_api_->glUniformMatrix4fvFn(location, count, transpose, value);
+}
+
+void TraceGLApi::glUniformMatrix4x2fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniformMatrix4x2fv")
+ gl_api_->glUniformMatrix4x2fvFn(location, count, transpose, value);
+}
+
+void TraceGLApi::glUniformMatrix4x3fvFn(GLint location,
+ GLsizei count,
+ GLboolean transpose,
+ const GLfloat* value) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniformMatrix4x3fv")
+ gl_api_->glUniformMatrix4x3fvFn(location, count, transpose, value);
+}
+
+GLboolean TraceGLApi::glUnmapBufferFn(GLenum target) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUnmapBuffer")
+ return gl_api_->glUnmapBufferFn(target);
+}
+
+void TraceGLApi::glUseProgramFn(GLuint program) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUseProgram")
+ gl_api_->glUseProgramFn(program);
+}
+
+void TraceGLApi::glValidateProgramFn(GLuint program) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glValidateProgram")
+ gl_api_->glValidateProgramFn(program);
+}
+
+void TraceGLApi::glVertexAttrib1fFn(GLuint indx, GLfloat x) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib1f")
+ gl_api_->glVertexAttrib1fFn(indx, x);
+}
+
+void TraceGLApi::glVertexAttrib1fvFn(GLuint indx, const GLfloat* values) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib1fv")
+ gl_api_->glVertexAttrib1fvFn(indx, values);
+}
+
+void TraceGLApi::glVertexAttrib2fFn(GLuint indx, GLfloat x, GLfloat y) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib2f")
+ gl_api_->glVertexAttrib2fFn(indx, x, y);
+}
+
+void TraceGLApi::glVertexAttrib2fvFn(GLuint indx, const GLfloat* values) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib2fv")
+ gl_api_->glVertexAttrib2fvFn(indx, values);
+}
+
+void TraceGLApi::glVertexAttrib3fFn(GLuint indx,
+ GLfloat x,
+ GLfloat y,
+ GLfloat z) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib3f")
+ gl_api_->glVertexAttrib3fFn(indx, x, y, z);
+}
+
+void TraceGLApi::glVertexAttrib3fvFn(GLuint indx, const GLfloat* values) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib3fv")
+ gl_api_->glVertexAttrib3fvFn(indx, values);
+}
+
+void TraceGLApi::glVertexAttrib4fFn(GLuint indx,
+ GLfloat x,
+ GLfloat y,
+ GLfloat z,
+ GLfloat w) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib4f")
+ gl_api_->glVertexAttrib4fFn(indx, x, y, z, w);
+}
+
+void TraceGLApi::glVertexAttrib4fvFn(GLuint indx, const GLfloat* values) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib4fv")
+ gl_api_->glVertexAttrib4fvFn(indx, values);
+}
+
+void TraceGLApi::glVertexAttribDivisorANGLEFn(GLuint index, GLuint divisor) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttribDivisorANGLE")
+ gl_api_->glVertexAttribDivisorANGLEFn(index, divisor);
+}
+
+void TraceGLApi::glVertexAttribI4iFn(GLuint indx,
+ GLint x,
+ GLint y,
+ GLint z,
+ GLint w) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttribI4i")
+ gl_api_->glVertexAttribI4iFn(indx, x, y, z, w);
+}
+
+void TraceGLApi::glVertexAttribI4ivFn(GLuint indx, const GLint* values) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttribI4iv")
+ gl_api_->glVertexAttribI4ivFn(indx, values);
+}
+
+void TraceGLApi::glVertexAttribI4uiFn(GLuint indx,
+ GLuint x,
+ GLuint y,
+ GLuint z,
+ GLuint w) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttribI4ui")
+ gl_api_->glVertexAttribI4uiFn(indx, x, y, z, w);
+}
+
+void TraceGLApi::glVertexAttribI4uivFn(GLuint indx, const GLuint* values) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttribI4uiv")
+ gl_api_->glVertexAttribI4uivFn(indx, values);
+}
+
+void TraceGLApi::glVertexAttribIPointerFn(GLuint indx,
+ GLint size,
+ GLenum type,
+ GLsizei stride,
+ const void* ptr) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttribIPointer")
+ gl_api_->glVertexAttribIPointerFn(indx, size, type, stride, ptr);
+}
+
+void TraceGLApi::glVertexAttribPointerFn(GLuint indx,
+ GLint size,
+ GLenum type,
+ GLboolean normalized,
+ GLsizei stride,
+ const void* ptr) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttribPointer")
+ gl_api_->glVertexAttribPointerFn(indx, size, type, normalized, stride, ptr);
+}
+
+void TraceGLApi::glViewportFn(GLint x, GLint y, GLsizei width, GLsizei height) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glViewport")
+ gl_api_->glViewportFn(x, y, width, height);
+}
+
+GLenum TraceGLApi::glWaitSyncFn(GLsync sync,
+ GLbitfield flags,
+ GLuint64 timeout) {
+ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glWaitSync")
+ return gl_api_->glWaitSyncFn(sync, flags, timeout);
+}
+
+} // namespace gl
« no previous file with comments | « ui/gl/gl_bindings_autogen_gl2.cc ('k') | ui/gl/gl_bindings_autogen_gl4.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698