| // 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.h> |
| |
| #include "ui/gl/gl_mock.h" |
| |
| namespace { |
| // This is called mainly to prevent the compiler combining the code of mock |
| // functions with identical contents, so that their function pointers will be |
| // different. |
| void MakeFunctionUnique(const char* func_name) { |
| VLOG(2) << "Calling mock " << func_name; |
| } |
| } // namespace |
| |
| namespace gl { |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glActiveTexture(GLenum texture) { |
| MakeFunctionUnique("glActiveTexture"); |
| interface_->ActiveTexture(texture); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glApplyFramebufferAttachmentCMAAINTEL(void) { |
| MakeFunctionUnique("glApplyFramebufferAttachmentCMAAINTEL"); |
| interface_->ApplyFramebufferAttachmentCMAAINTEL(); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glAttachShader(GLuint program, |
| GLuint shader) { |
| MakeFunctionUnique("glAttachShader"); |
| interface_->AttachShader(program, shader); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBeginQuery(GLenum target, |
| GLuint id) { |
| MakeFunctionUnique("glBeginQuery"); |
| interface_->BeginQuery(target, id); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBeginQueryARB(GLenum target, |
| GLuint id) { |
| MakeFunctionUnique("glBeginQueryARB"); |
| interface_->BeginQuery(target, id); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBeginQueryEXT(GLenum target, |
| GLuint id) { |
| MakeFunctionUnique("glBeginQueryEXT"); |
| interface_->BeginQuery(target, id); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBeginTransformFeedback(GLenum primitiveMode) { |
| MakeFunctionUnique("glBeginTransformFeedback"); |
| interface_->BeginTransformFeedback(primitiveMode); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBeginTransformFeedbackEXT(GLenum primitiveMode) { |
| MakeFunctionUnique("glBeginTransformFeedbackEXT"); |
| interface_->BeginTransformFeedback(primitiveMode); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindAttribLocation(GLuint program, |
| GLuint index, |
| const char* name) { |
| MakeFunctionUnique("glBindAttribLocation"); |
| interface_->BindAttribLocation(program, index, name); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBindBuffer(GLenum target, |
| GLuint buffer) { |
| MakeFunctionUnique("glBindBuffer"); |
| interface_->BindBuffer(target, buffer); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBindBufferBase(GLenum target, |
| GLuint index, |
| GLuint buffer) { |
| MakeFunctionUnique("glBindBufferBase"); |
| interface_->BindBufferBase(target, index, buffer); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBindBufferBaseEXT(GLenum target, |
| GLuint index, |
| GLuint buffer) { |
| MakeFunctionUnique("glBindBufferBaseEXT"); |
| interface_->BindBufferBase(target, index, buffer); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBindBufferRange(GLenum target, |
| GLuint index, |
| GLuint buffer, |
| GLintptr offset, |
| GLsizeiptr size) { |
| MakeFunctionUnique("glBindBufferRange"); |
| interface_->BindBufferRange(target, index, buffer, offset, size); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindBufferRangeEXT(GLenum target, |
| GLuint index, |
| GLuint buffer, |
| GLintptr offset, |
| GLsizeiptr size) { |
| MakeFunctionUnique("glBindBufferRangeEXT"); |
| interface_->BindBufferRange(target, index, buffer, offset, size); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindFragDataLocation(GLuint program, |
| GLuint colorNumber, |
| const char* name) { |
| MakeFunctionUnique("glBindFragDataLocation"); |
| interface_->BindFragDataLocation(program, colorNumber, name); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindFragDataLocationEXT(GLuint program, |
| GLuint colorNumber, |
| const char* name) { |
| MakeFunctionUnique("glBindFragDataLocationEXT"); |
| interface_->BindFragDataLocation(program, colorNumber, name); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindFragDataLocationIndexed(GLuint program, |
| GLuint colorNumber, |
| GLuint index, |
| const char* name) { |
| MakeFunctionUnique("glBindFragDataLocationIndexed"); |
| interface_->BindFragDataLocationIndexed(program, colorNumber, index, name); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindFragDataLocationIndexedEXT(GLuint program, |
| GLuint colorNumber, |
| GLuint index, |
| const char* name) { |
| MakeFunctionUnique("glBindFragDataLocationIndexedEXT"); |
| interface_->BindFragDataLocationIndexed(program, colorNumber, index, name); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindFramebuffer(GLenum target, GLuint framebuffer) { |
| MakeFunctionUnique("glBindFramebuffer"); |
| interface_->BindFramebufferEXT(target, framebuffer); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindFramebufferEXT(GLenum target, GLuint framebuffer) { |
| MakeFunctionUnique("glBindFramebufferEXT"); |
| interface_->BindFramebufferEXT(target, framebuffer); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBindImageTexture(GLuint index, |
| GLuint texture, |
| GLint level, |
| GLboolean layered, |
| GLint layer, |
| GLenum access, |
| GLint format) { |
| MakeFunctionUnique("glBindImageTexture"); |
| interface_->BindImageTextureEXT(index, texture, level, layered, layer, access, |
| format); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindImageTextureEXT(GLuint index, |
| GLuint texture, |
| GLint level, |
| GLboolean layered, |
| GLint layer, |
| GLenum access, |
| GLint format) { |
| MakeFunctionUnique("glBindImageTextureEXT"); |
| interface_->BindImageTextureEXT(index, texture, level, layered, layer, access, |
| format); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindRenderbuffer(GLenum target, GLuint renderbuffer) { |
| MakeFunctionUnique("glBindRenderbuffer"); |
| interface_->BindRenderbufferEXT(target, renderbuffer); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindRenderbufferEXT(GLenum target, |
| GLuint renderbuffer) { |
| MakeFunctionUnique("glBindRenderbufferEXT"); |
| interface_->BindRenderbufferEXT(target, renderbuffer); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBindSampler(GLuint unit, |
| GLuint sampler) { |
| MakeFunctionUnique("glBindSampler"); |
| interface_->BindSampler(unit, sampler); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBindTexture(GLenum target, |
| GLuint texture) { |
| MakeFunctionUnique("glBindTexture"); |
| interface_->BindTexture(target, texture); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindTransformFeedback(GLenum target, GLuint id) { |
| MakeFunctionUnique("glBindTransformFeedback"); |
| interface_->BindTransformFeedback(target, id); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindUniformLocationCHROMIUM(GLuint program, |
| GLint location, |
| const char* name) { |
| MakeFunctionUnique("glBindUniformLocationCHROMIUM"); |
| interface_->BindUniformLocationCHROMIUM(program, location, name); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBindVertexArray(GLuint array) { |
| MakeFunctionUnique("glBindVertexArray"); |
| interface_->BindVertexArrayOES(array); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBindVertexArrayAPPLE(GLuint array) { |
| MakeFunctionUnique("glBindVertexArrayAPPLE"); |
| interface_->BindVertexArrayOES(array); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBindVertexArrayOES(GLuint array) { |
| MakeFunctionUnique("glBindVertexArrayOES"); |
| interface_->BindVertexArrayOES(array); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBlendBarrierKHR(void) { |
| MakeFunctionUnique("glBlendBarrierKHR"); |
| interface_->BlendBarrierKHR(); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBlendBarrierNV(void) { |
| MakeFunctionUnique("glBlendBarrierNV"); |
| interface_->BlendBarrierKHR(); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBlendColor(GLclampf red, |
| GLclampf green, |
| GLclampf blue, |
| GLclampf alpha) { |
| MakeFunctionUnique("glBlendColor"); |
| interface_->BlendColor(red, green, blue, alpha); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBlendEquation(GLenum mode) { |
| MakeFunctionUnique("glBlendEquation"); |
| interface_->BlendEquation(mode); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBlendEquationSeparate(GLenum modeRGB, |
| GLenum modeAlpha) { |
| MakeFunctionUnique("glBlendEquationSeparate"); |
| interface_->BlendEquationSeparate(modeRGB, modeAlpha); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBlendFunc(GLenum sfactor, |
| GLenum dfactor) { |
| MakeFunctionUnique("glBlendFunc"); |
| interface_->BlendFunc(sfactor, dfactor); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBlendFuncSeparate(GLenum srcRGB, |
| GLenum dstRGB, |
| GLenum srcAlpha, |
| GLenum dstAlpha) { |
| MakeFunctionUnique("glBlendFuncSeparate"); |
| interface_->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBlitFramebuffer(GLint srcX0, |
| GLint srcY0, |
| GLint srcX1, |
| GLint srcY1, |
| GLint dstX0, |
| GLint dstY0, |
| GLint dstX1, |
| GLint dstY1, |
| GLbitfield mask, |
| GLenum filter) { |
| MakeFunctionUnique("glBlitFramebuffer"); |
| interface_->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, |
| dstY1, mask, filter); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glBlitFramebufferANGLE(GLint srcX0, |
| GLint srcY0, |
| GLint srcX1, |
| GLint srcY1, |
| GLint dstX0, |
| GLint dstY0, |
| GLint dstX1, |
| GLint dstY1, |
| GLbitfield mask, |
| GLenum filter) { |
| MakeFunctionUnique("glBlitFramebufferANGLE"); |
| interface_->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, |
| dstY1, mask, filter); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBlitFramebufferEXT(GLint srcX0, |
| GLint srcY0, |
| GLint srcX1, |
| GLint srcY1, |
| GLint dstX0, |
| GLint dstY0, |
| GLint dstX1, |
| GLint dstY1, |
| GLbitfield mask, |
| GLenum filter) { |
| MakeFunctionUnique("glBlitFramebufferEXT"); |
| interface_->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, |
| dstY1, mask, filter); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBufferData(GLenum target, |
| GLsizeiptr size, |
| const void* data, |
| GLenum usage) { |
| MakeFunctionUnique("glBufferData"); |
| interface_->BufferData(target, size, data, usage); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glBufferSubData(GLenum target, |
| GLintptr offset, |
| GLsizeiptr size, |
| const void* data) { |
| MakeFunctionUnique("glBufferSubData"); |
| interface_->BufferSubData(target, offset, size, data); |
| } |
| |
| GLenum GL_BINDING_CALL |
| MockGLInterface::Mock_glCheckFramebufferStatus(GLenum target) { |
| MakeFunctionUnique("glCheckFramebufferStatus"); |
| return interface_->CheckFramebufferStatusEXT(target); |
| } |
| |
| GLenum GL_BINDING_CALL |
| MockGLInterface::Mock_glCheckFramebufferStatusEXT(GLenum target) { |
| MakeFunctionUnique("glCheckFramebufferStatusEXT"); |
| return interface_->CheckFramebufferStatusEXT(target); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glClear(GLbitfield mask) { |
| MakeFunctionUnique("glClear"); |
| interface_->Clear(mask); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glClearBufferfi(GLenum buffer, |
| GLint drawbuffer, |
| const GLfloat depth, |
| GLint stencil) { |
| MakeFunctionUnique("glClearBufferfi"); |
| interface_->ClearBufferfi(buffer, drawbuffer, depth, stencil); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glClearBufferfv(GLenum buffer, |
| GLint drawbuffer, |
| const GLfloat* value) { |
| MakeFunctionUnique("glClearBufferfv"); |
| interface_->ClearBufferfv(buffer, drawbuffer, value); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glClearBufferiv(GLenum buffer, |
| GLint drawbuffer, |
| const GLint* value) { |
| MakeFunctionUnique("glClearBufferiv"); |
| interface_->ClearBufferiv(buffer, drawbuffer, value); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glClearBufferuiv(GLenum buffer, |
| GLint drawbuffer, |
| const GLuint* value) { |
| MakeFunctionUnique("glClearBufferuiv"); |
| interface_->ClearBufferuiv(buffer, drawbuffer, value); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glClearColor(GLclampf red, |
| GLclampf green, |
| GLclampf blue, |
| GLclampf alpha) { |
| MakeFunctionUnique("glClearColor"); |
| interface_->ClearColor(red, green, blue, alpha); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glClearDepth(GLclampd depth) { |
| MakeFunctionUnique("glClearDepth"); |
| interface_->ClearDepth(depth); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glClearDepthf(GLclampf depth) { |
| MakeFunctionUnique("glClearDepthf"); |
| interface_->ClearDepthf(depth); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glClearStencil(GLint s) { |
| MakeFunctionUnique("glClearStencil"); |
| interface_->ClearStencil(s); |
| } |
| |
| GLenum GL_BINDING_CALL |
| MockGLInterface::Mock_glClientWaitSync(GLsync sync, |
| GLbitfield flags, |
| GLuint64 timeout) { |
| MakeFunctionUnique("glClientWaitSync"); |
| return interface_->ClientWaitSync(sync, flags, timeout); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glColorMask(GLboolean red, |
| GLboolean green, |
| GLboolean blue, |
| GLboolean alpha) { |
| MakeFunctionUnique("glColorMask"); |
| interface_->ColorMask(red, green, blue, alpha); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glCompileShader(GLuint shader) { |
| MakeFunctionUnique("glCompileShader"); |
| interface_->CompileShader(shader); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCompressedCopyTextureCHROMIUM(GLuint sourceId, |
| GLuint destId) { |
| MakeFunctionUnique("glCompressedCopyTextureCHROMIUM"); |
| interface_->CompressedCopyTextureCHROMIUM(sourceId, destId); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCompressedTexImage2D(GLenum target, |
| GLint level, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLint border, |
| GLsizei imageSize, |
| const void* data) { |
| MakeFunctionUnique("glCompressedTexImage2D"); |
| interface_->CompressedTexImage2D(target, level, internalformat, width, height, |
| border, imageSize, data); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCompressedTexImage2DRobustANGLE(GLenum target, |
| GLint level, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLint border, |
| GLsizei imageSize, |
| GLsizei dataSize, |
| const void* data) { |
| MakeFunctionUnique("glCompressedTexImage2DRobustANGLE"); |
| interface_->CompressedTexImage2DRobustANGLE(target, level, internalformat, |
| width, height, border, imageSize, |
| dataSize, data); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCompressedTexImage3D(GLenum target, |
| GLint level, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLint border, |
| GLsizei imageSize, |
| const void* data) { |
| MakeFunctionUnique("glCompressedTexImage3D"); |
| interface_->CompressedTexImage3D(target, level, internalformat, width, height, |
| depth, border, imageSize, data); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCompressedTexImage3DRobustANGLE(GLenum target, |
| GLint level, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLint border, |
| GLsizei imageSize, |
| GLsizei dataSize, |
| const void* data) { |
| MakeFunctionUnique("glCompressedTexImage3DRobustANGLE"); |
| interface_->CompressedTexImage3DRobustANGLE(target, level, internalformat, |
| width, height, depth, border, |
| imageSize, dataSize, data); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCompressedTexSubImage2D(GLenum target, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLsizei width, |
| GLsizei height, |
| GLenum format, |
| GLsizei imageSize, |
| const void* data) { |
| MakeFunctionUnique("glCompressedTexSubImage2D"); |
| interface_->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, |
| height, format, imageSize, data); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCompressedTexSubImage2DRobustANGLE(GLenum target, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLsizei width, |
| GLsizei height, |
| GLenum format, |
| GLsizei imageSize, |
| GLsizei dataSize, |
| const void* data) { |
| MakeFunctionUnique("glCompressedTexSubImage2DRobustANGLE"); |
| interface_->CompressedTexSubImage2DRobustANGLE(target, level, xoffset, |
| yoffset, width, height, format, |
| imageSize, dataSize, data); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCompressedTexSubImage3D(GLenum target, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLint zoffset, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLenum format, |
| GLsizei imageSize, |
| const void* data) { |
| MakeFunctionUnique("glCompressedTexSubImage3D"); |
| interface_->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, |
| width, height, depth, format, imageSize, |
| data); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCompressedTexSubImage3DRobustANGLE(GLenum target, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLint zoffset, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLenum format, |
| GLsizei imageSize, |
| GLsizei dataSize, |
| const void* data) { |
| MakeFunctionUnique("glCompressedTexSubImage3DRobustANGLE"); |
| interface_->CompressedTexSubImage3DRobustANGLE( |
| target, level, xoffset, yoffset, zoffset, width, height, depth, format, |
| imageSize, dataSize, data); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCopyBufferSubData(GLenum readTarget, |
| GLenum writeTarget, |
| GLintptr readOffset, |
| GLintptr writeOffset, |
| GLsizeiptr size) { |
| MakeFunctionUnique("glCopyBufferSubData"); |
| interface_->CopyBufferSubData(readTarget, writeTarget, readOffset, |
| writeOffset, size); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glCopySubTextureCHROMIUM( |
| GLuint sourceId, |
| GLint sourceLevel, |
| GLenum destTarget, |
| GLuint destId, |
| GLint destLevel, |
| GLint xoffset, |
| GLint yoffset, |
| GLint x, |
| GLint y, |
| GLsizei width, |
| GLsizei height, |
| GLboolean unpackFlipY, |
| GLboolean unpackPremultiplyAlpha, |
| GLboolean unpackUnmultiplyAlpha) { |
| MakeFunctionUnique("glCopySubTextureCHROMIUM"); |
| interface_->CopySubTextureCHROMIUM( |
| sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, yoffset, x, |
| y, width, height, unpackFlipY, unpackPremultiplyAlpha, |
| unpackUnmultiplyAlpha); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCopyTexImage2D(GLenum target, |
| GLint level, |
| GLenum internalformat, |
| GLint x, |
| GLint y, |
| GLsizei width, |
| GLsizei height, |
| GLint border) { |
| MakeFunctionUnique("glCopyTexImage2D"); |
| interface_->CopyTexImage2D(target, level, internalformat, x, y, width, height, |
| border); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glCopyTexSubImage2D(GLenum target, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLint x, |
| GLint y, |
| GLsizei width, |
| GLsizei height) { |
| MakeFunctionUnique("glCopyTexSubImage2D"); |
| interface_->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, |
| height); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glCopyTexSubImage3D(GLenum target, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLint zoffset, |
| GLint x, |
| GLint y, |
| GLsizei width, |
| GLsizei height) { |
| MakeFunctionUnique("glCopyTexSubImage3D"); |
| interface_->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, |
| width, height); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCopyTextureCHROMIUM(GLuint sourceId, |
| GLint sourceLevel, |
| GLenum destTarget, |
| GLuint destId, |
| GLint destLevel, |
| GLint internalFormat, |
| GLenum destType, |
| GLboolean unpackFlipY, |
| GLboolean unpackPremultiplyAlpha, |
| GLboolean unpackUnmultiplyAlpha) { |
| MakeFunctionUnique("glCopyTextureCHROMIUM"); |
| interface_->CopyTextureCHROMIUM( |
| sourceId, sourceLevel, destTarget, destId, destLevel, internalFormat, |
| destType, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glCoverFillPathInstancedNV( |
| GLsizei numPaths, |
| GLenum pathNameType, |
| const void* paths, |
| GLuint pathBase, |
| GLenum coverMode, |
| GLenum transformType, |
| const GLfloat* transformValues) { |
| MakeFunctionUnique("glCoverFillPathInstancedNV"); |
| interface_->CoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, |
| coverMode, transformType, |
| transformValues); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glCoverFillPathNV(GLuint path, |
| GLenum coverMode) { |
| MakeFunctionUnique("glCoverFillPathNV"); |
| interface_->CoverFillPathNV(path, coverMode); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glCoverStrokePathInstancedNV( |
| GLsizei numPaths, |
| GLenum pathNameType, |
| const void* paths, |
| GLuint pathBase, |
| GLenum coverMode, |
| GLenum transformType, |
| const GLfloat* transformValues) { |
| MakeFunctionUnique("glCoverStrokePathInstancedNV"); |
| interface_->CoverStrokePathInstancedNV(numPaths, pathNameType, paths, |
| pathBase, coverMode, transformType, |
| transformValues); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCoverStrokePathNV(GLuint name, GLenum coverMode) { |
| MakeFunctionUnique("glCoverStrokePathNV"); |
| interface_->CoverStrokePathNV(name, coverMode); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glCoverageModulationNV(GLenum components) { |
| MakeFunctionUnique("glCoverageModulationNV"); |
| interface_->CoverageModulationNV(components); |
| } |
| |
| GLuint GL_BINDING_CALL MockGLInterface::Mock_glCreateProgram(void) { |
| MakeFunctionUnique("glCreateProgram"); |
| return interface_->CreateProgram(); |
| } |
| |
| GLuint GL_BINDING_CALL MockGLInterface::Mock_glCreateShader(GLenum type) { |
| MakeFunctionUnique("glCreateShader"); |
| return interface_->CreateShader(type); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glCullFace(GLenum mode) { |
| MakeFunctionUnique("glCullFace"); |
| interface_->CullFace(mode); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDebugMessageCallback(GLDEBUGPROC callback, |
| const void* userParam) { |
| MakeFunctionUnique("glDebugMessageCallback"); |
| interface_->DebugMessageCallback(callback, userParam); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDebugMessageCallbackKHR(GLDEBUGPROC callback, |
| const void* userParam) { |
| MakeFunctionUnique("glDebugMessageCallbackKHR"); |
| interface_->DebugMessageCallback(callback, userParam); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDebugMessageControl(GLenum source, |
| GLenum type, |
| GLenum severity, |
| GLsizei count, |
| const GLuint* ids, |
| GLboolean enabled) { |
| MakeFunctionUnique("glDebugMessageControl"); |
| interface_->DebugMessageControl(source, type, severity, count, ids, enabled); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDebugMessageControlKHR(GLenum source, |
| GLenum type, |
| GLenum severity, |
| GLsizei count, |
| const GLuint* ids, |
| GLboolean enabled) { |
| MakeFunctionUnique("glDebugMessageControlKHR"); |
| interface_->DebugMessageControl(source, type, severity, count, ids, enabled); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDebugMessageInsert(GLenum source, |
| GLenum type, |
| GLuint id, |
| GLenum severity, |
| GLsizei length, |
| const char* buf) { |
| MakeFunctionUnique("glDebugMessageInsert"); |
| interface_->DebugMessageInsert(source, type, id, severity, length, buf); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDebugMessageInsertKHR(GLenum source, |
| GLenum type, |
| GLuint id, |
| GLenum severity, |
| GLsizei length, |
| const char* buf) { |
| MakeFunctionUnique("glDebugMessageInsertKHR"); |
| interface_->DebugMessageInsert(source, type, id, severity, length, buf); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteBuffers(GLsizei n, const GLuint* buffers) { |
| MakeFunctionUnique("glDeleteBuffers"); |
| interface_->DeleteBuffersARB(n, buffers); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteFencesAPPLE(GLsizei n, const GLuint* fences) { |
| MakeFunctionUnique("glDeleteFencesAPPLE"); |
| interface_->DeleteFencesAPPLE(n, fences); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteFencesNV(GLsizei n, const GLuint* fences) { |
| MakeFunctionUnique("glDeleteFencesNV"); |
| interface_->DeleteFencesNV(n, fences); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteFramebuffers(GLsizei n, |
| const GLuint* framebuffers) { |
| MakeFunctionUnique("glDeleteFramebuffers"); |
| interface_->DeleteFramebuffersEXT(n, framebuffers); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteFramebuffersEXT(GLsizei n, |
| const GLuint* framebuffers) { |
| MakeFunctionUnique("glDeleteFramebuffersEXT"); |
| interface_->DeleteFramebuffersEXT(n, framebuffers); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDeletePathsNV(GLuint path, |
| GLsizei range) { |
| MakeFunctionUnique("glDeletePathsNV"); |
| interface_->DeletePathsNV(path, range); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDeleteProgram(GLuint program) { |
| MakeFunctionUnique("glDeleteProgram"); |
| interface_->DeleteProgram(program); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDeleteQueries(GLsizei n, |
| const GLuint* ids) { |
| MakeFunctionUnique("glDeleteQueries"); |
| interface_->DeleteQueries(n, ids); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteQueriesARB(GLsizei n, const GLuint* ids) { |
| MakeFunctionUnique("glDeleteQueriesARB"); |
| interface_->DeleteQueries(n, ids); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteQueriesEXT(GLsizei n, const GLuint* ids) { |
| MakeFunctionUnique("glDeleteQueriesEXT"); |
| interface_->DeleteQueries(n, ids); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteRenderbuffers(GLsizei n, |
| const GLuint* renderbuffers) { |
| MakeFunctionUnique("glDeleteRenderbuffers"); |
| interface_->DeleteRenderbuffersEXT(n, renderbuffers); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteRenderbuffersEXT(GLsizei n, |
| const GLuint* renderbuffers) { |
| MakeFunctionUnique("glDeleteRenderbuffersEXT"); |
| interface_->DeleteRenderbuffersEXT(n, renderbuffers); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteSamplers(GLsizei n, const GLuint* samplers) { |
| MakeFunctionUnique("glDeleteSamplers"); |
| interface_->DeleteSamplers(n, samplers); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDeleteShader(GLuint shader) { |
| MakeFunctionUnique("glDeleteShader"); |
| interface_->DeleteShader(shader); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDeleteSync(GLsync sync) { |
| MakeFunctionUnique("glDeleteSync"); |
| interface_->DeleteSync(sync); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteTextures(GLsizei n, const GLuint* textures) { |
| MakeFunctionUnique("glDeleteTextures"); |
| interface_->DeleteTextures(n, textures); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids) { |
| MakeFunctionUnique("glDeleteTransformFeedbacks"); |
| interface_->DeleteTransformFeedbacks(n, ids); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteVertexArrays(GLsizei n, const GLuint* arrays) { |
| MakeFunctionUnique("glDeleteVertexArrays"); |
| interface_->DeleteVertexArraysOES(n, arrays); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteVertexArraysAPPLE(GLsizei n, |
| const GLuint* arrays) { |
| MakeFunctionUnique("glDeleteVertexArraysAPPLE"); |
| interface_->DeleteVertexArraysOES(n, arrays); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays) { |
| MakeFunctionUnique("glDeleteVertexArraysOES"); |
| interface_->DeleteVertexArraysOES(n, arrays); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDepthFunc(GLenum func) { |
| MakeFunctionUnique("glDepthFunc"); |
| interface_->DepthFunc(func); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDepthMask(GLboolean flag) { |
| MakeFunctionUnique("glDepthMask"); |
| interface_->DepthMask(flag); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDepthRange(GLclampd zNear, |
| GLclampd zFar) { |
| MakeFunctionUnique("glDepthRange"); |
| interface_->DepthRange(zNear, zFar); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDepthRangef(GLclampf zNear, |
| GLclampf zFar) { |
| MakeFunctionUnique("glDepthRangef"); |
| interface_->DepthRangef(zNear, zFar); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDetachShader(GLuint program, |
| GLuint shader) { |
| MakeFunctionUnique("glDetachShader"); |
| interface_->DetachShader(program, shader); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDisable(GLenum cap) { |
| MakeFunctionUnique("glDisable"); |
| interface_->Disable(cap); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDisableVertexAttribArray(GLuint index) { |
| MakeFunctionUnique("glDisableVertexAttribArray"); |
| interface_->DisableVertexAttribArray(index); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDiscardFramebufferEXT(GLenum target, |
| GLsizei numAttachments, |
| const GLenum* attachments) { |
| MakeFunctionUnique("glDiscardFramebufferEXT"); |
| interface_->DiscardFramebufferEXT(target, numAttachments, attachments); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDrawArrays(GLenum mode, |
| GLint first, |
| GLsizei count) { |
| MakeFunctionUnique("glDrawArrays"); |
| interface_->DrawArrays(mode, first, count); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDrawArraysInstanced(GLenum mode, |
| GLint first, |
| GLsizei count, |
| GLsizei primcount) { |
| MakeFunctionUnique("glDrawArraysInstanced"); |
| interface_->DrawArraysInstancedANGLE(mode, first, count, primcount); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDrawArraysInstancedANGLE(GLenum mode, |
| GLint first, |
| GLsizei count, |
| GLsizei primcount) { |
| MakeFunctionUnique("glDrawArraysInstancedANGLE"); |
| interface_->DrawArraysInstancedANGLE(mode, first, count, primcount); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDrawArraysInstancedARB(GLenum mode, |
| GLint first, |
| GLsizei count, |
| GLsizei primcount) { |
| MakeFunctionUnique("glDrawArraysInstancedARB"); |
| interface_->DrawArraysInstancedANGLE(mode, first, count, primcount); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDrawBuffer(GLenum mode) { |
| MakeFunctionUnique("glDrawBuffer"); |
| interface_->DrawBuffer(mode); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDrawBuffers(GLsizei n, |
| const GLenum* bufs) { |
| MakeFunctionUnique("glDrawBuffers"); |
| interface_->DrawBuffersARB(n, bufs); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDrawBuffersARB(GLsizei n, const GLenum* bufs) { |
| MakeFunctionUnique("glDrawBuffersARB"); |
| interface_->DrawBuffersARB(n, bufs); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDrawBuffersEXT(GLsizei n, const GLenum* bufs) { |
| MakeFunctionUnique("glDrawBuffersEXT"); |
| interface_->DrawBuffersARB(n, bufs); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glDrawElements(GLenum mode, |
| GLsizei count, |
| GLenum type, |
| const void* indices) { |
| MakeFunctionUnique("glDrawElements"); |
| interface_->DrawElements(mode, count, type, indices); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDrawElementsInstanced(GLenum mode, |
| GLsizei count, |
| GLenum type, |
| const void* indices, |
| GLsizei primcount) { |
| MakeFunctionUnique("glDrawElementsInstanced"); |
| interface_->DrawElementsInstancedANGLE(mode, count, type, indices, primcount); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDrawElementsInstancedANGLE(GLenum mode, |
| GLsizei count, |
| GLenum type, |
| const void* indices, |
| GLsizei primcount) { |
| MakeFunctionUnique("glDrawElementsInstancedANGLE"); |
| interface_->DrawElementsInstancedANGLE(mode, count, type, indices, primcount); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDrawElementsInstancedARB(GLenum mode, |
| GLsizei count, |
| GLenum type, |
| const void* indices, |
| GLsizei primcount) { |
| MakeFunctionUnique("glDrawElementsInstancedARB"); |
| interface_->DrawElementsInstancedANGLE(mode, count, type, indices, primcount); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glDrawRangeElements(GLenum mode, |
| GLuint start, |
| GLuint end, |
| GLsizei count, |
| GLenum type, |
| const void* indices) { |
| MakeFunctionUnique("glDrawRangeElements"); |
| interface_->DrawRangeElements(mode, start, end, count, type, indices); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glEGLImageTargetRenderbufferStorageOES( |
| GLenum target, |
| GLeglImageOES image) { |
| MakeFunctionUnique("glEGLImageTargetRenderbufferStorageOES"); |
| interface_->EGLImageTargetRenderbufferStorageOES(target, image); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glEGLImageTargetTexture2DOES(GLenum target, |
| GLeglImageOES image) { |
| MakeFunctionUnique("glEGLImageTargetTexture2DOES"); |
| interface_->EGLImageTargetTexture2DOES(target, image); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glEnable(GLenum cap) { |
| MakeFunctionUnique("glEnable"); |
| interface_->Enable(cap); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glEnableVertexAttribArray(GLuint index) { |
| MakeFunctionUnique("glEnableVertexAttribArray"); |
| interface_->EnableVertexAttribArray(index); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glEndQuery(GLenum target) { |
| MakeFunctionUnique("glEndQuery"); |
| interface_->EndQuery(target); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glEndQueryARB(GLenum target) { |
| MakeFunctionUnique("glEndQueryARB"); |
| interface_->EndQuery(target); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glEndQueryEXT(GLenum target) { |
| MakeFunctionUnique("glEndQueryEXT"); |
| interface_->EndQuery(target); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glEndTransformFeedback(void) { |
| MakeFunctionUnique("glEndTransformFeedback"); |
| interface_->EndTransformFeedback(); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glEndTransformFeedbackEXT(void) { |
| MakeFunctionUnique("glEndTransformFeedbackEXT"); |
| interface_->EndTransformFeedback(); |
| } |
| |
| GLsync GL_BINDING_CALL MockGLInterface::Mock_glFenceSync(GLenum condition, |
| GLbitfield flags) { |
| MakeFunctionUnique("glFenceSync"); |
| return interface_->FenceSync(condition, flags); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glFinish(void) { |
| MakeFunctionUnique("glFinish"); |
| interface_->Finish(); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glFinishFenceAPPLE(GLuint fence) { |
| MakeFunctionUnique("glFinishFenceAPPLE"); |
| interface_->FinishFenceAPPLE(fence); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glFinishFenceNV(GLuint fence) { |
| MakeFunctionUnique("glFinishFenceNV"); |
| interface_->FinishFenceNV(fence); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glFlush(void) { |
| MakeFunctionUnique("glFlush"); |
| interface_->Flush(); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glFlushMappedBufferRange(GLenum target, |
| GLintptr offset, |
| GLsizeiptr length) { |
| MakeFunctionUnique("glFlushMappedBufferRange"); |
| interface_->FlushMappedBufferRange(target, offset, length); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glFlushMappedBufferRangeEXT(GLenum target, |
| GLintptr offset, |
| GLsizeiptr length) { |
| MakeFunctionUnique("glFlushMappedBufferRangeEXT"); |
| interface_->FlushMappedBufferRange(target, offset, length); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glFramebufferRenderbuffer(GLenum target, |
| GLenum attachment, |
| GLenum renderbuffertarget, |
| GLuint renderbuffer) { |
| MakeFunctionUnique("glFramebufferRenderbuffer"); |
| interface_->FramebufferRenderbufferEXT(target, attachment, renderbuffertarget, |
| renderbuffer); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glFramebufferRenderbufferEXT(GLenum target, |
| GLenum attachment, |
| GLenum renderbuffertarget, |
| GLuint renderbuffer) { |
| MakeFunctionUnique("glFramebufferRenderbufferEXT"); |
| interface_->FramebufferRenderbufferEXT(target, attachment, renderbuffertarget, |
| renderbuffer); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glFramebufferTexture2D(GLenum target, |
| GLenum attachment, |
| GLenum textarget, |
| GLuint texture, |
| GLint level) { |
| MakeFunctionUnique("glFramebufferTexture2D"); |
| interface_->FramebufferTexture2DEXT(target, attachment, textarget, texture, |
| level); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glFramebufferTexture2DEXT(GLenum target, |
| GLenum attachment, |
| GLenum textarget, |
| GLuint texture, |
| GLint level) { |
| MakeFunctionUnique("glFramebufferTexture2DEXT"); |
| interface_->FramebufferTexture2DEXT(target, attachment, textarget, texture, |
| level); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glFramebufferTexture2DMultisampleEXT(GLenum target, |
| GLenum attachment, |
| GLenum textarget, |
| GLuint texture, |
| GLint level, |
| GLsizei samples) { |
| MakeFunctionUnique("glFramebufferTexture2DMultisampleEXT"); |
| interface_->FramebufferTexture2DMultisampleEXT(target, attachment, textarget, |
| texture, level, samples); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glFramebufferTexture2DMultisampleIMG(GLenum target, |
| GLenum attachment, |
| GLenum textarget, |
| GLuint texture, |
| GLint level, |
| GLsizei samples) { |
| MakeFunctionUnique("glFramebufferTexture2DMultisampleIMG"); |
| interface_->FramebufferTexture2DMultisampleEXT(target, attachment, textarget, |
| texture, level, samples); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glFramebufferTextureLayer(GLenum target, |
| GLenum attachment, |
| GLuint texture, |
| GLint level, |
| GLint layer) { |
| MakeFunctionUnique("glFramebufferTextureLayer"); |
| interface_->FramebufferTextureLayer(target, attachment, texture, level, |
| layer); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glFrontFace(GLenum mode) { |
| MakeFunctionUnique("glFrontFace"); |
| interface_->FrontFace(mode); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGenBuffers(GLsizei n, |
| GLuint* buffers) { |
| MakeFunctionUnique("glGenBuffers"); |
| interface_->GenBuffersARB(n, buffers); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGenFencesAPPLE(GLsizei n, |
| GLuint* fences) { |
| MakeFunctionUnique("glGenFencesAPPLE"); |
| interface_->GenFencesAPPLE(n, fences); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGenFencesNV(GLsizei n, |
| GLuint* fences) { |
| MakeFunctionUnique("glGenFencesNV"); |
| interface_->GenFencesNV(n, fences); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGenFramebuffers(GLsizei n, GLuint* framebuffers) { |
| MakeFunctionUnique("glGenFramebuffers"); |
| interface_->GenFramebuffersEXT(n, framebuffers); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGenFramebuffersEXT(GLsizei n, GLuint* framebuffers) { |
| MakeFunctionUnique("glGenFramebuffersEXT"); |
| interface_->GenFramebuffersEXT(n, framebuffers); |
| } |
| |
| GLuint GL_BINDING_CALL MockGLInterface::Mock_glGenPathsNV(GLsizei range) { |
| MakeFunctionUnique("glGenPathsNV"); |
| return interface_->GenPathsNV(range); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGenQueries(GLsizei n, |
| GLuint* ids) { |
| MakeFunctionUnique("glGenQueries"); |
| interface_->GenQueries(n, ids); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGenQueriesARB(GLsizei n, |
| GLuint* ids) { |
| MakeFunctionUnique("glGenQueriesARB"); |
| interface_->GenQueries(n, ids); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGenQueriesEXT(GLsizei n, |
| GLuint* ids) { |
| MakeFunctionUnique("glGenQueriesEXT"); |
| interface_->GenQueries(n, ids); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) { |
| MakeFunctionUnique("glGenRenderbuffers"); |
| interface_->GenRenderbuffersEXT(n, renderbuffers); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGenRenderbuffersEXT(GLsizei n, GLuint* renderbuffers) { |
| MakeFunctionUnique("glGenRenderbuffersEXT"); |
| interface_->GenRenderbuffersEXT(n, renderbuffers); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGenSamplers(GLsizei n, |
| GLuint* samplers) { |
| MakeFunctionUnique("glGenSamplers"); |
| interface_->GenSamplers(n, samplers); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGenTextures(GLsizei n, |
| GLuint* textures) { |
| MakeFunctionUnique("glGenTextures"); |
| interface_->GenTextures(n, textures); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGenTransformFeedbacks(GLsizei n, GLuint* ids) { |
| MakeFunctionUnique("glGenTransformFeedbacks"); |
| interface_->GenTransformFeedbacks(n, ids); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGenVertexArrays(GLsizei n, |
| GLuint* arrays) { |
| MakeFunctionUnique("glGenVertexArrays"); |
| interface_->GenVertexArraysOES(n, arrays); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGenVertexArraysAPPLE(GLsizei n, GLuint* arrays) { |
| MakeFunctionUnique("glGenVertexArraysAPPLE"); |
| interface_->GenVertexArraysOES(n, arrays); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGenVertexArraysOES(GLsizei n, GLuint* arrays) { |
| MakeFunctionUnique("glGenVertexArraysOES"); |
| interface_->GenVertexArraysOES(n, arrays); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGenerateMipmap(GLenum target) { |
| MakeFunctionUnique("glGenerateMipmap"); |
| interface_->GenerateMipmapEXT(target); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGenerateMipmapEXT(GLenum target) { |
| MakeFunctionUnique("glGenerateMipmapEXT"); |
| interface_->GenerateMipmapEXT(target); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetActiveAttrib(GLuint program, |
| GLuint index, |
| GLsizei bufsize, |
| GLsizei* length, |
| GLint* size, |
| GLenum* type, |
| char* name) { |
| MakeFunctionUnique("glGetActiveAttrib"); |
| interface_->GetActiveAttrib(program, index, bufsize, length, size, type, |
| name); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetActiveUniform(GLuint program, |
| GLuint index, |
| GLsizei bufsize, |
| GLsizei* length, |
| GLint* size, |
| GLenum* type, |
| char* name) { |
| MakeFunctionUnique("glGetActiveUniform"); |
| interface_->GetActiveUniform(program, index, bufsize, length, size, type, |
| name); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetActiveUniformBlockName(GLuint program, |
| GLuint uniformBlockIndex, |
| GLsizei bufSize, |
| GLsizei* length, |
| char* uniformBlockName) { |
| MakeFunctionUnique("glGetActiveUniformBlockName"); |
| interface_->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, |
| length, uniformBlockName); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetActiveUniformBlockiv(GLuint program, |
| GLuint uniformBlockIndex, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetActiveUniformBlockiv"); |
| interface_->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, |
| params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetActiveUniformBlockivRobustANGLE( |
| GLuint program, |
| GLuint uniformBlockIndex, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetActiveUniformBlockivRobustANGLE"); |
| interface_->GetActiveUniformBlockivRobustANGLE( |
| program, uniformBlockIndex, pname, bufSize, length, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetActiveUniformsiv(GLuint program, |
| GLsizei uniformCount, |
| const GLuint* uniformIndices, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetActiveUniformsiv"); |
| interface_->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetAttachedShaders(GLuint program, |
| GLsizei maxcount, |
| GLsizei* count, |
| GLuint* shaders) { |
| MakeFunctionUnique("glGetAttachedShaders"); |
| interface_->GetAttachedShaders(program, maxcount, count, shaders); |
| } |
| |
| GLint GL_BINDING_CALL |
| MockGLInterface::Mock_glGetAttribLocation(GLuint program, const char* name) { |
| MakeFunctionUnique("glGetAttribLocation"); |
| return interface_->GetAttribLocation(program, name); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetBooleani_vRobustANGLE(GLenum target, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLboolean* data) { |
| MakeFunctionUnique("glGetBooleani_vRobustANGLE"); |
| interface_->GetBooleani_vRobustANGLE(target, index, bufSize, length, data); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetBooleanv(GLenum pname, |
| GLboolean* params) { |
| MakeFunctionUnique("glGetBooleanv"); |
| interface_->GetBooleanv(pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetBooleanvRobustANGLE(GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLboolean* data) { |
| MakeFunctionUnique("glGetBooleanvRobustANGLE"); |
| interface_->GetBooleanvRobustANGLE(pname, bufSize, length, data); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetBufferParameteri64vRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint64* params) { |
| MakeFunctionUnique("glGetBufferParameteri64vRobustANGLE"); |
| interface_->GetBufferParameteri64vRobustANGLE(target, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetBufferParameteriv(GLenum target, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetBufferParameteriv"); |
| interface_->GetBufferParameteriv(target, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetBufferParameterivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetBufferParameterivRobustANGLE"); |
| interface_->GetBufferParameterivRobustANGLE(target, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetBufferPointervRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| void** params) { |
| MakeFunctionUnique("glGetBufferPointervRobustANGLE"); |
| interface_->GetBufferPointervRobustANGLE(target, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetDebugMessageLog(GLuint count, |
| GLsizei bufSize, |
| GLenum* sources, |
| GLenum* types, |
| GLuint* ids, |
| GLenum* severities, |
| GLsizei* lengths, |
| char* messageLog) { |
| MakeFunctionUnique("glGetDebugMessageLog"); |
| interface_->GetDebugMessageLog(count, bufSize, sources, types, ids, |
| severities, lengths, messageLog); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetDebugMessageLogKHR(GLuint count, |
| GLsizei bufSize, |
| GLenum* sources, |
| GLenum* types, |
| GLuint* ids, |
| GLenum* severities, |
| GLsizei* lengths, |
| char* messageLog) { |
| MakeFunctionUnique("glGetDebugMessageLogKHR"); |
| interface_->GetDebugMessageLog(count, bufSize, sources, types, ids, |
| severities, lengths, messageLog); |
| } |
| |
| GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetError(void) { |
| MakeFunctionUnique("glGetError"); |
| return interface_->GetError(); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetFenceivNV(GLuint fence, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetFenceivNV"); |
| interface_->GetFenceivNV(fence, pname, params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetFloatv(GLenum pname, |
| GLfloat* params) { |
| MakeFunctionUnique("glGetFloatv"); |
| interface_->GetFloatv(pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetFloatvRobustANGLE(GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLfloat* data) { |
| MakeFunctionUnique("glGetFloatvRobustANGLE"); |
| interface_->GetFloatvRobustANGLE(pname, bufSize, length, data); |
| } |
| |
| GLint GL_BINDING_CALL |
| MockGLInterface::Mock_glGetFragDataIndex(GLuint program, const char* name) { |
| MakeFunctionUnique("glGetFragDataIndex"); |
| return interface_->GetFragDataIndex(program, name); |
| } |
| |
| GLint GL_BINDING_CALL |
| MockGLInterface::Mock_glGetFragDataIndexEXT(GLuint program, const char* name) { |
| MakeFunctionUnique("glGetFragDataIndexEXT"); |
| return interface_->GetFragDataIndex(program, name); |
| } |
| |
| GLint GL_BINDING_CALL |
| MockGLInterface::Mock_glGetFragDataLocation(GLuint program, const char* name) { |
| MakeFunctionUnique("glGetFragDataLocation"); |
| return interface_->GetFragDataLocation(program, name); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetFramebufferAttachmentParameteriv(GLenum target, |
| GLenum attachment, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetFramebufferAttachmentParameteriv"); |
| interface_->GetFramebufferAttachmentParameterivEXT(target, attachment, pname, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetFramebufferAttachmentParameterivEXT( |
| GLenum target, |
| GLenum attachment, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetFramebufferAttachmentParameterivEXT"); |
| interface_->GetFramebufferAttachmentParameterivEXT(target, attachment, pname, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetFramebufferAttachmentParameterivRobustANGLE( |
| GLenum target, |
| GLenum attachment, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetFramebufferAttachmentParameterivRobustANGLE"); |
| interface_->GetFramebufferAttachmentParameterivRobustANGLE( |
| target, attachment, pname, bufSize, length, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetFramebufferParameterivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetFramebufferParameterivRobustANGLE"); |
| interface_->GetFramebufferParameterivRobustANGLE(target, pname, bufSize, |
| length, params); |
| } |
| |
| GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatus(void) { |
| MakeFunctionUnique("glGetGraphicsResetStatus"); |
| return interface_->GetGraphicsResetStatusARB(); |
| } |
| |
| GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusARB(void) { |
| MakeFunctionUnique("glGetGraphicsResetStatusARB"); |
| return interface_->GetGraphicsResetStatusARB(); |
| } |
| |
| GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusEXT(void) { |
| MakeFunctionUnique("glGetGraphicsResetStatusEXT"); |
| return interface_->GetGraphicsResetStatusARB(); |
| } |
| |
| GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusKHR(void) { |
| MakeFunctionUnique("glGetGraphicsResetStatusKHR"); |
| return interface_->GetGraphicsResetStatusARB(); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64i_v(GLenum target, |
| GLuint index, |
| GLint64* data) { |
| MakeFunctionUnique("glGetInteger64i_v"); |
| interface_->GetInteger64i_v(target, index, data); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetInteger64i_vRobustANGLE(GLenum target, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint64* data) { |
| MakeFunctionUnique("glGetInteger64i_vRobustANGLE"); |
| interface_->GetInteger64i_vRobustANGLE(target, index, bufSize, length, data); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64v(GLenum pname, |
| GLint64* params) { |
| MakeFunctionUnique("glGetInteger64v"); |
| interface_->GetInteger64v(pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetInteger64vRobustANGLE(GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint64* data) { |
| MakeFunctionUnique("glGetInteger64vRobustANGLE"); |
| interface_->GetInteger64vRobustANGLE(pname, bufSize, length, data); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegeri_v(GLenum target, |
| GLuint index, |
| GLint* data) { |
| MakeFunctionUnique("glGetIntegeri_v"); |
| interface_->GetIntegeri_v(target, index, data); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetIntegeri_vRobustANGLE(GLenum target, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* data) { |
| MakeFunctionUnique("glGetIntegeri_vRobustANGLE"); |
| interface_->GetIntegeri_vRobustANGLE(target, index, bufSize, length, data); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegerv(GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetIntegerv"); |
| interface_->GetIntegerv(pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetIntegervRobustANGLE(GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* data) { |
| MakeFunctionUnique("glGetIntegervRobustANGLE"); |
| interface_->GetIntegervRobustANGLE(pname, bufSize, length, data); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetInternalformativ(GLenum target, |
| GLenum internalformat, |
| GLenum pname, |
| GLsizei bufSize, |
| GLint* params) { |
| MakeFunctionUnique("glGetInternalformativ"); |
| interface_->GetInternalformativ(target, internalformat, pname, bufSize, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetInternalformativRobustANGLE(GLenum target, |
| GLenum internalformat, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetInternalformativRobustANGLE"); |
| interface_->GetInternalformativRobustANGLE(target, internalformat, pname, |
| bufSize, length, params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetMultisamplefv(GLenum pname, |
| GLuint index, |
| GLfloat* val) { |
| MakeFunctionUnique("glGetMultisamplefv"); |
| interface_->GetMultisamplefv(pname, index, val); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetMultisamplefvRobustANGLE(GLenum pname, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLfloat* val) { |
| MakeFunctionUnique("glGetMultisamplefvRobustANGLE"); |
| interface_->GetMultisamplefvRobustANGLE(pname, index, bufSize, length, val); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetObjectLabel(GLenum identifier, |
| GLuint name, |
| GLsizei bufSize, |
| GLsizei* length, |
| char* label) { |
| MakeFunctionUnique("glGetObjectLabel"); |
| interface_->GetObjectLabel(identifier, name, bufSize, length, label); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetObjectLabelKHR(GLenum identifier, |
| GLuint name, |
| GLsizei bufSize, |
| GLsizei* length, |
| char* label) { |
| MakeFunctionUnique("glGetObjectLabelKHR"); |
| interface_->GetObjectLabel(identifier, name, bufSize, length, label); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetObjectPtrLabel(void* ptr, |
| GLsizei bufSize, |
| GLsizei* length, |
| char* label) { |
| MakeFunctionUnique("glGetObjectPtrLabel"); |
| interface_->GetObjectPtrLabel(ptr, bufSize, length, label); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetObjectPtrLabelKHR(void* ptr, |
| GLsizei bufSize, |
| GLsizei* length, |
| char* label) { |
| MakeFunctionUnique("glGetObjectPtrLabelKHR"); |
| interface_->GetObjectPtrLabel(ptr, bufSize, length, label); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetPointerv(GLenum pname, |
| void** params) { |
| MakeFunctionUnique("glGetPointerv"); |
| interface_->GetPointerv(pname, params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetPointervKHR(GLenum pname, |
| void** params) { |
| MakeFunctionUnique("glGetPointervKHR"); |
| interface_->GetPointerv(pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetPointervRobustANGLERobustANGLE(GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| void** params) { |
| MakeFunctionUnique("glGetPointervRobustANGLERobustANGLE"); |
| interface_->GetPointervRobustANGLERobustANGLE(pname, bufSize, length, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetProgramBinary(GLuint program, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLenum* binaryFormat, |
| GLvoid* binary) { |
| MakeFunctionUnique("glGetProgramBinary"); |
| interface_->GetProgramBinary(program, bufSize, length, binaryFormat, binary); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetProgramBinaryOES(GLuint program, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLenum* binaryFormat, |
| GLvoid* binary) { |
| MakeFunctionUnique("glGetProgramBinaryOES"); |
| interface_->GetProgramBinary(program, bufSize, length, binaryFormat, binary); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetProgramInfoLog(GLuint program, |
| GLsizei bufsize, |
| GLsizei* length, |
| char* infolog) { |
| MakeFunctionUnique("glGetProgramInfoLog"); |
| interface_->GetProgramInfoLog(program, bufsize, length, infolog); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetProgramInterfaceiv(GLuint program, |
| GLenum programInterface, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetProgramInterfaceiv"); |
| interface_->GetProgramInterfaceiv(program, programInterface, pname, params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetProgramInterfaceivRobustANGLE( |
| GLuint program, |
| GLenum programInterface, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetProgramInterfaceivRobustANGLE"); |
| interface_->GetProgramInterfaceivRobustANGLE(program, programInterface, pname, |
| bufSize, length, params); |
| } |
| |
| GLint GL_BINDING_CALL |
| MockGLInterface::Mock_glGetProgramResourceLocation(GLuint program, |
| GLenum programInterface, |
| const char* name) { |
| MakeFunctionUnique("glGetProgramResourceLocation"); |
| return interface_->GetProgramResourceLocation(program, programInterface, |
| name); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetProgramResourceName(GLuint program, |
| GLenum programInterface, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLchar* name) { |
| MakeFunctionUnique("glGetProgramResourceName"); |
| interface_->GetProgramResourceName(program, programInterface, index, bufSize, |
| length, name); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetProgramResourceiv(GLuint program, |
| GLenum programInterface, |
| GLuint index, |
| GLsizei propCount, |
| const GLenum* props, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetProgramResourceiv"); |
| interface_->GetProgramResourceiv(program, programInterface, index, propCount, |
| props, bufSize, length, params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetProgramiv(GLuint program, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetProgramiv"); |
| interface_->GetProgramiv(program, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetProgramivRobustANGLE(GLuint program, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetProgramivRobustANGLE"); |
| interface_->GetProgramivRobustANGLE(program, pname, bufSize, length, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryObjecti64v(GLuint id, |
| GLenum pname, |
| GLint64* params) { |
| MakeFunctionUnique("glGetQueryObjecti64v"); |
| interface_->GetQueryObjecti64v(id, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryObjecti64vEXT(GLuint id, |
| GLenum pname, |
| GLint64* params) { |
| MakeFunctionUnique("glGetQueryObjecti64vEXT"); |
| interface_->GetQueryObjecti64v(id, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryObjecti64vRobustANGLE(GLuint id, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint64* params) { |
| MakeFunctionUnique("glGetQueryObjecti64vRobustANGLE"); |
| interface_->GetQueryObjecti64vRobustANGLE(id, pname, bufSize, length, params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryObjectiv(GLuint id, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetQueryObjectiv"); |
| interface_->GetQueryObjectiv(id, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryObjectivARB(GLuint id, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetQueryObjectivARB"); |
| interface_->GetQueryObjectiv(id, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryObjectivEXT(GLuint id, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetQueryObjectivEXT"); |
| interface_->GetQueryObjectiv(id, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryObjectivRobustANGLE(GLuint id, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetQueryObjectivRobustANGLE"); |
| interface_->GetQueryObjectivRobustANGLE(id, pname, bufSize, length, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryObjectui64v(GLuint id, |
| GLenum pname, |
| GLuint64* params) { |
| MakeFunctionUnique("glGetQueryObjectui64v"); |
| interface_->GetQueryObjectui64v(id, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryObjectui64vEXT(GLuint id, |
| GLenum pname, |
| GLuint64* params) { |
| MakeFunctionUnique("glGetQueryObjectui64vEXT"); |
| interface_->GetQueryObjectui64v(id, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryObjectui64vRobustANGLE(GLuint id, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLuint64* params) { |
| MakeFunctionUnique("glGetQueryObjectui64vRobustANGLE"); |
| interface_->GetQueryObjectui64vRobustANGLE(id, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryObjectuiv(GLuint id, |
| GLenum pname, |
| GLuint* params) { |
| MakeFunctionUnique("glGetQueryObjectuiv"); |
| interface_->GetQueryObjectuiv(id, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryObjectuivARB(GLuint id, |
| GLenum pname, |
| GLuint* params) { |
| MakeFunctionUnique("glGetQueryObjectuivARB"); |
| interface_->GetQueryObjectuiv(id, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryObjectuivEXT(GLuint id, |
| GLenum pname, |
| GLuint* params) { |
| MakeFunctionUnique("glGetQueryObjectuivEXT"); |
| interface_->GetQueryObjectuiv(id, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryObjectuivRobustANGLE(GLuint id, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLuint* params) { |
| MakeFunctionUnique("glGetQueryObjectuivRobustANGLE"); |
| interface_->GetQueryObjectuivRobustANGLE(id, pname, bufSize, length, params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryiv(GLenum target, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetQueryiv"); |
| interface_->GetQueryiv(target, pname, params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryivARB(GLenum target, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetQueryivARB"); |
| interface_->GetQueryiv(target, pname, params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryivEXT(GLenum target, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetQueryivEXT"); |
| interface_->GetQueryiv(target, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetQueryivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetQueryivRobustANGLE"); |
| interface_->GetQueryivRobustANGLE(target, pname, bufSize, length, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetRenderbufferParameteriv(GLenum target, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetRenderbufferParameteriv"); |
| interface_->GetRenderbufferParameterivEXT(target, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetRenderbufferParameterivEXT(GLenum target, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetRenderbufferParameterivEXT"); |
| interface_->GetRenderbufferParameterivEXT(target, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetRenderbufferParameterivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetRenderbufferParameterivRobustANGLE"); |
| interface_->GetRenderbufferParameterivRobustANGLE(target, pname, bufSize, |
| length, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetSamplerParameterIivRobustANGLE(GLuint sampler, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetSamplerParameterIivRobustANGLE"); |
| interface_->GetSamplerParameterIivRobustANGLE(sampler, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetSamplerParameterIuivRobustANGLE(GLuint sampler, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLuint* params) { |
| MakeFunctionUnique("glGetSamplerParameterIuivRobustANGLE"); |
| interface_->GetSamplerParameterIuivRobustANGLE(sampler, pname, bufSize, |
| length, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetSamplerParameterfv(GLuint sampler, |
| GLenum pname, |
| GLfloat* params) { |
| MakeFunctionUnique("glGetSamplerParameterfv"); |
| interface_->GetSamplerParameterfv(sampler, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetSamplerParameterfvRobustANGLE(GLuint sampler, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLfloat* params) { |
| MakeFunctionUnique("glGetSamplerParameterfvRobustANGLE"); |
| interface_->GetSamplerParameterfvRobustANGLE(sampler, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetSamplerParameteriv(GLuint sampler, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetSamplerParameteriv"); |
| interface_->GetSamplerParameteriv(sampler, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetSamplerParameterivRobustANGLE(GLuint sampler, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetSamplerParameterivRobustANGLE"); |
| interface_->GetSamplerParameterivRobustANGLE(sampler, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderInfoLog(GLuint shader, |
| GLsizei bufsize, |
| GLsizei* length, |
| char* infolog) { |
| MakeFunctionUnique("glGetShaderInfoLog"); |
| interface_->GetShaderInfoLog(shader, bufsize, length, infolog); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetShaderPrecisionFormat(GLenum shadertype, |
| GLenum precisiontype, |
| GLint* range, |
| GLint* precision) { |
| MakeFunctionUnique("glGetShaderPrecisionFormat"); |
| interface_->GetShaderPrecisionFormat(shadertype, precisiontype, range, |
| precision); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderSource(GLuint shader, |
| GLsizei bufsize, |
| GLsizei* length, |
| char* source) { |
| MakeFunctionUnique("glGetShaderSource"); |
| interface_->GetShaderSource(shader, bufsize, length, source); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderiv(GLuint shader, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetShaderiv"); |
| interface_->GetShaderiv(shader, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetShaderivRobustANGLE(GLuint shader, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetShaderivRobustANGLE"); |
| interface_->GetShaderivRobustANGLE(shader, pname, bufSize, length, params); |
| } |
| |
| const GLubyte* GL_BINDING_CALL MockGLInterface::Mock_glGetString(GLenum name) { |
| MakeFunctionUnique("glGetString"); |
| return interface_->GetString(name); |
| } |
| |
| const GLubyte* GL_BINDING_CALL |
| MockGLInterface::Mock_glGetStringi(GLenum name, GLuint index) { |
| MakeFunctionUnique("glGetStringi"); |
| return interface_->GetStringi(name, index); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetSynciv(GLsync sync, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* values) { |
| MakeFunctionUnique("glGetSynciv"); |
| interface_->GetSynciv(sync, pname, bufSize, length, values); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetTexLevelParameterfv(GLenum target, |
| GLint level, |
| GLenum pname, |
| GLfloat* params) { |
| MakeFunctionUnique("glGetTexLevelParameterfv"); |
| interface_->GetTexLevelParameterfv(target, level, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetTexLevelParameterfvRobustANGLE(GLenum target, |
| GLint level, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLfloat* params) { |
| MakeFunctionUnique("glGetTexLevelParameterfvRobustANGLE"); |
| interface_->GetTexLevelParameterfvRobustANGLE(target, level, pname, bufSize, |
| length, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetTexLevelParameteriv(GLenum target, |
| GLint level, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetTexLevelParameteriv"); |
| interface_->GetTexLevelParameteriv(target, level, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetTexLevelParameterivRobustANGLE(GLenum target, |
| GLint level, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetTexLevelParameterivRobustANGLE"); |
| interface_->GetTexLevelParameterivRobustANGLE(target, level, pname, bufSize, |
| length, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetTexParameterIivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetTexParameterIivRobustANGLE"); |
| interface_->GetTexParameterIivRobustANGLE(target, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetTexParameterIuivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLuint* params) { |
| MakeFunctionUnique("glGetTexParameterIuivRobustANGLE"); |
| interface_->GetTexParameterIuivRobustANGLE(target, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetTexParameterfv(GLenum target, |
| GLenum pname, |
| GLfloat* params) { |
| MakeFunctionUnique("glGetTexParameterfv"); |
| interface_->GetTexParameterfv(target, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetTexParameterfvRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLfloat* params) { |
| MakeFunctionUnique("glGetTexParameterfvRobustANGLE"); |
| interface_->GetTexParameterfvRobustANGLE(target, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetTexParameteriv(GLenum target, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetTexParameteriv"); |
| interface_->GetTexParameteriv(target, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetTexParameterivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetTexParameterivRobustANGLE"); |
| interface_->GetTexParameterivRobustANGLE(target, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetTransformFeedbackVarying(GLuint program, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLsizei* size, |
| GLenum* type, |
| char* name) { |
| MakeFunctionUnique("glGetTransformFeedbackVarying"); |
| interface_->GetTransformFeedbackVarying(program, index, bufSize, length, size, |
| type, name); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetTransformFeedbackVaryingEXT(GLuint program, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLsizei* size, |
| GLenum* type, |
| char* name) { |
| MakeFunctionUnique("glGetTransformFeedbackVaryingEXT"); |
| interface_->GetTransformFeedbackVarying(program, index, bufSize, length, size, |
| type, name); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetTranslatedShaderSourceANGLE(GLuint shader, |
| GLsizei bufsize, |
| GLsizei* length, |
| char* source) { |
| MakeFunctionUnique("glGetTranslatedShaderSourceANGLE"); |
| interface_->GetTranslatedShaderSourceANGLE(shader, bufsize, length, source); |
| } |
| |
| GLuint GL_BINDING_CALL |
| MockGLInterface::Mock_glGetUniformBlockIndex(GLuint program, |
| const char* uniformBlockName) { |
| MakeFunctionUnique("glGetUniformBlockIndex"); |
| return interface_->GetUniformBlockIndex(program, uniformBlockName); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetUniformIndices(GLuint program, |
| GLsizei uniformCount, |
| const char* const* uniformNames, |
| GLuint* uniformIndices) { |
| MakeFunctionUnique("glGetUniformIndices"); |
| interface_->GetUniformIndices(program, uniformCount, uniformNames, |
| uniformIndices); |
| } |
| |
| GLint GL_BINDING_CALL |
| MockGLInterface::Mock_glGetUniformLocation(GLuint program, const char* name) { |
| MakeFunctionUnique("glGetUniformLocation"); |
| return interface_->GetUniformLocation(program, name); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformfv(GLuint program, |
| GLint location, |
| GLfloat* params) { |
| MakeFunctionUnique("glGetUniformfv"); |
| interface_->GetUniformfv(program, location, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetUniformfvRobustANGLE(GLuint program, |
| GLint location, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLfloat* params) { |
| MakeFunctionUnique("glGetUniformfvRobustANGLE"); |
| interface_->GetUniformfvRobustANGLE(program, location, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformiv(GLuint program, |
| GLint location, |
| GLint* params) { |
| MakeFunctionUnique("glGetUniformiv"); |
| interface_->GetUniformiv(program, location, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetUniformivRobustANGLE(GLuint program, |
| GLint location, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetUniformivRobustANGLE"); |
| interface_->GetUniformivRobustANGLE(program, location, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformuiv(GLuint program, |
| GLint location, |
| GLuint* params) { |
| MakeFunctionUnique("glGetUniformuiv"); |
| interface_->GetUniformuiv(program, location, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetUniformuivRobustANGLE(GLuint program, |
| GLint location, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLuint* params) { |
| MakeFunctionUnique("glGetUniformuivRobustANGLE"); |
| interface_->GetUniformuivRobustANGLE(program, location, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetVertexAttribIivRobustANGLE(GLuint index, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetVertexAttribIivRobustANGLE"); |
| interface_->GetVertexAttribIivRobustANGLE(index, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetVertexAttribIuivRobustANGLE(GLuint index, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLuint* params) { |
| MakeFunctionUnique("glGetVertexAttribIuivRobustANGLE"); |
| interface_->GetVertexAttribIuivRobustANGLE(index, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetVertexAttribPointerv(GLuint index, |
| GLenum pname, |
| void** pointer) { |
| MakeFunctionUnique("glGetVertexAttribPointerv"); |
| interface_->GetVertexAttribPointerv(index, pname, pointer); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetVertexAttribPointervRobustANGLE(GLuint index, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| void** pointer) { |
| MakeFunctionUnique("glGetVertexAttribPointervRobustANGLE"); |
| interface_->GetVertexAttribPointervRobustANGLE(index, pname, bufSize, length, |
| pointer); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetVertexAttribfv(GLuint index, |
| GLenum pname, |
| GLfloat* params) { |
| MakeFunctionUnique("glGetVertexAttribfv"); |
| interface_->GetVertexAttribfv(index, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetVertexAttribfvRobustANGLE(GLuint index, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLfloat* params) { |
| MakeFunctionUnique("glGetVertexAttribfvRobustANGLE"); |
| interface_->GetVertexAttribfvRobustANGLE(index, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glGetVertexAttribiv(GLuint index, |
| GLenum pname, |
| GLint* params) { |
| MakeFunctionUnique("glGetVertexAttribiv"); |
| interface_->GetVertexAttribiv(index, pname, params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetVertexAttribivRobustANGLE(GLuint index, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetVertexAttribivRobustANGLE"); |
| interface_->GetVertexAttribivRobustANGLE(index, pname, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetnUniformfvRobustANGLE(GLuint program, |
| GLint location, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLfloat* params) { |
| MakeFunctionUnique("glGetnUniformfvRobustANGLE"); |
| interface_->GetnUniformfvRobustANGLE(program, location, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetnUniformivRobustANGLE(GLuint program, |
| GLint location, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLint* params) { |
| MakeFunctionUnique("glGetnUniformivRobustANGLE"); |
| interface_->GetnUniformivRobustANGLE(program, location, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glGetnUniformuivRobustANGLE(GLuint program, |
| GLint location, |
| GLsizei bufSize, |
| GLsizei* length, |
| GLuint* params) { |
| MakeFunctionUnique("glGetnUniformuivRobustANGLE"); |
| interface_->GetnUniformuivRobustANGLE(program, location, bufSize, length, |
| params); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glHint(GLenum target, GLenum mode) { |
| MakeFunctionUnique("glHint"); |
| interface_->Hint(target, mode); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glInsertEventMarkerEXT(GLsizei length, |
| const char* marker) { |
| MakeFunctionUnique("glInsertEventMarkerEXT"); |
| interface_->InsertEventMarkerEXT(length, marker); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glInvalidateFramebuffer(GLenum target, |
| GLsizei numAttachments, |
| const GLenum* attachments) { |
| MakeFunctionUnique("glInvalidateFramebuffer"); |
| interface_->InvalidateFramebuffer(target, numAttachments, attachments); |
| } |
| |
| void GL_BINDING_CALL |
| MockGLInterface::Mock_glInvalidateSubFramebuffer(GLenum target, |
| GLsizei numAttachments, |
| const GLenum* attachments, |
| GLint x, |
| GLint y, |
| GLint width, |
| GLint height) { |
| MakeFunctionUnique("glInvalidateSubFramebuffer"); |
| interface_->InvalidateSubFramebuffer(target, numAttachments, attachments, x, |
| y, width, height); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsBuffer(GLuint buffer) { |
| MakeFunctionUnique("glIsBuffer"); |
| return interface_->IsBuffer(buffer); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsEnabled(GLenum cap) { |
| MakeFunctionUnique("glIsEnabled"); |
| return interface_->IsEnabled(cap); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsFenceAPPLE(GLuint fence) { |
| MakeFunctionUnique("glIsFenceAPPLE"); |
| return interface_->IsFenceAPPLE(fence); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsFenceNV(GLuint fence) { |
| MakeFunctionUnique("glIsFenceNV"); |
| return interface_->IsFenceNV(fence); |
| } |
| |
| GLboolean GL_BINDING_CALL |
| MockGLInterface::Mock_glIsFramebuffer(GLuint framebuffer) { |
| MakeFunctionUnique("glIsFramebuffer"); |
| return interface_->IsFramebufferEXT(framebuffer); |
| } |
| |
| GLboolean GL_BINDING_CALL |
| MockGLInterface::Mock_glIsFramebufferEXT(GLuint framebuffer) { |
| MakeFunctionUnique("glIsFramebufferEXT"); |
| return interface_->IsFramebufferEXT(framebuffer); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsPathNV(GLuint path) { |
| MakeFunctionUnique("glIsPathNV"); |
| return interface_->IsPathNV(path); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsProgram(GLuint program) { |
| MakeFunctionUnique("glIsProgram"); |
| return interface_->IsProgram(program); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsQuery(GLuint query) { |
| MakeFunctionUnique("glIsQuery"); |
| return interface_->IsQuery(query); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsQueryARB(GLuint query) { |
| MakeFunctionUnique("glIsQueryARB"); |
| return interface_->IsQuery(query); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsQueryEXT(GLuint query) { |
| MakeFunctionUnique("glIsQueryEXT"); |
| return interface_->IsQuery(query); |
| } |
| |
| GLboolean GL_BINDING_CALL |
| MockGLInterface::Mock_glIsRenderbuffer(GLuint renderbuffer) { |
| MakeFunctionUnique("glIsRenderbuffer"); |
| return interface_->IsRenderbufferEXT(renderbuffer); |
| } |
| |
| GLboolean GL_BINDING_CALL |
| MockGLInterface::Mock_glIsRenderbufferEXT(GLuint renderbuffer) { |
| MakeFunctionUnique("glIsRenderbufferEXT"); |
| return interface_->IsRenderbufferEXT(renderbuffer); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsSampler(GLuint sampler) { |
| MakeFunctionUnique("glIsSampler"); |
| return interface_->IsSampler(sampler); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsShader(GLuint shader) { |
| MakeFunctionUnique("glIsShader"); |
| return interface_->IsShader(shader); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsSync(GLsync sync) { |
| MakeFunctionUnique("glIsSync"); |
| return interface_->IsSync(sync); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsTexture(GLuint texture) { |
| MakeFunctionUnique("glIsTexture"); |
| return interface_->IsTexture(texture); |
| } |
| |
| GLboolean GL_BINDING_CALL |
| MockGLInterface::Mock_glIsTransformFeedback(GLuint id) { |
| MakeFunctionUnique("glIsTransformFeedback"); |
| return interface_->IsTransformFeedback(id); |
| } |
| |
| GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsVertexArray(GLuint array) { |
| MakeFunctionUnique("glIsVertexArray"); |
| return interface_->IsVertexArrayOES(array); |
| } |
| |
| GLboolean GL_BINDING_CALL |
| MockGLInterface::Mock_glIsVertexArrayAPPLE(GLuint array) { |
| MakeFunctionUnique("glIsVertexArrayAPPLE"); |
| return interface_->IsVertexArrayOES(array); |
| } |
| |
| GLboolean GL_BINDING_CALL |
| MockGLInterface::Mock_glIsVertexArrayOES(GLuint array) { |
| MakeFunctionUnique("glIsVertexArrayOES"); |
| return interface_->IsVertexArrayOES(array); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glLineWidth(GLfloat width) { |
| MakeFunctionUnique("glLineWidth"); |
| interface_->LineWidth(width); |
| } |
| |
| void GL_BINDING_CALL MockGLInterface::Mock_glLinkProgram(GLuint program) { |
| MakeFunctionUnique("glLinkProgram"); |
| interface_->LinkProgram(program); |
| } |
| |
| void* GL_BINDING_CALL MockGLInterface::Mock_glMapBuffer(GLenum target, |
| GLenum access) { |
| MakeFunctionUnique("glMapBuffer"); |
| return interface_->MapBuffer(target, access); |
| } |
| |
| void* GL_BINDING_CALL MockGLInterface::Mock_glMapBufferOES(GLenum target, |
| GLenum access) { |
| MakeFunctionUnique("glMapBufferOES"); |
| return interface_->MapBuffer |
