blob: 3fc581f92c61660b34aa1db1c310841bc839f89a [file] [log] [blame]
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*
* Generated from Khronos GL API description (gl.xml) revision b7aee529f02340247e45621e9dbd054817d39c71.
*/
void CallLogWrapper::glActiveShaderProgram (glw::GLuint pipeline, glw::GLuint program)
{
if (m_enableLog)
m_log << TestLog::Message << "glActiveShaderProgram(" << pipeline << ", " << program << ");" << TestLog::EndMessage;
m_gl.activeShaderProgram(pipeline, program);
}
void CallLogWrapper::glActiveTexture (glw::GLenum texture)
{
if (m_enableLog)
m_log << TestLog::Message << "glActiveTexture(" << getTextureUnitStr(texture) << ");" << TestLog::EndMessage;
m_gl.activeTexture(texture);
}
void CallLogWrapper::glAttachShader (glw::GLuint program, glw::GLuint shader)
{
if (m_enableLog)
m_log << TestLog::Message << "glAttachShader(" << program << ", " << shader << ");" << TestLog::EndMessage;
m_gl.attachShader(program, shader);
}
void CallLogWrapper::glBeginConditionalRender (glw::GLuint id, glw::GLenum mode)
{
if (m_enableLog)
m_log << TestLog::Message << "glBeginConditionalRender(" << id << ", " << toHex(mode) << ");" << TestLog::EndMessage;
m_gl.beginConditionalRender(id, mode);
}
void CallLogWrapper::glBeginQuery (glw::GLenum target, glw::GLuint id)
{
if (m_enableLog)
m_log << TestLog::Message << "glBeginQuery(" << getQueryTargetStr(target) << ", " << id << ");" << TestLog::EndMessage;
m_gl.beginQuery(target, id);
}
void CallLogWrapper::glBeginQueryIndexed (glw::GLenum target, glw::GLuint index, glw::GLuint id)
{
if (m_enableLog)
m_log << TestLog::Message << "glBeginQueryIndexed(" << toHex(target) << ", " << index << ", " << id << ");" << TestLog::EndMessage;
m_gl.beginQueryIndexed(target, index, id);
}
void CallLogWrapper::glBeginTransformFeedback (glw::GLenum primitiveMode)
{
if (m_enableLog)
m_log << TestLog::Message << "glBeginTransformFeedback(" << getPrimitiveTypeStr(primitiveMode) << ");" << TestLog::EndMessage;
m_gl.beginTransformFeedback(primitiveMode);
}
void CallLogWrapper::glBindAttribLocation (glw::GLuint program, glw::GLuint index, const glw::GLchar *name)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindAttribLocation(" << program << ", " << index << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
m_gl.bindAttribLocation(program, index, name);
}
void CallLogWrapper::glBindBuffer (glw::GLenum target, glw::GLuint buffer)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindBuffer(" << getBufferTargetStr(target) << ", " << buffer << ");" << TestLog::EndMessage;
m_gl.bindBuffer(target, buffer);
}
void CallLogWrapper::glBindBufferBase (glw::GLenum target, glw::GLuint index, glw::GLuint buffer)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindBufferBase(" << getBufferTargetStr(target) << ", " << index << ", " << buffer << ");" << TestLog::EndMessage;
m_gl.bindBufferBase(target, index, buffer);
}
void CallLogWrapper::glBindBufferRange (glw::GLenum target, glw::GLuint index, glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindBufferRange(" << getBufferTargetStr(target) << ", " << index << ", " << buffer << ", " << offset << ", " << size << ");" << TestLog::EndMessage;
m_gl.bindBufferRange(target, index, buffer, offset, size);
}
void CallLogWrapper::glBindBuffersBase (glw::GLenum target, glw::GLuint first, glw::GLsizei count, const glw::GLuint *buffers)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindBuffersBase(" << toHex(target) << ", " << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ");" << TestLog::EndMessage;
m_gl.bindBuffersBase(target, first, count, buffers);
}
void CallLogWrapper::glBindBuffersRange (glw::GLenum target, glw::GLuint first, glw::GLsizei count, const glw::GLuint *buffers, const glw::GLintptr *offsets, const glw::GLsizeiptr *sizes)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindBuffersRange(" << toHex(target) << ", " << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(offsets))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(sizes))) << ");" << TestLog::EndMessage;
m_gl.bindBuffersRange(target, first, count, buffers, offsets, sizes);
}
void CallLogWrapper::glBindFragDataLocation (glw::GLuint program, glw::GLuint color, const glw::GLchar *name)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindFragDataLocation(" << program << ", " << color << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
m_gl.bindFragDataLocation(program, color, name);
}
void CallLogWrapper::glBindFragDataLocationIndexed (glw::GLuint program, glw::GLuint colorNumber, glw::GLuint index, const glw::GLchar *name)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindFragDataLocationIndexed(" << program << ", " << colorNumber << ", " << index << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
m_gl.bindFragDataLocationIndexed(program, colorNumber, index, name);
}
void CallLogWrapper::glBindFramebuffer (glw::GLenum target, glw::GLuint framebuffer)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindFramebuffer(" << getFramebufferTargetStr(target) << ", " << framebuffer << ");" << TestLog::EndMessage;
m_gl.bindFramebuffer(target, framebuffer);
}
void CallLogWrapper::glBindImageTexture (glw::GLuint unit, glw::GLuint texture, glw::GLint level, glw::GLboolean layered, glw::GLint layer, glw::GLenum access, glw::GLenum format)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindImageTexture(" << unit << ", " << texture << ", " << level << ", " << getBooleanStr(layered) << ", " << layer << ", " << getImageAccessStr(access) << ", " << getUncompressedTextureFormatStr(format) << ");" << TestLog::EndMessage;
m_gl.bindImageTexture(unit, texture, level, layered, layer, access, format);
}
void CallLogWrapper::glBindImageTextures (glw::GLuint first, glw::GLsizei count, const glw::GLuint *textures)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindImageTextures(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(textures))) << ");" << TestLog::EndMessage;
m_gl.bindImageTextures(first, count, textures);
}
void CallLogWrapper::glBindMultiTextureEXT (glw::GLenum texunit, glw::GLenum target, glw::GLuint texture)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindMultiTextureEXT(" << toHex(texunit) << ", " << toHex(target) << ", " << texture << ");" << TestLog::EndMessage;
m_gl.bindMultiTextureEXT(texunit, target, texture);
}
void CallLogWrapper::glBindProgramPipeline (glw::GLuint pipeline)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindProgramPipeline(" << pipeline << ");" << TestLog::EndMessage;
m_gl.bindProgramPipeline(pipeline);
}
void CallLogWrapper::glBindRenderbuffer (glw::GLenum target, glw::GLuint renderbuffer)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindRenderbuffer(" << getFramebufferTargetStr(target) << ", " << renderbuffer << ");" << TestLog::EndMessage;
m_gl.bindRenderbuffer(target, renderbuffer);
}
void CallLogWrapper::glBindSampler (glw::GLuint unit, glw::GLuint sampler)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindSampler(" << unit << ", " << sampler << ");" << TestLog::EndMessage;
m_gl.bindSampler(unit, sampler);
}
void CallLogWrapper::glBindSamplers (glw::GLuint first, glw::GLsizei count, const glw::GLuint *samplers)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindSamplers(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(samplers))) << ");" << TestLog::EndMessage;
m_gl.bindSamplers(first, count, samplers);
}
void CallLogWrapper::glBindTexture (glw::GLenum target, glw::GLuint texture)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindTexture(" << getTextureTargetStr(target) << ", " << texture << ");" << TestLog::EndMessage;
m_gl.bindTexture(target, texture);
}
void CallLogWrapper::glBindTextureUnit (glw::GLuint unit, glw::GLuint texture)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindTextureUnit(" << unit << ", " << texture << ");" << TestLog::EndMessage;
m_gl.bindTextureUnit(unit, texture);
}
void CallLogWrapper::glBindTextures (glw::GLuint first, glw::GLsizei count, const glw::GLuint *textures)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindTextures(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(textures))) << ");" << TestLog::EndMessage;
m_gl.bindTextures(first, count, textures);
}
void CallLogWrapper::glBindTransformFeedback (glw::GLenum target, glw::GLuint id)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindTransformFeedback(" << getTransformFeedbackTargetStr(target) << ", " << id << ");" << TestLog::EndMessage;
m_gl.bindTransformFeedback(target, id);
}
void CallLogWrapper::glBindVertexArray (glw::GLuint array)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindVertexArray(" << array << ");" << TestLog::EndMessage;
m_gl.bindVertexArray(array);
}
void CallLogWrapper::glBindVertexBuffer (glw::GLuint bindingindex, glw::GLuint buffer, glw::GLintptr offset, glw::GLsizei stride)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindVertexBuffer(" << bindingindex << ", " << buffer << ", " << offset << ", " << stride << ");" << TestLog::EndMessage;
m_gl.bindVertexBuffer(bindingindex, buffer, offset, stride);
}
void CallLogWrapper::glBindVertexBuffers (glw::GLuint first, glw::GLsizei count, const glw::GLuint *buffers, const glw::GLintptr *offsets, const glw::GLsizei *strides)
{
if (m_enableLog)
m_log << TestLog::Message << "glBindVertexBuffers(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(offsets))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(strides))) << ");" << TestLog::EndMessage;
m_gl.bindVertexBuffers(first, count, buffers, offsets, strides);
}
void CallLogWrapper::glBlendBarrier (void)
{
if (m_enableLog)
m_log << TestLog::Message << "glBlendBarrier(" << ");" << TestLog::EndMessage;
m_gl.blendBarrier();
}
void CallLogWrapper::glBlendColor (glw::GLfloat red, glw::GLfloat green, glw::GLfloat blue, glw::GLfloat alpha)
{
if (m_enableLog)
m_log << TestLog::Message << "glBlendColor(" << red << ", " << green << ", " << blue << ", " << alpha << ");" << TestLog::EndMessage;
m_gl.blendColor(red, green, blue, alpha);
}
void CallLogWrapper::glBlendEquation (glw::GLenum mode)
{
if (m_enableLog)
m_log << TestLog::Message << "glBlendEquation(" << getBlendEquationStr(mode) << ");" << TestLog::EndMessage;
m_gl.blendEquation(mode);
}
void CallLogWrapper::glBlendEquationSeparate (glw::GLenum modeRGB, glw::GLenum modeAlpha)
{
if (m_enableLog)
m_log << TestLog::Message << "glBlendEquationSeparate(" << getBlendEquationStr(modeRGB) << ", " << getBlendEquationStr(modeAlpha) << ");" << TestLog::EndMessage;
m_gl.blendEquationSeparate(modeRGB, modeAlpha);
}
void CallLogWrapper::glBlendEquationSeparatei (glw::GLuint buf, glw::GLenum modeRGB, glw::GLenum modeAlpha)
{
if (m_enableLog)
m_log << TestLog::Message << "glBlendEquationSeparatei(" << buf << ", " << getBlendEquationStr(modeRGB) << ", " << getBlendEquationStr(modeAlpha) << ");" << TestLog::EndMessage;
m_gl.blendEquationSeparatei(buf, modeRGB, modeAlpha);
}
void CallLogWrapper::glBlendEquationi (glw::GLuint buf, glw::GLenum mode)
{
if (m_enableLog)
m_log << TestLog::Message << "glBlendEquationi(" << buf << ", " << getBlendEquationStr(mode) << ");" << TestLog::EndMessage;
m_gl.blendEquationi(buf, mode);
}
void CallLogWrapper::glBlendFunc (glw::GLenum sfactor, glw::GLenum dfactor)
{
if (m_enableLog)
m_log << TestLog::Message << "glBlendFunc(" << getBlendFactorStr(sfactor) << ", " << getBlendFactorStr(dfactor) << ");" << TestLog::EndMessage;
m_gl.blendFunc(sfactor, dfactor);
}
void CallLogWrapper::glBlendFuncSeparate (glw::GLenum sfactorRGB, glw::GLenum dfactorRGB, glw::GLenum sfactorAlpha, glw::GLenum dfactorAlpha)
{
if (m_enableLog)
m_log << TestLog::Message << "glBlendFuncSeparate(" << getBlendFactorStr(sfactorRGB) << ", " << getBlendFactorStr(dfactorRGB) << ", " << getBlendFactorStr(sfactorAlpha) << ", " << getBlendFactorStr(dfactorAlpha) << ");" << TestLog::EndMessage;
m_gl.blendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
void CallLogWrapper::glBlendFuncSeparatei (glw::GLuint buf, glw::GLenum srcRGB, glw::GLenum dstRGB, glw::GLenum srcAlpha, glw::GLenum dstAlpha)
{
if (m_enableLog)
m_log << TestLog::Message << "glBlendFuncSeparatei(" << buf << ", " << toHex(srcRGB) << ", " << toHex(dstRGB) << ", " << toHex(srcAlpha) << ", " << toHex(dstAlpha) << ");" << TestLog::EndMessage;
m_gl.blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void CallLogWrapper::glBlendFunci (glw::GLuint buf, glw::GLenum src, glw::GLenum dst)
{
if (m_enableLog)
m_log << TestLog::Message << "glBlendFunci(" << buf << ", " << toHex(src) << ", " << toHex(dst) << ");" << TestLog::EndMessage;
m_gl.blendFunci(buf, src, dst);
}
void CallLogWrapper::glBlitFramebuffer (glw::GLint srcX0, glw::GLint srcY0, glw::GLint srcX1, glw::GLint srcY1, glw::GLint dstX0, glw::GLint dstY0, glw::GLint dstX1, glw::GLint dstY1, glw::GLbitfield mask, glw::GLenum filter)
{
if (m_enableLog)
m_log << TestLog::Message << "glBlitFramebuffer(" << srcX0 << ", " << srcY0 << ", " << srcX1 << ", " << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1 << ", " << dstY1 << ", " << getBufferMaskStr(mask) << ", " << getTextureFilterStr(filter) << ");" << TestLog::EndMessage;
m_gl.blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void CallLogWrapper::glBlitNamedFramebuffer (glw::GLuint readFramebuffer, glw::GLuint drawFramebuffer, glw::GLint srcX0, glw::GLint srcY0, glw::GLint srcX1, glw::GLint srcY1, glw::GLint dstX0, glw::GLint dstY0, glw::GLint dstX1, glw::GLint dstY1, glw::GLbitfield mask, glw::GLenum filter)
{
if (m_enableLog)
m_log << TestLog::Message << "glBlitNamedFramebuffer(" << readFramebuffer << ", " << drawFramebuffer << ", " << srcX0 << ", " << srcY0 << ", " << srcX1 << ", " << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1 << ", " << dstY1 << ", " << toHex(mask) << ", " << toHex(filter) << ");" << TestLog::EndMessage;
m_gl.blitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
void CallLogWrapper::glBufferData (glw::GLenum target, glw::GLsizeiptr size, const void *data, glw::GLenum usage)
{
if (m_enableLog)
m_log << TestLog::Message << "glBufferData(" << getBufferTargetStr(target) << ", " << size << ", " << data << ", " << getUsageStr(usage) << ");" << TestLog::EndMessage;
m_gl.bufferData(target, size, data, usage);
}
void CallLogWrapper::glBufferPageCommitmentARB (glw::GLenum target, glw::GLintptr offset, glw::GLsizeiptr size, glw::GLboolean commit)
{
if (m_enableLog)
m_log << TestLog::Message << "glBufferPageCommitmentARB(" << toHex(target) << ", " << offset << ", " << size << ", " << getBooleanStr(commit) << ");" << TestLog::EndMessage;
m_gl.bufferPageCommitmentARB(target, offset, size, commit);
}
void CallLogWrapper::glBufferStorage (glw::GLenum target, glw::GLsizeiptr size, const void *data, glw::GLbitfield flags)
{
if (m_enableLog)
m_log << TestLog::Message << "glBufferStorage(" << toHex(target) << ", " << size << ", " << data << ", " << toHex(flags) << ");" << TestLog::EndMessage;
m_gl.bufferStorage(target, size, data, flags);
}
void CallLogWrapper::glBufferSubData (glw::GLenum target, glw::GLintptr offset, glw::GLsizeiptr size, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glBufferSubData(" << getBufferTargetStr(target) << ", " << offset << ", " << size << ", " << data << ");" << TestLog::EndMessage;
m_gl.bufferSubData(target, offset, size, data);
}
glw::GLenum CallLogWrapper::glCheckFramebufferStatus (glw::GLenum target)
{
if (m_enableLog)
m_log << TestLog::Message << "glCheckFramebufferStatus(" << getFramebufferTargetStr(target) << ");" << TestLog::EndMessage;
glw::GLenum returnValue = m_gl.checkFramebufferStatus(target);
if (m_enableLog)
m_log << TestLog::Message << "// " << getFramebufferStatusStr(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
glw::GLenum CallLogWrapper::glCheckNamedFramebufferStatus (glw::GLuint framebuffer, glw::GLenum target)
{
if (m_enableLog)
m_log << TestLog::Message << "glCheckNamedFramebufferStatus(" << framebuffer << ", " << toHex(target) << ");" << TestLog::EndMessage;
glw::GLenum returnValue = m_gl.checkNamedFramebufferStatus(framebuffer, target);
if (m_enableLog)
m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
glw::GLenum CallLogWrapper::glCheckNamedFramebufferStatusEXT (glw::GLuint framebuffer, glw::GLenum target)
{
if (m_enableLog)
m_log << TestLog::Message << "glCheckNamedFramebufferStatusEXT(" << framebuffer << ", " << toHex(target) << ");" << TestLog::EndMessage;
glw::GLenum returnValue = m_gl.checkNamedFramebufferStatusEXT(framebuffer, target);
if (m_enableLog)
m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
void CallLogWrapper::glClampColor (glw::GLenum target, glw::GLenum clamp)
{
if (m_enableLog)
m_log << TestLog::Message << "glClampColor(" << toHex(target) << ", " << toHex(clamp) << ");" << TestLog::EndMessage;
m_gl.clampColor(target, clamp);
}
void CallLogWrapper::glClear (glw::GLbitfield mask)
{
if (m_enableLog)
m_log << TestLog::Message << "glClear(" << getBufferMaskStr(mask) << ");" << TestLog::EndMessage;
m_gl.clear(mask);
}
void CallLogWrapper::glClearBufferData (glw::GLenum target, glw::GLenum internalformat, glw::GLenum format, glw::GLenum type, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearBufferData(" << toHex(target) << ", " << toHex(internalformat) << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
m_gl.clearBufferData(target, internalformat, format, type, data);
}
void CallLogWrapper::glClearBufferSubData (glw::GLenum target, glw::GLenum internalformat, glw::GLintptr offset, glw::GLsizeiptr size, glw::GLenum format, glw::GLenum type, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearBufferSubData(" << toHex(target) << ", " << toHex(internalformat) << ", " << offset << ", " << size << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
m_gl.clearBufferSubData(target, internalformat, offset, size, format, type, data);
}
void CallLogWrapper::glClearBufferfi (glw::GLenum buffer, glw::GLint drawbuffer, glw::GLfloat depth, glw::GLint stencil)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearBufferfi(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << depth << ", " << stencil << ");" << TestLog::EndMessage;
m_gl.clearBufferfi(buffer, drawbuffer, depth, stencil);
}
void CallLogWrapper::glClearBufferfv (glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLfloat *value)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearBufferfv(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
m_gl.clearBufferfv(buffer, drawbuffer, value);
}
void CallLogWrapper::glClearBufferiv (glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLint *value)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearBufferiv(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
m_gl.clearBufferiv(buffer, drawbuffer, value);
}
void CallLogWrapper::glClearBufferuiv (glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLuint *value)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearBufferuiv(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
m_gl.clearBufferuiv(buffer, drawbuffer, value);
}
void CallLogWrapper::glClearColor (glw::GLfloat red, glw::GLfloat green, glw::GLfloat blue, glw::GLfloat alpha)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearColor(" << red << ", " << green << ", " << blue << ", " << alpha << ");" << TestLog::EndMessage;
m_gl.clearColor(red, green, blue, alpha);
}
void CallLogWrapper::glClearDepth (glw::GLdouble depth)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearDepth(" << depth << ");" << TestLog::EndMessage;
m_gl.clearDepth(depth);
}
void CallLogWrapper::glClearDepthf (glw::GLfloat d)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearDepthf(" << d << ");" << TestLog::EndMessage;
m_gl.clearDepthf(d);
}
void CallLogWrapper::glClearNamedBufferData (glw::GLuint buffer, glw::GLenum internalformat, glw::GLenum format, glw::GLenum type, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearNamedBufferData(" << buffer << ", " << toHex(internalformat) << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
m_gl.clearNamedBufferData(buffer, internalformat, format, type, data);
}
void CallLogWrapper::glClearNamedBufferDataEXT (glw::GLuint buffer, glw::GLenum internalformat, glw::GLenum format, glw::GLenum type, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearNamedBufferDataEXT(" << buffer << ", " << toHex(internalformat) << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
m_gl.clearNamedBufferDataEXT(buffer, internalformat, format, type, data);
}
void CallLogWrapper::glClearNamedBufferSubData (glw::GLuint buffer, glw::GLenum internalformat, glw::GLintptr offset, glw::GLsizeiptr size, glw::GLenum format, glw::GLenum type, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearNamedBufferSubData(" << buffer << ", " << toHex(internalformat) << ", " << offset << ", " << size << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
m_gl.clearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
}
void CallLogWrapper::glClearNamedBufferSubDataEXT (glw::GLuint buffer, glw::GLenum internalformat, glw::GLsizeiptr offset, glw::GLsizeiptr size, glw::GLenum format, glw::GLenum type, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearNamedBufferSubDataEXT(" << buffer << ", " << toHex(internalformat) << ", " << offset << ", " << size << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
m_gl.clearNamedBufferSubDataEXT(buffer, internalformat, offset, size, format, type, data);
}
void CallLogWrapper::glClearNamedFramebufferfi (glw::GLuint framebuffer, glw::GLenum buffer, glw::GLint drawbuffer, glw::GLfloat depth, glw::GLint stencil)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearNamedFramebufferfi(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << depth << ", " << stencil << ");" << TestLog::EndMessage;
m_gl.clearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);
}
void CallLogWrapper::glClearNamedFramebufferfv (glw::GLuint framebuffer, glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLfloat *value)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearNamedFramebufferfv(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
m_gl.clearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
}
void CallLogWrapper::glClearNamedFramebufferiv (glw::GLuint framebuffer, glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLint *value)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearNamedFramebufferiv(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
m_gl.clearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
}
void CallLogWrapper::glClearNamedFramebufferuiv (glw::GLuint framebuffer, glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLuint *value)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearNamedFramebufferuiv(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
m_gl.clearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
}
void CallLogWrapper::glClearStencil (glw::GLint s)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearStencil(" << s << ");" << TestLog::EndMessage;
m_gl.clearStencil(s);
}
void CallLogWrapper::glClearTexImage (glw::GLuint texture, glw::GLint level, glw::GLenum format, glw::GLenum type, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearTexImage(" << texture << ", " << level << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
m_gl.clearTexImage(texture, level, format, type, data);
}
void CallLogWrapper::glClearTexSubImage (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint zoffset, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLenum format, glw::GLenum type, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glClearTexSubImage(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
m_gl.clearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
}
void CallLogWrapper::glClientAttribDefaultEXT (glw::GLbitfield mask)
{
if (m_enableLog)
m_log << TestLog::Message << "glClientAttribDefaultEXT(" << toHex(mask) << ");" << TestLog::EndMessage;
m_gl.clientAttribDefaultEXT(mask);
}
glw::GLenum CallLogWrapper::glClientWaitSync (glw::GLsync sync, glw::GLbitfield flags, glw::GLuint64 timeout)
{
if (m_enableLog)
m_log << TestLog::Message << "glClientWaitSync(" << sync << ", " << toHex(flags) << ", " << timeout << ");" << TestLog::EndMessage;
glw::GLenum returnValue = m_gl.clientWaitSync(sync, flags, timeout);
if (m_enableLog)
m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
return returnValue;
}
void CallLogWrapper::glClipControl (glw::GLenum origin, glw::GLenum depth)
{
if (m_enableLog)
m_log << TestLog::Message << "glClipControl(" << toHex(origin) << ", " << toHex(depth) << ");" << TestLog::EndMessage;
m_gl.clipControl(origin, depth);
}
void CallLogWrapper::glColorMask (glw::GLboolean red, glw::GLboolean green, glw::GLboolean blue, glw::GLboolean alpha)
{
if (m_enableLog)
m_log << TestLog::Message << "glColorMask(" << getBooleanStr(red) << ", " << getBooleanStr(green) << ", " << getBooleanStr(blue) << ", " << getBooleanStr(alpha) << ");" << TestLog::EndMessage;
m_gl.colorMask(red, green, blue, alpha);
}
void CallLogWrapper::glColorMaski (glw::GLuint index, glw::GLboolean r, glw::GLboolean g, glw::GLboolean b, glw::GLboolean a)
{
if (m_enableLog)
m_log << TestLog::Message << "glColorMaski(" << index << ", " << getBooleanStr(r) << ", " << getBooleanStr(g) << ", " << getBooleanStr(b) << ", " << getBooleanStr(a) << ");" << TestLog::EndMessage;
m_gl.colorMaski(index, r, g, b, a);
}
void CallLogWrapper::glCompileShader (glw::GLuint shader)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompileShader(" << shader << ");" << TestLog::EndMessage;
m_gl.compileShader(shader);
}
void CallLogWrapper::glCompressedMultiTexImage1DEXT (glw::GLenum texunit, glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLsizei width, glw::GLint border, glw::GLsizei imageSize, const void *bits)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedMultiTexImage1DEXT(" << toHex(texunit) << ", " << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << width << ", " << border << ", " << imageSize << ", " << bits << ");" << TestLog::EndMessage;
m_gl.compressedMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, imageSize, bits);
}
void CallLogWrapper::glCompressedMultiTexImage2DEXT (glw::GLenum texunit, glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLint border, glw::GLsizei imageSize, const void *bits)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedMultiTexImage2DEXT(" << toHex(texunit) << ", " << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << border << ", " << imageSize << ", " << bits << ");" << TestLog::EndMessage;
m_gl.compressedMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, imageSize, bits);
}
void CallLogWrapper::glCompressedMultiTexImage3DEXT (glw::GLenum texunit, glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLint border, glw::GLsizei imageSize, const void *bits)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedMultiTexImage3DEXT(" << toHex(texunit) << ", " << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << border << ", " << imageSize << ", " << bits << ");" << TestLog::EndMessage;
m_gl.compressedMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits);
}
void CallLogWrapper::glCompressedMultiTexSubImage1DEXT (glw::GLenum texunit, glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLsizei width, glw::GLenum format, glw::GLsizei imageSize, const void *bits)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedMultiTexSubImage1DEXT(" << toHex(texunit) << ", " << toHex(target) << ", " << level << ", " << xoffset << ", " << width << ", " << toHex(format) << ", " << imageSize << ", " << bits << ");" << TestLog::EndMessage;
m_gl.compressedMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, imageSize, bits);
}
void CallLogWrapper::glCompressedMultiTexSubImage2DEXT (glw::GLenum texunit, glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLsizei width, glw::GLsizei height, glw::GLenum format, glw::GLsizei imageSize, const void *bits)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedMultiTexSubImage2DEXT(" << toHex(texunit) << ", " << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height << ", " << toHex(format) << ", " << imageSize << ", " << bits << ");" << TestLog::EndMessage;
m_gl.compressedMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
}
void CallLogWrapper::glCompressedMultiTexSubImage3DEXT (glw::GLenum texunit, glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint zoffset, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLenum format, glw::GLsizei imageSize, const void *bits)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedMultiTexSubImage3DEXT(" << toHex(texunit) << ", " << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << toHex(format) << ", " << imageSize << ", " << bits << ");" << TestLog::EndMessage;
m_gl.compressedMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
}
void CallLogWrapper::glCompressedTexImage1D (glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLsizei width, glw::GLint border, glw::GLsizei imageSize, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTexImage1D(" << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << width << ", " << border << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
m_gl.compressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
void CallLogWrapper::glCompressedTexImage2D (glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLint border, glw::GLsizei imageSize, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTexImage2D(" << getTextureTargetStr(target) << ", " << level << ", " << getCompressedTextureFormatStr(internalformat) << ", " << width << ", " << height << ", " << border << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
m_gl.compressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
void CallLogWrapper::glCompressedTexImage3D (glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLint border, glw::GLsizei imageSize, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTexImage3D(" << getTextureTargetStr(target) << ", " << level << ", " << getCompressedTextureFormatStr(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << border << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
m_gl.compressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void CallLogWrapper::glCompressedTexImage3DOES (glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLint border, glw::GLsizei imageSize, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTexImage3DOES(" << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << border << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
m_gl.compressedTexImage3DOES(target, level, internalformat, width, height, depth, border, imageSize, data);
}
void CallLogWrapper::glCompressedTexSubImage1D (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLsizei width, glw::GLenum format, glw::GLsizei imageSize, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTexSubImage1D(" << toHex(target) << ", " << level << ", " << xoffset << ", " << width << ", " << toHex(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
m_gl.compressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
void CallLogWrapper::glCompressedTexSubImage2D (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLsizei width, glw::GLsizei height, glw::GLenum format, glw::GLsizei imageSize, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTexSubImage2D(" << getTextureTargetStr(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height << ", " << getCompressedTextureFormatStr(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
m_gl.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void CallLogWrapper::glCompressedTexSubImage3D (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint zoffset, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLenum format, glw::GLsizei imageSize, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTexSubImage3D(" << getTextureTargetStr(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << getCompressedTextureFormatStr(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
m_gl.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void CallLogWrapper::glCompressedTexSubImage3DOES (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint zoffset, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLenum format, glw::GLsizei imageSize, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTexSubImage3DOES(" << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << toHex(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
m_gl.compressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void CallLogWrapper::glCompressedTextureImage1DEXT (glw::GLuint texture, glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLsizei width, glw::GLint border, glw::GLsizei imageSize, const void *bits)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTextureImage1DEXT(" << texture << ", " << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << width << ", " << border << ", " << imageSize << ", " << bits << ");" << TestLog::EndMessage;
m_gl.compressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, bits);
}
void CallLogWrapper::glCompressedTextureImage2DEXT (glw::GLuint texture, glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLint border, glw::GLsizei imageSize, const void *bits)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTextureImage2DEXT(" << texture << ", " << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << border << ", " << imageSize << ", " << bits << ");" << TestLog::EndMessage;
m_gl.compressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, bits);
}
void CallLogWrapper::glCompressedTextureImage3DEXT (glw::GLuint texture, glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLint border, glw::GLsizei imageSize, const void *bits)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTextureImage3DEXT(" << texture << ", " << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << border << ", " << imageSize << ", " << bits << ");" << TestLog::EndMessage;
m_gl.compressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, bits);
}
void CallLogWrapper::glCompressedTextureSubImage1D (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLsizei width, glw::GLenum format, glw::GLsizei imageSize, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTextureSubImage1D(" << texture << ", " << level << ", " << xoffset << ", " << width << ", " << toHex(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
m_gl.compressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
}
void CallLogWrapper::glCompressedTextureSubImage1DEXT (glw::GLuint texture, glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLsizei width, glw::GLenum format, glw::GLsizei imageSize, const void *bits)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTextureSubImage1DEXT(" << texture << ", " << toHex(target) << ", " << level << ", " << xoffset << ", " << width << ", " << toHex(format) << ", " << imageSize << ", " << bits << ");" << TestLog::EndMessage;
m_gl.compressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, bits);
}
void CallLogWrapper::glCompressedTextureSubImage2D (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLsizei width, glw::GLsizei height, glw::GLenum format, glw::GLsizei imageSize, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTextureSubImage2D(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height << ", " << toHex(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
m_gl.compressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
}
void CallLogWrapper::glCompressedTextureSubImage2DEXT (glw::GLuint texture, glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLsizei width, glw::GLsizei height, glw::GLenum format, glw::GLsizei imageSize, const void *bits)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTextureSubImage2DEXT(" << texture << ", " << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height << ", " << toHex(format) << ", " << imageSize << ", " << bits << ");" << TestLog::EndMessage;
m_gl.compressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
}
void CallLogWrapper::glCompressedTextureSubImage3D (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint zoffset, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLenum format, glw::GLsizei imageSize, const void *data)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTextureSubImage3D(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << toHex(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
m_gl.compressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
void CallLogWrapper::glCompressedTextureSubImage3DEXT (glw::GLuint texture, glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint zoffset, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLenum format, glw::GLsizei imageSize, const void *bits)
{
if (m_enableLog)
m_log << TestLog::Message << "glCompressedTextureSubImage3DEXT(" << texture << ", " << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << toHex(format) << ", " << imageSize << ", " << bits << ");" << TestLog::EndMessage;
m_gl.compressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
}
void CallLogWrapper::glCopyBufferSubData (glw::GLenum readTarget, glw::GLenum writeTarget, glw::GLintptr readOffset, glw::GLintptr writeOffset, glw::GLsizeiptr size)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyBufferSubData(" << toHex(readTarget) << ", " << toHex(writeTarget) << ", " << readOffset << ", " << writeOffset << ", " << size << ");" << TestLog::EndMessage;
m_gl.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
}
void CallLogWrapper::glCopyImageSubData (glw::GLuint srcName, glw::GLenum srcTarget, glw::GLint srcLevel, glw::GLint srcX, glw::GLint srcY, glw::GLint srcZ, glw::GLuint dstName, glw::GLenum dstTarget, glw::GLint dstLevel, glw::GLint dstX, glw::GLint dstY, glw::GLint dstZ, glw::GLsizei srcWidth, glw::GLsizei srcHeight, glw::GLsizei srcDepth)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyImageSubData(" << srcName << ", " << toHex(srcTarget) << ", " << srcLevel << ", " << srcX << ", " << srcY << ", " << srcZ << ", " << dstName << ", " << toHex(dstTarget) << ", " << dstLevel << ", " << dstX << ", " << dstY << ", " << dstZ << ", " << srcWidth << ", " << srcHeight << ", " << srcDepth << ");" << TestLog::EndMessage;
m_gl.copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}
void CallLogWrapper::glCopyMultiTexImage1DEXT (glw::GLenum texunit, glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLint border)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyMultiTexImage1DEXT(" << toHex(texunit) << ", " << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << x << ", " << y << ", " << width << ", " << border << ");" << TestLog::EndMessage;
m_gl.copyMultiTexImage1DEXT(texunit, target, level, internalformat, x, y, width, border);
}
void CallLogWrapper::glCopyMultiTexImage2DEXT (glw::GLenum texunit, glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height, glw::GLint border)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyMultiTexImage2DEXT(" << toHex(texunit) << ", " << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << x << ", " << y << ", " << width << ", " << height << ", " << border << ");" << TestLog::EndMessage;
m_gl.copyMultiTexImage2DEXT(texunit, target, level, internalformat, x, y, width, height, border);
}
void CallLogWrapper::glCopyMultiTexSubImage1DEXT (glw::GLenum texunit, glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint x, glw::GLint y, glw::GLsizei width)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyMultiTexSubImage1DEXT(" << toHex(texunit) << ", " << toHex(target) << ", " << level << ", " << xoffset << ", " << x << ", " << y << ", " << width << ");" << TestLog::EndMessage;
m_gl.copyMultiTexSubImage1DEXT(texunit, target, level, xoffset, x, y, width);
}
void CallLogWrapper::glCopyMultiTexSubImage2DEXT (glw::GLenum texunit, glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyMultiTexSubImage2DEXT(" << toHex(texunit) << ", " << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
m_gl.copyMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, x, y, width, height);
}
void CallLogWrapper::glCopyMultiTexSubImage3DEXT (glw::GLenum texunit, glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint zoffset, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyMultiTexSubImage3DEXT(" << toHex(texunit) << ", " << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
m_gl.copyMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void CallLogWrapper::glCopyNamedBufferSubData (glw::GLuint readBuffer, glw::GLuint writeBuffer, glw::GLintptr readOffset, glw::GLintptr writeOffset, glw::GLsizeiptr size)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyNamedBufferSubData(" << readBuffer << ", " << writeBuffer << ", " << readOffset << ", " << writeOffset << ", " << size << ");" << TestLog::EndMessage;
m_gl.copyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
}
void CallLogWrapper::glCopyTexImage1D (glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLint border)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTexImage1D(" << getTextureTargetStr(target) << ", " << level << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << x << ", " << y << ", " << width << ", " << border << ");" << TestLog::EndMessage;
m_gl.copyTexImage1D(target, level, internalformat, x, y, width, border);
}
void CallLogWrapper::glCopyTexImage2D (glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height, glw::GLint border)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTexImage2D(" << getTextureTargetStr(target) << ", " << level << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << x << ", " << y << ", " << width << ", " << height << ", " << border << ");" << TestLog::EndMessage;
m_gl.copyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void CallLogWrapper::glCopyTexSubImage1D (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint x, glw::GLint y, glw::GLsizei width)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTexSubImage1D(" << toHex(target) << ", " << level << ", " << xoffset << ", " << x << ", " << y << ", " << width << ");" << TestLog::EndMessage;
m_gl.copyTexSubImage1D(target, level, xoffset, x, y, width);
}
void CallLogWrapper::glCopyTexSubImage2D (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTexSubImage2D(" << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
m_gl.copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
void CallLogWrapper::glCopyTexSubImage3D (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint zoffset, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTexSubImage3D(" << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
m_gl.copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void CallLogWrapper::glCopyTexSubImage3DOES (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint zoffset, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTexSubImage3DOES(" << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
m_gl.copyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void CallLogWrapper::glCopyTextureImage1DEXT (glw::GLuint texture, glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLint border)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTextureImage1DEXT(" << texture << ", " << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << x << ", " << y << ", " << width << ", " << border << ");" << TestLog::EndMessage;
m_gl.copyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border);
}
void CallLogWrapper::glCopyTextureImage2DEXT (glw::GLuint texture, glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height, glw::GLint border)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTextureImage2DEXT(" << texture << ", " << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << x << ", " << y << ", " << width << ", " << height << ", " << border << ");" << TestLog::EndMessage;
m_gl.copyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border);
}
void CallLogWrapper::glCopyTextureSubImage1D (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLint x, glw::GLint y, glw::GLsizei width)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTextureSubImage1D(" << texture << ", " << level << ", " << xoffset << ", " << x << ", " << y << ", " << width << ");" << TestLog::EndMessage;
m_gl.copyTextureSubImage1D(texture, level, xoffset, x, y, width);
}
void CallLogWrapper::glCopyTextureSubImage1DEXT (glw::GLuint texture, glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint x, glw::GLint y, glw::GLsizei width)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTextureSubImage1DEXT(" << texture << ", " << toHex(target) << ", " << level << ", " << xoffset << ", " << x << ", " << y << ", " << width << ");" << TestLog::EndMessage;
m_gl.copyTextureSubImage1DEXT(texture, target, level, xoffset, x, y, width);
}
void CallLogWrapper::glCopyTextureSubImage2D (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTextureSubImage2D(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
m_gl.copyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
}
void CallLogWrapper::glCopyTextureSubImage2DEXT (glw::GLuint texture, glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTextureSubImage2DEXT(" << texture << ", " << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
m_gl.copyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, x, y, width, height);
}
void CallLogWrapper::glCopyTextureSubImage3D (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint zoffset, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTextureSubImage3D(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
m_gl.copyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void CallLogWrapper::glCopyTextureSubImage3DEXT (glw::GLuint texture, glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint zoffset, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
{
if (m_enableLog)
m_log << TestLog::Message << "glCopyTextureSubImage3DEXT(" << texture << ", " << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
m_gl.copyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
void CallLogWrapper::glCreateBuffers (glw::GLsizei n, glw::GLuint *buffers)
{
if (m_enableLog)
m_log << TestLog::Message << "glCreateBuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ");" << TestLog::EndMessage;
m_gl.createBuffers(n, buffers);
}
void CallLogWrapper::glCreateFramebuffers (glw::GLsizei n, glw::GLuint *framebuffers)
{
if (m_enableLog)
m_log << TestLog::Message << "glCreateFramebuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(framebuffers))) << ");" << TestLog::EndMessage;
m_gl.createFramebuffers(n, framebuffers);
}
glw::GLuint CallLogWrapper::glCreateProgram (void)
{
if (m_enableLog)
m_log << TestLog::Message << "glCreateProgram(" << ");" << TestLog::EndMessage;
glw::GLuint returnValue = m_gl.createProgram();
if (m_enableLog)
m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
return returnValue;
}
void CallLogWrapper::glCreateProgramPipelines (glw::GLsizei n, glw::GLuint *pipelines)
{
if (m_enableLog)
m_log << TestLog::Message << "glCreateProgramPipelines(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(pipelines))) << ");" << TestLog::EndMessage;
m_gl.createProgramPipelines(n, pipelines);
}
void CallLogWrapper::glCreateQueries (glw::GLenum target, glw::GLsizei n, glw::GLuint *ids)
{
if (m_enableLog)
m_log << TestLog::Message << "glCreateQueries(" << toHex(target) << ", " << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
m_gl.createQueries(target, n, ids);
}
void CallLogWrapper::glCreateRenderbuffers (glw::GLsizei n, glw::GLuint *renderbuffers)
{
if (m_enableLog)
m_log << TestLog::Message << "glCreateRenderbuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(renderbuffers))) << ");" << TestLog::EndMessage;
m_gl.createRenderbuffers(n, renderbuffers);
}
void CallLogWrapper::glCreateSamplers (glw::GLsizei n, glw::GLuint *samplers)
{
if (m_enableLog)
m_log << TestLog::Message << "glCreateSamplers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(samplers))) << ");" << TestLog::EndMessage;
m_gl.createSamplers(n, samplers);
}
glw::GLuint CallLogWrapper::glCreateShader (glw::GLenum type)
{
if (m_enableLog)
m_log << TestLog::Message << "glCreateShader(" << getShaderTypeStr(type) << ");" << TestLog::EndMessage;
glw::GLuint returnValue = m_gl.createShader(type);
if (m_enableLog)
m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
return returnValue;
}
glw::GLuint CallLogWrapper::glCreateShaderProgramv (glw::GLenum type, glw::GLsizei count, const glw::GLchar *const*strings)
{
if (m_enableLog)
m_log << TestLog::Message << "glCreateShaderProgramv(" << toHex(type) << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(strings))) << ");" << TestLog::EndMessage;
glw::GLuint returnValue = m_gl.createShaderProgramv(type, count, strings);
if (m_enableLog)
m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
return returnValue;
}
void CallLogWrapper::glCreateTextures (glw::GLenum target, glw::GLsizei n, glw::GLuint *textures)
{
if (m_enableLog)
m_log << TestLog::Message << "glCreateTextures(" << toHex(target) << ", " << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(textures))) << ");" << TestLog::EndMessage;
m_gl.createTextures(target, n, textures);
}
void CallLogWrapper::glCreateTransformFeedbacks (glw::GLsizei n, glw::GLuint *ids)
{
if (m_enableLog)
m_log << TestLog::Message << "glCreateTransformFeedbacks(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
m_gl.createTransformFeedbacks(n, ids);
}
void CallLogWrapper::glCreateVertexArrays (glw::GLsizei n, glw::GLuint *arrays)
{
if (m_enableLog)
m_log << TestLog::Message << "glCreateVertexArrays(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(arrays))) << ");" << TestLog::EndMessage;
m_gl.createVertexArrays(n, arrays);
}
void CallLogWrapper::glCullFace (glw::GLenum mode)
{
if (m_enableLog)
m_log << TestLog::Message << "glCullFace(" << getFaceStr(mode) << ");" << TestLog::EndMessage;
m_gl.cullFace(mode);
}
void CallLogWrapper::glDebugMessageCallback (glw::GLDEBUGPROC callback, const void *userParam)
{
if (m_enableLog)
m_log << TestLog::Message << "glDebugMessageCallback(" << toHex(reinterpret_cast<deUintptr>(callback)) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(userParam))) << ");" << TestLog::EndMessage;
m_gl.debugMessageCallback(callback, userParam);
}
void CallLogWrapper::glDebugMessageControl (glw::GLenum source, glw::GLenum type, glw::GLenum severity, glw::GLsizei count, const glw::GLuint *ids, glw::GLboolean enabled)
{
if (m_enableLog)
m_log << TestLog::Message << "glDebugMessageControl(" << getDebugMessageSourceStr(source) << ", " << getDebugMessageTypeStr(type) << ", " << getDebugMessageSeverityStr(severity) << ", " << count << ", " << getPointerStr(ids, (count)) << ", " << getBooleanStr(enabled) << ");" << TestLog::EndMessage;
m_gl.debugMessageControl(source, type, severity, count, ids, enabled);
}
void CallLogWrapper::glDebugMessageInsert (glw::GLenum source, glw::GLenum type, glw::GLuint id, glw::GLenum severity, glw::GLsizei length, const glw::GLchar *buf)
{
if (m_enableLog)
m_log << TestLog::Message << "glDebugMessageInsert(" << getDebugMessageSourceStr(source) << ", " << getDebugMessageTypeStr(type) << ", " << id << ", " << getDebugMessageSeverityStr(severity) << ", " << length << ", " << getStringStr(buf) << ");" << TestLog::EndMessage;
m_gl.debugMessageInsert(source, type, id, severity, length, buf);
}
void CallLogWrapper::glDeleteBuffers (glw::GLsizei n, const glw::GLuint *buffers)
{
if (m_enableLog)
m_log << TestLog::Message << "glDeleteBuffers(" << n << ", " << getPointerStr(buffers, n) << ");" << TestLog::EndMessage;
m_gl.deleteBuffers(n, buffers);
}
void CallLogWrapper::glDeleteFramebuffers (glw::GLsizei n, const glw::GLuint *framebuffers)
{
if (m_enableLog)
m_log << TestLog::Message << "glDeleteFramebuffers(" << n << ", " << getPointerStr(framebuffers, n) << ");" << TestLog::EndMessage;
m_gl.deleteFramebuffers(n, framebuffers);
}
void CallLogWrapper::glDeleteProgram (glw::GLuint program)
{
if (m_enableLog)
m_log << TestLog::Message << "glDeleteProgram(" << program << ");" << TestLog::EndMessage;
m_gl.deleteProgram(program);
}
void CallLogWrapper::glDeleteProgramPipelines (glw::GLsizei n, const glw::GLuint *pipelines)
{
if (m_enableLog)
m_log << TestLog::Message << "glDeleteProgramPipelines(" << n << ", " << getPointerStr(pipelines, n) << ");" << TestLog::EndMessage;
m_gl.deleteProgramPipelines(n, pipelines);
}
void CallLogWrapper::glDeleteQueries (glw::GLsizei n, const glw::GLuint *ids)
{
if (m_enableLog)
m_log << TestLog::Message << "glDeleteQueries(" << n << ", " << getPointerStr(ids, n) << ");" << TestLog::EndMessage;
m_gl.deleteQueries(n, ids);
}
void CallLogWrapper::glDeleteRenderbuffers (glw::GLsizei n, const glw::GLuint *renderbuffers)
{
if (m_enableLog)
m_log << TestLog::Message << "glDeleteRenderbuffers(" << n << ", " << getPointerStr(renderbuffers, n) << ");" << TestLog::EndMessage;
m_gl.deleteRenderbuffers(n, renderbuffers);
}
void CallLogWrapper::glDeleteSamplers (glw::GLsizei count, const glw::GLuint *samplers)
{
if (m_enableLog)
m_log << TestLog::Message << "glDeleteSamplers(" << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(samplers))) << ");" << TestLog::EndMessage;
m_gl.deleteSamplers(count, samplers);
}
void CallLogWrapper::glDeleteShader (glw::GLuint shader)
{
if (m_enableLog)
m_log << TestLog::Message << "glDeleteShader(" << shader << ");" << TestLog::EndMessage;
m_gl.deleteShader(shader);
}
void CallLogWrapper::glDeleteSync (glw::GLsync sync)
{
if (m_enableLog)
m_log << TestLog::Message << "glDeleteSync(" << sync << ");" << TestLog::EndMessage;
m_gl.deleteSync(sync);
}
void CallLogWrapper::glDeleteTextures (glw::GLsizei n, const glw::GLuint *textures)
{
if (m_enableLog)
m_log << TestLog::Message << "glDeleteTextures(" << n << ", " << getPointerStr(textures, n) << ");" << TestLog::EndMessage;
m_gl.deleteTextures(n, textures);
}
void CallLogWrapper::glDeleteTransformFeedbacks (glw::GLsizei n, const glw::GLuint *ids)
{
if (m_enableLog)
m_log << TestLog::Message << "glDeleteTransformFeedbacks(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
m_gl.deleteTransformFeedbacks(n, ids);
}
void CallLogWrapper::glDeleteVertexArrays (glw::GLsizei n, const glw::GLuint *arrays)
{
if (m_enableLog)
m_log << TestLog::Message << "glDeleteVertexArrays(" << n << ", " << getPointerStr(arrays, n) << ");" << TestLog::EndMessage;
m_gl.deleteVertexArrays(n, arrays);
}
void CallLogWrapper::glDepthBoundsEXT (glw::GLclampd zmin, glw::GLclampd zmax)
{
if (m_enableLog)
m_log << TestLog::Message << "glDepthBoundsEXT(" << zmin << ", " << zmax << ");" << TestLog::EndMessage;
m_gl.depthBoundsEXT(zmin, zmax);
}
void CallLogWrapper::glDepthFunc (glw::GLenum func)
{
if (m_enableLog)
m_log << TestLog::Message << "glDepthFunc(" << getCompareFuncStr(func) << ");" << TestLog::EndMessage;
m_gl.depthFunc(func);
}
void CallLogWrapper::glDepthMask (glw::GLboolean flag)
{
if (m_enableLog)
m_log << TestLog::Message << "glDepthMask(" << getBooleanStr(flag) << ");" << TestLog::EndMessage;
m_gl.depthMask(flag);
}
void CallLogWrapper::glDepthRange (glw::GLdouble n, glw::GLdouble f)
{
if (m_enableLog)
m_log << TestLog::Message << "glDepthRange(" << n << ", " << f << ");" << TestLog::EndMessage;
m_gl.depthRange(n, f);
}
void CallLogWrapper::glDepthRangeArrayfvOES (glw::GLuint first, glw::GLsizei count, const glw::GLfloat *v)
{
if (m_enableLog)
m_log << TestLog::Message << "glDepthRangeArrayfvOES(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
m_gl.depthRangeArrayfvOES(first, count, v);
}
void CallLogWrapper::glDepthRangeArrayv (glw::GLuint first, glw::GLsizei count, const glw::GLdouble *v)
{
if (m_enableLog)
m_log << TestLog::Message << "glDepthRangeArrayv(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
m_gl.depthRangeArrayv(first, count, v);
}
void CallLogWrapper::glDepthRangeIndexed (glw::GLuint index, glw::GLdouble n, glw::GLdouble f)
{
if (m_enableLog)
m_log << TestLog::Message << "glDepthRangeIndexed(" << index << ", " << n << ", " << f << ");" << TestLog::EndMessage;
m_gl.depthRangeIndexed(index, n, f);
}
void CallLogWrapper::glDepthRangeIndexedfOES (glw::GLuint index, glw::GLfloat n, glw::GLfloat f)
{
if (m_enableLog)
m_log << TestLog::Message << "glDepthRangeIndexedfOES(" << index << ", " << n << ", " << f << ");" << TestLog::EndMessage;
m_gl.depthRangeIndexedfOES(index, n, f);
}
void CallLogWrapper::glDepthRangef (glw::GLfloat n, glw::GLfloat f)
{
if (m_enableLog)
m_log << TestLog::Message << "glDepthRangef(" << n << ", " << f << ");" << TestLog::EndMessage;
m_gl.depthRangef(n, f);
}
void CallLogWrapper::glDetachShader (glw::GLuint program, glw::GLuint shader)
{
if (m_enableLog)
m_log << TestLog::Message << "glDetachShader(" << program << ", " << shader << ");" << TestLog::EndMessage;
m_gl.detachShader(program, shader);
}
void CallLogWrapper::glDisable (glw::GLenum cap)
{
if (m_enableLog)
m_log << TestLog::Message << "glDisable(" << getEnableCapStr(cap) << ");" << TestLog::EndMessage;
m_gl.disable(cap);
}
void CallLogWrapper::glDisableClientStateIndexedEXT (glw::GLenum array, glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glDisableClientStateIndexedEXT(" << toHex(array) << ", " << index << ");" << TestLog::EndMessage;
m_gl.disableClientStateIndexedEXT(array, index);
}
void CallLogWrapper::glDisableClientStateiEXT (glw::GLenum array, glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glDisableClientStateiEXT(" << toHex(array) << ", " << index << ");" << TestLog::EndMessage;
m_gl.disableClientStateiEXT(array, index);
}
void CallLogWrapper::glDisableVertexArrayAttrib (glw::GLuint vaobj, glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glDisableVertexArrayAttrib(" << vaobj << ", " << index << ");" << TestLog::EndMessage;
m_gl.disableVertexArrayAttrib(vaobj, index);
}
void CallLogWrapper::glDisableVertexArrayAttribEXT (glw::GLuint vaobj, glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glDisableVertexArrayAttribEXT(" << vaobj << ", " << index << ");" << TestLog::EndMessage;
m_gl.disableVertexArrayAttribEXT(vaobj, index);
}
void CallLogWrapper::glDisableVertexArrayEXT (glw::GLuint vaobj, glw::GLenum array)
{
if (m_enableLog)
m_log << TestLog::Message << "glDisableVertexArrayEXT(" << vaobj << ", " << toHex(array) << ");" << TestLog::EndMessage;
m_gl.disableVertexArrayEXT(vaobj, array);
}
void CallLogWrapper::glDisableVertexAttribArray (glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glDisableVertexAttribArray(" << index << ");" << TestLog::EndMessage;
m_gl.disableVertexAttribArray(index);
}
void CallLogWrapper::glDisablei (glw::GLenum target, glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glDisablei(" << getIndexedEnableCapStr(target) << ", " << index << ");" << TestLog::EndMessage;
m_gl.disablei(target, index);
}
void CallLogWrapper::glDispatchCompute (glw::GLuint num_groups_x, glw::GLuint num_groups_y, glw::GLuint num_groups_z)
{
if (m_enableLog)
m_log << TestLog::Message << "glDispatchCompute(" << num_groups_x << ", " << num_groups_y << ", " << num_groups_z << ");" << TestLog::EndMessage;
m_gl.dispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}
void CallLogWrapper::glDispatchComputeIndirect (glw::GLintptr indirect)
{
if (m_enableLog)
m_log << TestLog::Message << "glDispatchComputeIndirect(" << indirect << ");" << TestLog::EndMessage;
m_gl.dispatchComputeIndirect(indirect);
}
void CallLogWrapper::glDrawArrays (glw::GLenum mode, glw::GLint first, glw::GLsizei count)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawArrays(" << getPrimitiveTypeStr(mode) << ", " << first << ", " << count << ");" << TestLog::EndMessage;
m_gl.drawArrays(mode, first, count);
}
void CallLogWrapper::glDrawArraysIndirect (glw::GLenum mode, const void *indirect)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawArraysIndirect(" << getPrimitiveTypeStr(mode) << ", " << indirect << ");" << TestLog::EndMessage;
m_gl.drawArraysIndirect(mode, indirect);
}
void CallLogWrapper::glDrawArraysInstanced (glw::GLenum mode, glw::GLint first, glw::GLsizei count, glw::GLsizei instancecount)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawArraysInstanced(" << getPrimitiveTypeStr(mode) << ", " << first << ", " << count << ", " << instancecount << ");" << TestLog::EndMessage;
m_gl.drawArraysInstanced(mode, first, count, instancecount);
}
void CallLogWrapper::glDrawArraysInstancedBaseInstance (glw::GLenum mode, glw::GLint first, glw::GLsizei count, glw::GLsizei instancecount, glw::GLuint baseinstance)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawArraysInstancedBaseInstance(" << toHex(mode) << ", " << first << ", " << count << ", " << instancecount << ", " << baseinstance << ");" << TestLog::EndMessage;
m_gl.drawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}
void CallLogWrapper::glDrawBuffer (glw::GLenum buf)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawBuffer(" << toHex(buf) << ");" << TestLog::EndMessage;
m_gl.drawBuffer(buf);
}
void CallLogWrapper::glDrawBuffers (glw::GLsizei n, const glw::GLenum *bufs)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawBuffers(" << n << ", " << getEnumPointerStr(bufs, n, getDrawReadBufferName) << ");" << TestLog::EndMessage;
m_gl.drawBuffers(n, bufs);
}
void CallLogWrapper::glDrawElements (glw::GLenum mode, glw::GLsizei count, glw::GLenum type, const void *indices)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawElements(" << getPrimitiveTypeStr(mode) << ", " << count << ", " << getTypeStr(type) << ", " << indices << ");" << TestLog::EndMessage;
m_gl.drawElements(mode, count, type, indices);
}
void CallLogWrapper::glDrawElementsBaseVertex (glw::GLenum mode, glw::GLsizei count, glw::GLenum type, const void *indices, glw::GLint basevertex)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawElementsBaseVertex(" << getPrimitiveTypeStr(mode) << ", " << count << ", " << getTypeStr(type) << ", " << indices << ", " << basevertex << ");" << TestLog::EndMessage;
m_gl.drawElementsBaseVertex(mode, count, type, indices, basevertex);
}
void CallLogWrapper::glDrawElementsIndirect (glw::GLenum mode, glw::GLenum type, const void *indirect)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawElementsIndirect(" << getPrimitiveTypeStr(mode) << ", " << getTypeStr(type) << ", " << indirect << ");" << TestLog::EndMessage;
m_gl.drawElementsIndirect(mode, type, indirect);
}
void CallLogWrapper::glDrawElementsInstanced (glw::GLenum mode, glw::GLsizei count, glw::GLenum type, const void *indices, glw::GLsizei instancecount)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawElementsInstanced(" << getPrimitiveTypeStr(mode) << ", " << count << ", " << getTypeStr(type) << ", " << indices << ", " << instancecount << ");" << TestLog::EndMessage;
m_gl.drawElementsInstanced(mode, count, type, indices, instancecount);
}
void CallLogWrapper::glDrawElementsInstancedBaseInstance (glw::GLenum mode, glw::GLsizei count, glw::GLenum type, const void *indices, glw::GLsizei instancecount, glw::GLuint baseinstance)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawElementsInstancedBaseInstance(" << toHex(mode) << ", " << count << ", " << toHex(type) << ", " << indices << ", " << instancecount << ", " << baseinstance << ");" << TestLog::EndMessage;
m_gl.drawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
}
void CallLogWrapper::glDrawElementsInstancedBaseVertex (glw::GLenum mode, glw::GLsizei count, glw::GLenum type, const void *indices, glw::GLsizei instancecount, glw::GLint basevertex)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawElementsInstancedBaseVertex(" << getPrimitiveTypeStr(mode) << ", " << count << ", " << getTypeStr(type) << ", " << indices << ", " << instancecount << ", " << basevertex << ");" << TestLog::EndMessage;
m_gl.drawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
}
void CallLogWrapper::glDrawElementsInstancedBaseVertexBaseInstance (glw::GLenum mode, glw::GLsizei count, glw::GLenum type, const void *indices, glw::GLsizei instancecount, glw::GLint basevertex, glw::GLuint baseinstance)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawElementsInstancedBaseVertexBaseInstance(" << toHex(mode) << ", " << count << ", " << toHex(type) << ", " << indices << ", " << instancecount << ", " << basevertex << ", " << baseinstance << ");" << TestLog::EndMessage;
m_gl.drawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
}
void CallLogWrapper::glDrawRangeElements (glw::GLenum mode, glw::GLuint start, glw::GLuint end, glw::GLsizei count, glw::GLenum type, const void *indices)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawRangeElements(" << getPrimitiveTypeStr(mode) << ", " << start << ", " << end << ", " << count << ", " << getTypeStr(type) << ", " << indices << ");" << TestLog::EndMessage;
m_gl.drawRangeElements(mode, start, end, count, type, indices);
}
void CallLogWrapper::glDrawRangeElementsBaseVertex (glw::GLenum mode, glw::GLuint start, glw::GLuint end, glw::GLsizei count, glw::GLenum type, const void *indices, glw::GLint basevertex)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawRangeElementsBaseVertex(" << getPrimitiveTypeStr(mode) << ", " << start << ", " << end << ", " << count << ", " << getTypeStr(type) << ", " << indices << ", " << basevertex << ");" << TestLog::EndMessage;
m_gl.drawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
}
void CallLogWrapper::glDrawTransformFeedback (glw::GLenum mode, glw::GLuint id)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawTransformFeedback(" << toHex(mode) << ", " << id << ");" << TestLog::EndMessage;
m_gl.drawTransformFeedback(mode, id);
}
void CallLogWrapper::glDrawTransformFeedbackInstanced (glw::GLenum mode, glw::GLuint id, glw::GLsizei instancecount)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawTransformFeedbackInstanced(" << toHex(mode) << ", " << id << ", " << instancecount << ");" << TestLog::EndMessage;
m_gl.drawTransformFeedbackInstanced(mode, id, instancecount);
}
void CallLogWrapper::glDrawTransformFeedbackStream (glw::GLenum mode, glw::GLuint id, glw::GLuint stream)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawTransformFeedbackStream(" << toHex(mode) << ", " << id << ", " << stream << ");" << TestLog::EndMessage;
m_gl.drawTransformFeedbackStream(mode, id, stream);
}
void CallLogWrapper::glDrawTransformFeedbackStreamInstanced (glw::GLenum mode, glw::GLuint id, glw::GLuint stream, glw::GLsizei instancecount)
{
if (m_enableLog)
m_log << TestLog::Message << "glDrawTransformFeedbackStreamInstanced(" << toHex(mode) << ", " << id << ", " << stream << ", " << instancecount << ");" << TestLog::EndMessage;
m_gl.drawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}
void CallLogWrapper::glEGLImageTargetRenderbufferStorageOES (glw::GLenum target, glw::GLeglImageOES image)
{
if (m_enableLog)
m_log << TestLog::Message << "glEGLImageTargetRenderbufferStorageOES(" << toHex(target) << ", " << image << ");" << TestLog::EndMessage;
m_gl.eglImageTargetRenderbufferStorageOES(target, image);
}
void CallLogWrapper::glEGLImageTargetTexture2DOES (glw::GLenum target, glw::GLeglImageOES image)
{
if (m_enableLog)
m_log << TestLog::Message << "glEGLImageTargetTexture2DOES(" << toHex(target) << ", " << image << ");" << TestLog::EndMessage;
m_gl.eglImageTargetTexture2DOES(target, image);
}
void CallLogWrapper::glEnable (glw::GLenum cap)
{
if (m_enableLog)
m_log << TestLog::Message << "glEnable(" << getEnableCapStr(cap) << ");" << TestLog::EndMessage;
m_gl.enable(cap);
}
void CallLogWrapper::glEnableClientStateIndexedEXT (glw::GLenum array, glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glEnableClientStateIndexedEXT(" << toHex(array) << ", " << index << ");" << TestLog::EndMessage;
m_gl.enableClientStateIndexedEXT(array, index);
}
void CallLogWrapper::glEnableClientStateiEXT (glw::GLenum array, glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glEnableClientStateiEXT(" << toHex(array) << ", " << index << ");" << TestLog::EndMessage;
m_gl.enableClientStateiEXT(array, index);
}
void CallLogWrapper::glEnableVertexArrayAttrib (glw::GLuint vaobj, glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glEnableVertexArrayAttrib(" << vaobj << ", " << index << ");" << TestLog::EndMessage;
m_gl.enableVertexArrayAttrib(vaobj, index);
}
void CallLogWrapper::glEnableVertexArrayAttribEXT (glw::GLuint vaobj, glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glEnableVertexArrayAttribEXT(" << vaobj << ", " << index << ");" << TestLog::EndMessage;
m_gl.enableVertexArrayAttribEXT(vaobj, index);
}
void CallLogWrapper::glEnableVertexArrayEXT (glw::GLuint vaobj, glw::GLenum array)
{
if (m_enableLog)
m_log << TestLog::Message << "glEnableVertexArrayEXT(" << vaobj << ", " << toHex(array) << ");" << TestLog::EndMessage;
m_gl.enableVertexArrayEXT(vaobj, array);
}
void CallLogWrapper::glEnableVertexAttribArray (glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glEnableVertexAttribArray(" << index << ");" << TestLog::EndMessage;
m_gl.enableVertexAttribArray(index);
}
void CallLogWrapper::glEnablei (glw::GLenum target, glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glEnablei(" << getIndexedEnableCapStr(target) << ", " << index << ");" << TestLog::EndMessage;
m_gl.enablei(target, index);
}
void CallLogWrapper::glEndConditionalRender (void)
{
if (m_enableLog)
m_log << TestLog::Message << "glEndConditionalRender(" << ");" << TestLog::EndMessage;
m_gl.endConditionalRender();
}
void CallLogWrapper::glEndQuery (glw::GLenum target)
{
if (m_enableLog)
m_log << TestLog::Message << "glEndQuery(" << getQueryTargetStr(target) << ");" << TestLog::EndMessage;
m_gl.endQuery(target);
}
void CallLogWrapper::glEndQueryIndexed (glw::GLenum target, glw::GLuint index)
{
if (m_enableLog)
m_log << TestLog::Message << "glEndQueryIndexed(" << toHex(target) << ", " << index << ");" << TestLog::EndMessage;
m_gl.endQueryIndexed(target, index);
}
void CallLogWrapper::glEndTransformFeedback (void)
{
if (m_enableLog)
m_log << TestLog::Message << "glEndTransformFeedback(" << ");" << TestLog::EndMessage;
m_gl.endTransformFeedback();
}
glw::GLsync CallLogWrapper::glFenceSync (glw::GLenum condition, glw::GLbitfield flags)
{
if (m_enableLog)
m_log << TestLog::Message << "glFenceSync(" << toHex(condition) << ", " << toHex(flags) << ");" << TestLog::EndMessage;
glw::GLsync returnValue = m_gl.fenceSync(condition, flags);
if (m_enableLog)
m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
return returnValue;
}
void CallLogWrapper::glFinish (void)
{
if (m_enableLog)
m_log << TestLog::Message << "glFinish(" << ");" << TestLog::EndMessage;
m_gl.finish();
}
void CallLogWrapper::glFlush (void)
{
if (m_enableLog)
m_log << TestLog::Message << "glFlush(" << ");" << TestLog::EndMessage;
m_gl.flush();
}
void CallLogWrapper::glFlushMappedBufferRange (glw::GLenum target, glw::GLintptr offset, glw::GLsizeiptr length)
{
if (m_enableLog)
m_log << TestLog::Message << "glFlushMappedBufferRange(" << getBufferTargetStr(target) << ", " << offset << ", " << length << ");" << TestLog::EndMessage;
m_gl.flushMappedBufferRange(target, offset, length);
}
void CallLogWrapper::glFlushMappedNamedBufferRange (glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr length)
{
if (m_enableLog)
m_log << TestLog::Message << "glFlushMappedNamedBufferRange(" << buffer << ", " << offset << ", " << length << ");" << TestLog::EndMessage;
m_gl.flushMappedNamedBufferRange(buffer, offset, length);
}
void CallLogWrapper::glFlushMappedNamedBufferRangeEXT (glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr length)
{
if (m_enableLog)
m_log << TestLog::Message << "glFlushMappedNamedBufferRangeEXT(" << buffer << ", " << offset << ", " << length << ");" << TestLog::EndMessage;
m_gl.flushMappedNamedBufferRangeEXT(buffer, offset, length);
}
void CallLogWrapper::glFramebufferDrawBufferEXT (glw::GLuint framebuffer, glw::GLenum mode)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferDrawBufferEXT(" << framebuffer << ", " << toHex(mode) << ");" << TestLog::EndMessage;
m_gl.framebufferDrawBufferEXT(framebuffer, mode);
}
void CallLogWrapper::glFramebufferDrawBuffersEXT (glw::GLuint framebuffer, glw::GLsizei n, const glw::GLenum *bufs)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferDrawBuffersEXT(" << framebuffer << ", " << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(bufs))) << ");" << TestLog::EndMessage;
m_gl.framebufferDrawBuffersEXT(framebuffer, n, bufs);
}
void CallLogWrapper::glFramebufferParameteri (glw::GLenum target, glw::GLenum pname, glw::GLint param)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferParameteri(" << getFramebufferTargetStr(target) << ", " << getFramebufferParameterStr(pname) << ", " << param << ");" << TestLog::EndMessage;
m_gl.framebufferParameteri(target, pname, param);
}
void CallLogWrapper::glFramebufferReadBufferEXT (glw::GLuint framebuffer, glw::GLenum mode)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferReadBufferEXT(" << framebuffer << ", " << toHex(mode) << ");" << TestLog::EndMessage;
m_gl.framebufferReadBufferEXT(framebuffer, mode);
}
void CallLogWrapper::glFramebufferRenderbuffer (glw::GLenum target, glw::GLenum attachment, glw::GLenum renderbuffertarget, glw::GLuint renderbuffer)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferRenderbuffer(" << getFramebufferTargetStr(target) << ", " << getFramebufferAttachmentStr(attachment) << ", " << getFramebufferTargetStr(renderbuffertarget) << ", " << renderbuffer << ");" << TestLog::EndMessage;
m_gl.framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
void CallLogWrapper::glFramebufferTexture (glw::GLenum target, glw::GLenum attachment, glw::GLuint texture, glw::GLint level)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferTexture(" << getFramebufferTargetStr(target) << ", " << getFramebufferAttachmentStr(attachment) << ", " << texture << ", " << level << ");" << TestLog::EndMessage;
m_gl.framebufferTexture(target, attachment, texture, level);
}
void CallLogWrapper::glFramebufferTexture1D (glw::GLenum target, glw::GLenum attachment, glw::GLenum textarget, glw::GLuint texture, glw::GLint level)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferTexture1D(" << toHex(target) << ", " << toHex(attachment) << ", " << toHex(textarget) << ", " << texture << ", " << level << ");" << TestLog::EndMessage;
m_gl.framebufferTexture1D(target, attachment, textarget, texture, level);
}
void CallLogWrapper::glFramebufferTexture2D (glw::GLenum target, glw::GLenum attachment, glw::GLenum textarget, glw::GLuint texture, glw::GLint level)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferTexture2D(" << getFramebufferTargetStr(target) << ", " << getFramebufferAttachmentStr(attachment) << ", " << getTextureTargetStr(textarget) << ", " << texture << ", " << level << ");" << TestLog::EndMessage;
m_gl.framebufferTexture2D(target, attachment, textarget, texture, level);
}
void CallLogWrapper::glFramebufferTexture3D (glw::GLenum target, glw::GLenum attachment, glw::GLenum textarget, glw::GLuint texture, glw::GLint level, glw::GLint zoffset)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferTexture3D(" << toHex(target) << ", " << toHex(attachment) << ", " << toHex(textarget) << ", " << texture << ", " << level << ", " << zoffset << ");" << TestLog::EndMessage;
m_gl.framebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
void CallLogWrapper::glFramebufferTexture3DOES (glw::GLenum target, glw::GLenum attachment, glw::GLenum textarget, glw::GLuint texture, glw::GLint level, glw::GLint zoffset)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferTexture3DOES(" << toHex(target) << ", " << toHex(attachment) << ", " << toHex(textarget) << ", " << texture << ", " << level << ", " << zoffset << ");" << TestLog::EndMessage;
m_gl.framebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset);
}
void CallLogWrapper::glFramebufferTextureLayer (glw::GLenum target, glw::GLenum attachment, glw::GLuint texture, glw::GLint level, glw::GLint layer)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferTextureLayer(" << getFramebufferTargetStr(target) << ", " << getFramebufferAttachmentStr(attachment) << ", " << texture << ", " << level << ", " << layer << ");" << TestLog::EndMessage;
m_gl.framebufferTextureLayer(target, attachment, texture, level, layer);
}
void CallLogWrapper::glFramebufferTextureMultisampleMultiviewOVR (glw::GLenum target, glw::GLenum attachment, glw::GLuint texture, glw::GLint level, glw::GLsizei samples, glw::GLint baseViewIndex, glw::GLsizei numViews)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferTextureMultisampleMultiviewOVR(" << toHex(target) << ", " << toHex(attachment) << ", " << texture << ", " << level << ", " << samples << ", " << baseViewIndex << ", " << numViews << ");" << TestLog::EndMessage;
m_gl.framebufferTextureMultisampleMultiviewOVR(target, attachment, texture, level, samples, baseViewIndex, numViews);
}
void CallLogWrapper::glFramebufferTextureMultiviewOVR (glw::GLenum target, glw::GLenum attachment, glw::GLuint texture, glw::GLint level, glw::GLint baseViewIndex, glw::GLsizei numViews)
{
if (m_enableLog)
m_log << TestLog::Message << "glFramebufferTextureMultiviewOVR(" << toHex(target) << ", " << toHex(attachment) << ", " << texture << ", " << level << ", " << baseViewIndex << ", " << numViews << ");" << TestLog::EndMessage;
m_gl.framebufferTextureMultiviewOVR(target, attachment, texture, level, baseViewIndex, numViews);
}
void CallLogWrapper::glFrontFace (glw::GLenum mode)
{
if (m_enableLog)
m_log << TestLog::Message << "glFrontFace(" << getWindingStr(mode) << ");" << TestLog::EndMessage;
m_gl.frontFace(mode);
}
void CallLogWrapper::glGenBuffers (glw::GLsizei n, glw::GLuint *buffers)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenBuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ");" << TestLog::EndMessage;
m_gl.genBuffers(n, buffers);
if (m_enableLog)
m_log << TestLog::Message << "// buffers = " << getPointerStr(buffers, n) << TestLog::EndMessage;
}
void CallLogWrapper::glGenFramebuffers (glw::GLsizei n, glw::GLuint *framebuffers)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenFramebuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(framebuffers))) << ");" << TestLog::EndMessage;
m_gl.genFramebuffers(n, framebuffers);
if (m_enableLog)
m_log << TestLog::Message << "// framebuffers = " << getPointerStr(framebuffers, n) << TestLog::EndMessage;
}
void CallLogWrapper::glGenProgramPipelines (glw::GLsizei n, glw::GLuint *pipelines)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenProgramPipelines(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(pipelines))) << ");" << TestLog::EndMessage;
m_gl.genProgramPipelines(n, pipelines);
if (m_enableLog)
m_log << TestLog::Message << "// pipelines = " << getPointerStr(pipelines, n) << TestLog::EndMessage;
}
void CallLogWrapper::glGenQueries (glw::GLsizei n, glw::GLuint *ids)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenQueries(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
m_gl.genQueries(n, ids);
if (m_enableLog)
m_log << TestLog::Message << "// ids = " << getPointerStr(ids, n) << TestLog::EndMessage;
}
void CallLogWrapper::glGenRenderbuffers (glw::GLsizei n, glw::GLuint *renderbuffers)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenRenderbuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(renderbuffers))) << ");" << TestLog::EndMessage;
m_gl.genRenderbuffers(n, renderbuffers);
if (m_enableLog)
m_log << TestLog::Message << "// renderbuffers = " << getPointerStr(renderbuffers, n) << TestLog::EndMessage;
}
void CallLogWrapper::glGenSamplers (glw::GLsizei count, glw::GLuint *samplers)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenSamplers(" << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(samplers))) << ");" << TestLog::EndMessage;
m_gl.genSamplers(count, samplers);
}
void CallLogWrapper::glGenTextures (glw::GLsizei n, glw::GLuint *textures)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenTextures(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(textures))) << ");" << TestLog::EndMessage;
m_gl.genTextures(n, textures);
if (m_enableLog)
m_log << TestLog::Message << "// textures = " << getPointerStr(textures, n) << TestLog::EndMessage;
}
void CallLogWrapper::glGenTransformFeedbacks (glw::GLsizei n, glw::GLuint *ids)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenTransformFeedbacks(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
m_gl.genTransformFeedbacks(n, ids);
if (m_enableLog)
m_log << TestLog::Message << "// ids = " << getPointerStr(ids, n) << TestLog::EndMessage;
}
void CallLogWrapper::glGenVertexArrays (glw::GLsizei n, glw::GLuint *arrays)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenVertexArrays(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(arrays))) << ");" << TestLog::EndMessage;
m_gl.genVertexArrays(n, arrays);
if (m_enableLog)
m_log << TestLog::Message << "// arrays = " << getPointerStr(arrays, n) << TestLog::EndMessage;
}
void CallLogWrapper::glGenerateMipmap (glw::GLenum target)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenerateMipmap(" << getTextureTargetStr(target) << ");" << TestLog::EndMessage;
m_gl.generateMipmap(target);
}
void CallLogWrapper::glGenerateMultiTexMipmapEXT (glw::GLenum texunit, glw::GLenum target)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenerateMultiTexMipmapEXT(" << toHex(texunit) << ", " << toHex(target) << ");" << TestLog::EndMessage;
m_gl.generateMultiTexMipmapEXT(texunit, target);
}
void CallLogWrapper::glGenerateTextureMipmap (glw::GLuint texture)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenerateTextureMipmap(" << texture << ");" << TestLog::EndMessage;
m_gl.generateTextureMipmap(texture);
}
void CallLogWrapper::glGenerateTextureMipmapEXT (glw::GLuint texture, glw::GLenum target)
{
if (m_enableLog)
m_log << TestLog::Message << "glGenerateTextureMipmapEXT(" << texture << ", " << toHex(target) << ");" << TestLog::EndMessage;
m_gl.generateTextureMipmapEXT(texture, target);
}
void CallLogWrapper::glGetActiveAtomicCounterBufferiv (glw::GLuint program, glw::GLuint bufferIndex, glw::GLenum pname, glw::GLint *params)
{
if (m_enableLog)
m_log << TestLog::Message << "glGetActiveAtomicCounterBufferiv(" << program << ", " << bufferIndex << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
m_gl.getActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
}
void CallLogWrapper::glGetActiveAttrib (glw::GLuint program, glw::GLuint index, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLint *size, glw::GLenum *type, glw::GLchar *name)
{
if (m_enableLog)
m_log << TestLog::Message << "glGetActiveAttrib(" << program << ", " << index << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(size))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(type))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(name))) << ");" << TestLog::EndMessage;
m_gl.getActiveAttrib(program, index, bufSize, length, size, type, name);
}
void CallLogWrapper::glGetActiveSubroutineName (glw::GLuint program, glw::GLenum shadertype, glw::GLuint index, glw::GLsizei bufsize, glw::GLsizei *length, glw::GLchar *name)
{
if (m_enableLog)
m_log << TestLog::Message << "glGetActiveSubroutineName(" << program << ", " << toHex(shadertype) << ", " << index << ", " << bufsize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(name))) << ");" << TestLog::EndMessage;
m_gl.getActiveSubroutineName(program, shadertype, index, bufsize, length, name);
}
void CallLogWrapper::glGetActiveSubroutineUniformName (glw::GLuint program, glw::GLenum shadertype, glw::GLuint index, glw::GLsizei bufsize, glw::GLsizei *length, glw::GLchar *name)
{
if (m_enableLog)
m_log << TestLog::Message << "glGetActiveSubroutineUniformName(" << program << ", " << toHex(shadertype) << ", " << index << ", " << bufsize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(name))) << ");" << TestLog::EndMessage;
m_gl.getActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
}
void CallLogWrapper::glGetActiveSubroutineUniformiv (glw::GLuint program, glw::GLenum shadertype, glw::GLuint index, glw::GLenum pname, glw::GLint *values)
{
if (m_enableLog)
m_log << TestLog::Message << "glGetActiveSubroutineUniformiv(" << program << ", " << toHex(shadertype) << ", " << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(