framework/opengl/gluCallLogWrapper.inl

   1 /* WARNING: This is auto-generated file. Do not modify, since changes will
   2  * be lost! Modify the generating script instead.
   3  *
   4  * Generated from Khronos GL API description (gl.xml) revision 30159.
   5  */
   6
   7 void CallLogWrapper::glActiveShaderProgram (glw::GLuint pipeline, glw::GLuint program)
   8 {
   9         if (m_enableLog)
  10                 m_log << TestLog::Message << "glActiveShaderProgram(" << pipeline << ", " << program << ");" << TestLog::EndMessage;
  11         m_gl.activeShaderProgram(pipeline, program);
  12 }
  13
  14 void CallLogWrapper::glActiveTexture (glw::GLenum texture)
  15 {
  16         if (m_enableLog)
  17                 m_log << TestLog::Message << "glActiveTexture(" << getTextureUnitStr(texture) << ");" << TestLog::EndMessage;
  18         m_gl.activeTexture(texture);
  19 }
  20
  21 void CallLogWrapper::glAttachShader (glw::GLuint program, glw::GLuint shader)
  22 {
  23         if (m_enableLog)
  24                 m_log << TestLog::Message << "glAttachShader(" << program << ", " << shader << ");" << TestLog::EndMessage;
  25         m_gl.attachShader(program, shader);
  26 }
  27
  28 void CallLogWrapper::glBeginConditionalRender (glw::GLuint id, glw::GLenum mode)
  29 {
  30         if (m_enableLog)
  31                 m_log << TestLog::Message << "glBeginConditionalRender(" << id << ", " << toHex(mode) << ");" << TestLog::EndMessage;
  32         m_gl.beginConditionalRender(id, mode);
  33 }
  34
  35 void CallLogWrapper::glBeginQuery (glw::GLenum target, glw::GLuint id)
  36 {
  37         if (m_enableLog)
  38                 m_log << TestLog::Message << "glBeginQuery(" << getQueryTargetStr(target) << ", " << id << ");" << TestLog::EndMessage;
  39         m_gl.beginQuery(target, id);
  40 }
  41
  42 void CallLogWrapper::glBeginQueryIndexed (glw::GLenum target, glw::GLuint index, glw::GLuint id)
  43 {
  44         if (m_enableLog)
  45                 m_log << TestLog::Message << "glBeginQueryIndexed(" << toHex(target) << ", " << index << ", " << id << ");" << TestLog::EndMessage;
  46         m_gl.beginQueryIndexed(target, index, id);
  47 }
  48
  49 void CallLogWrapper::glBeginTransformFeedback (glw::GLenum primitiveMode)
  50 {
  51         if (m_enableLog)
  52                 m_log << TestLog::Message << "glBeginTransformFeedback(" << getPrimitiveTypeStr(primitiveMode) << ");" << TestLog::EndMessage;
  53         m_gl.beginTransformFeedback(primitiveMode);
  54 }
  55
  56 void CallLogWrapper::glBindAttribLocation (glw::GLuint program, glw::GLuint index, const glw::GLchar *name)
  57 {
  58         if (m_enableLog)
  59                 m_log << TestLog::Message << "glBindAttribLocation(" << program << ", " << index << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
  60         m_gl.bindAttribLocation(program, index, name);
  61 }
  62
  63 void CallLogWrapper::glBindBuffer (glw::GLenum target, glw::GLuint buffer)
  64 {
  65         if (m_enableLog)
  66                 m_log << TestLog::Message << "glBindBuffer(" << getBufferTargetStr(target) << ", " << buffer << ");" << TestLog::EndMessage;
  67         m_gl.bindBuffer(target, buffer);
  68 }
  69
  70 void CallLogWrapper::glBindBufferBase (glw::GLenum target, glw::GLuint index, glw::GLuint buffer)
  71 {
  72         if (m_enableLog)
  73                 m_log << TestLog::Message << "glBindBufferBase(" << getBufferTargetStr(target) << ", " << index << ", " << buffer << ");" << TestLog::EndMessage;
  74         m_gl.bindBufferBase(target, index, buffer);
  75 }
  76
  77 void CallLogWrapper::glBindBufferRange (glw::GLenum target, glw::GLuint index, glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size)
  78 {
  79         if (m_enableLog)
  80                 m_log << TestLog::Message << "glBindBufferRange(" << getBufferTargetStr(target) << ", " << index << ", " << buffer << ", " << offset << ", " << size << ");" << TestLog::EndMessage;
  81         m_gl.bindBufferRange(target, index, buffer, offset, size);
  82 }
  83
  84 void CallLogWrapper::glBindBuffersBase (glw::GLenum target, glw::GLuint first, glw::GLsizei count, const glw::GLuint *buffers)
  85 {
  86         if (m_enableLog)
  87                 m_log << TestLog::Message << "glBindBuffersBase(" << toHex(target) << ", " << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ");" << TestLog::EndMessage;
  88         m_gl.bindBuffersBase(target, first, count, buffers);
  89 }
  90
  91 void CallLogWrapper::glBindBuffersRange (glw::GLenum target, glw::GLuint first, glw::GLsizei count, const glw::GLuint *buffers, const glw::GLintptr *offsets, const glw::GLsizeiptr *sizes)
  92 {
  93         if (m_enableLog)
  94                 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;
  95         m_gl.bindBuffersRange(target, first, count, buffers, offsets, sizes);
  96 }
  97
  98 void CallLogWrapper::glBindFragDataLocation (glw::GLuint program, glw::GLuint color, const glw::GLchar *name)
  99 {
 100         if (m_enableLog)
 101                 m_log << TestLog::Message << "glBindFragDataLocation(" << program << ", " << color << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
 102         m_gl.bindFragDataLocation(program, color, name);
 103 }
 104
 105 void CallLogWrapper::glBindFragDataLocationIndexed (glw::GLuint program, glw::GLuint colorNumber, glw::GLuint index, const glw::GLchar *name)
 106 {
 107         if (m_enableLog)
 108                 m_log << TestLog::Message << "glBindFragDataLocationIndexed(" << program << ", " << colorNumber << ", " << index << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
 109         m_gl.bindFragDataLocationIndexed(program, colorNumber, index, name);
 110 }
 111
 112 void CallLogWrapper::glBindFramebuffer (glw::GLenum target, glw::GLuint framebuffer)
 113 {
 114         if (m_enableLog)
 115                 m_log << TestLog::Message << "glBindFramebuffer(" << getFramebufferTargetStr(target) << ", " << framebuffer << ");" << TestLog::EndMessage;
 116         m_gl.bindFramebuffer(target, framebuffer);
 117 }
 118
 119 void CallLogWrapper::glBindImageTexture (glw::GLuint unit, glw::GLuint texture, glw::GLint level, glw::GLboolean layered, glw::GLint layer, glw::GLenum access, glw::GLenum format)
 120 {
 121         if (m_enableLog)
 122                 m_log << TestLog::Message << "glBindImageTexture(" << unit << ", " << texture << ", " << level << ", " << getBooleanStr(layered) << ", " << layer << ", " << getImageAccessStr(access) << ", " << getUncompressedTextureFormatStr(format) << ");" << TestLog::EndMessage;
 123         m_gl.bindImageTexture(unit, texture, level, layered, layer, access, format);
 124 }
 125
 126 void CallLogWrapper::glBindImageTextures (glw::GLuint first, glw::GLsizei count, const glw::GLuint *textures)
 127 {
 128         if (m_enableLog)
 129                 m_log << TestLog::Message << "glBindImageTextures(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(textures))) << ");" << TestLog::EndMessage;
 130         m_gl.bindImageTextures(first, count, textures);
 131 }
 132
 133 void CallLogWrapper::glBindProgramPipeline (glw::GLuint pipeline)
 134 {
 135         if (m_enableLog)
 136                 m_log << TestLog::Message << "glBindProgramPipeline(" << pipeline << ");" << TestLog::EndMessage;
 137         m_gl.bindProgramPipeline(pipeline);
 138 }
 139
 140 void CallLogWrapper::glBindRenderbuffer (glw::GLenum target, glw::GLuint renderbuffer)
 141 {
 142         if (m_enableLog)
 143                 m_log << TestLog::Message << "glBindRenderbuffer(" << getFramebufferTargetStr(target) << ", " << renderbuffer << ");" << TestLog::EndMessage;
 144         m_gl.bindRenderbuffer(target, renderbuffer);
 145 }
 146
 147 void CallLogWrapper::glBindSampler (glw::GLuint unit, glw::GLuint sampler)
 148 {
 149         if (m_enableLog)
 150                 m_log << TestLog::Message << "glBindSampler(" << unit << ", " << sampler << ");" << TestLog::EndMessage;
 151         m_gl.bindSampler(unit, sampler);
 152 }
 153
 154 void CallLogWrapper::glBindSamplers (glw::GLuint first, glw::GLsizei count, const glw::GLuint *samplers)
 155 {
 156         if (m_enableLog)
 157                 m_log << TestLog::Message << "glBindSamplers(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(samplers))) << ");" << TestLog::EndMessage;
 158         m_gl.bindSamplers(first, count, samplers);
 159 }
 160
 161 void CallLogWrapper::glBindTexture (glw::GLenum target, glw::GLuint texture)
 162 {
 163         if (m_enableLog)
 164                 m_log << TestLog::Message << "glBindTexture(" << getTextureTargetStr(target) << ", " << texture << ");" << TestLog::EndMessage;
 165         m_gl.bindTexture(target, texture);
 166 }
 167
 168 void CallLogWrapper::glBindTextureUnit (glw::GLuint unit, glw::GLuint texture)
 169 {
 170         if (m_enableLog)
 171                 m_log << TestLog::Message << "glBindTextureUnit(" << unit << ", " << texture << ");" << TestLog::EndMessage;
 172         m_gl.bindTextureUnit(unit, texture);
 173 }
 174
 175 void CallLogWrapper::glBindTextures (glw::GLuint first, glw::GLsizei count, const glw::GLuint *textures)
 176 {
 177         if (m_enableLog)
 178                 m_log << TestLog::Message << "glBindTextures(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(textures))) << ");" << TestLog::EndMessage;
 179         m_gl.bindTextures(first, count, textures);
 180 }
 181
 182 void CallLogWrapper::glBindTransformFeedback (glw::GLenum target, glw::GLuint id)
 183 {
 184         if (m_enableLog)
 185                 m_log << TestLog::Message << "glBindTransformFeedback(" << getTransformFeedbackTargetStr(target) << ", " << id << ");" << TestLog::EndMessage;
 186         m_gl.bindTransformFeedback(target, id);
 187 }
 188
 189 void CallLogWrapper::glBindVertexArray (glw::GLuint array)
 190 {
 191         if (m_enableLog)
 192                 m_log << TestLog::Message << "glBindVertexArray(" << array << ");" << TestLog::EndMessage;
 193         m_gl.bindVertexArray(array);
 194 }
 195
 196 void CallLogWrapper::glBindVertexBuffer (glw::GLuint bindingindex, glw::GLuint buffer, glw::GLintptr offset, glw::GLsizei stride)
 197 {
 198         if (m_enableLog)
 199                 m_log << TestLog::Message << "glBindVertexBuffer(" << bindingindex << ", " << buffer << ", " << offset << ", " << stride << ");" << TestLog::EndMessage;
 200         m_gl.bindVertexBuffer(bindingindex, buffer, offset, stride);
 201 }
 202
 203 void CallLogWrapper::glBindVertexBuffers (glw::GLuint first, glw::GLsizei count, const glw::GLuint *buffers, const glw::GLintptr *offsets, const glw::GLsizei *strides)
 204 {
 205         if (m_enableLog)
 206                 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;
 207         m_gl.bindVertexBuffers(first, count, buffers, offsets, strides);
 208 }
 209
 210 void CallLogWrapper::glBlendBarrierKHR (void)
 211 {
 212         if (m_enableLog)
 213                 m_log << TestLog::Message << "glBlendBarrierKHR(" << ");" << TestLog::EndMessage;
 214         m_gl.blendBarrierKHR();
 215 }
 216
 217 void CallLogWrapper::glBlendColor (glw::GLfloat red, glw::GLfloat green, glw::GLfloat blue, glw::GLfloat alpha)
 218 {
 219         if (m_enableLog)
 220                 m_log << TestLog::Message << "glBlendColor(" << red << ", " << green << ", " << blue << ", " << alpha << ");" << TestLog::EndMessage;
 221         m_gl.blendColor(red, green, blue, alpha);
 222 }
 223
 224 void CallLogWrapper::glBlendEquation (glw::GLenum mode)
 225 {
 226         if (m_enableLog)
 227                 m_log << TestLog::Message << "glBlendEquation(" << getBlendEquationStr(mode) << ");" << TestLog::EndMessage;
 228         m_gl.blendEquation(mode);
 229 }
 230
 231 void CallLogWrapper::glBlendEquationSeparate (glw::GLenum modeRGB, glw::GLenum modeAlpha)
 232 {
 233         if (m_enableLog)
 234                 m_log << TestLog::Message << "glBlendEquationSeparate(" << getBlendEquationStr(modeRGB) << ", " << getBlendEquationStr(modeAlpha) << ");" << TestLog::EndMessage;
 235         m_gl.blendEquationSeparate(modeRGB, modeAlpha);
 236 }
 237
 238 void CallLogWrapper::glBlendEquationSeparatei (glw::GLuint buf, glw::GLenum modeRGB, glw::GLenum modeAlpha)
 239 {
 240         if (m_enableLog)
 241                 m_log << TestLog::Message << "glBlendEquationSeparatei(" << buf << ", " << getBlendEquationStr(modeRGB) << ", " << getBlendEquationStr(modeAlpha) << ");" << TestLog::EndMessage;
 242         m_gl.blendEquationSeparatei(buf, modeRGB, modeAlpha);
 243 }
 244
 245 void CallLogWrapper::glBlendEquationi (glw::GLuint buf, glw::GLenum mode)
 246 {
 247         if (m_enableLog)
 248                 m_log << TestLog::Message << "glBlendEquationi(" << buf << ", " << getBlendEquationStr(mode) << ");" << TestLog::EndMessage;
 249         m_gl.blendEquationi(buf, mode);
 250 }
 251
 252 void CallLogWrapper::glBlendFunc (glw::GLenum sfactor, glw::GLenum dfactor)
 253 {
 254         if (m_enableLog)
 255                 m_log << TestLog::Message << "glBlendFunc(" << getBlendFactorStr(sfactor) << ", " << getBlendFactorStr(dfactor) << ");" << TestLog::EndMessage;
 256         m_gl.blendFunc(sfactor, dfactor);
 257 }
 258
 259 void CallLogWrapper::glBlendFuncSeparate (glw::GLenum sfactorRGB, glw::GLenum dfactorRGB, glw::GLenum sfactorAlpha, glw::GLenum dfactorAlpha)
 260 {
 261         if (m_enableLog)
 262                 m_log << TestLog::Message << "glBlendFuncSeparate(" << getBlendFactorStr(sfactorRGB) << ", " << getBlendFactorStr(dfactorRGB) << ", " << getBlendFactorStr(sfactorAlpha) << ", " << getBlendFactorStr(dfactorAlpha) << ");" << TestLog::EndMessage;
 263         m_gl.blendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 264 }
 265
 266 void CallLogWrapper::glBlendFuncSeparatei (glw::GLuint buf, glw::GLenum srcRGB, glw::GLenum dstRGB, glw::GLenum srcAlpha, glw::GLenum dstAlpha)
 267 {
 268         if (m_enableLog)
 269                 m_log << TestLog::Message << "glBlendFuncSeparatei(" << buf << ", " << toHex(srcRGB) << ", " << toHex(dstRGB) << ", " << toHex(srcAlpha) << ", " << toHex(dstAlpha) << ");" << TestLog::EndMessage;
 270         m_gl.blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 271 }
 272
 273 void CallLogWrapper::glBlendFunci (glw::GLuint buf, glw::GLenum src, glw::GLenum dst)
 274 {
 275         if (m_enableLog)
 276                 m_log << TestLog::Message << "glBlendFunci(" << buf << ", " << toHex(src) << ", " << toHex(dst) << ");" << TestLog::EndMessage;
 277         m_gl.blendFunci(buf, src, dst);
 278 }
 279
 280 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)
 281 {
 282         if (m_enableLog)
 283                 m_log << TestLog::Message << "glBlitFramebuffer(" << srcX0 << ", " << srcY0 << ", " << srcX1 << ", " << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1 << ", " << dstY1 << ", " << getBufferMaskStr(mask) << ", " << getTextureFilterStr(filter) << ");" << TestLog::EndMessage;
 284         m_gl.blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 285 }
 286
 287 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)
 288 {
 289         if (m_enableLog)
 290                 m_log << TestLog::Message << "glBlitNamedFramebuffer(" << readFramebuffer << ", " << drawFramebuffer << ", " << srcX0 << ", " << srcY0 << ", " << srcX1 << ", " << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1 << ", " << dstY1 << ", " << toHex(mask) << ", " << toHex(filter) << ");" << TestLog::EndMessage;
 291         m_gl.blitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 292 }
 293
 294 void CallLogWrapper::glBufferData (glw::GLenum target, glw::GLsizeiptr size, const void *data, glw::GLenum usage)
 295 {
 296         if (m_enableLog)
 297                 m_log << TestLog::Message << "glBufferData(" << getBufferTargetStr(target) << ", " << size << ", " << data << ", " << getUsageStr(usage) << ");" << TestLog::EndMessage;
 298         m_gl.bufferData(target, size, data, usage);
 299 }
 300
 301 void CallLogWrapper::glBufferStorage (glw::GLenum target, glw::GLsizeiptr size, const void *data, glw::GLbitfield flags)
 302 {
 303         if (m_enableLog)
 304                 m_log << TestLog::Message << "glBufferStorage(" << toHex(target) << ", " << size << ", " << data << ", " << toHex(flags) << ");" << TestLog::EndMessage;
 305         m_gl.bufferStorage(target, size, data, flags);
 306 }
 307
 308 void CallLogWrapper::glBufferSubData (glw::GLenum target, glw::GLintptr offset, glw::GLsizeiptr size, const void *data)
 309 {
 310         if (m_enableLog)
 311                 m_log << TestLog::Message << "glBufferSubData(" << getBufferTargetStr(target) << ", " << offset << ", " << size << ", " << data << ");" << TestLog::EndMessage;
 312         m_gl.bufferSubData(target, offset, size, data);
 313 }
 314
 315 glw::GLenum CallLogWrapper::glCheckFramebufferStatus (glw::GLenum target)
 316 {
 317         if (m_enableLog)
 318                 m_log << TestLog::Message << "glCheckFramebufferStatus(" << getFramebufferTargetStr(target) << ");" << TestLog::EndMessage;
 319         glw::GLenum returnValue = m_gl.checkFramebufferStatus(target);
 320         if (m_enableLog)
 321                 m_log << TestLog::Message << "// " << getFramebufferStatusStr(returnValue) << " returned" << TestLog::EndMessage;
 322         return returnValue;
 323 }
 324
 325 glw::GLenum CallLogWrapper::glCheckNamedFramebufferStatus (glw::GLuint framebuffer, glw::GLenum target)
 326 {
 327         if (m_enableLog)
 328                 m_log << TestLog::Message << "glCheckNamedFramebufferStatus(" << framebuffer << ", " << toHex(target) << ");" << TestLog::EndMessage;
 329         glw::GLenum returnValue = m_gl.checkNamedFramebufferStatus(framebuffer, target);
 330         if (m_enableLog)
 331                 m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
 332         return returnValue;
 333 }
 334
 335 void CallLogWrapper::glClampColor (glw::GLenum target, glw::GLenum clamp)
 336 {
 337         if (m_enableLog)
 338                 m_log << TestLog::Message << "glClampColor(" << toHex(target) << ", " << toHex(clamp) << ");" << TestLog::EndMessage;
 339         m_gl.clampColor(target, clamp);
 340 }
 341
 342 void CallLogWrapper::glClear (glw::GLbitfield mask)
 343 {
 344         if (m_enableLog)
 345                 m_log << TestLog::Message << "glClear(" << getBufferMaskStr(mask) << ");" << TestLog::EndMessage;
 346         m_gl.clear(mask);
 347 }
 348
 349 void CallLogWrapper::glClearBufferData (glw::GLenum target, glw::GLenum internalformat, glw::GLenum format, glw::GLenum type, const void *data)
 350 {
 351         if (m_enableLog)
 352                 m_log << TestLog::Message << "glClearBufferData(" << toHex(target) << ", " << toHex(internalformat) << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
 353         m_gl.clearBufferData(target, internalformat, format, type, data);
 354 }
 355
 356 void CallLogWrapper::glClearBufferSubData (glw::GLenum target, glw::GLenum internalformat, glw::GLintptr offset, glw::GLsizeiptr size, glw::GLenum format, glw::GLenum type, const void *data)
 357 {
 358         if (m_enableLog)
 359                 m_log << TestLog::Message << "glClearBufferSubData(" << toHex(target) << ", " << toHex(internalformat) << ", " << offset << ", " << size << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
 360         m_gl.clearBufferSubData(target, internalformat, offset, size, format, type, data);
 361 }
 362
 363 void CallLogWrapper::glClearBufferfi (glw::GLenum buffer, glw::GLint drawbuffer, glw::GLfloat depth, glw::GLint stencil)
 364 {
 365         if (m_enableLog)
 366                 m_log << TestLog::Message << "glClearBufferfi(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << depth << ", " << stencil << ");" << TestLog::EndMessage;
 367         m_gl.clearBufferfi(buffer, drawbuffer, depth, stencil);
 368 }
 369
 370 void CallLogWrapper::glClearBufferfv (glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLfloat *value)
 371 {
 372         if (m_enableLog)
 373                 m_log << TestLog::Message << "glClearBufferfv(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
 374         m_gl.clearBufferfv(buffer, drawbuffer, value);
 375 }
 376
 377 void CallLogWrapper::glClearBufferiv (glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLint *value)
 378 {
 379         if (m_enableLog)
 380                 m_log << TestLog::Message << "glClearBufferiv(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
 381         m_gl.clearBufferiv(buffer, drawbuffer, value);
 382 }
 383
 384 void CallLogWrapper::glClearBufferuiv (glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLuint *value)
 385 {
 386         if (m_enableLog)
 387                 m_log << TestLog::Message << "glClearBufferuiv(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
 388         m_gl.clearBufferuiv(buffer, drawbuffer, value);
 389 }
 390
 391 void CallLogWrapper::glClearColor (glw::GLfloat red, glw::GLfloat green, glw::GLfloat blue, glw::GLfloat alpha)
 392 {
 393         if (m_enableLog)
 394                 m_log << TestLog::Message << "glClearColor(" << red << ", " << green << ", " << blue << ", " << alpha << ");" << TestLog::EndMessage;
 395         m_gl.clearColor(red, green, blue, alpha);
 396 }
 397
 398 void CallLogWrapper::glClearDepth (glw::GLdouble depth)
 399 {
 400         if (m_enableLog)
 401                 m_log << TestLog::Message << "glClearDepth(" << depth << ");" << TestLog::EndMessage;
 402         m_gl.clearDepth(depth);
 403 }
 404
 405 void CallLogWrapper::glClearDepthf (glw::GLfloat d)
 406 {
 407         if (m_enableLog)
 408                 m_log << TestLog::Message << "glClearDepthf(" << d << ");" << TestLog::EndMessage;
 409         m_gl.clearDepthf(d);
 410 }
 411
 412 void CallLogWrapper::glClearNamedBufferData (glw::GLuint buffer, glw::GLenum internalformat, glw::GLenum format, glw::GLenum type, const void *data)
 413 {
 414         if (m_enableLog)
 415                 m_log << TestLog::Message << "glClearNamedBufferData(" << buffer << ", " << toHex(internalformat) << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
 416         m_gl.clearNamedBufferData(buffer, internalformat, format, type, data);
 417 }
 418
 419 void CallLogWrapper::glClearNamedBufferSubData (glw::GLuint buffer, glw::GLenum internalformat, glw::GLintptr offset, glw::GLsizeiptr size, glw::GLenum format, glw::GLenum type, const void *data)
 420 {
 421         if (m_enableLog)
 422                 m_log << TestLog::Message << "glClearNamedBufferSubData(" << buffer << ", " << toHex(internalformat) << ", " << offset << ", " << size << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
 423         m_gl.clearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
 424 }
 425
 426 void CallLogWrapper::glClearNamedFramebufferfi (glw::GLuint framebuffer, glw::GLenum buffer, const glw::GLfloat depth, glw::GLint stencil)
 427 {
 428         if (m_enableLog)
 429                 m_log << TestLog::Message << "glClearNamedFramebufferfi(" << framebuffer << ", " << toHex(buffer) << ", " << depth << ", " << stencil << ");" << TestLog::EndMessage;
 430         m_gl.clearNamedFramebufferfi(framebuffer, buffer, depth, stencil);
 431 }
 432
 433 void CallLogWrapper::glClearNamedFramebufferfv (glw::GLuint framebuffer, glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLfloat *value)
 434 {
 435         if (m_enableLog)
 436                 m_log << TestLog::Message << "glClearNamedFramebufferfv(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
 437         m_gl.clearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
 438 }
 439
 440 void CallLogWrapper::glClearNamedFramebufferiv (glw::GLuint framebuffer, glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLint *value)
 441 {
 442         if (m_enableLog)
 443                 m_log << TestLog::Message << "glClearNamedFramebufferiv(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
 444         m_gl.clearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
 445 }
 446
 447 void CallLogWrapper::glClearNamedFramebufferuiv (glw::GLuint framebuffer, glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLuint *value)
 448 {
 449         if (m_enableLog)
 450                 m_log << TestLog::Message << "glClearNamedFramebufferuiv(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
 451         m_gl.clearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
 452 }
 453
 454 void CallLogWrapper::glClearStencil (glw::GLint s)
 455 {
 456         if (m_enableLog)
 457                 m_log << TestLog::Message << "glClearStencil(" << s << ");" << TestLog::EndMessage;
 458         m_gl.clearStencil(s);
 459 }
 460
 461 void CallLogWrapper::glClearTexImage (glw::GLuint texture, glw::GLint level, glw::GLenum format, glw::GLenum type, const void *data)
 462 {
 463         if (m_enableLog)
 464                 m_log << TestLog::Message << "glClearTexImage(" << texture << ", " << level << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
 465         m_gl.clearTexImage(texture, level, format, type, data);
 466 }
 467
 468 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)
 469 {
 470         if (m_enableLog)
 471                 m_log << TestLog::Message << "glClearTexSubImage(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << toHex(format) << ", " << toHex(type) << ", " << data << ");" << TestLog::EndMessage;
 472         m_gl.clearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
 473 }
 474
 475 glw::GLenum CallLogWrapper::glClientWaitSync (glw::GLsync sync, glw::GLbitfield flags, glw::GLuint64 timeout)
 476 {
 477         if (m_enableLog)
 478                 m_log << TestLog::Message << "glClientWaitSync(" << sync << ", " << toHex(flags) << ", " << timeout << ");" << TestLog::EndMessage;
 479         glw::GLenum returnValue = m_gl.clientWaitSync(sync, flags, timeout);
 480         if (m_enableLog)
 481                 m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
 482         return returnValue;
 483 }
 484
 485 void CallLogWrapper::glClipControl (glw::GLenum origin, glw::GLenum depth)
 486 {
 487         if (m_enableLog)
 488                 m_log << TestLog::Message << "glClipControl(" << toHex(origin) << ", " << toHex(depth) << ");" << TestLog::EndMessage;
 489         m_gl.clipControl(origin, depth);
 490 }
 491
 492 void CallLogWrapper::glColorMask (glw::GLboolean red, glw::GLboolean green, glw::GLboolean blue, glw::GLboolean alpha)
 493 {
 494         if (m_enableLog)
 495                 m_log << TestLog::Message << "glColorMask(" << getBooleanStr(red) << ", " << getBooleanStr(green) << ", " << getBooleanStr(blue) << ", " << getBooleanStr(alpha) << ");" << TestLog::EndMessage;
 496         m_gl.colorMask(red, green, blue, alpha);
 497 }
 498
 499 void CallLogWrapper::glColorMaski (glw::GLuint index, glw::GLboolean r, glw::GLboolean g, glw::GLboolean b, glw::GLboolean a)
 500 {
 501         if (m_enableLog)
 502                 m_log << TestLog::Message << "glColorMaski(" << index << ", " << getBooleanStr(r) << ", " << getBooleanStr(g) << ", " << getBooleanStr(b) << ", " << getBooleanStr(a) << ");" << TestLog::EndMessage;
 503         m_gl.colorMaski(index, r, g, b, a);
 504 }
 505
 506 void CallLogWrapper::glCompileShader (glw::GLuint shader)
 507 {
 508         if (m_enableLog)
 509                 m_log << TestLog::Message << "glCompileShader(" << shader << ");" << TestLog::EndMessage;
 510         m_gl.compileShader(shader);
 511 }
 512
 513 void CallLogWrapper::glCompressedTexImage1D (glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLsizei width, glw::GLint border, glw::GLsizei imageSize, const void *data)
 514 {
 515         if (m_enableLog)
 516                 m_log << TestLog::Message << "glCompressedTexImage1D(" << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << width << ", " << border << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
 517         m_gl.compressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 518 }
 519
 520 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)
 521 {
 522         if (m_enableLog)
 523                 m_log << TestLog::Message << "glCompressedTexImage2D(" << getTextureTargetStr(target) << ", " << level << ", " << getCompressedTextureFormatStr(internalformat) << ", " << width << ", " << height << ", " << border << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
 524         m_gl.compressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 525 }
 526
 527 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)
 528 {
 529         if (m_enableLog)
 530                 m_log << TestLog::Message << "glCompressedTexImage3D(" << getTextureTargetStr(target) << ", " << level << ", " << getCompressedTextureFormatStr(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << border << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
 531         m_gl.compressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 532 }
 533
 534 void CallLogWrapper::glCompressedTexSubImage1D (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLsizei width, glw::GLenum format, glw::GLsizei imageSize, const void *data)
 535 {
 536         if (m_enableLog)
 537                 m_log << TestLog::Message << "glCompressedTexSubImage1D(" << toHex(target) << ", " << level << ", " << xoffset << ", " << width << ", " << toHex(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
 538         m_gl.compressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 539 }
 540
 541 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)
 542 {
 543         if (m_enableLog)
 544                 m_log << TestLog::Message << "glCompressedTexSubImage2D(" << getTextureTargetStr(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height << ", " << getCompressedTextureFormatStr(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
 545         m_gl.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 546 }
 547
 548 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)
 549 {
 550         if (m_enableLog)
 551                 m_log << TestLog::Message << "glCompressedTexSubImage3D(" << getTextureTargetStr(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << getCompressedTextureFormatStr(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
 552         m_gl.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 553 }
 554
 555 void CallLogWrapper::glCompressedTextureSubImage1D (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLsizei width, glw::GLenum format, glw::GLsizei imageSize, const void *data)
 556 {
 557         if (m_enableLog)
 558                 m_log << TestLog::Message << "glCompressedTextureSubImage1D(" << texture << ", " << level << ", " << xoffset << ", " << width << ", " << toHex(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
 559         m_gl.compressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
 560 }
 561
 562 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)
 563 {
 564         if (m_enableLog)
 565                 m_log << TestLog::Message << "glCompressedTextureSubImage2D(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height << ", " << toHex(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
 566         m_gl.compressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
 567 }
 568
 569 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)
 570 {
 571         if (m_enableLog)
 572                 m_log << TestLog::Message << "glCompressedTextureSubImage3D(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << toHex(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
 573         m_gl.compressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 574 }
 575
 576 void CallLogWrapper::glCopyBufferSubData (glw::GLenum readTarget, glw::GLenum writeTarget, glw::GLintptr readOffset, glw::GLintptr writeOffset, glw::GLsizeiptr size)
 577 {
 578         if (m_enableLog)
 579                 m_log << TestLog::Message << "glCopyBufferSubData(" << toHex(readTarget) << ", " << toHex(writeTarget) << ", " << readOffset << ", " << writeOffset << ", " << size << ");" << TestLog::EndMessage;
 580         m_gl.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 581 }
 582
 583 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)
 584 {
 585         if (m_enableLog)
 586                 m_log << TestLog::Message << "glCopyImageSubData(" << srcName << ", " << toHex(srcTarget) << ", " << srcLevel << ", " << srcX << ", " << srcY << ", " << srcZ << ", " << dstName << ", " << toHex(dstTarget) << ", " << dstLevel << ", " << dstX << ", " << dstY << ", " << dstZ << ", " << srcWidth << ", " << srcHeight << ", " << srcDepth << ");" << TestLog::EndMessage;
 587         m_gl.copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
 588 }
 589
 590 void CallLogWrapper::glCopyNamedBufferSubData (glw::GLuint readBuffer, glw::GLuint writeBuffer, glw::GLintptr readOffset, glw::GLintptr writeOffset, glw::GLsizeiptr size)
 591 {
 592         if (m_enableLog)
 593                 m_log << TestLog::Message << "glCopyNamedBufferSubData(" << readBuffer << ", " << writeBuffer << ", " << readOffset << ", " << writeOffset << ", " << size << ");" << TestLog::EndMessage;
 594         m_gl.copyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
 595 }
 596
 597 void CallLogWrapper::glCopyTexImage1D (glw::GLenum target, glw::GLint level, glw::GLenum internalformat, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLint border)
 598 {
 599         if (m_enableLog)
 600                 m_log << TestLog::Message << "glCopyTexImage1D(" << getTextureTargetStr(target) << ", " << level << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << x << ", " << y << ", " << width << ", " << border << ");" << TestLog::EndMessage;
 601         m_gl.copyTexImage1D(target, level, internalformat, x, y, width, border);
 602 }
 603
 604 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)
 605 {
 606         if (m_enableLog)
 607                 m_log << TestLog::Message << "glCopyTexImage2D(" << getTextureTargetStr(target) << ", " << level << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << x << ", " << y << ", " << width << ", " << height << ", " << border << ");" << TestLog::EndMessage;
 608         m_gl.copyTexImage2D(target, level, internalformat, x, y, width, height, border);
 609 }
 610
 611 void CallLogWrapper::glCopyTexSubImage1D (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint x, glw::GLint y, glw::GLsizei width)
 612 {
 613         if (m_enableLog)
 614                 m_log << TestLog::Message << "glCopyTexSubImage1D(" << toHex(target) << ", " << level << ", " << xoffset << ", " << x << ", " << y << ", " << width << ");" << TestLog::EndMessage;
 615         m_gl.copyTexSubImage1D(target, level, xoffset, x, y, width);
 616 }
 617
 618 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)
 619 {
 620         if (m_enableLog)
 621                 m_log << TestLog::Message << "glCopyTexSubImage2D(" << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
 622         m_gl.copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 623 }
 624
 625 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)
 626 {
 627         if (m_enableLog)
 628                 m_log << TestLog::Message << "glCopyTexSubImage3D(" << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
 629         m_gl.copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 630 }
 631
 632 void CallLogWrapper::glCopyTextureSubImage1D (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLint x, glw::GLint y, glw::GLsizei width)
 633 {
 634         if (m_enableLog)
 635                 m_log << TestLog::Message << "glCopyTextureSubImage1D(" << texture << ", " << level << ", " << xoffset << ", " << x << ", " << y << ", " << width << ");" << TestLog::EndMessage;
 636         m_gl.copyTextureSubImage1D(texture, level, xoffset, x, y, width);
 637 }
 638
 639 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)
 640 {
 641         if (m_enableLog)
 642                 m_log << TestLog::Message << "glCopyTextureSubImage2D(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
 643         m_gl.copyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
 644 }
 645
 646 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)
 647 {
 648         if (m_enableLog)
 649                 m_log << TestLog::Message << "glCopyTextureSubImage3D(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
 650         m_gl.copyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
 651 }
 652
 653 void CallLogWrapper::glCreateBuffers (glw::GLsizei n, glw::GLuint *buffers)
 654 {
 655         if (m_enableLog)
 656                 m_log << TestLog::Message << "glCreateBuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ");" << TestLog::EndMessage;
 657         m_gl.createBuffers(n, buffers);
 658 }
 659
 660 void CallLogWrapper::glCreateFramebuffers (glw::GLsizei n, glw::GLuint *framebuffers)
 661 {
 662         if (m_enableLog)
 663                 m_log << TestLog::Message << "glCreateFramebuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(framebuffers))) << ");" << TestLog::EndMessage;
 664         m_gl.createFramebuffers(n, framebuffers);
 665 }
 666
 667 glw::GLuint CallLogWrapper::glCreateProgram (void)
 668 {
 669         if (m_enableLog)
 670                 m_log << TestLog::Message << "glCreateProgram(" << ");" << TestLog::EndMessage;
 671         glw::GLuint returnValue = m_gl.createProgram();
 672         if (m_enableLog)
 673                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
 674         return returnValue;
 675 }
 676
 677 void CallLogWrapper::glCreateProgramPipelines (glw::GLsizei n, glw::GLuint *pipelines)
 678 {
 679         if (m_enableLog)
 680                 m_log << TestLog::Message << "glCreateProgramPipelines(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(pipelines))) << ");" << TestLog::EndMessage;
 681         m_gl.createProgramPipelines(n, pipelines);
 682 }
 683
 684 void CallLogWrapper::glCreateQueries (glw::GLenum target, glw::GLsizei n, glw::GLuint *ids)
 685 {
 686         if (m_enableLog)
 687                 m_log << TestLog::Message << "glCreateQueries(" << toHex(target) << ", " << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
 688         m_gl.createQueries(target, n, ids);
 689 }
 690
 691 void CallLogWrapper::glCreateRenderbuffers (glw::GLsizei n, glw::GLuint *renderbuffers)
 692 {
 693         if (m_enableLog)
 694                 m_log << TestLog::Message << "glCreateRenderbuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(renderbuffers))) << ");" << TestLog::EndMessage;
 695         m_gl.createRenderbuffers(n, renderbuffers);
 696 }
 697
 698 void CallLogWrapper::glCreateSamplers (glw::GLsizei n, glw::GLuint *samplers)
 699 {
 700         if (m_enableLog)
 701                 m_log << TestLog::Message << "glCreateSamplers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(samplers))) << ");" << TestLog::EndMessage;
 702         m_gl.createSamplers(n, samplers);
 703 }
 704
 705 glw::GLuint CallLogWrapper::glCreateShader (glw::GLenum type)
 706 {
 707         if (m_enableLog)
 708                 m_log << TestLog::Message << "glCreateShader(" << getShaderTypeStr(type) << ");" << TestLog::EndMessage;
 709         glw::GLuint returnValue = m_gl.createShader(type);
 710         if (m_enableLog)
 711                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
 712         return returnValue;
 713 }
 714
 715 glw::GLuint CallLogWrapper::glCreateShaderProgramv (glw::GLenum type, glw::GLsizei count, const glw::GLchar *const*strings)
 716 {
 717         if (m_enableLog)
 718                 m_log << TestLog::Message << "glCreateShaderProgramv(" << toHex(type) << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(strings))) << ");" << TestLog::EndMessage;
 719         glw::GLuint returnValue = m_gl.createShaderProgramv(type, count, strings);
 720         if (m_enableLog)
 721                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
 722         return returnValue;
 723 }
 724
 725 void CallLogWrapper::glCreateTextures (glw::GLenum target, glw::GLsizei n, glw::GLuint *textures)
 726 {
 727         if (m_enableLog)
 728                 m_log << TestLog::Message << "glCreateTextures(" << toHex(target) << ", " << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(textures))) << ");" << TestLog::EndMessage;
 729         m_gl.createTextures(target, n, textures);
 730 }
 731
 732 void CallLogWrapper::glCreateTransformFeedbacks (glw::GLsizei n, glw::GLuint *ids)
 733 {
 734         if (m_enableLog)
 735                 m_log << TestLog::Message << "glCreateTransformFeedbacks(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
 736         m_gl.createTransformFeedbacks(n, ids);
 737 }
 738
 739 void CallLogWrapper::glCreateVertexArrays (glw::GLsizei n, glw::GLuint *arrays)
 740 {
 741         if (m_enableLog)
 742                 m_log << TestLog::Message << "glCreateVertexArrays(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(arrays))) << ");" << TestLog::EndMessage;
 743         m_gl.createVertexArrays(n, arrays);
 744 }
 745
 746 void CallLogWrapper::glCullFace (glw::GLenum mode)
 747 {
 748         if (m_enableLog)
 749                 m_log << TestLog::Message << "glCullFace(" << getFaceStr(mode) << ");" << TestLog::EndMessage;
 750         m_gl.cullFace(mode);
 751 }
 752
 753 void CallLogWrapper::glDebugMessageCallback (glw::GLDEBUGPROC callback, const void *userParam)
 754 {
 755         if (m_enableLog)
 756                 m_log << TestLog::Message << "glDebugMessageCallback(" << toHex(reinterpret_cast<deUintptr>(callback)) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(userParam))) << ");" << TestLog::EndMessage;
 757         m_gl.debugMessageCallback(callback, userParam);
 758 }
 759
 760 void CallLogWrapper::glDebugMessageControl (glw::GLenum source, glw::GLenum type, glw::GLenum severity, glw::GLsizei count, const glw::GLuint *ids, glw::GLboolean enabled)
 761 {
 762         if (m_enableLog)
 763                 m_log << TestLog::Message << "glDebugMessageControl(" << getDebugMessageSourceStr(source) << ", " << getDebugMessageTypeStr(type) << ", " << getDebugMessageSeverityStr(severity) << ", " << count << ", " << getPointerStr(ids, (count)) << ", " << getBooleanStr(enabled) << ");" << TestLog::EndMessage;
 764         m_gl.debugMessageControl(source, type, severity, count, ids, enabled);
 765 }
 766
 767 void CallLogWrapper::glDebugMessageInsert (glw::GLenum source, glw::GLenum type, glw::GLuint id, glw::GLenum severity, glw::GLsizei length, const glw::GLchar *buf)
 768 {
 769         if (m_enableLog)
 770                 m_log << TestLog::Message << "glDebugMessageInsert(" << getDebugMessageSourceStr(source) << ", " << getDebugMessageTypeStr(type) << ", " << id << ", " << getDebugMessageSeverityStr(severity) << ", " << length << ", " << getStringStr(buf) << ");" << TestLog::EndMessage;
 771         m_gl.debugMessageInsert(source, type, id, severity, length, buf);
 772 }
 773
 774 void CallLogWrapper::glDeleteBuffers (glw::GLsizei n, const glw::GLuint *buffers)
 775 {
 776         if (m_enableLog)
 777                 m_log << TestLog::Message << "glDeleteBuffers(" << n << ", " << getPointerStr(buffers, n) << ");" << TestLog::EndMessage;
 778         m_gl.deleteBuffers(n, buffers);
 779 }
 780
 781 void CallLogWrapper::glDeleteFramebuffers (glw::GLsizei n, const glw::GLuint *framebuffers)
 782 {
 783         if (m_enableLog)
 784                 m_log << TestLog::Message << "glDeleteFramebuffers(" << n << ", " << getPointerStr(framebuffers, n) << ");" << TestLog::EndMessage;
 785         m_gl.deleteFramebuffers(n, framebuffers);
 786 }
 787
 788 void CallLogWrapper::glDeleteProgram (glw::GLuint program)
 789 {
 790         if (m_enableLog)
 791                 m_log << TestLog::Message << "glDeleteProgram(" << program << ");" << TestLog::EndMessage;
 792         m_gl.deleteProgram(program);
 793 }
 794
 795 void CallLogWrapper::glDeleteProgramPipelines (glw::GLsizei n, const glw::GLuint *pipelines)
 796 {
 797         if (m_enableLog)
 798                 m_log << TestLog::Message << "glDeleteProgramPipelines(" << n << ", " << getPointerStr(pipelines, n) << ");" << TestLog::EndMessage;
 799         m_gl.deleteProgramPipelines(n, pipelines);
 800 }
 801
 802 void CallLogWrapper::glDeleteQueries (glw::GLsizei n, const glw::GLuint *ids)
 803 {
 804         if (m_enableLog)
 805                 m_log << TestLog::Message << "glDeleteQueries(" << n << ", " << getPointerStr(ids, n) << ");" << TestLog::EndMessage;
 806         m_gl.deleteQueries(n, ids);
 807 }
 808
 809 void CallLogWrapper::glDeleteRenderbuffers (glw::GLsizei n, const glw::GLuint *renderbuffers)
 810 {
 811         if (m_enableLog)
 812                 m_log << TestLog::Message << "glDeleteRenderbuffers(" << n << ", " << getPointerStr(renderbuffers, n) << ");" << TestLog::EndMessage;
 813         m_gl.deleteRenderbuffers(n, renderbuffers);
 814 }
 815
 816 void CallLogWrapper::glDeleteSamplers (glw::GLsizei count, const glw::GLuint *samplers)
 817 {
 818         if (m_enableLog)
 819                 m_log << TestLog::Message << "glDeleteSamplers(" << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(samplers))) << ");" << TestLog::EndMessage;
 820         m_gl.deleteSamplers(count, samplers);
 821 }
 822
 823 void CallLogWrapper::glDeleteShader (glw::GLuint shader)
 824 {
 825         if (m_enableLog)
 826                 m_log << TestLog::Message << "glDeleteShader(" << shader << ");" << TestLog::EndMessage;
 827         m_gl.deleteShader(shader);
 828 }
 829
 830 void CallLogWrapper::glDeleteSync (glw::GLsync sync)
 831 {
 832         if (m_enableLog)
 833                 m_log << TestLog::Message << "glDeleteSync(" << sync << ");" << TestLog::EndMessage;
 834         m_gl.deleteSync(sync);
 835 }
 836
 837 void CallLogWrapper::glDeleteTextures (glw::GLsizei n, const glw::GLuint *textures)
 838 {
 839         if (m_enableLog)
 840                 m_log << TestLog::Message << "glDeleteTextures(" << n << ", " << getPointerStr(textures, n) << ");" << TestLog::EndMessage;
 841         m_gl.deleteTextures(n, textures);
 842 }
 843
 844 void CallLogWrapper::glDeleteTransformFeedbacks (glw::GLsizei n, const glw::GLuint *ids)
 845 {
 846         if (m_enableLog)
 847                 m_log << TestLog::Message << "glDeleteTransformFeedbacks(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
 848         m_gl.deleteTransformFeedbacks(n, ids);
 849 }
 850
 851 void CallLogWrapper::glDeleteVertexArrays (glw::GLsizei n, const glw::GLuint *arrays)
 852 {
 853         if (m_enableLog)
 854                 m_log << TestLog::Message << "glDeleteVertexArrays(" << n << ", " << getPointerStr(arrays, n) << ");" << TestLog::EndMessage;
 855         m_gl.deleteVertexArrays(n, arrays);
 856 }
 857
 858 void CallLogWrapper::glDepthFunc (glw::GLenum func)
 859 {
 860         if (m_enableLog)
 861                 m_log << TestLog::Message << "glDepthFunc(" << getCompareFuncStr(func) << ");" << TestLog::EndMessage;
 862         m_gl.depthFunc(func);
 863 }
 864
 865 void CallLogWrapper::glDepthMask (glw::GLboolean flag)
 866 {
 867         if (m_enableLog)
 868                 m_log << TestLog::Message << "glDepthMask(" << getBooleanStr(flag) << ");" << TestLog::EndMessage;
 869         m_gl.depthMask(flag);
 870 }
 871
 872 void CallLogWrapper::glDepthRange (glw::GLdouble near, glw::GLdouble far)
 873 {
 874         if (m_enableLog)
 875                 m_log << TestLog::Message << "glDepthRange(" << near << ", " << far << ");" << TestLog::EndMessage;
 876         m_gl.depthRange(near, far);
 877 }
 878
 879 void CallLogWrapper::glDepthRangeArrayv (glw::GLuint first, glw::GLsizei count, const glw::GLdouble *v)
 880 {
 881         if (m_enableLog)
 882                 m_log << TestLog::Message << "glDepthRangeArrayv(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
 883         m_gl.depthRangeArrayv(first, count, v);
 884 }
 885
 886 void CallLogWrapper::glDepthRangeIndexed (glw::GLuint index, glw::GLdouble n, glw::GLdouble f)
 887 {
 888         if (m_enableLog)
 889                 m_log << TestLog::Message << "glDepthRangeIndexed(" << index << ", " << n << ", " << f << ");" << TestLog::EndMessage;
 890         m_gl.depthRangeIndexed(index, n, f);
 891 }
 892
 893 void CallLogWrapper::glDepthRangef (glw::GLfloat n, glw::GLfloat f)
 894 {
 895         if (m_enableLog)
 896                 m_log << TestLog::Message << "glDepthRangef(" << n << ", " << f << ");" << TestLog::EndMessage;
 897         m_gl.depthRangef(n, f);
 898 }
 899
 900 void CallLogWrapper::glDetachShader (glw::GLuint program, glw::GLuint shader)
 901 {
 902         if (m_enableLog)
 903                 m_log << TestLog::Message << "glDetachShader(" << program << ", " << shader << ");" << TestLog::EndMessage;
 904         m_gl.detachShader(program, shader);
 905 }
 906
 907 void CallLogWrapper::glDisable (glw::GLenum cap)
 908 {
 909         if (m_enableLog)
 910                 m_log << TestLog::Message << "glDisable(" << getEnableCapStr(cap) << ");" << TestLog::EndMessage;
 911         m_gl.disable(cap);
 912 }
 913
 914 void CallLogWrapper::glDisableVertexArrayAttrib (glw::GLuint vaobj, glw::GLuint index)
 915 {
 916         if (m_enableLog)
 917                 m_log << TestLog::Message << "glDisableVertexArrayAttrib(" << vaobj << ", " << index << ");" << TestLog::EndMessage;
 918         m_gl.disableVertexArrayAttrib(vaobj, index);
 919 }
 920
 921 void CallLogWrapper::glDisableVertexAttribArray (glw::GLuint index)
 922 {
 923         if (m_enableLog)
 924                 m_log << TestLog::Message << "glDisableVertexAttribArray(" << index << ");" << TestLog::EndMessage;
 925         m_gl.disableVertexAttribArray(index);
 926 }
 927
 928 void CallLogWrapper::glDisablei (glw::GLenum target, glw::GLuint index)
 929 {
 930         if (m_enableLog)
 931                 m_log << TestLog::Message << "glDisablei(" << getIndexedEnableCapStr(target) << ", " << index << ");" << TestLog::EndMessage;
 932         m_gl.disablei(target, index);
 933 }
 934
 935 void CallLogWrapper::glDispatchCompute (glw::GLuint num_groups_x, glw::GLuint num_groups_y, glw::GLuint num_groups_z)
 936 {
 937         if (m_enableLog)
 938                 m_log << TestLog::Message << "glDispatchCompute(" << num_groups_x << ", " << num_groups_y << ", " << num_groups_z << ");" << TestLog::EndMessage;
 939         m_gl.dispatchCompute(num_groups_x, num_groups_y, num_groups_z);
 940 }
 941
 942 void CallLogWrapper::glDispatchComputeIndirect (glw::GLintptr indirect)
 943 {
 944         if (m_enableLog)
 945                 m_log << TestLog::Message << "glDispatchComputeIndirect(" << indirect << ");" << TestLog::EndMessage;
 946         m_gl.dispatchComputeIndirect(indirect);
 947 }
 948
 949 void CallLogWrapper::glDrawArrays (glw::GLenum mode, glw::GLint first, glw::GLsizei count)
 950 {
 951         if (m_enableLog)
 952                 m_log << TestLog::Message << "glDrawArrays(" << getPrimitiveTypeStr(mode) << ", " << first << ", " << count << ");" << TestLog::EndMessage;
 953         m_gl.drawArrays(mode, first, count);
 954 }
 955
 956 void CallLogWrapper::glDrawArraysIndirect (glw::GLenum mode, const void *indirect)
 957 {
 958         if (m_enableLog)
 959                 m_log << TestLog::Message << "glDrawArraysIndirect(" << getPrimitiveTypeStr(mode) << ", " << indirect << ");" << TestLog::EndMessage;
 960         m_gl.drawArraysIndirect(mode, indirect);
 961 }
 962
 963 void CallLogWrapper::glDrawArraysInstanced (glw::GLenum mode, glw::GLint first, glw::GLsizei count, glw::GLsizei instancecount)
 964 {
 965         if (m_enableLog)
 966                 m_log << TestLog::Message << "glDrawArraysInstanced(" << getPrimitiveTypeStr(mode) << ", " << first << ", " << count << ", " << instancecount << ");" << TestLog::EndMessage;
 967         m_gl.drawArraysInstanced(mode, first, count, instancecount);
 968 }
 969
 970 void CallLogWrapper::glDrawArraysInstancedBaseInstance (glw::GLenum mode, glw::GLint first, glw::GLsizei count, glw::GLsizei instancecount, glw::GLuint baseinstance)
 971 {
 972         if (m_enableLog)
 973                 m_log << TestLog::Message << "glDrawArraysInstancedBaseInstance(" << toHex(mode) << ", " << first << ", " << count << ", " << instancecount << ", " << baseinstance << ");" << TestLog::EndMessage;
 974         m_gl.drawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
 975 }
 976
 977 void CallLogWrapper::glDrawBuffer (glw::GLenum buf)
 978 {
 979         if (m_enableLog)
 980                 m_log << TestLog::Message << "glDrawBuffer(" << toHex(buf) << ");" << TestLog::EndMessage;
 981         m_gl.drawBuffer(buf);
 982 }
 983
 984 void CallLogWrapper::glDrawBuffers (glw::GLsizei n, const glw::GLenum *bufs)
 985 {
 986         if (m_enableLog)
 987                 m_log << TestLog::Message << "glDrawBuffers(" << n << ", " << getEnumPointerStr(bufs, n, getDrawReadBufferName) << ");" << TestLog::EndMessage;
 988         m_gl.drawBuffers(n, bufs);
 989 }
 990
 991 void CallLogWrapper::glDrawElements (glw::GLenum mode, glw::GLsizei count, glw::GLenum type, const void *indices)
 992 {
 993         if (m_enableLog)
 994                 m_log << TestLog::Message << "glDrawElements(" << getPrimitiveTypeStr(mode) << ", " << count << ", " << getTypeStr(type) << ", " << indices << ");" << TestLog::EndMessage;
 995         m_gl.drawElements(mode, count, type, indices);
 996 }
 997
 998 void CallLogWrapper::glDrawElementsBaseVertex (glw::GLenum mode, glw::GLsizei count, glw::GLenum type, const void *indices, glw::GLint basevertex)
 999 {
1000         if (m_enableLog)
1001                 m_log << TestLog::Message << "glDrawElementsBaseVertex(" << getPrimitiveTypeStr(mode) << ", " << count << ", " << getTypeStr(type) << ", " << indices << ", " << basevertex << ");" << TestLog::EndMessage;
1002         m_gl.drawElementsBaseVertex(mode, count, type, indices, basevertex);
1003 }
1004
1005 void CallLogWrapper::glDrawElementsIndirect (glw::GLenum mode, glw::GLenum type, const void *indirect)
1006 {
1007         if (m_enableLog)
1008                 m_log << TestLog::Message << "glDrawElementsIndirect(" << getPrimitiveTypeStr(mode) << ", " << getTypeStr(type) << ", " << indirect << ");" << TestLog::EndMessage;
1009         m_gl.drawElementsIndirect(mode, type, indirect);
1010 }
1011
1012 void CallLogWrapper::glDrawElementsInstanced (glw::GLenum mode, glw::GLsizei count, glw::GLenum type, const void *indices, glw::GLsizei instancecount)
1013 {
1014         if (m_enableLog)
1015                 m_log << TestLog::Message << "glDrawElementsInstanced(" << getPrimitiveTypeStr(mode) << ", " << count << ", " << getTypeStr(type) << ", " << indices << ", " << instancecount << ");" << TestLog::EndMessage;
1016         m_gl.drawElementsInstanced(mode, count, type, indices, instancecount);
1017 }
1018
1019 void CallLogWrapper::glDrawElementsInstancedBaseInstance (glw::GLenum mode, glw::GLsizei count, glw::GLenum type, const void *indices, glw::GLsizei instancecount, glw::GLuint baseinstance)
1020 {
1021         if (m_enableLog)
1022                 m_log << TestLog::Message << "glDrawElementsInstancedBaseInstance(" << toHex(mode) << ", " << count << ", " << toHex(type) << ", " << indices << ", " << instancecount << ", " << baseinstance << ");" << TestLog::EndMessage;
1023         m_gl.drawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
1024 }
1025
1026 void CallLogWrapper::glDrawElementsInstancedBaseVertex (glw::GLenum mode, glw::GLsizei count, glw::GLenum type, const void *indices, glw::GLsizei instancecount, glw::GLint basevertex)
1027 {
1028         if (m_enableLog)
1029                 m_log << TestLog::Message << "glDrawElementsInstancedBaseVertex(" << getPrimitiveTypeStr(mode) << ", " << count << ", " << getTypeStr(type) << ", " << indices << ", " << instancecount << ", " << basevertex << ");" << TestLog::EndMessage;
1030         m_gl.drawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
1031 }
1032
1033 void CallLogWrapper::glDrawElementsInstancedBaseVertexBaseInstance (glw::GLenum mode, glw::GLsizei count, glw::GLenum type, const void *indices, glw::GLsizei instancecount, glw::GLint basevertex, glw::GLuint baseinstance)
1034 {
1035         if (m_enableLog)
1036                 m_log << TestLog::Message << "glDrawElementsInstancedBaseVertexBaseInstance(" << toHex(mode) << ", " << count << ", " << toHex(type) << ", " << indices << ", " << instancecount << ", " << basevertex << ", " << baseinstance << ");" << TestLog::EndMessage;
1037         m_gl.drawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
1038 }
1039
1040 void CallLogWrapper::glDrawRangeElements (glw::GLenum mode, glw::GLuint start, glw::GLuint end, glw::GLsizei count, glw::GLenum type, const void *indices)
1041 {
1042         if (m_enableLog)
1043                 m_log << TestLog::Message << "glDrawRangeElements(" << getPrimitiveTypeStr(mode) << ", " << start << ", " << end << ", " << count << ", " << getTypeStr(type) << ", " << indices << ");" << TestLog::EndMessage;
1044         m_gl.drawRangeElements(mode, start, end, count, type, indices);
1045 }
1046
1047 void CallLogWrapper::glDrawRangeElementsBaseVertex (glw::GLenum mode, glw::GLuint start, glw::GLuint end, glw::GLsizei count, glw::GLenum type, const void *indices, glw::GLint basevertex)
1048 {
1049         if (m_enableLog)
1050                 m_log << TestLog::Message << "glDrawRangeElementsBaseVertex(" << getPrimitiveTypeStr(mode) << ", " << start << ", " << end << ", " << count << ", " << getTypeStr(type) << ", " << indices << ", " << basevertex << ");" << TestLog::EndMessage;
1051         m_gl.drawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
1052 }
1053
1054 void CallLogWrapper::glDrawTransformFeedback (glw::GLenum mode, glw::GLuint id)
1055 {
1056         if (m_enableLog)
1057                 m_log << TestLog::Message << "glDrawTransformFeedback(" << toHex(mode) << ", " << id << ");" << TestLog::EndMessage;
1058         m_gl.drawTransformFeedback(mode, id);
1059 }
1060
1061 void CallLogWrapper::glDrawTransformFeedbackInstanced (glw::GLenum mode, glw::GLuint id, glw::GLsizei instancecount)
1062 {
1063         if (m_enableLog)
1064                 m_log << TestLog::Message << "glDrawTransformFeedbackInstanced(" << toHex(mode) << ", " << id << ", " << instancecount << ");" << TestLog::EndMessage;
1065         m_gl.drawTransformFeedbackInstanced(mode, id, instancecount);
1066 }
1067
1068 void CallLogWrapper::glDrawTransformFeedbackStream (glw::GLenum mode, glw::GLuint id, glw::GLuint stream)
1069 {
1070         if (m_enableLog)
1071                 m_log << TestLog::Message << "glDrawTransformFeedbackStream(" << toHex(mode) << ", " << id << ", " << stream << ");" << TestLog::EndMessage;
1072         m_gl.drawTransformFeedbackStream(mode, id, stream);
1073 }
1074
1075 void CallLogWrapper::glDrawTransformFeedbackStreamInstanced (glw::GLenum mode, glw::GLuint id, glw::GLuint stream, glw::GLsizei instancecount)
1076 {
1077         if (m_enableLog)
1078                 m_log << TestLog::Message << "glDrawTransformFeedbackStreamInstanced(" << toHex(mode) << ", " << id << ", " << stream << ", " << instancecount << ");" << TestLog::EndMessage;
1079         m_gl.drawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
1080 }
1081
1082 void CallLogWrapper::glEGLImageTargetRenderbufferStorageOES (glw::GLenum target, glw::GLeglImageOES image)
1083 {
1084         if (m_enableLog)
1085                 m_log << TestLog::Message << "glEGLImageTargetRenderbufferStorageOES(" << toHex(target) << ", " << image << ");" << TestLog::EndMessage;
1086         m_gl.eglImageTargetRenderbufferStorageOES(target, image);
1087 }
1088
1089 void CallLogWrapper::glEGLImageTargetTexture2DOES (glw::GLenum target, glw::GLeglImageOES image)
1090 {
1091         if (m_enableLog)
1092                 m_log << TestLog::Message << "glEGLImageTargetTexture2DOES(" << toHex(target) << ", " << image << ");" << TestLog::EndMessage;
1093         m_gl.eglImageTargetTexture2DOES(target, image);
1094 }
1095
1096 void CallLogWrapper::glEnable (glw::GLenum cap)
1097 {
1098         if (m_enableLog)
1099                 m_log << TestLog::Message << "glEnable(" << getEnableCapStr(cap) << ");" << TestLog::EndMessage;
1100         m_gl.enable(cap);
1101 }
1102
1103 void CallLogWrapper::glEnableVertexArrayAttrib (glw::GLuint vaobj, glw::GLuint index)
1104 {
1105         if (m_enableLog)
1106                 m_log << TestLog::Message << "glEnableVertexArrayAttrib(" << vaobj << ", " << index << ");" << TestLog::EndMessage;
1107         m_gl.enableVertexArrayAttrib(vaobj, index);
1108 }
1109
1110 void CallLogWrapper::glEnableVertexAttribArray (glw::GLuint index)
1111 {
1112         if (m_enableLog)
1113                 m_log << TestLog::Message << "glEnableVertexAttribArray(" << index << ");" << TestLog::EndMessage;
1114         m_gl.enableVertexAttribArray(index);
1115 }
1116
1117 void CallLogWrapper::glEnablei (glw::GLenum target, glw::GLuint index)
1118 {
1119         if (m_enableLog)
1120                 m_log << TestLog::Message << "glEnablei(" << getIndexedEnableCapStr(target) << ", " << index << ");" << TestLog::EndMessage;
1121         m_gl.enablei(target, index);
1122 }
1123
1124 void CallLogWrapper::glEndConditionalRender (void)
1125 {
1126         if (m_enableLog)
1127                 m_log << TestLog::Message << "glEndConditionalRender(" << ");" << TestLog::EndMessage;
1128         m_gl.endConditionalRender();
1129 }
1130
1131 void CallLogWrapper::glEndQuery (glw::GLenum target)
1132 {
1133         if (m_enableLog)
1134                 m_log << TestLog::Message << "glEndQuery(" << getQueryTargetStr(target) << ");" << TestLog::EndMessage;
1135         m_gl.endQuery(target);
1136 }
1137
1138 void CallLogWrapper::glEndQueryIndexed (glw::GLenum target, glw::GLuint index)
1139 {
1140         if (m_enableLog)
1141                 m_log << TestLog::Message << "glEndQueryIndexed(" << toHex(target) << ", " << index << ");" << TestLog::EndMessage;
1142         m_gl.endQueryIndexed(target, index);
1143 }
1144
1145 void CallLogWrapper::glEndTransformFeedback (void)
1146 {
1147         if (m_enableLog)
1148                 m_log << TestLog::Message << "glEndTransformFeedback(" << ");" << TestLog::EndMessage;
1149         m_gl.endTransformFeedback();
1150 }
1151
1152 glw::GLsync CallLogWrapper::glFenceSync (glw::GLenum condition, glw::GLbitfield flags)
1153 {
1154         if (m_enableLog)
1155                 m_log << TestLog::Message << "glFenceSync(" << toHex(condition) << ", " << toHex(flags) << ");" << TestLog::EndMessage;
1156         glw::GLsync returnValue = m_gl.fenceSync(condition, flags);
1157         if (m_enableLog)
1158                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
1159         return returnValue;
1160 }
1161
1162 void CallLogWrapper::glFinish (void)
1163 {
1164         if (m_enableLog)
1165                 m_log << TestLog::Message << "glFinish(" << ");" << TestLog::EndMessage;
1166         m_gl.finish();
1167 }
1168
1169 void CallLogWrapper::glFlush (void)
1170 {
1171         if (m_enableLog)
1172                 m_log << TestLog::Message << "glFlush(" << ");" << TestLog::EndMessage;
1173         m_gl.flush();
1174 }
1175
1176 void CallLogWrapper::glFlushMappedBufferRange (glw::GLenum target, glw::GLintptr offset, glw::GLsizeiptr length)
1177 {
1178         if (m_enableLog)
1179                 m_log << TestLog::Message << "glFlushMappedBufferRange(" << getBufferTargetStr(target) << ", " << offset << ", " << length << ");" << TestLog::EndMessage;
1180         m_gl.flushMappedBufferRange(target, offset, length);
1181 }
1182
1183 void CallLogWrapper::glFlushMappedNamedBufferRange (glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr length)
1184 {
1185         if (m_enableLog)
1186                 m_log << TestLog::Message << "glFlushMappedNamedBufferRange(" << buffer << ", " << offset << ", " << length << ");" << TestLog::EndMessage;
1187         m_gl.flushMappedNamedBufferRange(buffer, offset, length);
1188 }
1189
1190 void CallLogWrapper::glFramebufferParameteri (glw::GLenum target, glw::GLenum pname, glw::GLint param)
1191 {
1192         if (m_enableLog)
1193                 m_log << TestLog::Message << "glFramebufferParameteri(" << getFramebufferTargetStr(target) << ", " << getFramebufferParameterStr(pname) << ", " << param << ");" << TestLog::EndMessage;
1194         m_gl.framebufferParameteri(target, pname, param);
1195 }
1196
1197 void CallLogWrapper::glFramebufferRenderbuffer (glw::GLenum target, glw::GLenum attachment, glw::GLenum renderbuffertarget, glw::GLuint renderbuffer)
1198 {
1199         if (m_enableLog)
1200                 m_log << TestLog::Message << "glFramebufferRenderbuffer(" << getFramebufferTargetStr(target) << ", " << getFramebufferAttachmentStr(attachment) << ", " << getFramebufferTargetStr(renderbuffertarget) << ", " << renderbuffer << ");" << TestLog::EndMessage;
1201         m_gl.framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
1202 }
1203
1204 void CallLogWrapper::glFramebufferTexture (glw::GLenum target, glw::GLenum attachment, glw::GLuint texture, glw::GLint level)
1205 {
1206         if (m_enableLog)
1207                 m_log << TestLog::Message << "glFramebufferTexture(" << getFramebufferTargetStr(target) << ", " << getFramebufferAttachmentStr(attachment) << ", " << texture << ", " << level << ");" << TestLog::EndMessage;
1208         m_gl.framebufferTexture(target, attachment, texture, level);
1209 }
1210
1211 void CallLogWrapper::glFramebufferTexture1D (glw::GLenum target, glw::GLenum attachment, glw::GLenum textarget, glw::GLuint texture, glw::GLint level)
1212 {
1213         if (m_enableLog)
1214                 m_log << TestLog::Message << "glFramebufferTexture1D(" << toHex(target) << ", " << toHex(attachment) << ", " << toHex(textarget) << ", " << texture << ", " << level << ");" << TestLog::EndMessage;
1215         m_gl.framebufferTexture1D(target, attachment, textarget, texture, level);
1216 }
1217
1218 void CallLogWrapper::glFramebufferTexture2D (glw::GLenum target, glw::GLenum attachment, glw::GLenum textarget, glw::GLuint texture, glw::GLint level)
1219 {
1220         if (m_enableLog)
1221                 m_log << TestLog::Message << "glFramebufferTexture2D(" << getFramebufferTargetStr(target) << ", " << getFramebufferAttachmentStr(attachment) << ", " << getTextureTargetStr(textarget) << ", " << texture << ", " << level << ");" << TestLog::EndMessage;
1222         m_gl.framebufferTexture2D(target, attachment, textarget, texture, level);
1223 }
1224
1225 void CallLogWrapper::glFramebufferTexture3D (glw::GLenum target, glw::GLenum attachment, glw::GLenum textarget, glw::GLuint texture, glw::GLint level, glw::GLint zoffset)
1226 {
1227         if (m_enableLog)
1228                 m_log << TestLog::Message << "glFramebufferTexture3D(" << toHex(target) << ", " << toHex(attachment) << ", " << toHex(textarget) << ", " << texture << ", " << level << ", " << zoffset << ");" << TestLog::EndMessage;
1229         m_gl.framebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
1230 }
1231
1232 void CallLogWrapper::glFramebufferTextureLayer (glw::GLenum target, glw::GLenum attachment, glw::GLuint texture, glw::GLint level, glw::GLint layer)
1233 {
1234         if (m_enableLog)
1235                 m_log << TestLog::Message << "glFramebufferTextureLayer(" << getFramebufferTargetStr(target) << ", " << getFramebufferAttachmentStr(attachment) << ", " << texture << ", " << level << ", " << layer << ");" << TestLog::EndMessage;
1236         m_gl.framebufferTextureLayer(target, attachment, texture, level, layer);
1237 }
1238
1239 void CallLogWrapper::glFrontFace (glw::GLenum mode)
1240 {
1241         if (m_enableLog)
1242                 m_log << TestLog::Message << "glFrontFace(" << getWindingStr(mode) << ");" << TestLog::EndMessage;
1243         m_gl.frontFace(mode);
1244 }
1245
1246 void CallLogWrapper::glGenBuffers (glw::GLsizei n, glw::GLuint *buffers)
1247 {
1248         if (m_enableLog)
1249                 m_log << TestLog::Message << "glGenBuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ");" << TestLog::EndMessage;
1250         m_gl.genBuffers(n, buffers);
1251         if (m_enableLog)
1252                 m_log << TestLog::Message << "// buffers = " << getPointerStr(buffers, n) << TestLog::EndMessage;
1253 }
1254
1255 void CallLogWrapper::glGenFramebuffers (glw::GLsizei n, glw::GLuint *framebuffers)
1256 {
1257         if (m_enableLog)
1258                 m_log << TestLog::Message << "glGenFramebuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(framebuffers))) << ");" << TestLog::EndMessage;
1259         m_gl.genFramebuffers(n, framebuffers);
1260         if (m_enableLog)
1261                 m_log << TestLog::Message << "// framebuffers = " << getPointerStr(framebuffers, n) << TestLog::EndMessage;
1262 }
1263
1264 void CallLogWrapper::glGenProgramPipelines (glw::GLsizei n, glw::GLuint *pipelines)
1265 {
1266         if (m_enableLog)
1267                 m_log << TestLog::Message << "glGenProgramPipelines(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(pipelines))) << ");" << TestLog::EndMessage;
1268         m_gl.genProgramPipelines(n, pipelines);
1269         if (m_enableLog)
1270                 m_log << TestLog::Message << "// pipelines = " << getPointerStr(pipelines, n) << TestLog::EndMessage;
1271 }
1272
1273 void CallLogWrapper::glGenQueries (glw::GLsizei n, glw::GLuint *ids)
1274 {
1275         if (m_enableLog)
1276                 m_log << TestLog::Message << "glGenQueries(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
1277         m_gl.genQueries(n, ids);
1278         if (m_enableLog)
1279                 m_log << TestLog::Message << "// ids = " << getPointerStr(ids, n) << TestLog::EndMessage;
1280 }
1281
1282 void CallLogWrapper::glGenRenderbuffers (glw::GLsizei n, glw::GLuint *renderbuffers)
1283 {
1284         if (m_enableLog)
1285                 m_log << TestLog::Message << "glGenRenderbuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(renderbuffers))) << ");" << TestLog::EndMessage;
1286         m_gl.genRenderbuffers(n, renderbuffers);
1287         if (m_enableLog)
1288                 m_log << TestLog::Message << "// renderbuffers = " << getPointerStr(renderbuffers, n) << TestLog::EndMessage;
1289 }
1290
1291 void CallLogWrapper::glGenSamplers (glw::GLsizei count, glw::GLuint *samplers)
1292 {
1293         if (m_enableLog)
1294                 m_log << TestLog::Message << "glGenSamplers(" << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(samplers))) << ");" << TestLog::EndMessage;
1295         m_gl.genSamplers(count, samplers);
1296 }
1297
1298 void CallLogWrapper::glGenTextures (glw::GLsizei n, glw::GLuint *textures)
1299 {
1300         if (m_enableLog)
1301                 m_log << TestLog::Message << "glGenTextures(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(textures))) << ");" << TestLog::EndMessage;
1302         m_gl.genTextures(n, textures);
1303         if (m_enableLog)
1304                 m_log << TestLog::Message << "// textures = " << getPointerStr(textures, n) << TestLog::EndMessage;
1305 }
1306
1307 void CallLogWrapper::glGenTransformFeedbacks (glw::GLsizei n, glw::GLuint *ids)
1308 {
1309         if (m_enableLog)
1310                 m_log << TestLog::Message << "glGenTransformFeedbacks(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
1311         m_gl.genTransformFeedbacks(n, ids);
1312         if (m_enableLog)
1313                 m_log << TestLog::Message << "// ids = " << getPointerStr(ids, n) << TestLog::EndMessage;
1314 }
1315
1316 void CallLogWrapper::glGenVertexArrays (glw::GLsizei n, glw::GLuint *arrays)
1317 {
1318         if (m_enableLog)
1319                 m_log << TestLog::Message << "glGenVertexArrays(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(arrays))) << ");" << TestLog::EndMessage;
1320         m_gl.genVertexArrays(n, arrays);
1321         if (m_enableLog)
1322                 m_log << TestLog::Message << "// arrays = " << getPointerStr(arrays, n) << TestLog::EndMessage;
1323 }
1324
1325 void CallLogWrapper::glGenerateMipmap (glw::GLenum target)
1326 {
1327         if (m_enableLog)
1328                 m_log << TestLog::Message << "glGenerateMipmap(" << getTextureTargetStr(target) << ");" << TestLog::EndMessage;
1329         m_gl.generateMipmap(target);
1330 }
1331
1332 void CallLogWrapper::glGenerateTextureMipmap (glw::GLuint texture)
1333 {
1334         if (m_enableLog)
1335                 m_log << TestLog::Message << "glGenerateTextureMipmap(" << texture << ");" << TestLog::EndMessage;
1336         m_gl.generateTextureMipmap(texture);
1337 }
1338
1339 void CallLogWrapper::glGetActiveAtomicCounterBufferiv (glw::GLuint program, glw::GLuint bufferIndex, glw::GLenum pname, glw::GLint *params)
1340 {
1341         if (m_enableLog)
1342                 m_log << TestLog::Message << "glGetActiveAtomicCounterBufferiv(" << program << ", " << bufferIndex << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1343         m_gl.getActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
1344 }
1345
1346 void CallLogWrapper::glGetActiveAttrib (glw::GLuint program, glw::GLuint index, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLint *size, glw::GLenum *type, glw::GLchar *name)
1347 {
1348         if (m_enableLog)
1349                 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;
1350         m_gl.getActiveAttrib(program, index, bufSize, length, size, type, name);
1351 }
1352
1353 void CallLogWrapper::glGetActiveSubroutineName (glw::GLuint program, glw::GLenum shadertype, glw::GLuint index, glw::GLsizei bufsize, glw::GLsizei *length, glw::GLchar *name)
1354 {
1355         if (m_enableLog)
1356                 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;
1357         m_gl.getActiveSubroutineName(program, shadertype, index, bufsize, length, name);
1358 }
1359
1360 void CallLogWrapper::glGetActiveSubroutineUniformName (glw::GLuint program, glw::GLenum shadertype, glw::GLuint index, glw::GLsizei bufsize, glw::GLsizei *length, glw::GLchar *name)
1361 {
1362         if (m_enableLog)
1363                 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;
1364         m_gl.getActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
1365 }
1366
1367 void CallLogWrapper::glGetActiveSubroutineUniformiv (glw::GLuint program, glw::GLenum shadertype, glw::GLuint index, glw::GLenum pname, glw::GLint *values)
1368 {
1369         if (m_enableLog)
1370                 m_log << TestLog::Message << "glGetActiveSubroutineUniformiv(" << program << ", " << toHex(shadertype) << ", " << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(values))) << ");" << TestLog::EndMessage;
1371         m_gl.getActiveSubroutineUniformiv(program, shadertype, index, pname, values);
1372 }
1373
1374 void CallLogWrapper::glGetActiveUniform (glw::GLuint program, glw::GLuint index, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLint *size, glw::GLenum *type, glw::GLchar *name)
1375 {
1376         if (m_enableLog)
1377                 m_log << TestLog::Message << "glGetActiveUniform(" << 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;
1378         m_gl.getActiveUniform(program, index, bufSize, length, size, type, name);
1379         if (m_enableLog)
1380         {
1381                 m_log << TestLog::Message << "// length = " << getPointerStr(length, 1) << TestLog::EndMessage;
1382                 m_log << TestLog::Message << "// size = " << getPointerStr(size, 1) << TestLog::EndMessage;
1383                 m_log << TestLog::Message << "// type = " << getEnumPointerStr(type, 1, getShaderVarTypeName) << TestLog::EndMessage;
1384                 m_log << TestLog::Message << "// name = " << getStringStr(name) << TestLog::EndMessage;
1385         }
1386 }
1387
1388 void CallLogWrapper::glGetActiveUniformBlockName (glw::GLuint program, glw::GLuint uniformBlockIndex, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *uniformBlockName)
1389 {
1390         if (m_enableLog)
1391                 m_log << TestLog::Message << "glGetActiveUniformBlockName(" << program << ", " << uniformBlockIndex << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(uniformBlockName))) << ");" << TestLog::EndMessage;
1392         m_gl.getActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
1393 }
1394
1395 void CallLogWrapper::glGetActiveUniformBlockiv (glw::GLuint program, glw::GLuint uniformBlockIndex, glw::GLenum pname, glw::GLint *params)
1396 {
1397         if (m_enableLog)
1398                 m_log << TestLog::Message << "glGetActiveUniformBlockiv(" << program << ", " << uniformBlockIndex << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1399         m_gl.getActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
1400 }
1401
1402 void CallLogWrapper::glGetActiveUniformName (glw::GLuint program, glw::GLuint uniformIndex, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *uniformName)
1403 {
1404         if (m_enableLog)
1405                 m_log << TestLog::Message << "glGetActiveUniformName(" << program << ", " << uniformIndex << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(uniformName))) << ");" << TestLog::EndMessage;
1406         m_gl.getActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
1407 }
1408
1409 void CallLogWrapper::glGetActiveUniformsiv (glw::GLuint program, glw::GLsizei uniformCount, const glw::GLuint *uniformIndices, glw::GLenum pname, glw::GLint *params)
1410 {
1411         if (m_enableLog)
1412                 m_log << TestLog::Message << "glGetActiveUniformsiv(" << program << ", " << uniformCount << ", " << getPointerStr(uniformIndices, uniformCount) << ", " << getUniformParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1413         m_gl.getActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
1414         if (m_enableLog)
1415                 m_log << TestLog::Message << "// params = " << getPointerStr(params, uniformCount) << TestLog::EndMessage;
1416 }
1417
1418 void CallLogWrapper::glGetAttachedShaders (glw::GLuint program, glw::GLsizei maxCount, glw::GLsizei *count, glw::GLuint *shaders)
1419 {
1420         if (m_enableLog)
1421                 m_log << TestLog::Message << "glGetAttachedShaders(" << program << ", " << maxCount << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(count))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(shaders))) << ");" << TestLog::EndMessage;
1422         m_gl.getAttachedShaders(program, maxCount, count, shaders);
1423 }
1424
1425 glw::GLint CallLogWrapper::glGetAttribLocation (glw::GLuint program, const glw::GLchar *name)
1426 {
1427         if (m_enableLog)
1428                 m_log << TestLog::Message << "glGetAttribLocation(" << program << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
1429         glw::GLint returnValue = m_gl.getAttribLocation(program, name);
1430         if (m_enableLog)
1431                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
1432         return returnValue;
1433 }
1434
1435 void CallLogWrapper::glGetBooleani_v (glw::GLenum target, glw::GLuint index, glw::GLboolean *data)
1436 {
1437         if (m_enableLog)
1438                 m_log << TestLog::Message << "glGetBooleani_v(" << getGettableIndexedStateStr(target) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
1439         m_gl.getBooleani_v(target, index, data);
1440         if (m_enableLog)
1441                 m_log << TestLog::Message << "// data = " << getBooleanPointerStr(data, getIndexedQueryNumArgsOut(target)) << TestLog::EndMessage;
1442 }
1443
1444 void CallLogWrapper::glGetBooleanv (glw::GLenum pname, glw::GLboolean *data)
1445 {
1446         if (m_enableLog)
1447                 m_log << TestLog::Message << "glGetBooleanv(" << getGettableStateStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
1448         m_gl.getBooleanv(pname, data);
1449         if (m_enableLog)
1450                 m_log << TestLog::Message << "// data = " << getBooleanPointerStr(data, getBasicQueryNumArgsOut(pname)) << TestLog::EndMessage;
1451 }
1452
1453 void CallLogWrapper::glGetBufferParameteri64v (glw::GLenum target, glw::GLenum pname, glw::GLint64 *params)
1454 {
1455         if (m_enableLog)
1456                 m_log << TestLog::Message << "glGetBufferParameteri64v(" << getBufferTargetStr(target) << ", " << getBufferQueryStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1457         m_gl.getBufferParameteri64v(target, pname, params);
1458 }
1459
1460 void CallLogWrapper::glGetBufferParameteriv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
1461 {
1462         if (m_enableLog)
1463                 m_log << TestLog::Message << "glGetBufferParameteriv(" << getBufferTargetStr(target) << ", " << getBufferQueryStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1464         m_gl.getBufferParameteriv(target, pname, params);
1465 }
1466
1467 void CallLogWrapper::glGetBufferPointerv (glw::GLenum target, glw::GLenum pname, void **params)
1468 {
1469         if (m_enableLog)
1470                 m_log << TestLog::Message << "glGetBufferPointerv(" << toHex(target) << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1471         m_gl.getBufferPointerv(target, pname, params);
1472 }
1473
1474 void CallLogWrapper::glGetBufferSubData (glw::GLenum target, glw::GLintptr offset, glw::GLsizeiptr size, void *data)
1475 {
1476         if (m_enableLog)
1477                 m_log << TestLog::Message << "glGetBufferSubData(" << toHex(target) << ", " << offset << ", " << size << ", " << data << ");" << TestLog::EndMessage;
1478         m_gl.getBufferSubData(target, offset, size, data);
1479 }
1480
1481 void CallLogWrapper::glGetCompressedTexImage (glw::GLenum target, glw::GLint level, void *img)
1482 {
1483         if (m_enableLog)
1484                 m_log << TestLog::Message << "glGetCompressedTexImage(" << toHex(target) << ", " << level << ", " << img << ");" << TestLog::EndMessage;
1485         m_gl.getCompressedTexImage(target, level, img);
1486 }
1487
1488 void CallLogWrapper::glGetCompressedTextureImage (glw::GLuint texture, glw::GLint level, glw::GLsizei bufSize, void *pixels)
1489 {
1490         if (m_enableLog)
1491                 m_log << TestLog::Message << "glGetCompressedTextureImage(" << texture << ", " << level << ", " << bufSize << ", " << pixels << ");" << TestLog::EndMessage;
1492         m_gl.getCompressedTextureImage(texture, level, bufSize, pixels);
1493 }
1494
1495 void CallLogWrapper::glGetCompressedTextureSubImage (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::GLsizei bufSize, void *pixels)
1496 {
1497         if (m_enableLog)
1498                 m_log << TestLog::Message << "glGetCompressedTextureSubImage(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << bufSize << ", " << pixels << ");" << TestLog::EndMessage;
1499         m_gl.getCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
1500 }
1501
1502 glw::GLuint CallLogWrapper::glGetDebugMessageLog (glw::GLuint count, glw::GLsizei bufSize, glw::GLenum *sources, glw::GLenum *types, glw::GLuint *ids, glw::GLenum *severities, glw::GLsizei *lengths, glw::GLchar *messageLog)
1503 {
1504         if (m_enableLog)
1505                 m_log << TestLog::Message << "glGetDebugMessageLog(" << count << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(sources))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(types))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(severities))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(lengths))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(messageLog))) << ");" << TestLog::EndMessage;
1506         glw::GLuint returnValue = m_gl.getDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
1507         if (m_enableLog)
1508                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
1509         return returnValue;
1510 }
1511
1512 void CallLogWrapper::glGetDoublei_v (glw::GLenum target, glw::GLuint index, glw::GLdouble *data)
1513 {
1514         if (m_enableLog)
1515                 m_log << TestLog::Message << "glGetDoublei_v(" << toHex(target) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
1516         m_gl.getDoublei_v(target, index, data);
1517 }
1518
1519 void CallLogWrapper::glGetDoublev (glw::GLenum pname, glw::GLdouble *data)
1520 {
1521         if (m_enableLog)
1522                 m_log << TestLog::Message << "glGetDoublev(" << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
1523         m_gl.getDoublev(pname, data);
1524 }
1525
1526 glw::GLenum CallLogWrapper::glGetError (void)
1527 {
1528         if (m_enableLog)
1529                 m_log << TestLog::Message << "glGetError(" << ");" << TestLog::EndMessage;
1530         glw::GLenum returnValue = m_gl.getError();
1531         if (m_enableLog)
1532                 m_log << TestLog::Message << "// " << getErrorStr(returnValue) << " returned" << TestLog::EndMessage;
1533         return returnValue;
1534 }
1535
1536 void CallLogWrapper::glGetFloati_v (glw::GLenum target, glw::GLuint index, glw::GLfloat *data)
1537 {
1538         if (m_enableLog)
1539                 m_log << TestLog::Message << "glGetFloati_v(" << toHex(target) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
1540         m_gl.getFloati_v(target, index, data);
1541 }
1542
1543 void CallLogWrapper::glGetFloatv (glw::GLenum pname, glw::GLfloat *data)
1544 {
1545         if (m_enableLog)
1546                 m_log << TestLog::Message << "glGetFloatv(" << getGettableStateStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
1547         m_gl.getFloatv(pname, data);
1548         if (m_enableLog)
1549                 m_log << TestLog::Message << "// data = " << getPointerStr(data, getBasicQueryNumArgsOut(pname)) << TestLog::EndMessage;
1550 }
1551
1552 glw::GLint CallLogWrapper::glGetFragDataIndex (glw::GLuint program, const glw::GLchar *name)
1553 {
1554         if (m_enableLog)
1555                 m_log << TestLog::Message << "glGetFragDataIndex(" << program << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
1556         glw::GLint returnValue = m_gl.getFragDataIndex(program, name);
1557         if (m_enableLog)
1558                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
1559         return returnValue;
1560 }
1561
1562 glw::GLint CallLogWrapper::glGetFragDataLocation (glw::GLuint program, const glw::GLchar *name)
1563 {
1564         if (m_enableLog)
1565                 m_log << TestLog::Message << "glGetFragDataLocation(" << program << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
1566         glw::GLint returnValue = m_gl.getFragDataLocation(program, name);
1567         if (m_enableLog)
1568                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
1569         return returnValue;
1570 }
1571
1572 void CallLogWrapper::glGetFramebufferAttachmentParameteriv (glw::GLenum target, glw::GLenum attachment, glw::GLenum pname, glw::GLint *params)
1573 {
1574         if (m_enableLog)
1575                 m_log << TestLog::Message << "glGetFramebufferAttachmentParameteriv(" << getFramebufferTargetStr(target) << ", " << getFramebufferAttachmentStr(attachment) << ", " << getFramebufferAttachmentParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1576         m_gl.getFramebufferAttachmentParameteriv(target, attachment, pname, params);
1577         if (m_enableLog)
1578                 m_log << TestLog::Message << "// params = " << getFramebufferAttachmentParameterValueStr(pname, params) << TestLog::EndMessage;
1579 }
1580
1581 void CallLogWrapper::glGetFramebufferParameteriv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
1582 {
1583         if (m_enableLog)
1584                 m_log << TestLog::Message << "glGetFramebufferParameteriv(" << getFramebufferTargetStr(target) << ", " << getFramebufferParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1585         m_gl.getFramebufferParameteriv(target, pname, params);
1586         if (m_enableLog)
1587                 m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1588 }
1589
1590 glw::GLenum CallLogWrapper::glGetGraphicsResetStatus (void)
1591 {
1592         if (m_enableLog)
1593                 m_log << TestLog::Message << "glGetGraphicsResetStatus(" << ");" << TestLog::EndMessage;
1594         glw::GLenum returnValue = m_gl.getGraphicsResetStatus();
1595         if (m_enableLog)
1596                 m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
1597         return returnValue;
1598 }
1599
1600 void CallLogWrapper::glGetInteger64i_v (glw::GLenum target, glw::GLuint index, glw::GLint64 *data)
1601 {
1602         if (m_enableLog)
1603                 m_log << TestLog::Message << "glGetInteger64i_v(" << getGettableIndexedStateStr(target) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
1604         m_gl.getInteger64i_v(target, index, data);
1605         if (m_enableLog)
1606                 m_log << TestLog::Message << "// data = " << getPointerStr(data, getIndexedQueryNumArgsOut(target)) << TestLog::EndMessage;
1607 }
1608
1609 void CallLogWrapper::glGetInteger64v (glw::GLenum pname, glw::GLint64 *data)
1610 {
1611         if (m_enableLog)
1612                 m_log << TestLog::Message << "glGetInteger64v(" << getGettableStateStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
1613         m_gl.getInteger64v(pname, data);
1614         if (m_enableLog)
1615                 m_log << TestLog::Message << "// data = " << getPointerStr(data, getBasicQueryNumArgsOut(pname)) << TestLog::EndMessage;
1616 }
1617
1618 void CallLogWrapper::glGetIntegeri_v (glw::GLenum target, glw::GLuint index, glw::GLint *data)
1619 {
1620         if (m_enableLog)
1621                 m_log << TestLog::Message << "glGetIntegeri_v(" << getGettableIndexedStateStr(target) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
1622         m_gl.getIntegeri_v(target, index, data);
1623         if (m_enableLog)
1624                 m_log << TestLog::Message << "// data = " << getPointerStr(data, getIndexedQueryNumArgsOut(target)) << TestLog::EndMessage;
1625 }
1626
1627 void CallLogWrapper::glGetIntegerv (glw::GLenum pname, glw::GLint *data)
1628 {
1629         if (m_enableLog)
1630                 m_log << TestLog::Message << "glGetIntegerv(" << getGettableStateStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
1631         m_gl.getIntegerv(pname, data);
1632         if (m_enableLog)
1633                 m_log << TestLog::Message << "// data = " << getPointerStr(data, getBasicQueryNumArgsOut(pname)) << TestLog::EndMessage;
1634 }
1635
1636 void CallLogWrapper::glGetInternalformati64v (glw::GLenum target, glw::GLenum internalformat, glw::GLenum pname, glw::GLsizei bufSize, glw::GLint64 *params)
1637 {
1638         if (m_enableLog)
1639                 m_log << TestLog::Message << "glGetInternalformati64v(" << toHex(target) << ", " << toHex(internalformat) << ", " << toHex(pname) << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1640         m_gl.getInternalformati64v(target, internalformat, pname, bufSize, params);
1641 }
1642
1643 void CallLogWrapper::glGetInternalformativ (glw::GLenum target, glw::GLenum internalformat, glw::GLenum pname, glw::GLsizei bufSize, glw::GLint *params)
1644 {
1645         if (m_enableLog)
1646                 m_log << TestLog::Message << "glGetInternalformativ(" << getInternalFormatTargetStr(target) << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << getInternalFormatParameterStr(pname) << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1647         m_gl.getInternalformativ(target, internalformat, pname, bufSize, params);
1648         if (m_enableLog)
1649                 m_log << TestLog::Message << "// params = " << getPointerStr(params, bufSize) << TestLog::EndMessage;
1650 }
1651
1652 void CallLogWrapper::glGetMultisamplefv (glw::GLenum pname, glw::GLuint index, glw::GLfloat *val)
1653 {
1654         if (m_enableLog)
1655                 m_log << TestLog::Message << "glGetMultisamplefv(" << getMultisampleParameterStr(pname) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(val))) << ");" << TestLog::EndMessage;
1656         m_gl.getMultisamplefv(pname, index, val);
1657         if (m_enableLog)
1658                 m_log << TestLog::Message << "// val = " << getPointerStr(val, 2) << TestLog::EndMessage;
1659 }
1660
1661 void CallLogWrapper::glGetNamedBufferParameteri64v (glw::GLuint buffer, glw::GLenum pname, glw::GLint64 *params)
1662 {
1663         if (m_enableLog)
1664                 m_log << TestLog::Message << "glGetNamedBufferParameteri64v(" << buffer << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1665         m_gl.getNamedBufferParameteri64v(buffer, pname, params);
1666 }
1667
1668 void CallLogWrapper::glGetNamedBufferParameteriv (glw::GLuint buffer, glw::GLenum pname, glw::GLint *params)
1669 {
1670         if (m_enableLog)
1671                 m_log << TestLog::Message << "glGetNamedBufferParameteriv(" << buffer << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1672         m_gl.getNamedBufferParameteriv(buffer, pname, params);
1673 }
1674
1675 void CallLogWrapper::glGetNamedBufferPointerv (glw::GLuint buffer, glw::GLenum pname, void **params)
1676 {
1677         if (m_enableLog)
1678                 m_log << TestLog::Message << "glGetNamedBufferPointerv(" << buffer << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1679         m_gl.getNamedBufferPointerv(buffer, pname, params);
1680 }
1681
1682 void CallLogWrapper::glGetNamedBufferSubData (glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size, void *data)
1683 {
1684         if (m_enableLog)
1685                 m_log << TestLog::Message << "glGetNamedBufferSubData(" << buffer << ", " << offset << ", " << size << ", " << data << ");" << TestLog::EndMessage;
1686         m_gl.getNamedBufferSubData(buffer, offset, size, data);
1687 }
1688
1689 void CallLogWrapper::glGetNamedFramebufferAttachmentParameteriv (glw::GLuint framebuffer, glw::GLenum attachment, glw::GLenum pname, glw::GLint *params)
1690 {
1691         if (m_enableLog)
1692                 m_log << TestLog::Message << "glGetNamedFramebufferAttachmentParameteriv(" << framebuffer << ", " << toHex(attachment) << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1693         m_gl.getNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
1694 }
1695
1696 void CallLogWrapper::glGetNamedFramebufferParameteriv (glw::GLuint framebuffer, glw::GLenum pname, glw::GLint *param)
1697 {
1698         if (m_enableLog)
1699                 m_log << TestLog::Message << "glGetNamedFramebufferParameteriv(" << framebuffer << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
1700         m_gl.getNamedFramebufferParameteriv(framebuffer, pname, param);
1701 }
1702
1703 void CallLogWrapper::glGetNamedRenderbufferParameteriv (glw::GLuint renderbuffer, glw::GLenum pname, glw::GLint *params)
1704 {
1705         if (m_enableLog)
1706                 m_log << TestLog::Message << "glGetNamedRenderbufferParameteriv(" << renderbuffer << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1707         m_gl.getNamedRenderbufferParameteriv(renderbuffer, pname, params);
1708 }
1709
1710 void CallLogWrapper::glGetObjectLabel (glw::GLenum identifier, glw::GLuint name, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *label)
1711 {
1712         if (m_enableLog)
1713                 m_log << TestLog::Message << "glGetObjectLabel(" << toHex(identifier) << ", " << name << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(label))) << ");" << TestLog::EndMessage;
1714         m_gl.getObjectLabel(identifier, name, bufSize, length, label);
1715 }
1716
1717 void CallLogWrapper::glGetObjectPtrLabel (const void *ptr, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *label)
1718 {
1719         if (m_enableLog)
1720                 m_log << TestLog::Message << "glGetObjectPtrLabel(" << ptr << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(label))) << ");" << TestLog::EndMessage;
1721         m_gl.getObjectPtrLabel(ptr, bufSize, length, label);
1722 }
1723
1724 void CallLogWrapper::glGetPointerv (glw::GLenum pname, void **params)
1725 {
1726         if (m_enableLog)
1727                 m_log << TestLog::Message << "glGetPointerv(" << getPointerStateStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1728         m_gl.getPointerv(pname, params);
1729         if (m_enableLog)
1730                 m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1731 }
1732
1733 void CallLogWrapper::glGetProgramBinary (glw::GLuint program, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLenum *binaryFormat, void *binary)
1734 {
1735         if (m_enableLog)
1736                 m_log << TestLog::Message << "glGetProgramBinary(" << program << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(binaryFormat))) << ", " << binary << ");" << TestLog::EndMessage;
1737         m_gl.getProgramBinary(program, bufSize, length, binaryFormat, binary);
1738 }
1739
1740 void CallLogWrapper::glGetProgramInfoLog (glw::GLuint program, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *infoLog)
1741 {
1742         if (m_enableLog)
1743                 m_log << TestLog::Message << "glGetProgramInfoLog(" << program << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(infoLog))) << ");" << TestLog::EndMessage;
1744         m_gl.getProgramInfoLog(program, bufSize, length, infoLog);
1745         if (m_enableLog)
1746                 m_log << TestLog::Message << "// length = " << getPointerStr(length, 1) << TestLog::EndMessage;
1747 }
1748
1749 void CallLogWrapper::glGetProgramInterfaceiv (glw::GLuint program, glw::GLenum programInterface, glw::GLenum pname, glw::GLint *params)
1750 {
1751         if (m_enableLog)
1752                 m_log << TestLog::Message << "glGetProgramInterfaceiv(" << program << ", " << toHex(programInterface) << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1753         m_gl.getProgramInterfaceiv(program, programInterface, pname, params);
1754 }
1755
1756 void CallLogWrapper::glGetProgramPipelineInfoLog (glw::GLuint pipeline, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *infoLog)
1757 {
1758         if (m_enableLog)
1759                 m_log << TestLog::Message << "glGetProgramPipelineInfoLog(" << pipeline << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(infoLog))) << ");" << TestLog::EndMessage;
1760         m_gl.getProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
1761         if (m_enableLog)
1762                 m_log << TestLog::Message << "// length = " << getPointerStr(length, 1) << TestLog::EndMessage;
1763 }
1764
1765 void CallLogWrapper::glGetProgramPipelineiv (glw::GLuint pipeline, glw::GLenum pname, glw::GLint *params)
1766 {
1767         if (m_enableLog)
1768                 m_log << TestLog::Message << "glGetProgramPipelineiv(" << pipeline << ", " << getPipelineParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1769         m_gl.getProgramPipelineiv(pipeline, pname, params);
1770         if (m_enableLog)
1771                 m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1772 }
1773
1774 glw::GLuint CallLogWrapper::glGetProgramResourceIndex (glw::GLuint program, glw::GLenum programInterface, const glw::GLchar *name)
1775 {
1776         if (m_enableLog)
1777                 m_log << TestLog::Message << "glGetProgramResourceIndex(" << program << ", " << getProgramInterfaceStr(programInterface) << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
1778         glw::GLuint returnValue = m_gl.getProgramResourceIndex(program, programInterface, name);
1779         if (m_enableLog)
1780                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
1781         return returnValue;
1782 }
1783
1784 glw::GLint CallLogWrapper::glGetProgramResourceLocation (glw::GLuint program, glw::GLenum programInterface, const glw::GLchar *name)
1785 {
1786         if (m_enableLog)
1787                 m_log << TestLog::Message << "glGetProgramResourceLocation(" << program << ", " << toHex(programInterface) << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
1788         glw::GLint returnValue = m_gl.getProgramResourceLocation(program, programInterface, name);
1789         if (m_enableLog)
1790                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
1791         return returnValue;
1792 }
1793
1794 glw::GLint CallLogWrapper::glGetProgramResourceLocationIndex (glw::GLuint program, glw::GLenum programInterface, const glw::GLchar *name)
1795 {
1796         if (m_enableLog)
1797                 m_log << TestLog::Message << "glGetProgramResourceLocationIndex(" << program << ", " << toHex(programInterface) << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
1798         glw::GLint returnValue = m_gl.getProgramResourceLocationIndex(program, programInterface, name);
1799         if (m_enableLog)
1800                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
1801         return returnValue;
1802 }
1803
1804 void CallLogWrapper::glGetProgramResourceName (glw::GLuint program, glw::GLenum programInterface, glw::GLuint index, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *name)
1805 {
1806         if (m_enableLog)
1807                 m_log << TestLog::Message << "glGetProgramResourceName(" << program << ", " << toHex(programInterface) << ", " << index << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(name))) << ");" << TestLog::EndMessage;
1808         m_gl.getProgramResourceName(program, programInterface, index, bufSize, length, name);
1809 }
1810
1811 void CallLogWrapper::glGetProgramResourceiv (glw::GLuint program, glw::GLenum programInterface, glw::GLuint index, glw::GLsizei propCount, const glw::GLenum *props, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLint *params)
1812 {
1813         if (m_enableLog)
1814                 m_log << TestLog::Message << "glGetProgramResourceiv(" << program << ", " << getProgramInterfaceStr(programInterface) << ", " << index << ", " << propCount << ", " << getEnumPointerStr(props, propCount, getProgramResourcePropertyName) << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1815         m_gl.getProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
1816         if (m_enableLog)
1817         {
1818                 m_log << TestLog::Message << "// length = " << getPointerStr(length, 1) << TestLog::EndMessage;
1819                 m_log << TestLog::Message << "// params = " << getPointerStr(params, ((length == DE_NULL) ? (bufSize) : ((bufSize < *length) ? (bufSize) : (*length)))) << TestLog::EndMessage;
1820         }
1821 }
1822
1823 void CallLogWrapper::glGetProgramStageiv (glw::GLuint program, glw::GLenum shadertype, glw::GLenum pname, glw::GLint *values)
1824 {
1825         if (m_enableLog)
1826                 m_log << TestLog::Message << "glGetProgramStageiv(" << program << ", " << toHex(shadertype) << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(values))) << ");" << TestLog::EndMessage;
1827         m_gl.getProgramStageiv(program, shadertype, pname, values);
1828 }
1829
1830 void CallLogWrapper::glGetProgramiv (glw::GLuint program, glw::GLenum pname, glw::GLint *params)
1831 {
1832         if (m_enableLog)
1833                 m_log << TestLog::Message << "glGetProgramiv(" << program << ", " << getProgramParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1834         m_gl.getProgramiv(program, pname, params);
1835         if (m_enableLog)
1836                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getProgramQueryNumArgsOut(pname)) << TestLog::EndMessage;
1837 }
1838
1839 void CallLogWrapper::glGetQueryBufferObjecti64v (glw::GLuint id, glw::GLuint buffer, glw::GLenum pname, glw::GLintptr offset)
1840 {
1841         if (m_enableLog)
1842                 m_log << TestLog::Message << "glGetQueryBufferObjecti64v(" << id << ", " << buffer << ", " << toHex(pname) << ", " << offset << ");" << TestLog::EndMessage;
1843         m_gl.getQueryBufferObjecti64v(id, buffer, pname, offset);
1844 }
1845
1846 void CallLogWrapper::glGetQueryBufferObjectiv (glw::GLuint id, glw::GLuint buffer, glw::GLenum pname, glw::GLintptr offset)
1847 {
1848         if (m_enableLog)
1849                 m_log << TestLog::Message << "glGetQueryBufferObjectiv(" << id << ", " << buffer << ", " << toHex(pname) << ", " << offset << ");" << TestLog::EndMessage;
1850         m_gl.getQueryBufferObjectiv(id, buffer, pname, offset);
1851 }
1852
1853 void CallLogWrapper::glGetQueryBufferObjectui64v (glw::GLuint id, glw::GLuint buffer, glw::GLenum pname, glw::GLintptr offset)
1854 {
1855         if (m_enableLog)
1856                 m_log << TestLog::Message << "glGetQueryBufferObjectui64v(" << id << ", " << buffer << ", " << toHex(pname) << ", " << offset << ");" << TestLog::EndMessage;
1857         m_gl.getQueryBufferObjectui64v(id, buffer, pname, offset);
1858 }
1859
1860 void CallLogWrapper::glGetQueryBufferObjectuiv (glw::GLuint id, glw::GLuint buffer, glw::GLenum pname, glw::GLintptr offset)
1861 {
1862         if (m_enableLog)
1863                 m_log << TestLog::Message << "glGetQueryBufferObjectuiv(" << id << ", " << buffer << ", " << toHex(pname) << ", " << offset << ");" << TestLog::EndMessage;
1864         m_gl.getQueryBufferObjectuiv(id, buffer, pname, offset);
1865 }
1866
1867 void CallLogWrapper::glGetQueryIndexediv (glw::GLenum target, glw::GLuint index, glw::GLenum pname, glw::GLint *params)
1868 {
1869         if (m_enableLog)
1870                 m_log << TestLog::Message << "glGetQueryIndexediv(" << toHex(target) << ", " << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1871         m_gl.getQueryIndexediv(target, index, pname, params);
1872 }
1873
1874 void CallLogWrapper::glGetQueryObjecti64v (glw::GLuint id, glw::GLenum pname, glw::GLint64 *params)
1875 {
1876         if (m_enableLog)
1877                 m_log << TestLog::Message << "glGetQueryObjecti64v(" << id << ", " << getQueryObjectParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1878         m_gl.getQueryObjecti64v(id, pname, params);
1879         if (m_enableLog)
1880                 m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1881 }
1882
1883 void CallLogWrapper::glGetQueryObjectiv (glw::GLuint id, glw::GLenum pname, glw::GLint *params)
1884 {
1885         if (m_enableLog)
1886                 m_log << TestLog::Message << "glGetQueryObjectiv(" << id << ", " << getQueryObjectParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1887         m_gl.getQueryObjectiv(id, pname, params);
1888         if (m_enableLog)
1889                 m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1890 }
1891
1892 void CallLogWrapper::glGetQueryObjectui64v (glw::GLuint id, glw::GLenum pname, glw::GLuint64 *params)
1893 {
1894         if (m_enableLog)
1895                 m_log << TestLog::Message << "glGetQueryObjectui64v(" << id << ", " << getQueryObjectParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1896         m_gl.getQueryObjectui64v(id, pname, params);
1897         if (m_enableLog)
1898                 m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1899 }
1900
1901 void CallLogWrapper::glGetQueryObjectuiv (glw::GLuint id, glw::GLenum pname, glw::GLuint *params)
1902 {
1903         if (m_enableLog)
1904                 m_log << TestLog::Message << "glGetQueryObjectuiv(" << id << ", " << getQueryObjectParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1905         m_gl.getQueryObjectuiv(id, pname, params);
1906         if (m_enableLog)
1907                 m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1908 }
1909
1910 void CallLogWrapper::glGetQueryiv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
1911 {
1912         if (m_enableLog)
1913                 m_log << TestLog::Message << "glGetQueryiv(" << getQueryTargetStr(target) << ", " << getQueryParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1914         m_gl.getQueryiv(target, pname, params);
1915         if (m_enableLog)
1916                 m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1917 }
1918
1919 void CallLogWrapper::glGetRenderbufferParameteriv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
1920 {
1921         if (m_enableLog)
1922                 m_log << TestLog::Message << "glGetRenderbufferParameteriv(" << getFramebufferTargetStr(target) << ", " << getRenderbufferParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1923         m_gl.getRenderbufferParameteriv(target, pname, params);
1924 }
1925
1926 void CallLogWrapper::glGetSamplerParameterIiv (glw::GLuint sampler, glw::GLenum pname, glw::GLint *params)
1927 {
1928         if (m_enableLog)
1929                 m_log << TestLog::Message << "glGetSamplerParameterIiv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1930         m_gl.getSamplerParameterIiv(sampler, pname, params);
1931         if (m_enableLog)
1932                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getTextureParamQueryNumArgsOut(pname)) << TestLog::EndMessage;
1933 }
1934
1935 void CallLogWrapper::glGetSamplerParameterIuiv (glw::GLuint sampler, glw::GLenum pname, glw::GLuint *params)
1936 {
1937         if (m_enableLog)
1938                 m_log << TestLog::Message << "glGetSamplerParameterIuiv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1939         m_gl.getSamplerParameterIuiv(sampler, pname, params);
1940         if (m_enableLog)
1941                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getTextureParamQueryNumArgsOut(pname)) << TestLog::EndMessage;
1942 }
1943
1944 void CallLogWrapper::glGetSamplerParameterfv (glw::GLuint sampler, glw::GLenum pname, glw::GLfloat *params)
1945 {
1946         if (m_enableLog)
1947                 m_log << TestLog::Message << "glGetSamplerParameterfv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1948         m_gl.getSamplerParameterfv(sampler, pname, params);
1949         if (m_enableLog)
1950                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getTextureParamQueryNumArgsOut(pname)) << TestLog::EndMessage;
1951 }
1952
1953 void CallLogWrapper::glGetSamplerParameteriv (glw::GLuint sampler, glw::GLenum pname, glw::GLint *params)
1954 {
1955         if (m_enableLog)
1956                 m_log << TestLog::Message << "glGetSamplerParameteriv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1957         m_gl.getSamplerParameteriv(sampler, pname, params);
1958         if (m_enableLog)
1959                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getTextureParamQueryNumArgsOut(pname)) << TestLog::EndMessage;
1960 }
1961
1962 void CallLogWrapper::glGetShaderInfoLog (glw::GLuint shader, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *infoLog)
1963 {
1964         if (m_enableLog)
1965                 m_log << TestLog::Message << "glGetShaderInfoLog(" << shader << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(infoLog))) << ");" << TestLog::EndMessage;
1966         m_gl.getShaderInfoLog(shader, bufSize, length, infoLog);
1967         if (m_enableLog)
1968                 m_log << TestLog::Message << "// length = " << getPointerStr(length, 1) << TestLog::EndMessage;
1969 }
1970
1971 void CallLogWrapper::glGetShaderPrecisionFormat (glw::GLenum shadertype, glw::GLenum precisiontype, glw::GLint *range, glw::GLint *precision)
1972 {
1973         if (m_enableLog)
1974                 m_log << TestLog::Message << "glGetShaderPrecisionFormat(" << getShaderTypeStr(shadertype) << ", " << getPrecisionFormatTypeStr(precisiontype) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(range))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(precision))) << ");" << TestLog::EndMessage;
1975         m_gl.getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
1976 }
1977
1978 void CallLogWrapper::glGetShaderSource (glw::GLuint shader, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *source)
1979 {
1980         if (m_enableLog)
1981                 m_log << TestLog::Message << "glGetShaderSource(" << shader << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(source))) << ");" << TestLog::EndMessage;
1982         m_gl.getShaderSource(shader, bufSize, length, source);
1983 }
1984
1985 void CallLogWrapper::glGetShaderiv (glw::GLuint shader, glw::GLenum pname, glw::GLint *params)
1986 {
1987         if (m_enableLog)
1988                 m_log << TestLog::Message << "glGetShaderiv(" << shader << ", " << getShaderParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
1989         m_gl.getShaderiv(shader, pname, params);
1990         if (m_enableLog)
1991                 m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1992 }
1993
1994 const glw::GLubyte * CallLogWrapper::glGetString (glw::GLenum name)
1995 {
1996         if (m_enableLog)
1997                 m_log << TestLog::Message << "glGetString(" << getGettableStringStr(name) << ");" << TestLog::EndMessage;
1998         const glw::GLubyte * returnValue = m_gl.getString(name);
1999         if (m_enableLog)
2000                 m_log << TestLog::Message << "// " << getStringStr(returnValue) << " returned" << TestLog::EndMessage;
2001         return returnValue;
2002 }
2003
2004 const glw::GLubyte * CallLogWrapper::glGetStringi (glw::GLenum name, glw::GLuint index)
2005 {
2006         if (m_enableLog)
2007                 m_log << TestLog::Message << "glGetStringi(" << getGettableStringStr(name) << ", " << index << ");" << TestLog::EndMessage;
2008         const glw::GLubyte * returnValue = m_gl.getStringi(name, index);
2009         if (m_enableLog)
2010                 m_log << TestLog::Message << "// " << getStringStr(returnValue) << " returned" << TestLog::EndMessage;
2011         return returnValue;
2012 }
2013
2014 glw::GLuint CallLogWrapper::glGetSubroutineIndex (glw::GLuint program, glw::GLenum shadertype, const glw::GLchar *name)
2015 {
2016         if (m_enableLog)
2017                 m_log << TestLog::Message << "glGetSubroutineIndex(" << program << ", " << toHex(shadertype) << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
2018         glw::GLuint returnValue = m_gl.getSubroutineIndex(program, shadertype, name);
2019         if (m_enableLog)
2020                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2021         return returnValue;
2022 }
2023
2024 glw::GLint CallLogWrapper::glGetSubroutineUniformLocation (glw::GLuint program, glw::GLenum shadertype, const glw::GLchar *name)
2025 {
2026         if (m_enableLog)
2027                 m_log << TestLog::Message << "glGetSubroutineUniformLocation(" << program << ", " << toHex(shadertype) << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
2028         glw::GLint returnValue = m_gl.getSubroutineUniformLocation(program, shadertype, name);
2029         if (m_enableLog)
2030                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2031         return returnValue;
2032 }
2033
2034 void CallLogWrapper::glGetSynciv (glw::GLsync sync, glw::GLenum pname, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLint *values)
2035 {
2036         if (m_enableLog)
2037                 m_log << TestLog::Message << "glGetSynciv(" << sync << ", " << toHex(pname) << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(values))) << ");" << TestLog::EndMessage;
2038         m_gl.getSynciv(sync, pname, bufSize, length, values);
2039 }
2040
2041 void CallLogWrapper::glGetTexImage (glw::GLenum target, glw::GLint level, glw::GLenum format, glw::GLenum type, void *pixels)
2042 {
2043         if (m_enableLog)
2044                 m_log << TestLog::Message << "glGetTexImage(" << toHex(target) << ", " << level << ", " << toHex(format) << ", " << toHex(type) << ", " << pixels << ");" << TestLog::EndMessage;
2045         m_gl.getTexImage(target, level, format, type, pixels);
2046 }
2047
2048 void CallLogWrapper::glGetTexLevelParameterfv (glw::GLenum target, glw::GLint level, glw::GLenum pname, glw::GLfloat *params)
2049 {
2050         if (m_enableLog)
2051                 m_log << TestLog::Message << "glGetTexLevelParameterfv(" << getTextureTargetStr(target) << ", " << level << ", " << getTextureLevelParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2052         m_gl.getTexLevelParameterfv(target, level, pname, params);
2053         if (m_enableLog)
2054                 m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
2055 }
2056
2057 void CallLogWrapper::glGetTexLevelParameteriv (glw::GLenum target, glw::GLint level, glw::GLenum pname, glw::GLint *params)
2058 {
2059         if (m_enableLog)
2060                 m_log << TestLog::Message << "glGetTexLevelParameteriv(" << getTextureTargetStr(target) << ", " << level << ", " << getTextureLevelParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2061         m_gl.getTexLevelParameteriv(target, level, pname, params);
2062         if (m_enableLog)
2063                 m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
2064 }
2065
2066 void CallLogWrapper::glGetTexParameterIiv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
2067 {
2068         if (m_enableLog)
2069                 m_log << TestLog::Message << "glGetTexParameterIiv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2070         m_gl.getTexParameterIiv(target, pname, params);
2071         if (m_enableLog)
2072                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getTextureParamQueryNumArgsOut(pname)) << TestLog::EndMessage;
2073 }
2074
2075 void CallLogWrapper::glGetTexParameterIuiv (glw::GLenum target, glw::GLenum pname, glw::GLuint *params)
2076 {
2077         if (m_enableLog)
2078                 m_log << TestLog::Message << "glGetTexParameterIuiv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2079         m_gl.getTexParameterIuiv(target, pname, params);
2080         if (m_enableLog)
2081                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getTextureParamQueryNumArgsOut(pname)) << TestLog::EndMessage;
2082 }
2083
2084 void CallLogWrapper::glGetTexParameterfv (glw::GLenum target, glw::GLenum pname, glw::GLfloat *params)
2085 {
2086         if (m_enableLog)
2087                 m_log << TestLog::Message << "glGetTexParameterfv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2088         m_gl.getTexParameterfv(target, pname, params);
2089         if (m_enableLog)
2090                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getTextureParamQueryNumArgsOut(pname)) << TestLog::EndMessage;
2091 }
2092
2093 void CallLogWrapper::glGetTexParameteriv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
2094 {
2095         if (m_enableLog)
2096                 m_log << TestLog::Message << "glGetTexParameteriv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2097         m_gl.getTexParameteriv(target, pname, params);
2098         if (m_enableLog)
2099                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getTextureParamQueryNumArgsOut(pname)) << TestLog::EndMessage;
2100 }
2101
2102 void CallLogWrapper::glGetTextureImage (glw::GLuint texture, glw::GLint level, glw::GLenum format, glw::GLenum type, glw::GLsizei bufSize, void *pixels)
2103 {
2104         if (m_enableLog)
2105                 m_log << TestLog::Message << "glGetTextureImage(" << texture << ", " << level << ", " << toHex(format) << ", " << toHex(type) << ", " << bufSize << ", " << pixels << ");" << TestLog::EndMessage;
2106         m_gl.getTextureImage(texture, level, format, type, bufSize, pixels);
2107 }
2108
2109 void CallLogWrapper::glGetTextureLevelParameterfv (glw::GLuint texture, glw::GLint level, glw::GLenum pname, glw::GLfloat *params)
2110 {
2111         if (m_enableLog)
2112                 m_log << TestLog::Message << "glGetTextureLevelParameterfv(" << texture << ", " << level << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2113         m_gl.getTextureLevelParameterfv(texture, level, pname, params);
2114 }
2115
2116 void CallLogWrapper::glGetTextureLevelParameteriv (glw::GLuint texture, glw::GLint level, glw::GLenum pname, glw::GLint *params)
2117 {
2118         if (m_enableLog)
2119                 m_log << TestLog::Message << "glGetTextureLevelParameteriv(" << texture << ", " << level << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2120         m_gl.getTextureLevelParameteriv(texture, level, pname, params);
2121 }
2122
2123 void CallLogWrapper::glGetTextureParameterIiv (glw::GLuint texture, glw::GLenum pname, glw::GLint *params)
2124 {
2125         if (m_enableLog)
2126                 m_log << TestLog::Message << "glGetTextureParameterIiv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2127         m_gl.getTextureParameterIiv(texture, pname, params);
2128 }
2129
2130 void CallLogWrapper::glGetTextureParameterIuiv (glw::GLuint texture, glw::GLenum pname, glw::GLuint *params)
2131 {
2132         if (m_enableLog)
2133                 m_log << TestLog::Message << "glGetTextureParameterIuiv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2134         m_gl.getTextureParameterIuiv(texture, pname, params);
2135 }
2136
2137 void CallLogWrapper::glGetTextureParameterfv (glw::GLuint texture, glw::GLenum pname, glw::GLfloat *params)
2138 {
2139         if (m_enableLog)
2140                 m_log << TestLog::Message << "glGetTextureParameterfv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2141         m_gl.getTextureParameterfv(texture, pname, params);
2142 }
2143
2144 void CallLogWrapper::glGetTextureParameteriv (glw::GLuint texture, glw::GLenum pname, glw::GLint *params)
2145 {
2146         if (m_enableLog)
2147                 m_log << TestLog::Message << "glGetTextureParameteriv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2148         m_gl.getTextureParameteriv(texture, pname, params);
2149 }
2150
2151 void CallLogWrapper::glGetTextureSubImage (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, glw::GLsizei bufSize, void *pixels)
2152 {
2153         if (m_enableLog)
2154                 m_log << TestLog::Message << "glGetTextureSubImage(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << toHex(format) << ", " << toHex(type) << ", " << bufSize << ", " << pixels << ");" << TestLog::EndMessage;
2155         m_gl.getTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
2156 }
2157
2158 void CallLogWrapper::glGetTransformFeedbackVarying (glw::GLuint program, glw::GLuint index, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLsizei *size, glw::GLenum *type, glw::GLchar *name)
2159 {
2160         if (m_enableLog)
2161                 m_log << TestLog::Message << "glGetTransformFeedbackVarying(" << 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;
2162         m_gl.getTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
2163 }
2164
2165 void CallLogWrapper::glGetTransformFeedbacki64_v (glw::GLuint xfb, glw::GLenum pname, glw::GLuint index, glw::GLint64 *param)
2166 {
2167         if (m_enableLog)
2168                 m_log << TestLog::Message << "glGetTransformFeedbacki64_v(" << xfb << ", " << toHex(pname) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
2169         m_gl.getTransformFeedbacki64_v(xfb, pname, index, param);
2170 }
2171
2172 void CallLogWrapper::glGetTransformFeedbacki_v (glw::GLuint xfb, glw::GLenum pname, glw::GLuint index, glw::GLint *param)
2173 {
2174         if (m_enableLog)
2175                 m_log << TestLog::Message << "glGetTransformFeedbacki_v(" << xfb << ", " << toHex(pname) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
2176         m_gl.getTransformFeedbacki_v(xfb, pname, index, param);
2177 }
2178
2179 void CallLogWrapper::glGetTransformFeedbackiv (glw::GLuint xfb, glw::GLenum pname, glw::GLint *param)
2180 {
2181         if (m_enableLog)
2182                 m_log << TestLog::Message << "glGetTransformFeedbackiv(" << xfb << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
2183         m_gl.getTransformFeedbackiv(xfb, pname, param);
2184 }
2185
2186 glw::GLuint CallLogWrapper::glGetUniformBlockIndex (glw::GLuint program, const glw::GLchar *uniformBlockName)
2187 {
2188         if (m_enableLog)
2189                 m_log << TestLog::Message << "glGetUniformBlockIndex(" << program << ", " << getStringStr(uniformBlockName) << ");" << TestLog::EndMessage;
2190         glw::GLuint returnValue = m_gl.getUniformBlockIndex(program, uniformBlockName);
2191         if (m_enableLog)
2192                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2193         return returnValue;
2194 }
2195
2196 void CallLogWrapper::glGetUniformIndices (glw::GLuint program, glw::GLsizei uniformCount, const glw::GLchar *const*uniformNames, glw::GLuint *uniformIndices)
2197 {
2198         if (m_enableLog)
2199                 m_log << TestLog::Message << "glGetUniformIndices(" << program << ", " << uniformCount << ", " << getPointerStr(uniformNames, uniformCount) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(uniformIndices))) << ");" << TestLog::EndMessage;
2200         m_gl.getUniformIndices(program, uniformCount, uniformNames, uniformIndices);
2201         if (m_enableLog)
2202                 m_log << TestLog::Message << "// uniformIndices = " << getPointerStr(uniformIndices, uniformCount) << TestLog::EndMessage;
2203 }
2204
2205 glw::GLint CallLogWrapper::glGetUniformLocation (glw::GLuint program, const glw::GLchar *name)
2206 {
2207         if (m_enableLog)
2208                 m_log << TestLog::Message << "glGetUniformLocation(" << program << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
2209         glw::GLint returnValue = m_gl.getUniformLocation(program, name);
2210         if (m_enableLog)
2211                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2212         return returnValue;
2213 }
2214
2215 void CallLogWrapper::glGetUniformSubroutineuiv (glw::GLenum shadertype, glw::GLint location, glw::GLuint *params)
2216 {
2217         if (m_enableLog)
2218                 m_log << TestLog::Message << "glGetUniformSubroutineuiv(" << toHex(shadertype) << ", " << location << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2219         m_gl.getUniformSubroutineuiv(shadertype, location, params);
2220 }
2221
2222 void CallLogWrapper::glGetUniformdv (glw::GLuint program, glw::GLint location, glw::GLdouble *params)
2223 {
2224         if (m_enableLog)
2225                 m_log << TestLog::Message << "glGetUniformdv(" << program << ", " << location << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2226         m_gl.getUniformdv(program, location, params);
2227 }
2228
2229 void CallLogWrapper::glGetUniformfv (glw::GLuint program, glw::GLint location, glw::GLfloat *params)
2230 {
2231         if (m_enableLog)
2232                 m_log << TestLog::Message << "glGetUniformfv(" << program << ", " << location << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2233         m_gl.getUniformfv(program, location, params);
2234 }
2235
2236 void CallLogWrapper::glGetUniformiv (glw::GLuint program, glw::GLint location, glw::GLint *params)
2237 {
2238         if (m_enableLog)
2239                 m_log << TestLog::Message << "glGetUniformiv(" << program << ", " << location << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2240         m_gl.getUniformiv(program, location, params);
2241 }
2242
2243 void CallLogWrapper::glGetUniformuiv (glw::GLuint program, glw::GLint location, glw::GLuint *params)
2244 {
2245         if (m_enableLog)
2246                 m_log << TestLog::Message << "glGetUniformuiv(" << program << ", " << location << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2247         m_gl.getUniformuiv(program, location, params);
2248 }
2249
2250 void CallLogWrapper::glGetVertexArrayIndexed64iv (glw::GLuint vaobj, glw::GLuint index, glw::GLenum pname, glw::GLint64 *param)
2251 {
2252         if (m_enableLog)
2253                 m_log << TestLog::Message << "glGetVertexArrayIndexed64iv(" << vaobj << ", " << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
2254         m_gl.getVertexArrayIndexed64iv(vaobj, index, pname, param);
2255 }
2256
2257 void CallLogWrapper::glGetVertexArrayIndexediv (glw::GLuint vaobj, glw::GLuint index, glw::GLenum pname, glw::GLint *param)
2258 {
2259         if (m_enableLog)
2260                 m_log << TestLog::Message << "glGetVertexArrayIndexediv(" << vaobj << ", " << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
2261         m_gl.getVertexArrayIndexediv(vaobj, index, pname, param);
2262 }
2263
2264 void CallLogWrapper::glGetVertexArrayiv (glw::GLuint vaobj, glw::GLenum pname, glw::GLint *param)
2265 {
2266         if (m_enableLog)
2267                 m_log << TestLog::Message << "glGetVertexArrayiv(" << vaobj << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
2268         m_gl.getVertexArrayiv(vaobj, pname, param);
2269 }
2270
2271 void CallLogWrapper::glGetVertexAttribIiv (glw::GLuint index, glw::GLenum pname, glw::GLint *params)
2272 {
2273         if (m_enableLog)
2274                 m_log << TestLog::Message << "glGetVertexAttribIiv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2275         m_gl.getVertexAttribIiv(index, pname, params);
2276         if (m_enableLog)
2277                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getAttributeQueryNumArgsOut(pname)) << TestLog::EndMessage;
2278 }
2279
2280 void CallLogWrapper::glGetVertexAttribIuiv (glw::GLuint index, glw::GLenum pname, glw::GLuint *params)
2281 {
2282         if (m_enableLog)
2283                 m_log << TestLog::Message << "glGetVertexAttribIuiv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2284         m_gl.getVertexAttribIuiv(index, pname, params);
2285         if (m_enableLog)
2286                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getAttributeQueryNumArgsOut(pname)) << TestLog::EndMessage;
2287 }
2288
2289 void CallLogWrapper::glGetVertexAttribLdv (glw::GLuint index, glw::GLenum pname, glw::GLdouble *params)
2290 {
2291         if (m_enableLog)
2292                 m_log << TestLog::Message << "glGetVertexAttribLdv(" << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2293         m_gl.getVertexAttribLdv(index, pname, params);
2294 }
2295
2296 void CallLogWrapper::glGetVertexAttribPointerv (glw::GLuint index, glw::GLenum pname, void **pointer)
2297 {
2298         if (m_enableLog)
2299                 m_log << TestLog::Message << "glGetVertexAttribPointerv(" << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(pointer))) << ");" << TestLog::EndMessage;
2300         m_gl.getVertexAttribPointerv(index, pname, pointer);
2301 }
2302
2303 void CallLogWrapper::glGetVertexAttribdv (glw::GLuint index, glw::GLenum pname, glw::GLdouble *params)
2304 {
2305         if (m_enableLog)
2306                 m_log << TestLog::Message << "glGetVertexAttribdv(" << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2307         m_gl.getVertexAttribdv(index, pname, params);
2308 }
2309
2310 void CallLogWrapper::glGetVertexAttribfv (glw::GLuint index, glw::GLenum pname, glw::GLfloat *params)
2311 {
2312         if (m_enableLog)
2313                 m_log << TestLog::Message << "glGetVertexAttribfv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2314         m_gl.getVertexAttribfv(index, pname, params);
2315         if (m_enableLog)
2316                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getAttributeQueryNumArgsOut(pname)) << TestLog::EndMessage;
2317 }
2318
2319 void CallLogWrapper::glGetVertexAttribiv (glw::GLuint index, glw::GLenum pname, glw::GLint *params)
2320 {
2321         if (m_enableLog)
2322                 m_log << TestLog::Message << "glGetVertexAttribiv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2323         m_gl.getVertexAttribiv(index, pname, params);
2324         if (m_enableLog)
2325                 m_log << TestLog::Message << "// params = " << getPointerStr(params, getAttributeQueryNumArgsOut(pname)) << TestLog::EndMessage;
2326 }
2327
2328 void CallLogWrapper::glGetnCompressedTexImage (glw::GLenum target, glw::GLint lod, glw::GLsizei bufSize, void *pixels)
2329 {
2330         if (m_enableLog)
2331                 m_log << TestLog::Message << "glGetnCompressedTexImage(" << toHex(target) << ", " << lod << ", " << bufSize << ", " << pixels << ");" << TestLog::EndMessage;
2332         m_gl.getnCompressedTexImage(target, lod, bufSize, pixels);
2333 }
2334
2335 void CallLogWrapper::glGetnTexImage (glw::GLenum target, glw::GLint level, glw::GLenum format, glw::GLenum type, glw::GLsizei bufSize, void *pixels)
2336 {
2337         if (m_enableLog)
2338                 m_log << TestLog::Message << "glGetnTexImage(" << toHex(target) << ", " << level << ", " << toHex(format) << ", " << toHex(type) << ", " << bufSize << ", " << pixels << ");" << TestLog::EndMessage;
2339         m_gl.getnTexImage(target, level, format, type, bufSize, pixels);
2340 }
2341
2342 void CallLogWrapper::glGetnUniformdv (glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, glw::GLdouble *params)
2343 {
2344         if (m_enableLog)
2345                 m_log << TestLog::Message << "glGetnUniformdv(" << program << ", " << location << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2346         m_gl.getnUniformdv(program, location, bufSize, params);
2347 }
2348
2349 void CallLogWrapper::glGetnUniformfv (glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, glw::GLfloat *params)
2350 {
2351         if (m_enableLog)
2352                 m_log << TestLog::Message << "glGetnUniformfv(" << program << ", " << location << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2353         m_gl.getnUniformfv(program, location, bufSize, params);
2354 }
2355
2356 void CallLogWrapper::glGetnUniformiv (glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, glw::GLint *params)
2357 {
2358         if (m_enableLog)
2359                 m_log << TestLog::Message << "glGetnUniformiv(" << program << ", " << location << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2360         m_gl.getnUniformiv(program, location, bufSize, params);
2361 }
2362
2363 void CallLogWrapper::glGetnUniformuiv (glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, glw::GLuint *params)
2364 {
2365         if (m_enableLog)
2366                 m_log << TestLog::Message << "glGetnUniformuiv(" << program << ", " << location << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2367         m_gl.getnUniformuiv(program, location, bufSize, params);
2368 }
2369
2370 void CallLogWrapper::glHint (glw::GLenum target, glw::GLenum mode)
2371 {
2372         if (m_enableLog)
2373                 m_log << TestLog::Message << "glHint(" << getHintStr(target) << ", " << getHintModeStr(mode) << ");" << TestLog::EndMessage;
2374         m_gl.hint(target, mode);
2375 }
2376
2377 void CallLogWrapper::glInsertEventMarkerEXT (glw::GLsizei length, const glw::GLchar *marker)
2378 {
2379         if (m_enableLog)
2380                 m_log << TestLog::Message << "glInsertEventMarkerEXT(" << length << ", " << getStringStr(marker) << ");" << TestLog::EndMessage;
2381         m_gl.insertEventMarkerEXT(length, marker);
2382 }
2383
2384 void CallLogWrapper::glInvalidateBufferData (glw::GLuint buffer)
2385 {
2386         if (m_enableLog)
2387                 m_log << TestLog::Message << "glInvalidateBufferData(" << buffer << ");" << TestLog::EndMessage;
2388         m_gl.invalidateBufferData(buffer);
2389 }
2390
2391 void CallLogWrapper::glInvalidateBufferSubData (glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr length)
2392 {
2393         if (m_enableLog)
2394                 m_log << TestLog::Message << "glInvalidateBufferSubData(" << buffer << ", " << offset << ", " << length << ");" << TestLog::EndMessage;
2395         m_gl.invalidateBufferSubData(buffer, offset, length);
2396 }
2397
2398 void CallLogWrapper::glInvalidateFramebuffer (glw::GLenum target, glw::GLsizei numAttachments, const glw::GLenum *attachments)
2399 {
2400         if (m_enableLog)
2401                 m_log << TestLog::Message << "glInvalidateFramebuffer(" << getFramebufferTargetStr(target) << ", " << numAttachments << ", " << getEnumPointerStr(attachments, numAttachments, getInvalidateAttachmentName) << ");" << TestLog::EndMessage;
2402         m_gl.invalidateFramebuffer(target, numAttachments, attachments);
2403 }
2404
2405 void CallLogWrapper::glInvalidateNamedFramebufferData (glw::GLuint framebuffer, glw::GLsizei numAttachments, const glw::GLenum *attachments)
2406 {
2407         if (m_enableLog)
2408                 m_log << TestLog::Message << "glInvalidateNamedFramebufferData(" << framebuffer << ", " << numAttachments << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(attachments))) << ");" << TestLog::EndMessage;
2409         m_gl.invalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
2410 }
2411
2412 void CallLogWrapper::glInvalidateNamedFramebufferSubData (glw::GLuint framebuffer, glw::GLsizei numAttachments, const glw::GLenum *attachments, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
2413 {
2414         if (m_enableLog)
2415                 m_log << TestLog::Message << "glInvalidateNamedFramebufferSubData(" << framebuffer << ", " << numAttachments << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(attachments))) << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
2416         m_gl.invalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
2417 }
2418
2419 void CallLogWrapper::glInvalidateSubFramebuffer (glw::GLenum target, glw::GLsizei numAttachments, const glw::GLenum *attachments, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
2420 {
2421         if (m_enableLog)
2422                 m_log << TestLog::Message << "glInvalidateSubFramebuffer(" << getFramebufferTargetStr(target) << ", " << numAttachments << ", " << getEnumPointerStr(attachments, numAttachments, getInvalidateAttachmentName) << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
2423         m_gl.invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
2424 }
2425
2426 void CallLogWrapper::glInvalidateTexImage (glw::GLuint texture, glw::GLint level)
2427 {
2428         if (m_enableLog)
2429                 m_log << TestLog::Message << "glInvalidateTexImage(" << texture << ", " << level << ");" << TestLog::EndMessage;
2430         m_gl.invalidateTexImage(texture, level);
2431 }
2432
2433 void CallLogWrapper::glInvalidateTexSubImage (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLint zoffset, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth)
2434 {
2435         if (m_enableLog)
2436                 m_log << TestLog::Message << "glInvalidateTexSubImage(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ");" << TestLog::EndMessage;
2437         m_gl.invalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
2438 }
2439
2440 glw::GLboolean CallLogWrapper::glIsBuffer (glw::GLuint buffer)
2441 {
2442         if (m_enableLog)
2443                 m_log << TestLog::Message << "glIsBuffer(" << buffer << ");" << TestLog::EndMessage;
2444         glw::GLboolean returnValue = m_gl.isBuffer(buffer);
2445         if (m_enableLog)
2446                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2447         return returnValue;
2448 }
2449
2450 glw::GLboolean CallLogWrapper::glIsEnabled (glw::GLenum cap)
2451 {
2452         if (m_enableLog)
2453                 m_log << TestLog::Message << "glIsEnabled(" << getEnableCapStr(cap) << ");" << TestLog::EndMessage;
2454         glw::GLboolean returnValue = m_gl.isEnabled(cap);
2455         if (m_enableLog)
2456                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2457         return returnValue;
2458 }
2459
2460 glw::GLboolean CallLogWrapper::glIsEnabledi (glw::GLenum target, glw::GLuint index)
2461 {
2462         if (m_enableLog)
2463                 m_log << TestLog::Message << "glIsEnabledi(" << getIndexedEnableCapStr(target) << ", " << index << ");" << TestLog::EndMessage;
2464         glw::GLboolean returnValue = m_gl.isEnabledi(target, index);
2465         if (m_enableLog)
2466                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2467         return returnValue;
2468 }
2469
2470 glw::GLboolean CallLogWrapper::glIsFramebuffer (glw::GLuint framebuffer)
2471 {
2472         if (m_enableLog)
2473                 m_log << TestLog::Message << "glIsFramebuffer(" << framebuffer << ");" << TestLog::EndMessage;
2474         glw::GLboolean returnValue = m_gl.isFramebuffer(framebuffer);
2475         if (m_enableLog)
2476                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2477         return returnValue;
2478 }
2479
2480 glw::GLboolean CallLogWrapper::glIsProgram (glw::GLuint program)
2481 {
2482         if (m_enableLog)
2483                 m_log << TestLog::Message << "glIsProgram(" << program << ");" << TestLog::EndMessage;
2484         glw::GLboolean returnValue = m_gl.isProgram(program);
2485         if (m_enableLog)
2486                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2487         return returnValue;
2488 }
2489
2490 glw::GLboolean CallLogWrapper::glIsProgramPipeline (glw::GLuint pipeline)
2491 {
2492         if (m_enableLog)
2493                 m_log << TestLog::Message << "glIsProgramPipeline(" << pipeline << ");" << TestLog::EndMessage;
2494         glw::GLboolean returnValue = m_gl.isProgramPipeline(pipeline);
2495         if (m_enableLog)
2496                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2497         return returnValue;
2498 }
2499
2500 glw::GLboolean CallLogWrapper::glIsQuery (glw::GLuint id)
2501 {
2502         if (m_enableLog)
2503                 m_log << TestLog::Message << "glIsQuery(" << id << ");" << TestLog::EndMessage;
2504         glw::GLboolean returnValue = m_gl.isQuery(id);
2505         if (m_enableLog)
2506                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2507         return returnValue;
2508 }
2509
2510 glw::GLboolean CallLogWrapper::glIsRenderbuffer (glw::GLuint renderbuffer)
2511 {
2512         if (m_enableLog)
2513                 m_log << TestLog::Message << "glIsRenderbuffer(" << renderbuffer << ");" << TestLog::EndMessage;
2514         glw::GLboolean returnValue = m_gl.isRenderbuffer(renderbuffer);
2515         if (m_enableLog)
2516                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2517         return returnValue;
2518 }
2519
2520 glw::GLboolean CallLogWrapper::glIsSampler (glw::GLuint sampler)
2521 {
2522         if (m_enableLog)
2523                 m_log << TestLog::Message << "glIsSampler(" << sampler << ");" << TestLog::EndMessage;
2524         glw::GLboolean returnValue = m_gl.isSampler(sampler);
2525         if (m_enableLog)
2526                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2527         return returnValue;
2528 }
2529
2530 glw::GLboolean CallLogWrapper::glIsShader (glw::GLuint shader)
2531 {
2532         if (m_enableLog)
2533                 m_log << TestLog::Message << "glIsShader(" << shader << ");" << TestLog::EndMessage;
2534         glw::GLboolean returnValue = m_gl.isShader(shader);
2535         if (m_enableLog)
2536                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2537         return returnValue;
2538 }
2539
2540 glw::GLboolean CallLogWrapper::glIsSync (glw::GLsync sync)
2541 {
2542         if (m_enableLog)
2543                 m_log << TestLog::Message << "glIsSync(" << sync << ");" << TestLog::EndMessage;
2544         glw::GLboolean returnValue = m_gl.isSync(sync);
2545         if (m_enableLog)
2546                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2547         return returnValue;
2548 }
2549
2550 glw::GLboolean CallLogWrapper::glIsTexture (glw::GLuint texture)
2551 {
2552         if (m_enableLog)
2553                 m_log << TestLog::Message << "glIsTexture(" << texture << ");" << TestLog::EndMessage;
2554         glw::GLboolean returnValue = m_gl.isTexture(texture);
2555         if (m_enableLog)
2556                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2557         return returnValue;
2558 }
2559
2560 glw::GLboolean CallLogWrapper::glIsTransformFeedback (glw::GLuint id)
2561 {
2562         if (m_enableLog)
2563                 m_log << TestLog::Message << "glIsTransformFeedback(" << id << ");" << TestLog::EndMessage;
2564         glw::GLboolean returnValue = m_gl.isTransformFeedback(id);
2565         if (m_enableLog)
2566                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2567         return returnValue;
2568 }
2569
2570 glw::GLboolean CallLogWrapper::glIsVertexArray (glw::GLuint array)
2571 {
2572         if (m_enableLog)
2573                 m_log << TestLog::Message << "glIsVertexArray(" << array << ");" << TestLog::EndMessage;
2574         glw::GLboolean returnValue = m_gl.isVertexArray(array);
2575         if (m_enableLog)
2576                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2577         return returnValue;
2578 }
2579
2580 void CallLogWrapper::glLineWidth (glw::GLfloat width)
2581 {
2582         if (m_enableLog)
2583                 m_log << TestLog::Message << "glLineWidth(" << width << ");" << TestLog::EndMessage;
2584         m_gl.lineWidth(width);
2585 }
2586
2587 void CallLogWrapper::glLinkProgram (glw::GLuint program)
2588 {
2589         if (m_enableLog)
2590                 m_log << TestLog::Message << "glLinkProgram(" << program << ");" << TestLog::EndMessage;
2591         m_gl.linkProgram(program);
2592 }
2593
2594 void CallLogWrapper::glLogicOp (glw::GLenum opcode)
2595 {
2596         if (m_enableLog)
2597                 m_log << TestLog::Message << "glLogicOp(" << toHex(opcode) << ");" << TestLog::EndMessage;
2598         m_gl.logicOp(opcode);
2599 }
2600
2601 void * CallLogWrapper::glMapBuffer (glw::GLenum target, glw::GLenum access)
2602 {
2603         if (m_enableLog)
2604                 m_log << TestLog::Message << "glMapBuffer(" << toHex(target) << ", " << toHex(access) << ");" << TestLog::EndMessage;
2605         void * returnValue = m_gl.mapBuffer(target, access);
2606         if (m_enableLog)
2607                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2608         return returnValue;
2609 }
2610
2611 void * CallLogWrapper::glMapBufferRange (glw::GLenum target, glw::GLintptr offset, glw::GLsizeiptr length, glw::GLbitfield access)
2612 {
2613         if (m_enableLog)
2614                 m_log << TestLog::Message << "glMapBufferRange(" << getBufferTargetStr(target) << ", " << offset << ", " << length << ", " << getBufferMapFlagsStr(access) << ");" << TestLog::EndMessage;
2615         void * returnValue = m_gl.mapBufferRange(target, offset, length, access);
2616         if (m_enableLog)
2617                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2618         return returnValue;
2619 }
2620
2621 void * CallLogWrapper::glMapNamedBuffer (glw::GLuint buffer, glw::GLenum access)
2622 {
2623         if (m_enableLog)
2624                 m_log << TestLog::Message << "glMapNamedBuffer(" << buffer << ", " << toHex(access) << ");" << TestLog::EndMessage;
2625         void * returnValue = m_gl.mapNamedBuffer(buffer, access);
2626         if (m_enableLog)
2627                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2628         return returnValue;
2629 }
2630
2631 void * CallLogWrapper::glMapNamedBufferRange (glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr length, glw::GLbitfield access)
2632 {
2633         if (m_enableLog)
2634                 m_log << TestLog::Message << "glMapNamedBufferRange(" << buffer << ", " << offset << ", " << length << ", " << toHex(access) << ");" << TestLog::EndMessage;
2635         void * returnValue = m_gl.mapNamedBufferRange(buffer, offset, length, access);
2636         if (m_enableLog)
2637                 m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2638         return returnValue;
2639 }
2640
2641 void CallLogWrapper::glMemoryBarrier (glw::GLbitfield barriers)
2642 {
2643         if (m_enableLog)
2644                 m_log << TestLog::Message << "glMemoryBarrier(" << getMemoryBarrierFlagsStr(barriers) << ");" << TestLog::EndMessage;
2645         m_gl.memoryBarrier(barriers);
2646 }
2647
2648 void CallLogWrapper::glMemoryBarrierByRegion (glw::GLbitfield barriers)
2649 {
2650         if (m_enableLog)
2651                 m_log << TestLog::Message << "glMemoryBarrierByRegion(" << toHex(barriers) << ");" << TestLog::EndMessage;
2652         m_gl.memoryBarrierByRegion(barriers);
2653 }
2654
2655 void CallLogWrapper::glMinSampleShading (glw::GLfloat value)
2656 {
2657         if (m_enableLog)
2658                 m_log << TestLog::Message << "glMinSampleShading(" << value << ");" << TestLog::EndMessage;
2659         m_gl.minSampleShading(value);
2660 }
2661
2662 void CallLogWrapper::glMultiDrawArrays (glw::GLenum mode, const glw::GLint *first, const glw::GLsizei *count, glw::GLsizei drawcount)
2663 {
2664         if (m_enableLog)
2665                 m_log << TestLog::Message << "glMultiDrawArrays(" << getPrimitiveTypeStr(mode) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(first))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(count))) << ", " << drawcount << ");" << TestLog::EndMessage;
2666         m_gl.multiDrawArrays(mode, first, count, drawcount);
2667 }
2668
2669 void CallLogWrapper::glMultiDrawArraysIndirect (glw::GLenum mode, const void *indirect, glw::GLsizei drawcount, glw::GLsizei stride)
2670 {
2671         if (m_enableLog)
2672                 m_log << TestLog::Message << "glMultiDrawArraysIndirect(" << toHex(mode) << ", " << indirect << ", " << drawcount << ", " << stride << ");" << TestLog::EndMessage;
2673         m_gl.multiDrawArraysIndirect(mode, indirect, drawcount, stride);
2674 }
2675
2676 void CallLogWrapper::glMultiDrawElements (glw::GLenum mode, const glw::GLsizei *count, glw::GLenum type, const void *const*indices, glw::GLsizei drawcount)
2677 {
2678         if (m_enableLog)
2679                 m_log << TestLog::Message << "glMultiDrawElements(" << getPrimitiveTypeStr(mode) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(count))) << ", " << getTypeStr(type) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(indices))) << ", " << drawcount << ");" << TestLog::EndMessage;
2680         m_gl.multiDrawElements(mode, count, type, indices, drawcount);
2681 }
2682
2683 void CallLogWrapper::glMultiDrawElementsBaseVertex (glw::GLenum mode, const glw::GLsizei *count, glw::GLenum type, const void *const*indices, glw::GLsizei drawcount, const glw::GLint *basevertex)
2684 {
2685         if (m_enableLog)
2686                 m_log << TestLog::Message << "glMultiDrawElementsBaseVertex(" << getPrimitiveTypeStr(mode) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(count))) << ", " << getTypeStr(type) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(indices))) << ", " << drawcount << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(basevertex))) << ");" << TestLog::EndMessage;
2687         m_gl.multiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
2688 }
2689
2690 void CallLogWrapper::glMultiDrawElementsIndirect (glw::GLenum mode, glw::GLenum type, const void *indirect, glw::GLsizei drawcount, glw::GLsizei stride)
2691 {
2692         if (m_enableLog)
2693                 m_log << TestLog::Message << "glMultiDrawElementsIndirect(" << toHex(mode) << ", " << toHex(type) << ", " << indirect << ", " << drawcount << ", " << stride << ");" << TestLog::EndMessage;
2694         m_gl.multiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
2695 }
2696
2697 void CallLogWrapper::glNamedBufferData (glw::GLuint buffer, glw::GLsizeiptr size, const void *data, glw::GLenum usage)
2698 {
2699         if (m_enableLog)
2700                 m_log << TestLog::Message << "glNamedBufferData(" << buffer << ", " << size << ", " << data << ", " << toHex(usage) << ");" << TestLog::EndMessage;
2701         m_gl.namedBufferData(buffer, size, data, usage);
2702 }
2703
2704 void CallLogWrapper::glNamedBufferStorage (glw::GLuint buffer, glw::GLsizeiptr size, const void *data, glw::GLbitfield flags)
2705 {
2706         if (m_enableLog)
2707                 m_log << TestLog::Message << "glNamedBufferStorage(" << buffer << ", " << size << ", " << data << ", " << toHex(flags) << ");" << TestLog::EndMessage;
2708         m_gl.namedBufferStorage(buffer, size, data, flags);
2709 }
2710
2711 void CallLogWrapper::glNamedBufferSubData (glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size, const void *data)
2712 {
2713         if (m_enableLog)
2714                 m_log << TestLog::Message << "glNamedBufferSubData(" << buffer << ", " << offset << ", " << size << ", " << data << ");" << TestLog::EndMessage;
2715         m_gl.namedBufferSubData(buffer, offset, size, data);
2716 }
2717
2718 void CallLogWrapper::glNamedFramebufferDrawBuffer (glw::GLuint framebuffer, glw::GLenum buf)
2719 {
2720         if (m_enableLog)
2721                 m_log << TestLog::Message << "glNamedFramebufferDrawBuffer(" << framebuffer << ", " << toHex(buf) << ");" << TestLog::EndMessage;
2722         m_gl.namedFramebufferDrawBuffer(framebuffer, buf);
2723 }
2724
2725 void CallLogWrapper::glNamedFramebufferDrawBuffers (glw::GLuint framebuffer, glw::GLsizei n, const glw::GLenum *bufs)
2726 {
2727         if (m_enableLog)
2728                 m_log << TestLog::Message << "glNamedFramebufferDrawBuffers(" << framebuffer << ", " << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(bufs))) << ");" << TestLog::EndMessage;
2729         m_gl.namedFramebufferDrawBuffers(framebuffer, n, bufs);
2730 }
2731
2732 void CallLogWrapper::glNamedFramebufferParameteri (glw::GLuint framebuffer, glw::GLenum pname, glw::GLint param)
2733 {
2734         if (m_enableLog)
2735                 m_log << TestLog::Message << "glNamedFramebufferParameteri(" << framebuffer << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
2736         m_gl.namedFramebufferParameteri(framebuffer, pname, param);
2737 }
2738
2739 void CallLogWrapper::glNamedFramebufferReadBuffer (glw::GLuint framebuffer, glw::GLenum src)
2740 {
2741         if (m_enableLog)
2742                 m_log << TestLog::Message << "glNamedFramebufferReadBuffer(" << framebuffer << ", " << toHex(src) << ");" << TestLog::EndMessage;
2743         m_gl.namedFramebufferReadBuffer(framebuffer, src);
2744 }
2745
2746 void CallLogWrapper::glNamedFramebufferRenderbuffer (glw::GLuint framebuffer, glw::GLenum attachment, glw::GLenum renderbuffertarget, glw::GLuint renderbuffer)
2747 {
2748         if (m_enableLog)
2749                 m_log << TestLog::Message << "glNamedFramebufferRenderbuffer(" << framebuffer << ", " << toHex(attachment) << ", " << toHex(renderbuffertarget) << ", " << renderbuffer << ");" << TestLog::EndMessage;
2750         m_gl.namedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
2751 }
2752
2753 void CallLogWrapper::glNamedFramebufferTexture (glw::GLuint framebuffer, glw::GLenum attachment, glw::GLuint texture, glw::GLint level)
2754 {
2755         if (m_enableLog)
2756                 m_log << TestLog::Message << "glNamedFramebufferTexture(" << framebuffer << ", " << toHex(attachment) << ", " << texture << ", " << level << ");" << TestLog::EndMessage;
2757         m_gl.namedFramebufferTexture(framebuffer, attachment, texture, level);
2758 }
2759
2760 void CallLogWrapper::glNamedFramebufferTextureLayer (glw::GLuint framebuffer, glw::GLenum attachment, glw::GLuint texture, glw::GLint level, glw::GLint layer)
2761 {
2762         if (m_enableLog)
2763                 m_log << TestLog::Message << "glNamedFramebufferTextureLayer(" << framebuffer << ", " << toHex(attachment) << ", " << texture << ", " << level << ", " << layer << ");" << TestLog::EndMessage;
2764         m_gl.namedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
2765 }
2766
2767 void CallLogWrapper::glNamedRenderbufferStorage (glw::GLuint renderbuffer, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height)
2768 {
2769         if (m_enableLog)
2770                 m_log << TestLog::Message << "glNamedRenderbufferStorage(" << renderbuffer << ", " << toHex(internalformat) << ", " << width << ", " << height << ");" << TestLog::EndMessage;
2771         m_gl.namedRenderbufferStorage(renderbuffer, internalformat, width, height);
2772 }
2773
2774 void CallLogWrapper::glNamedRenderbufferStorageMultisample (glw::GLuint renderbuffer, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height)
2775 {
2776         if (m_enableLog)
2777                 m_log << TestLog::Message << "glNamedRenderbufferStorageMultisample(" << renderbuffer << ", " << samples << ", " << toHex(internalformat) << ", " << width << ", " << height << ");" << TestLog::EndMessage;
2778         m_gl.namedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
2779 }
2780
2781 void CallLogWrapper::glObjectLabel (glw::GLenum identifier, glw::GLuint name, glw::GLsizei length, const glw::GLchar *label)
2782 {
2783         if (m_enableLog)
2784                 m_log << TestLog::Message << "glObjectLabel(" << toHex(identifier) << ", " << name << ", " << length << ", " << getStringStr(label) << ");" << TestLog::EndMessage;
2785         m_gl.objectLabel(identifier, name, length, label);
2786 }
2787
2788 void CallLogWrapper::glObjectPtrLabel (const void *ptr, glw::GLsizei length, const glw::GLchar *label)
2789 {
2790         if (m_enableLog)
2791                 m_log << TestLog::Message << "glObjectPtrLabel(" << ptr << ", " << length << ", " << getStringStr(label) << ");" << TestLog::EndMessage;
2792         m_gl.objectPtrLabel(ptr, length, label);
2793 }
2794
2795 void CallLogWrapper::glPatchParameterfv (glw::GLenum pname, const glw::GLfloat *values)
2796 {
2797         if (m_enableLog)
2798                 m_log << TestLog::Message << "glPatchParameterfv(" << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(values))) << ");" << TestLog::EndMessage;
2799         m_gl.patchParameterfv(pname, values);
2800 }
2801
2802 void CallLogWrapper::glPatchParameteri (glw::GLenum pname, glw::GLint value)
2803 {
2804         if (m_enableLog)
2805                 m_log << TestLog::Message << "glPatchParameteri(" << getPatchParamStr(pname) << ", " << value << ");" << TestLog::EndMessage;
2806         m_gl.patchParameteri(pname, value);
2807 }
2808
2809 void CallLogWrapper::glPauseTransformFeedback (void)
2810 {
2811         if (m_enableLog)
2812                 m_log << TestLog::Message << "glPauseTransformFeedback(" << ");" << TestLog::EndMessage;
2813         m_gl.pauseTransformFeedback();
2814 }
2815
2816 void CallLogWrapper::glPixelStoref (glw::GLenum pname, glw::GLfloat param)
2817 {
2818         if (m_enableLog)
2819                 m_log << TestLog::Message << "glPixelStoref(" << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
2820         m_gl.pixelStoref(pname, param);
2821 }
2822
2823 void CallLogWrapper::glPixelStorei (glw::GLenum pname, glw::GLint param)
2824 {
2825         if (m_enableLog)
2826                 m_log << TestLog::Message << "glPixelStorei(" << getPixelStoreParameterStr(pname) << ", " << param << ");" << TestLog::EndMessage;
2827         m_gl.pixelStorei(pname, param);
2828 }
2829
2830 void CallLogWrapper::glPointParameterf (glw::GLenum pname, glw::GLfloat param)
2831 {
2832         if (m_enableLog)
2833                 m_log << TestLog::Message << "glPointParameterf(" << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
2834         m_gl.pointParameterf(pname, param);
2835 }
2836
2837 void CallLogWrapper::glPointParameterfv (glw::GLenum pname, const glw::GLfloat *params)
2838 {
2839         if (m_enableLog)
2840                 m_log << TestLog::Message << "glPointParameterfv(" << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2841         m_gl.pointParameterfv(pname, params);
2842 }
2843
2844 void CallLogWrapper::glPointParameteri (glw::GLenum pname, glw::GLint param)
2845 {
2846         if (m_enableLog)
2847                 m_log << TestLog::Message << "glPointParameteri(" << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
2848         m_gl.pointParameteri(pname, param);
2849 }
2850
2851 void CallLogWrapper::glPointParameteriv (glw::GLenum pname, const glw::GLint *params)
2852 {
2853         if (m_enableLog)
2854                 m_log << TestLog::Message << "glPointParameteriv(" << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
2855         m_gl.pointParameteriv(pname, params);
2856 }
2857
2858 void CallLogWrapper::glPointSize (glw::GLfloat size)
2859 {
2860         if (m_enableLog)
2861                 m_log << TestLog::Message << "glPointSize(" << size << ");" << TestLog::EndMessage;
2862         m_gl.pointSize(size);
2863 }
2864
2865 void CallLogWrapper::glPolygonMode (glw::GLenum face, glw::GLenum mode)
2866 {
2867         if (m_enableLog)
2868                 m_log << TestLog::Message << "glPolygonMode(" << toHex(face) << ", " << toHex(mode) << ");" << TestLog::EndMessage;
2869         m_gl.polygonMode(face, mode);
2870 }
2871
2872 void CallLogWrapper::glPolygonOffset (glw::GLfloat factor, glw::GLfloat units)
2873 {
2874         if (m_enableLog)
2875                 m_log << TestLog::Message << "glPolygonOffset(" << factor << ", " << units << ");" << TestLog::EndMessage;
2876         m_gl.polygonOffset(factor, units);
2877 }
2878
2879 void CallLogWrapper::glPopDebugGroup (void)
2880 {
2881         if (m_enableLog)
2882                 m_log << TestLog::Message << "glPopDebugGroup(" << ");" << TestLog::EndMessage;
2883         m_gl.popDebugGroup();
2884 }
2885
2886 void CallLogWrapper::glPopGroupMarkerEXT (void)
2887 {
2888         if (m_enableLog)
2889                 m_log << TestLog::Message << "glPopGroupMarkerEXT(" << ");" << TestLog::EndMessage;
2890         m_gl.popGroupMarkerEXT();
2891 }
2892
2893 void CallLogWrapper::glPrimitiveBoundingBoxEXT (glw::GLfloat minX, glw::GLfloat minY, glw::GLfloat minZ, glw::GLfloat minW, glw::GLfloat maxX, glw::GLfloat maxY, glw::GLfloat maxZ, glw::GLfloat maxW)
2894 {
2895         if (m_enableLog)
2896                 m_log << TestLog::Message << "glPrimitiveBoundingBoxEXT(" << minX << ", " << minY << ", " << minZ << ", " << minW << ", " << maxX << ", " << maxY << ", " << maxZ << ", " << maxW << ");" << TestLog::EndMessage;
2897         m_gl.primitiveBoundingBoxEXT(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
2898 }
2899
2900 void CallLogWrapper::glPrimitiveRestartIndex (glw::GLuint index)
2901 {
2902         if (m_enableLog)
2903                 m_log << TestLog::Message << "glPrimitiveRestartIndex(" << index << ");" << TestLog::EndMessage;
2904         m_gl.primitiveRestartIndex(index);
2905 }
2906
2907 void CallLogWrapper::glProgramBinary (glw::GLuint program, glw::GLenum binaryFormat, const void *binary, glw::GLsizei length)
2908 {
2909         if (m_enableLog)
2910                 m_log << TestLog::Message << "glProgramBinary(" << program << ", " << toHex(binaryFormat) << ", " << binary << ", " << length << ");" << TestLog::EndMessage;
2911         m_gl.programBinary(program, binaryFormat, binary, length);
2912 }
2913
2914 void CallLogWrapper::glProgramParameteri (glw::GLuint program, glw::GLenum pname, glw::GLint value)
2915 {
2916         if (m_enableLog)
2917                 m_log << TestLog::Message << "glProgramParameteri(" << program << ", " << getProgramParamStr(pname) << ", " << value << ");" << TestLog::EndMessage;
2918         m_gl.programParameteri(program, pname, value);
2919 }
2920
2921 void CallLogWrapper::glProgramUniform1d (glw::GLuint program, glw::GLint location, glw::GLdouble v0)
2922 {
2923         if (m_enableLog)
2924                 m_log << TestLog::Message << "glProgramUniform1d(" << program << ", " << location << ", " << v0 << ");" << TestLog::EndMessage;
2925         m_gl.programUniform1d(program, location, v0);
2926 }
2927
2928 void CallLogWrapper::glProgramUniform1dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
2929 {
2930         if (m_enableLog)
2931                 m_log << TestLog::Message << "glProgramUniform1dv(" << program << ", " << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
2932         m_gl.programUniform1dv(program, location, count, value);
2933 }
2934
2935 void CallLogWrapper::glProgramUniform1f (glw::GLuint program, glw::GLint location, glw::GLfloat v0)
2936 {
2937         if (m_enableLog)
2938                 m_log << TestLog::Message << "glProgramUniform1f(" << program << ", " << location << ", " << v0 << ");" << TestLog::EndMessage;
2939         m_gl.programUniform1f(program, location, v0);
2940 }
2941
2942 void CallLogWrapper::glProgramUniform1fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
2943 {
2944         if (m_enableLog)
2945                 m_log << TestLog::Message << "glProgramUniform1fv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 1)) << ");" << TestLog::EndMessage;
2946         m_gl.programUniform1fv(program, location, count, value);
2947 }
2948
2949 void CallLogWrapper::glProgramUniform1i (glw::GLuint program, glw::GLint location, glw::GLint v0)
2950 {
2951         if (m_enableLog)
2952                 m_log << TestLog::Message << "glProgramUniform1i(" << program << ", " << location << ", " << v0 << ");" << TestLog::EndMessage;
2953         m_gl.programUniform1i(program, location, v0);
2954 }
2955
2956 void CallLogWrapper::glProgramUniform1iv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLint *value)
2957 {
2958         if (m_enableLog)
2959                 m_log << TestLog::Message << "glProgramUniform1iv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 1)) << ");" << TestLog::EndMessage;
2960         m_gl.programUniform1iv(program, location, count, value);
2961 }
2962
2963 void CallLogWrapper::glProgramUniform1ui (glw::GLuint program, glw::GLint location, glw::GLuint v0)
2964 {
2965         if (m_enableLog)
2966                 m_log << TestLog::Message << "glProgramUniform1ui(" << program << ", " << location << ", " << v0 << ");" << TestLog::EndMessage;
2967         m_gl.programUniform1ui(program, location, v0);
2968 }
2969
2970 void CallLogWrapper::glProgramUniform1uiv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
2971 {
2972         if (m_enableLog)
2973                 m_log << TestLog::Message << "glProgramUniform1uiv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 1)) << ");" << TestLog::EndMessage;
2974         m_gl.programUniform1uiv(program, location, count, value);
2975 }
2976
2977 void CallLogWrapper::glProgramUniform2d (glw::GLuint program, glw::GLint location, glw::GLdouble v0, glw::GLdouble v1)
2978 {
2979         if (m_enableLog)
2980                 m_log << TestLog::Message << "glProgramUniform2d(" << program << ", " << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
2981         m_gl.programUniform2d(program, location, v0, v1);
2982 }
2983
2984 void CallLogWrapper::glProgramUniform2dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
2985 {
2986         if (m_enableLog)
2987                 m_log << TestLog::Message << "glProgramUniform2dv(" << program << ", " << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
2988         m_gl.programUniform2dv(program, location, count, value);
2989 }
2990
2991 void CallLogWrapper::glProgramUniform2f (glw::GLuint program, glw::GLint location, glw::GLfloat v0, glw::GLfloat v1)
2992 {
2993         if (m_enableLog)
2994                 m_log << TestLog::Message << "glProgramUniform2f(" << program << ", " << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
2995         m_gl.programUniform2f(program, location, v0, v1);
2996 }
2997
2998 void CallLogWrapper::glProgramUniform2fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
2999 {
3000         if (m_enableLog)
3001                 m_log << TestLog::Message << "glProgramUniform2fv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 2)) << ");" << TestLog::EndMessage;
3002         m_gl.programUniform2fv(program, location, count, value);
3003 }
3004
3005 void CallLogWrapper::glProgramUniform2i (glw::GLuint program, glw::GLint location, glw::GLint v0, glw::GLint v1)
3006 {
3007         if (m_enableLog)
3008                 m_log << TestLog::Message << "glProgramUniform2i(" << program << ", " << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
3009         m_gl.programUniform2i(program, location, v0, v1);
3010 }
3011
3012 void CallLogWrapper::glProgramUniform2iv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3013 {
3014         if (m_enableLog)
3015                 m_log << TestLog::Message << "glProgramUniform2iv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 2)) << ");" << TestLog::EndMessage;
3016         m_gl.programUniform2iv(program, location, count, value);
3017 }
3018
3019 void CallLogWrapper::glProgramUniform2ui (glw::GLuint program, glw::GLint location, glw::GLuint v0, glw::GLuint v1)
3020 {
3021         if (m_enableLog)
3022                 m_log << TestLog::Message << "glProgramUniform2ui(" << program << ", " << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
3023         m_gl.programUniform2ui(program, location, v0, v1);
3024 }
3025
3026 void CallLogWrapper::glProgramUniform2uiv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
3027 {
3028         if (m_enableLog)
3029                 m_log << TestLog::Message << "glProgramUniform2uiv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 2)) << ");" << TestLog::EndMessage;
3030         m_gl.programUniform2uiv(program, location, count, value);
3031 }
3032
3033 void CallLogWrapper::glProgramUniform3d (glw::GLuint program, glw::GLint location, glw::GLdouble v0, glw::GLdouble v1, glw::GLdouble v2)
3034 {
3035         if (m_enableLog)
3036                 m_log << TestLog::Message << "glProgramUniform3d(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3037         m_gl.programUniform3d(program, location, v0, v1, v2);
3038 }
3039
3040 void CallLogWrapper::glProgramUniform3dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
3041 {
3042         if (m_enableLog)
3043                 m_log << TestLog::Message << "glProgramUniform3dv(" << program << ", " << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3044         m_gl.programUniform3dv(program, location, count, value);
3045 }
3046
3047 void CallLogWrapper::glProgramUniform3f (glw::GLuint program, glw::GLint location, glw::GLfloat v0, glw::GLfloat v1, glw::GLfloat v2)
3048 {
3049         if (m_enableLog)
3050                 m_log << TestLog::Message << "glProgramUniform3f(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3051         m_gl.programUniform3f(program, location, v0, v1, v2);
3052 }
3053
3054 void CallLogWrapper::glProgramUniform3fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
3055 {
3056         if (m_enableLog)
3057                 m_log << TestLog::Message << "glProgramUniform3fv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 3)) << ");" << TestLog::EndMessage;
3058         m_gl.programUniform3fv(program, location, count, value);
3059 }
3060
3061 void CallLogWrapper::glProgramUniform3i (glw::GLuint program, glw::GLint location, glw::GLint v0, glw::GLint v1, glw::GLint v2)
3062 {
3063         if (m_enableLog)
3064                 m_log << TestLog::Message << "glProgramUniform3i(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3065         m_gl.programUniform3i(program, location, v0, v1, v2);
3066 }
3067
3068 void CallLogWrapper::glProgramUniform3iv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3069 {
3070         if (m_enableLog)
3071                 m_log << TestLog::Message << "glProgramUniform3iv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 3)) << ");" << TestLog::EndMessage;
3072         m_gl.programUniform3iv(program, location, count, value);
3073 }
3074
3075 void CallLogWrapper::glProgramUniform3ui (glw::GLuint program, glw::GLint location, glw::GLuint v0, glw::GLuint v1, glw::GLuint v2)
3076 {
3077         if (m_enableLog)
3078                 m_log << TestLog::Message << "glProgramUniform3ui(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3079         m_gl.programUniform3ui(program, location, v0, v1, v2);
3080 }
3081
3082 void CallLogWrapper::glProgramUniform3uiv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
3083 {
3084         if (m_enableLog)
3085                 m_log << TestLog::Message << "glProgramUniform3uiv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 3)) << ");" << TestLog::EndMessage;
3086         m_gl.programUniform3uiv(program, location, count, value);
3087 }
3088
3089 void CallLogWrapper::glProgramUniform4d (glw::GLuint program, glw::GLint location, glw::GLdouble v0, glw::GLdouble v1, glw::GLdouble v2, glw::GLdouble v3)
3090 {
3091         if (m_enableLog)
3092                 m_log << TestLog::Message << "glProgramUniform4d(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3093         m_gl.programUniform4d(program, location, v0, v1, v2, v3);
3094 }
3095
3096 void CallLogWrapper::glProgramUniform4dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
3097 {
3098         if (m_enableLog)
3099                 m_log << TestLog::Message << "glProgramUniform4dv(" << program << ", " << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3100         m_gl.programUniform4dv(program, location, count, value);
3101 }
3102
3103 void CallLogWrapper::glProgramUniform4f (glw::GLuint program, glw::GLint location, glw::GLfloat v0, glw::GLfloat v1, glw::GLfloat v2, glw::GLfloat v3)
3104 {
3105         if (m_enableLog)
3106                 m_log << TestLog::Message << "glProgramUniform4f(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3107         m_gl.programUniform4f(program, location, v0, v1, v2, v3);
3108 }
3109
3110 void CallLogWrapper::glProgramUniform4fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
3111 {
3112         if (m_enableLog)
3113                 m_log << TestLog::Message << "glProgramUniform4fv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 4)) << ");" << TestLog::EndMessage;
3114         m_gl.programUniform4fv(program, location, count, value);
3115 }
3116
3117 void CallLogWrapper::glProgramUniform4i (glw::GLuint program, glw::GLint location, glw::GLint v0, glw::GLint v1, glw::GLint v2, glw::GLint v3)
3118 {
3119         if (m_enableLog)
3120                 m_log << TestLog::Message << "glProgramUniform4i(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3121         m_gl.programUniform4i(program, location, v0, v1, v2, v3);
3122 }
3123
3124 void CallLogWrapper::glProgramUniform4iv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3125 {
3126         if (m_enableLog)
3127                 m_log << TestLog::Message << "glProgramUniform4iv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 4)) << ");" << TestLog::EndMessage;
3128         m_gl.programUniform4iv(program, location, count, value);
3129 }
3130
3131 void CallLogWrapper::glProgramUniform4ui (glw::GLuint program, glw::GLint location, glw::GLuint v0, glw::GLuint v1, glw::GLuint v2, glw::GLuint v3)
3132 {
3133         if (m_enableLog)
3134                 m_log << TestLog::Message << "glProgramUniform4ui(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3135         m_gl.programUniform4ui(program, location, v0, v1, v2, v3);
3136 }
3137
3138 void CallLogWrapper::glProgramUniform4uiv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
3139 {
3140         if (m_enableLog)
3141                 m_log << TestLog::Message << "glProgramUniform4uiv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 4)) << ");" << TestLog::EndMessage;
3142         m_gl.programUniform4uiv(program, location, count, value);
3143 }
3144
3145 void CallLogWrapper::glProgramUniformMatrix2dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3146 {
3147         if (m_enableLog)
3148                 m_log << TestLog::Message << "glProgramUniformMatrix2dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3149         m_gl.programUniformMatrix2dv(program, location, count, transpose, value);
3150 }
3151
3152 void CallLogWrapper::glProgramUniformMatrix2fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3153 {
3154         if (m_enableLog)
3155                 m_log << TestLog::Message << "glProgramUniformMatrix2fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 2*2)) << ");" << TestLog::EndMessage;
3156         m_gl.programUniformMatrix2fv(program, location, count, transpose, value);
3157 }
3158
3159 void CallLogWrapper::glProgramUniformMatrix2x3dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3160 {
3161         if (m_enableLog)
3162                 m_log << TestLog::Message << "glProgramUniformMatrix2x3dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3163         m_gl.programUniformMatrix2x3dv(program, location, count, transpose, value);
3164 }
3165
3166 void CallLogWrapper::glProgramUniformMatrix2x3fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3167 {
3168         if (m_enableLog)
3169                 m_log << TestLog::Message << "glProgramUniformMatrix2x3fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 2*3)) << ");" << TestLog::EndMessage;
3170         m_gl.programUniformMatrix2x3fv(program, location, count, transpose, value);
3171 }
3172
3173 void CallLogWrapper::glProgramUniformMatrix2x4dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3174 {
3175         if (m_enableLog)
3176                 m_log << TestLog::Message << "glProgramUniformMatrix2x4dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3177         m_gl.programUniformMatrix2x4dv(program, location, count, transpose, value);
3178 }
3179
3180 void CallLogWrapper::glProgramUniformMatrix2x4fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3181 {
3182         if (m_enableLog)
3183                 m_log << TestLog::Message << "glProgramUniformMatrix2x4fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 2*4)) << ");" << TestLog::EndMessage;
3184         m_gl.programUniformMatrix2x4fv(program, location, count, transpose, value);
3185 }
3186
3187 void CallLogWrapper::glProgramUniformMatrix3dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3188 {
3189         if (m_enableLog)
3190                 m_log << TestLog::Message << "glProgramUniformMatrix3dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3191         m_gl.programUniformMatrix3dv(program, location, count, transpose, value);
3192 }
3193
3194 void CallLogWrapper::glProgramUniformMatrix3fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3195 {
3196         if (m_enableLog)
3197                 m_log << TestLog::Message << "glProgramUniformMatrix3fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 3*3)) << ");" << TestLog::EndMessage;
3198         m_gl.programUniformMatrix3fv(program, location, count, transpose, value);
3199 }
3200
3201 void CallLogWrapper::glProgramUniformMatrix3x2dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3202 {
3203         if (m_enableLog)
3204                 m_log << TestLog::Message << "glProgramUniformMatrix3x2dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3205         m_gl.programUniformMatrix3x2dv(program, location, count, transpose, value);
3206 }
3207
3208 void CallLogWrapper::glProgramUniformMatrix3x2fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3209 {
3210         if (m_enableLog)
3211                 m_log << TestLog::Message << "glProgramUniformMatrix3x2fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 3*2)) << ");" << TestLog::EndMessage;
3212         m_gl.programUniformMatrix3x2fv(program, location, count, transpose, value);
3213 }
3214
3215 void CallLogWrapper::glProgramUniformMatrix3x4dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3216 {
3217         if (m_enableLog)
3218                 m_log << TestLog::Message << "glProgramUniformMatrix3x4dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3219         m_gl.programUniformMatrix3x4dv(program, location, count, transpose, value);
3220 }
3221
3222 void CallLogWrapper::glProgramUniformMatrix3x4fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3223 {
3224         if (m_enableLog)
3225                 m_log << TestLog::Message << "glProgramUniformMatrix3x4fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 3*4)) << ");" << TestLog::EndMessage;
3226         m_gl.programUniformMatrix3x4fv(program, location, count, transpose, value);
3227 }
3228
3229 void CallLogWrapper::glProgramUniformMatrix4dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3230 {
3231         if (m_enableLog)
3232                 m_log << TestLog::Message << "glProgramUniformMatrix4dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3233         m_gl.programUniformMatrix4dv(program, location, count, transpose, value);
3234 }
3235
3236 void CallLogWrapper::glProgramUniformMatrix4fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3237 {
3238         if (m_enableLog)
3239                 m_log << TestLog::Message << "glProgramUniformMatrix4fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 4*4)) << ");" << TestLog::EndMessage;
3240         m_gl.programUniformMatrix4fv(program, location, count, transpose, value);
3241 }
3242
3243 void CallLogWrapper::glProgramUniformMatrix4x2dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3244 {
3245         if (m_enableLog)
3246                 m_log << TestLog::Message << "glProgramUniformMatrix4x2dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3247         m_gl.programUniformMatrix4x2dv(program, location, count, transpose, value);
3248 }
3249
3250 void CallLogWrapper::glProgramUniformMatrix4x2fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3251 {
3252         if (m_enableLog)
3253                 m_log << TestLog::Message << "glProgramUniformMatrix4x2fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 4*2)) << ");" << TestLog::EndMessage;
3254         m_gl.programUniformMatrix4x2fv(program, location, count, transpose, value);
3255 }
3256
3257 void CallLogWrapper::glProgramUniformMatrix4x3dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3258 {
3259         if (m_enableLog)
3260                 m_log << TestLog::Message << "glProgramUniformMatrix4x3dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3261         m_gl.programUniformMatrix4x3dv(program, location, count, transpose, value);
3262 }
3263
3264 void CallLogWrapper::glProgramUniformMatrix4x3fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3265 {
3266         if (m_enableLog)
3267                 m_log << TestLog::Message << "glProgramUniformMatrix4x3fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 4*3)) << ");" << TestLog::EndMessage;
3268         m_gl.programUniformMatrix4x3fv(program, location, count, transpose, value);
3269 }
3270
3271 void CallLogWrapper::glProvokingVertex (glw::GLenum mode)
3272 {
3273         if (m_enableLog)
3274                 m_log << TestLog::Message << "glProvokingVertex(" << getProvokingVertexStr(mode) << ");" << TestLog::EndMessage;
3275         m_gl.provokingVertex(mode);
3276 }
3277
3278 void CallLogWrapper::glPushDebugGroup (glw::GLenum source, glw::GLuint id, glw::GLsizei length, const glw::GLchar *message)
3279 {
3280         if (m_enableLog)
3281                 m_log << TestLog::Message << "glPushDebugGroup(" << getDebugMessageSourceStr(source) << ", " << id << ", " << length << ", " << getStringStr(message) << ");" << TestLog::EndMessage;
3282         m_gl.pushDebugGroup(source, id, length, message);
3283 }
3284
3285 void CallLogWrapper::glPushGroupMarkerEXT (glw::GLsizei length, const glw::GLchar *marker)
3286 {
3287         if (m_enableLog)
3288                 m_log << TestLog::Message << "glPushGroupMarkerEXT(" << length << ", " << getStringStr(marker) << ");" << TestLog::EndMessage;
3289         m_gl.pushGroupMarkerEXT(length, marker);
3290 }
3291
3292 void CallLogWrapper::glQueryCounter (glw::GLuint id, glw::GLenum target)
3293 {
3294         if (m_enableLog)
3295                 m_log << TestLog::Message << "glQueryCounter(" << id << ", " << toHex(target) << ");" << TestLog::EndMessage;
3296         m_gl.queryCounter(id, target);
3297 }
3298
3299 void CallLogWrapper::glReadBuffer (glw::GLenum src)
3300 {
3301         if (m_enableLog)
3302                 m_log << TestLog::Message << "glReadBuffer(" << getDrawReadBufferStr(src) << ");" << TestLog::EndMessage;
3303         m_gl.readBuffer(src);
3304 }
3305
3306 void CallLogWrapper::glReadPixels (glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height, glw::GLenum format, glw::GLenum type, void *pixels)
3307 {
3308         if (m_enableLog)
3309                 m_log << TestLog::Message << "glReadPixels(" << x << ", " << y << ", " << width << ", " << height << ", " << getUncompressedTextureFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3310         m_gl.readPixels(x, y, width, height, format, type, pixels);
3311 }
3312
3313 void CallLogWrapper::glReadnPixels (glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height, glw::GLenum format, glw::GLenum type, glw::GLsizei bufSize, void *data)
3314 {
3315         if (m_enableLog)
3316                 m_log << TestLog::Message << "glReadnPixels(" << x << ", " << y << ", " << width << ", " << height << ", " << toHex(format) << ", " << toHex(type) << ", " << bufSize << ", " << data << ");" << TestLog::EndMessage;
3317         m_gl.readnPixels(x, y, width, height, format, type, bufSize, data);
3318 }
3319
3320 void CallLogWrapper::glReleaseShaderCompiler (void)
3321 {
3322         if (m_enableLog)
3323                 m_log << TestLog::Message << "glReleaseShaderCompiler(" << ");" << TestLog::EndMessage;
3324         m_gl.releaseShaderCompiler();
3325 }
3326
3327 void CallLogWrapper::glRenderbufferStorage (glw::GLenum target, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height)
3328 {
3329         if (m_enableLog)
3330                 m_log << TestLog::Message << "glRenderbufferStorage(" << getFramebufferTargetStr(target) << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << width << ", " << height << ");" << TestLog::EndMessage;
3331         m_gl.renderbufferStorage(target, internalformat, width, height);
3332 }
3333
3334 void CallLogWrapper::glRenderbufferStorageMultisample (glw::GLenum target, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height)
3335 {
3336         if (m_enableLog)
3337                 m_log << TestLog::Message << "glRenderbufferStorageMultisample(" << getFramebufferTargetStr(target) << ", " << samples << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << width << ", " << height << ");" << TestLog::EndMessage;
3338         m_gl.renderbufferStorageMultisample(target, samples, internalformat, width, height);
3339 }
3340
3341 void CallLogWrapper::glResumeTransformFeedback (void)
3342 {
3343         if (m_enableLog)
3344                 m_log << TestLog::Message << "glResumeTransformFeedback(" << ");" << TestLog::EndMessage;
3345         m_gl.resumeTransformFeedback();
3346 }
3347
3348 void CallLogWrapper::glSampleCoverage (glw::GLfloat value, glw::GLboolean invert)
3349 {
3350         if (m_enableLog)
3351                 m_log << TestLog::Message << "glSampleCoverage(" << value << ", " << getBooleanStr(invert) << ");" << TestLog::EndMessage;
3352         m_gl.sampleCoverage(value, invert);
3353 }
3354
3355 void CallLogWrapper::glSampleMaski (glw::GLuint maskNumber, glw::GLbitfield mask)
3356 {
3357         if (m_enableLog)
3358                 m_log << TestLog::Message << "glSampleMaski(" << maskNumber << ", " << toHex(mask) << ");" << TestLog::EndMessage;
3359         m_gl.sampleMaski(maskNumber, mask);
3360 }
3361
3362 void CallLogWrapper::glSamplerParameterIiv (glw::GLuint sampler, glw::GLenum pname, const glw::GLint *param)
3363 {
3364         if (m_enableLog)
3365                 m_log << TestLog::Message << "glSamplerParameterIiv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << getPointerStr(param, getTextureParamNumArgs(pname)) << ");" << TestLog::EndMessage;
3366         m_gl.samplerParameterIiv(sampler, pname, param);
3367 }
3368
3369 void CallLogWrapper::glSamplerParameterIuiv (glw::GLuint sampler, glw::GLenum pname, const glw::GLuint *param)
3370 {
3371         if (m_enableLog)
3372                 m_log << TestLog::Message << "glSamplerParameterIuiv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << getPointerStr(param, getTextureParamNumArgs(pname)) << ");" << TestLog::EndMessage;
3373         m_gl.samplerParameterIuiv(sampler, pname, param);
3374 }
3375
3376 void CallLogWrapper::glSamplerParameterf (glw::GLuint sampler, glw::GLenum pname, glw::GLfloat param)
3377 {
3378         if (m_enableLog)
3379                 m_log << TestLog::Message << "glSamplerParameterf(" << sampler << ", " << getTextureParameterStr(pname) << ", " << param << ");" << TestLog::EndMessage;
3380         m_gl.samplerParameterf(sampler, pname, param);
3381 }
3382
3383 void CallLogWrapper::glSamplerParameterfv (glw::GLuint sampler, glw::GLenum pname, const glw::GLfloat *param)
3384 {
3385         if (m_enableLog)
3386                 m_log << TestLog::Message << "glSamplerParameterfv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << getPointerStr(param, getTextureParamNumArgs(pname)) << ");" << TestLog::EndMessage;
3387         m_gl.samplerParameterfv(sampler, pname, param);
3388 }
3389
3390 void CallLogWrapper::glSamplerParameteri (glw::GLuint sampler, glw::GLenum pname, glw::GLint param)
3391 {
3392         if (m_enableLog)
3393                 m_log << TestLog::Message << "glSamplerParameteri(" << sampler << ", " << getTextureParameterStr(pname) << ", " << getTextureParameterValueStr(pname, param) << ");" << TestLog::EndMessage;
3394         m_gl.samplerParameteri(sampler, pname, param);
3395 }
3396
3397 void CallLogWrapper::glSamplerParameteriv (glw::GLuint sampler, glw::GLenum pname, const glw::GLint *param)
3398 {
3399         if (m_enableLog)
3400                 m_log << TestLog::Message << "glSamplerParameteriv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << getPointerStr(param, getTextureParamNumArgs(pname)) << ");" << TestLog::EndMessage;
3401         m_gl.samplerParameteriv(sampler, pname, param);
3402 }
3403
3404 void CallLogWrapper::glScissor (glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
3405 {
3406         if (m_enableLog)
3407                 m_log << TestLog::Message << "glScissor(" << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
3408         m_gl.scissor(x, y, width, height);
3409 }
3410
3411 void CallLogWrapper::glScissorArrayv (glw::GLuint first, glw::GLsizei count, const glw::GLint *v)
3412 {
3413         if (m_enableLog)
3414                 m_log << TestLog::Message << "glScissorArrayv(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
3415         m_gl.scissorArrayv(first, count, v);
3416 }
3417
3418 void CallLogWrapper::glScissorIndexed (glw::GLuint index, glw::GLint left, glw::GLint bottom, glw::GLsizei width, glw::GLsizei height)
3419 {
3420         if (m_enableLog)
3421                 m_log << TestLog::Message << "glScissorIndexed(" << index << ", " << left << ", " << bottom << ", " << width << ", " << height << ");" << TestLog::EndMessage;
3422         m_gl.scissorIndexed(index, left, bottom, width, height);
3423 }
3424
3425 void CallLogWrapper::glScissorIndexedv (glw::GLuint index, const glw::GLint *v)
3426 {
3427         if (m_enableLog)
3428                 m_log << TestLog::Message << "glScissorIndexedv(" << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
3429         m_gl.scissorIndexedv(index, v);
3430 }
3431
3432 void CallLogWrapper::glShaderBinary (glw::GLsizei count, const glw::GLuint *shaders, glw::GLenum binaryformat, const void *binary, glw::GLsizei length)
3433 {
3434         if (m_enableLog)
3435                 m_log << TestLog::Message << "glShaderBinary(" << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(shaders))) << ", " << toHex(binaryformat) << ", " << binary << ", " << length << ");" << TestLog::EndMessage;
3436         m_gl.shaderBinary(count, shaders, binaryformat, binary, length);
3437 }
3438
3439 void CallLogWrapper::glShaderSource (glw::GLuint shader, glw::GLsizei count, const glw::GLchar *const*string, const glw::GLint *length)
3440 {
3441         if (m_enableLog)
3442                 m_log << TestLog::Message << "glShaderSource(" << shader << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(string))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ");" << TestLog::EndMessage;
3443         m_gl.shaderSource(shader, count, string, length);
3444 }
3445
3446 void CallLogWrapper::glShaderStorageBlockBinding (glw::GLuint program, glw::GLuint storageBlockIndex, glw::GLuint storageBlockBinding)
3447 {
3448         if (m_enableLog)
3449                 m_log << TestLog::Message << "glShaderStorageBlockBinding(" << program << ", " << storageBlockIndex << ", " << storageBlockBinding << ");" << TestLog::EndMessage;
3450         m_gl.shaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
3451 }
3452
3453 void CallLogWrapper::glStencilFunc (glw::GLenum func, glw::GLint ref, glw::GLuint mask)
3454 {
3455         if (m_enableLog)
3456                 m_log << TestLog::Message << "glStencilFunc(" << getCompareFuncStr(func) << ", " << ref << ", " << mask << ");" << TestLog::EndMessage;
3457         m_gl.stencilFunc(func, ref, mask);
3458 }
3459
3460 void CallLogWrapper::glStencilFuncSeparate (glw::GLenum face, glw::GLenum func, glw::GLint ref, glw::GLuint mask)
3461 {
3462         if (m_enableLog)
3463                 m_log << TestLog::Message << "glStencilFuncSeparate(" << getFaceStr(face) << ", " << getCompareFuncStr(func) << ", " << ref << ", " << mask << ");" << TestLog::EndMessage;
3464         m_gl.stencilFuncSeparate(face, func, ref, mask);
3465 }
3466
3467 void CallLogWrapper::glStencilMask (glw::GLuint mask)
3468 {
3469         if (m_enableLog)
3470                 m_log << TestLog::Message << "glStencilMask(" << mask << ");" << TestLog::EndMessage;
3471         m_gl.stencilMask(mask);
3472 }
3473
3474 void CallLogWrapper::glStencilMaskSeparate (glw::GLenum face, glw::GLuint mask)
3475 {
3476         if (m_enableLog)
3477                 m_log << TestLog::Message << "glStencilMaskSeparate(" << getFaceStr(face) << ", " << mask << ");" << TestLog::EndMessage;
3478         m_gl.stencilMaskSeparate(face, mask);
3479 }
3480
3481 void CallLogWrapper::glStencilOp (glw::GLenum fail, glw::GLenum zfail, glw::GLenum zpass)
3482 {
3483         if (m_enableLog)
3484                 m_log << TestLog::Message << "glStencilOp(" << getStencilOpStr(fail) << ", " << getStencilOpStr(zfail) << ", " << getStencilOpStr(zpass) << ");" << TestLog::EndMessage;
3485         m_gl.stencilOp(fail, zfail, zpass);
3486 }
3487
3488 void CallLogWrapper::glStencilOpSeparate (glw::GLenum face, glw::GLenum sfail, glw::GLenum dpfail, glw::GLenum dppass)
3489 {
3490         if (m_enableLog)
3491                 m_log << TestLog::Message << "glStencilOpSeparate(" << getFaceStr(face) << ", " << getStencilOpStr(sfail) << ", " << getStencilOpStr(dpfail) << ", " << getStencilOpStr(dppass) << ");" << TestLog::EndMessage;
3492         m_gl.stencilOpSeparate(face, sfail, dpfail, dppass);
3493 }
3494
3495 void CallLogWrapper::glTexBuffer (glw::GLenum target, glw::GLenum internalformat, glw::GLuint buffer)
3496 {
3497         if (m_enableLog)
3498                 m_log << TestLog::Message << "glTexBuffer(" << getBufferTargetStr(target) << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << buffer << ");" << TestLog::EndMessage;
3499         m_gl.texBuffer(target, internalformat, buffer);
3500 }
3501
3502 void CallLogWrapper::glTexBufferRange (glw::GLenum target, glw::GLenum internalformat, glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size)
3503 {
3504         if (m_enableLog)
3505                 m_log << TestLog::Message << "glTexBufferRange(" << getBufferTargetStr(target) << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << buffer << ", " << offset << ", " << size << ");" << TestLog::EndMessage;
3506         m_gl.texBufferRange(target, internalformat, buffer, offset, size);
3507 }
3508
3509 void CallLogWrapper::glTexImage1D (glw::GLenum target, glw::GLint level, glw::GLint internalformat, glw::GLsizei width, glw::GLint border, glw::GLenum format, glw::GLenum type, const void *pixels)
3510 {
3511         if (m_enableLog)
3512                 m_log << TestLog::Message << "glTexImage1D(" << getTextureTargetStr(target) << ", " << level << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << width << ", " << border << ", " << getUncompressedTextureFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3513         m_gl.texImage1D(target, level, internalformat, width, border, format, type, pixels);
3514 }
3515
3516 void CallLogWrapper::glTexImage2D (glw::GLenum target, glw::GLint level, glw::GLint internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLint border, glw::GLenum format, glw::GLenum type, const void *pixels)
3517 {
3518         if (m_enableLog)
3519                 m_log << TestLog::Message << "glTexImage2D(" << getTextureTargetStr(target) << ", " << level << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << width << ", " << height << ", " << border << ", " << getUncompressedTextureFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3520         m_gl.texImage2D(target, level, internalformat, width, height, border, format, type, pixels);
3521 }
3522
3523 void CallLogWrapper::glTexImage2DMultisample (glw::GLenum target, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLboolean fixedsamplelocations)
3524 {
3525         if (m_enableLog)
3526                 m_log << TestLog::Message << "glTexImage2DMultisample(" << getTextureTargetStr(target) << ", " << samples << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << width << ", " << height << ", " << getBooleanStr(fixedsamplelocations) << ");" << TestLog::EndMessage;
3527         m_gl.texImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
3528 }
3529
3530 void CallLogWrapper::glTexImage3D (glw::GLenum target, glw::GLint level, glw::GLint internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLint border, glw::GLenum format, glw::GLenum type, const void *pixels)
3531 {
3532         if (m_enableLog)
3533                 m_log << TestLog::Message << "glTexImage3D(" << getTextureTargetStr(target) << ", " << level << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << border << ", " << getUncompressedTextureFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3534         m_gl.texImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
3535 }
3536
3537 void CallLogWrapper::glTexImage3DMultisample (glw::GLenum target, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLboolean fixedsamplelocations)
3538 {
3539         if (m_enableLog)
3540                 m_log << TestLog::Message << "glTexImage3DMultisample(" << toHex(target) << ", " << samples << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << getBooleanStr(fixedsamplelocations) << ");" << TestLog::EndMessage;
3541         m_gl.texImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
3542 }
3543
3544 void CallLogWrapper::glTexParameterIiv (glw::GLenum target, glw::GLenum pname, const glw::GLint *params)
3545 {
3546         if (m_enableLog)
3547                 m_log << TestLog::Message << "glTexParameterIiv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << getPointerStr(params, getTextureParamNumArgs(pname)) << ");" << TestLog::EndMessage;
3548         m_gl.texParameterIiv(target, pname, params);
3549 }
3550
3551 void CallLogWrapper::glTexParameterIuiv (glw::GLenum target, glw::GLenum pname, const glw::GLuint *params)
3552 {
3553         if (m_enableLog)
3554                 m_log << TestLog::Message << "glTexParameterIuiv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << getPointerStr(params, getTextureParamNumArgs(pname)) << ");" << TestLog::EndMessage;
3555         m_gl.texParameterIuiv(target, pname, params);
3556 }
3557
3558 void CallLogWrapper::glTexParameterf (glw::GLenum target, glw::GLenum pname, glw::GLfloat param)
3559 {
3560         if (m_enableLog)
3561                 m_log << TestLog::Message << "glTexParameterf(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << param << ");" << TestLog::EndMessage;
3562         m_gl.texParameterf(target, pname, param);
3563 }
3564
3565 void CallLogWrapper::glTexParameterfv (glw::GLenum target, glw::GLenum pname, const glw::GLfloat *params)
3566 {
3567         if (m_enableLog)
3568                 m_log << TestLog::Message << "glTexParameterfv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << getPointerStr(params, getTextureParamNumArgs(pname)) << ");" << TestLog::EndMessage;
3569         m_gl.texParameterfv(target, pname, params);
3570 }
3571
3572 void CallLogWrapper::glTexParameteri (glw::GLenum target, glw::GLenum pname, glw::GLint param)
3573 {
3574         if (m_enableLog)
3575                 m_log << TestLog::Message << "glTexParameteri(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << getTextureParameterValueStr(pname, param) << ");" << TestLog::EndMessage;
3576         m_gl.texParameteri(target, pname, param);
3577 }
3578
3579 void CallLogWrapper::glTexParameteriv (glw::GLenum target, glw::GLenum pname, const glw::GLint *params)
3580 {
3581         if (m_enableLog)
3582                 m_log << TestLog::Message << "glTexParameteriv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << getPointerStr(params, getTextureParamNumArgs(pname)) << ");" << TestLog::EndMessage;
3583         m_gl.texParameteriv(target, pname, params);
3584 }
3585
3586 void CallLogWrapper::glTexStorage1D (glw::GLenum target, glw::GLsizei levels, glw::GLenum internalformat, glw::GLsizei width)
3587 {
3588         if (m_enableLog)
3589                 m_log << TestLog::Message << "glTexStorage1D(" << toHex(target) << ", " << levels << ", " << toHex(internalformat) << ", " << width << ");" << TestLog::EndMessage;
3590         m_gl.texStorage1D(target, levels, internalformat, width);
3591 }
3592
3593 void CallLogWrapper::glTexStorage2D (glw::GLenum target, glw::GLsizei levels, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height)
3594 {
3595         if (m_enableLog)
3596                 m_log << TestLog::Message << "glTexStorage2D(" << getTextureTargetStr(target) << ", " << levels << ", " << getTextureFormatStr(internalformat) << ", " << width << ", " << height << ");" << TestLog::EndMessage;
3597         m_gl.texStorage2D(target, levels, internalformat, width, height);
3598 }
3599
3600 void CallLogWrapper::glTexStorage2DMultisample (glw::GLenum target, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLboolean fixedsamplelocations)
3601 {
3602         if (m_enableLog)
3603                 m_log << TestLog::Message << "glTexStorage2DMultisample(" << getTextureTargetStr(target) << ", " << samples << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << width << ", " << height << ", " << getBooleanStr(fixedsamplelocations) << ");" << TestLog::EndMessage;
3604         m_gl.texStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
3605 }
3606
3607 void CallLogWrapper::glTexStorage3D (glw::GLenum target, glw::GLsizei levels, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth)
3608 {
3609         if (m_enableLog)
3610                 m_log << TestLog::Message << "glTexStorage3D(" << getTextureTargetStr(target) << ", " << levels << ", " << getTextureFormatStr(internalformat) << ", " << width << ", " << height << ", " << depth << ");" << TestLog::EndMessage;
3611         m_gl.texStorage3D(target, levels, internalformat, width, height, depth);
3612 }
3613
3614 void CallLogWrapper::glTexStorage3DMultisample (glw::GLenum target, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLboolean fixedsamplelocations)
3615 {
3616         if (m_enableLog)
3617                 m_log << TestLog::Message << "glTexStorage3DMultisample(" << getTextureTargetStr(target) << ", " << samples << ", " << getUncompressedTextureFormatStr(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << getBooleanStr(fixedsamplelocations) << ");" << TestLog::EndMessage;
3618         m_gl.texStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
3619 }
3620
3621 void CallLogWrapper::glTexSubImage1D (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLsizei width, glw::GLenum format, glw::GLenum type, const void *pixels)
3622 {
3623         if (m_enableLog)
3624                 m_log << TestLog::Message << "glTexSubImage1D(" << getTextureTargetStr(target) << ", " << level << ", " << xoffset << ", " << width << ", " << getUncompressedTextureFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3625         m_gl.texSubImage1D(target, level, xoffset, width, format, type, pixels);
3626 }
3627
3628 void CallLogWrapper::glTexSubImage2D (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLsizei width, glw::GLsizei height, glw::GLenum format, glw::GLenum type, const void *pixels)
3629 {
3630         if (m_enableLog)
3631                 m_log << TestLog::Message << "glTexSubImage2D(" << getTextureTargetStr(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height << ", " << getUncompressedTextureFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3632         m_gl.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
3633 }
3634
3635 void CallLogWrapper::glTexSubImage3D (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::GLenum type, const void *pixels)
3636 {
3637         if (m_enableLog)
3638                 m_log << TestLog::Message << "glTexSubImage3D(" << getTextureTargetStr(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << getUncompressedTextureFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3639         m_gl.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
3640 }
3641
3642 void CallLogWrapper::glTextureBarrier (void)
3643 {
3644         if (m_enableLog)
3645                 m_log << TestLog::Message << "glTextureBarrier(" << ");" << TestLog::EndMessage;
3646         m_gl.textureBarrier();
3647 }
3648
3649 void CallLogWrapper::glTextureBuffer (glw::GLuint texture, glw::GLenum internalformat, glw::GLuint buffer)
3650 {
3651         if (m_enableLog)
3652                 m_log << TestLog::Message << "glTextureBuffer(" << texture << ", " << toHex(internalformat) << ", " << buffer << ");" << TestLog::EndMessage;
3653         m_gl.textureBuffer(texture, internalformat, buffer);
3654 }
3655
3656 void CallLogWrapper::glTextureBufferRange (glw::GLuint texture, glw::GLenum internalformat, glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size)
3657 {
3658         if (m_enableLog)
3659                 m_log << TestLog::Message << "glTextureBufferRange(" << texture << ", " << toHex(internalformat) << ", " << buffer << ", " << offset << ", " << size << ");" << TestLog::EndMessage;
3660         m_gl.textureBufferRange(texture, internalformat, buffer, offset, size);
3661 }
3662
3663 void CallLogWrapper::glTextureParameterIiv (glw::GLuint texture, glw::GLenum pname, const glw::GLint *params)
3664 {
3665         if (m_enableLog)
3666                 m_log << TestLog::Message << "glTextureParameterIiv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
3667         m_gl.textureParameterIiv(texture, pname, params);
3668 }
3669
3670 void CallLogWrapper::glTextureParameterIuiv (glw::GLuint texture, glw::GLenum pname, const glw::GLuint *params)
3671 {
3672         if (m_enableLog)
3673                 m_log << TestLog::Message << "glTextureParameterIuiv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
3674         m_gl.textureParameterIuiv(texture, pname, params);
3675 }
3676
3677 void CallLogWrapper::glTextureParameterf (glw::GLuint texture, glw::GLenum pname, glw::GLfloat param)
3678 {
3679         if (m_enableLog)
3680                 m_log << TestLog::Message << "glTextureParameterf(" << texture << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
3681         m_gl.textureParameterf(texture, pname, param);
3682 }
3683
3684 void CallLogWrapper::glTextureParameterfv (glw::GLuint texture, glw::GLenum pname, const glw::GLfloat *param)
3685 {
3686         if (m_enableLog)
3687                 m_log << TestLog::Message << "glTextureParameterfv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
3688         m_gl.textureParameterfv(texture, pname, param);
3689 }
3690
3691 void CallLogWrapper::glTextureParameteri (glw::GLuint texture, glw::GLenum pname, glw::GLint param)
3692 {
3693         if (m_enableLog)
3694                 m_log << TestLog::Message << "glTextureParameteri(" << texture << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
3695         m_gl.textureParameteri(texture, pname, param);
3696 }
3697
3698 void CallLogWrapper::glTextureParameteriv (glw::GLuint texture, glw::GLenum pname, const glw::GLint *param)
3699 {
3700         if (m_enableLog)
3701                 m_log << TestLog::Message << "glTextureParameteriv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
3702         m_gl.textureParameteriv(texture, pname, param);
3703 }
3704
3705 void CallLogWrapper::glTextureStorage1D (glw::GLuint texture, glw::GLsizei levels, glw::GLenum internalformat, glw::GLsizei width)
3706 {
3707         if (m_enableLog)
3708                 m_log << TestLog::Message << "glTextureStorage1D(" << texture << ", " << levels << ", " << toHex(internalformat) << ", " << width << ");" << TestLog::EndMessage;
3709         m_gl.textureStorage1D(texture, levels, internalformat, width);
3710 }
3711
3712 void CallLogWrapper::glTextureStorage2D (glw::GLuint texture, glw::GLsizei levels, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height)
3713 {
3714         if (m_enableLog)
3715                 m_log << TestLog::Message << "glTextureStorage2D(" << texture << ", " << levels << ", " << toHex(internalformat) << ", " << width << ", " << height << ");" << TestLog::EndMessage;
3716         m_gl.textureStorage2D(texture, levels, internalformat, width, height);
3717 }
3718
3719 void CallLogWrapper::glTextureStorage2DMultisample (glw::GLuint texture, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLboolean fixedsamplelocations)
3720 {
3721         if (m_enableLog)
3722                 m_log << TestLog::Message << "glTextureStorage2DMultisample(" << texture << ", " << samples << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << getBooleanStr(fixedsamplelocations) << ");" << TestLog::EndMessage;
3723         m_gl.textureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
3724 }
3725
3726 void CallLogWrapper::glTextureStorage3D (glw::GLuint texture, glw::GLsizei levels, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth)
3727 {
3728         if (m_enableLog)
3729                 m_log << TestLog::Message << "glTextureStorage3D(" << texture << ", " << levels << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << depth << ");" << TestLog::EndMessage;
3730         m_gl.textureStorage3D(texture, levels, internalformat, width, height, depth);
3731 }
3732
3733 void CallLogWrapper::glTextureStorage3DMultisample (glw::GLuint texture, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLboolean fixedsamplelocations)
3734 {
3735         if (m_enableLog)
3736                 m_log << TestLog::Message << "glTextureStorage3DMultisample(" << texture << ", " << samples << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << getBooleanStr(fixedsamplelocations) << ");" << TestLog::EndMessage;
3737         m_gl.textureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
3738 }
3739
3740 void CallLogWrapper::glTextureSubImage1D (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLsizei width, glw::GLenum format, glw::GLenum type, const void *pixels)
3741 {
3742         if (m_enableLog)
3743                 m_log << TestLog::Message << "glTextureSubImage1D(" << texture << ", " << level << ", " << xoffset << ", " << width << ", " << toHex(format) << ", " << toHex(type) << ", " << pixels << ");" << TestLog::EndMessage;
3744         m_gl.textureSubImage1D(texture, level, xoffset, width, format, type, pixels);
3745 }
3746
3747 void CallLogWrapper::glTextureSubImage2D (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLint yoffset, glw::GLsizei width, glw::GLsizei height, glw::GLenum format, glw::GLenum type, const void *pixels)
3748 {
3749         if (m_enableLog)
3750                 m_log << TestLog::Message << "glTextureSubImage2D(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height << ", " << toHex(format) << ", " << toHex(type) << ", " << pixels << ");" << TestLog::EndMessage;
3751         m_gl.textureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
3752 }
3753
3754 void CallLogWrapper::glTextureSubImage3D (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 *pixels)
3755 {
3756         if (m_enableLog)
3757                 m_log << TestLog::Message << "glTextureSubImage3D(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << toHex(format) << ", " << toHex(type) << ", " << pixels << ");" << TestLog::EndMessage;
3758         m_gl.textureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
3759 }
3760
3761 void CallLogWrapper::glTextureView (glw::GLuint texture, glw::GLenum target, glw::GLuint origtexture, glw::GLenum internalformat, glw::GLuint minlevel, glw::GLuint numlevels, glw::GLuint minlayer, glw::GLuint numlayers)
3762 {
3763         if (m_enableLog)
3764                 m_log << TestLog::Message << "glTextureView(" << texture << ", " << toHex(target) << ", " << origtexture << ", " << toHex(internalformat) << ", " << minlevel << ", " << numlevels << ", " << minlayer << ", " << numlayers << ");" << TestLog::EndMessage;
3765         m_gl.textureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
3766 }
3767
3768 void CallLogWrapper::glTransformFeedbackBufferBase (glw::GLuint xfb, glw::GLuint index, glw::GLuint buffer)
3769 {
3770         if (m_enableLog)
3771                 m_log << TestLog::Message << "glTransformFeedbackBufferBase(" << xfb << ", " << index << ", " << buffer << ");" << TestLog::EndMessage;
3772         m_gl.transformFeedbackBufferBase(xfb, index, buffer);
3773 }
3774
3775 void CallLogWrapper::glTransformFeedbackBufferRange (glw::GLuint xfb, glw::GLuint index, glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size)
3776 {
3777         if (m_enableLog)
3778                 m_log << TestLog::Message << "glTransformFeedbackBufferRange(" << xfb << ", " << index << ", " << buffer << ", " << offset << ", " << size << ");" << TestLog::EndMessage;
3779         m_gl.transformFeedbackBufferRange(xfb, index, buffer, offset, size);
3780 }
3781
3782 void CallLogWrapper::glTransformFeedbackVaryings (glw::GLuint program, glw::GLsizei count, const glw::GLchar *const*varyings, glw::GLenum bufferMode)
3783 {
3784         if (m_enableLog)
3785                 m_log << TestLog::Message << "glTransformFeedbackVaryings(" << program << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(varyings))) << ", " << toHex(bufferMode) << ");" << TestLog::EndMessage;
3786         m_gl.transformFeedbackVaryings(program, count, varyings, bufferMode);
3787 }
3788
3789 void CallLogWrapper::glUniform1d (glw::GLint location, glw::GLdouble x)
3790 {
3791         if (m_enableLog)
3792                 m_log << TestLog::Message << "glUniform1d(" << location << ", " << x << ");" << TestLog::EndMessage;
3793         m_gl.uniform1d(location, x);
3794 }
3795
3796 void CallLogWrapper::glUniform1dv (glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
3797 {
3798         if (m_enableLog)
3799                 m_log << TestLog::Message << "glUniform1dv(" << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3800         m_gl.uniform1dv(location, count, value);
3801 }
3802
3803 void CallLogWrapper::glUniform1f (glw::GLint location, glw::GLfloat v0)
3804 {
3805         if (m_enableLog)
3806                 m_log << TestLog::Message << "glUniform1f(" << location << ", " << v0 << ");" << TestLog::EndMessage;
3807         m_gl.uniform1f(location, v0);
3808 }
3809
3810 void CallLogWrapper::glUniform1fv (glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
3811 {
3812         if (m_enableLog)
3813                 m_log << TestLog::Message << "glUniform1fv(" << location << ", " << count << ", " << getPointerStr(value, (count * 1)) << ");" << TestLog::EndMessage;
3814         m_gl.uniform1fv(location, count, value);
3815 }
3816
3817 void CallLogWrapper::glUniform1i (glw::GLint location, glw::GLint v0)
3818 {
3819         if (m_enableLog)
3820                 m_log << TestLog::Message << "glUniform1i(" << location << ", " << v0 << ");" << TestLog::EndMessage;
3821         m_gl.uniform1i(location, v0);
3822 }
3823
3824 void CallLogWrapper::glUniform1iv (glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3825 {
3826         if (m_enableLog)
3827                 m_log << TestLog::Message << "glUniform1iv(" << location << ", " << count << ", " << getPointerStr(value, (count * 1)) << ");" << TestLog::EndMessage;
3828         m_gl.uniform1iv(location, count, value);
3829 }
3830
3831 void CallLogWrapper::glUniform1ui (glw::GLint location, glw::GLuint v0)
3832 {
3833         if (m_enableLog)
3834                 m_log << TestLog::Message << "glUniform1ui(" << location << ", " << v0 << ");" << TestLog::EndMessage;
3835         m_gl.uniform1ui(location, v0);
3836 }
3837
3838 void CallLogWrapper::glUniform1uiv (glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
3839 {
3840         if (m_enableLog)
3841                 m_log << TestLog::Message << "glUniform1uiv(" << location << ", " << count << ", " << getPointerStr(value, (count * 1)) << ");" << TestLog::EndMessage;
3842         m_gl.uniform1uiv(location, count, value);
3843 }
3844
3845 void CallLogWrapper::glUniform2d (glw::GLint location, glw::GLdouble x, glw::GLdouble y)
3846 {
3847         if (m_enableLog)
3848                 m_log << TestLog::Message << "glUniform2d(" << location << ", " << x << ", " << y << ");" << TestLog::EndMessage;
3849         m_gl.uniform2d(location, x, y);
3850 }
3851
3852 void CallLogWrapper::glUniform2dv (glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
3853 {
3854         if (m_enableLog)
3855                 m_log << TestLog::Message << "glUniform2dv(" << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3856         m_gl.uniform2dv(location, count, value);
3857 }
3858
3859 void CallLogWrapper::glUniform2f (glw::GLint location, glw::GLfloat v0, glw::GLfloat v1)
3860 {
3861         if (m_enableLog)
3862                 m_log << TestLog::Message << "glUniform2f(" << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
3863         m_gl.uniform2f(location, v0, v1);
3864 }
3865
3866 void CallLogWrapper::glUniform2fv (glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
3867 {
3868         if (m_enableLog)
3869                 m_log << TestLog::Message << "glUniform2fv(" << location << ", " << count << ", " << getPointerStr(value, (count * 2)) << ");" << TestLog::EndMessage;
3870         m_gl.uniform2fv(location, count, value);
3871 }
3872
3873 void CallLogWrapper::glUniform2i (glw::GLint location, glw::GLint v0, glw::GLint v1)
3874 {
3875         if (m_enableLog)
3876                 m_log << TestLog::Message << "glUniform2i(" << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
3877         m_gl.uniform2i(location, v0, v1);
3878 }
3879
3880 void CallLogWrapper::glUniform2iv (glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3881 {
3882         if (m_enableLog)
3883                 m_log << TestLog::Message << "glUniform2iv(" << location << ", " << count << ", " << getPointerStr(value, (count * 2)) << ");" << TestLog::EndMessage;
3884         m_gl.uniform2iv(location, count, value);
3885 }
3886
3887 void CallLogWrapper::glUniform2ui (glw::GLint location, glw::GLuint v0, glw::GLuint v1)
3888 {
3889         if (m_enableLog)
3890                 m_log << TestLog::Message << "glUniform2ui(" << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
3891         m_gl.uniform2ui(location, v0, v1);
3892 }
3893
3894 void CallLogWrapper::glUniform2uiv (glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
3895 {
3896         if (m_enableLog)
3897                 m_log << TestLog::Message << "glUniform2uiv(" << location << ", " << count << ", " << getPointerStr(value, (count * 2)) << ");" << TestLog::EndMessage;
3898         m_gl.uniform2uiv(location, count, value);
3899 }
3900
3901 void CallLogWrapper::glUniform3d (glw::GLint location, glw::GLdouble x, glw::GLdouble y, glw::GLdouble z)
3902 {
3903         if (m_enableLog)
3904                 m_log << TestLog::Message << "glUniform3d(" << location << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
3905         m_gl.uniform3d(location, x, y, z);
3906 }
3907
3908 void CallLogWrapper::glUniform3dv (glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
3909 {
3910         if (m_enableLog)
3911                 m_log << TestLog::Message << "glUniform3dv(" << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3912         m_gl.uniform3dv(location, count, value);
3913 }
3914
3915 void CallLogWrapper::glUniform3f (glw::GLint location, glw::GLfloat v0, glw::GLfloat v1, glw::GLfloat v2)
3916 {
3917         if (m_enableLog)
3918                 m_log << TestLog::Message << "glUniform3f(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3919         m_gl.uniform3f(location, v0, v1, v2);
3920 }
3921
3922 void CallLogWrapper::glUniform3fv (glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
3923 {
3924         if (m_enableLog)
3925                 m_log << TestLog::Message << "glUniform3fv(" << location << ", " << count << ", " << getPointerStr(value, (count * 3)) << ");" << TestLog::EndMessage;
3926         m_gl.uniform3fv(location, count, value);
3927 }
3928
3929 void CallLogWrapper::glUniform3i (glw::GLint location, glw::GLint v0, glw::GLint v1, glw::GLint v2)
3930 {
3931         if (m_enableLog)
3932                 m_log << TestLog::Message << "glUniform3i(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3933         m_gl.uniform3i(location, v0, v1, v2);
3934 }
3935
3936 void CallLogWrapper::glUniform3iv (glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3937 {
3938         if (m_enableLog)
3939                 m_log << TestLog::Message << "glUniform3iv(" << location << ", " << count << ", " << getPointerStr(value, (count * 3)) << ");" << TestLog::EndMessage;
3940         m_gl.uniform3iv(location, count, value);
3941 }
3942
3943 void CallLogWrapper::glUniform3ui (glw::GLint location, glw::GLuint v0, glw::GLuint v1, glw::GLuint v2)
3944 {
3945         if (m_enableLog)
3946                 m_log << TestLog::Message << "glUniform3ui(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3947         m_gl.uniform3ui(location, v0, v1, v2);
3948 }
3949
3950 void CallLogWrapper::glUniform3uiv (glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
3951 {
3952         if (m_enableLog)
3953                 m_log << TestLog::Message << "glUniform3uiv(" << location << ", " << count << ", " << getPointerStr(value, (count * 3)) << ");" << TestLog::EndMessage;
3954         m_gl.uniform3uiv(location, count, value);
3955 }
3956
3957 void CallLogWrapper::glUniform4d (glw::GLint location, glw::GLdouble x, glw::GLdouble y, glw::GLdouble z, glw::GLdouble w)
3958 {
3959         if (m_enableLog)
3960                 m_log << TestLog::Message << "glUniform4d(" << location << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
3961         m_gl.uniform4d(location, x, y, z, w);
3962 }
3963
3964 void CallLogWrapper::glUniform4dv (glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
3965 {
3966         if (m_enableLog)
3967                 m_log << TestLog::Message << "glUniform4dv(" << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
3968         m_gl.uniform4dv(location, count, value);
3969 }
3970
3971 void CallLogWrapper::glUniform4f (glw::GLint location, glw::GLfloat v0, glw::GLfloat v1, glw::GLfloat v2, glw::GLfloat v3)
3972 {
3973         if (m_enableLog)
3974                 m_log << TestLog::Message << "glUniform4f(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3975         m_gl.uniform4f(location, v0, v1, v2, v3);
3976 }
3977
3978 void CallLogWrapper::glUniform4fv (glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
3979 {
3980         if (m_enableLog)
3981                 m_log << TestLog::Message << "glUniform4fv(" << location << ", " << count << ", " << getPointerStr(value, (count * 4)) << ");" << TestLog::EndMessage;
3982         m_gl.uniform4fv(location, count, value);
3983 }
3984
3985 void CallLogWrapper::glUniform4i (glw::GLint location, glw::GLint v0, glw::GLint v1, glw::GLint v2, glw::GLint v3)
3986 {
3987         if (m_enableLog)
3988                 m_log << TestLog::Message << "glUniform4i(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3989         m_gl.uniform4i(location, v0, v1, v2, v3);
3990 }
3991
3992 void CallLogWrapper::glUniform4iv (glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3993 {
3994         if (m_enableLog)
3995                 m_log << TestLog::Message << "glUniform4iv(" << location << ", " << count << ", " << getPointerStr(value, (count * 4)) << ");" << TestLog::EndMessage;
3996         m_gl.uniform4iv(location, count, value);
3997 }
3998
3999 void CallLogWrapper::glUniform4ui (glw::GLint location, glw::GLuint v0, glw::GLuint v1, glw::GLuint v2, glw::GLuint v3)
4000 {
4001         if (m_enableLog)
4002                 m_log << TestLog::Message << "glUniform4ui(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
4003         m_gl.uniform4ui(location, v0, v1, v2, v3);
4004 }
4005
4006 void CallLogWrapper::glUniform4uiv (glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
4007 {
4008         if (m_enableLog)
4009                 m_log << TestLog::Message << "glUniform4uiv(" << location << ", " << count << ", " << getPointerStr(value, (count * 4)) << ");" << TestLog::EndMessage;
4010         m_gl.uniform4uiv(location, count, value);
4011 }
4012
4013 void CallLogWrapper::glUniformBlockBinding (glw::GLuint program, glw::GLuint uniformBlockIndex, glw::GLuint uniformBlockBinding)
4014 {
4015         if (m_enableLog)
4016                 m_log << TestLog::Message << "glUniformBlockBinding(" << program << ", " << uniformBlockIndex << ", " << uniformBlockBinding << ");" << TestLog::EndMessage;
4017         m_gl.uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
4018 }
4019
4020 void CallLogWrapper::glUniformMatrix2dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4021 {
4022         if (m_enableLog)
4023                 m_log << TestLog::Message << "glUniformMatrix2dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4024         m_gl.uniformMatrix2dv(location, count, transpose, value);
4025 }
4026
4027 void CallLogWrapper::glUniformMatrix2fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4028 {
4029         if (m_enableLog)
4030                 m_log << TestLog::Message << "glUniformMatrix2fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 2*2)) << ");" << TestLog::EndMessage;
4031         m_gl.uniformMatrix2fv(location, count, transpose, value);
4032 }
4033
4034 void CallLogWrapper::glUniformMatrix2x3dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4035 {
4036         if (m_enableLog)
4037                 m_log << TestLog::Message << "glUniformMatrix2x3dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4038         m_gl.uniformMatrix2x3dv(location, count, transpose, value);
4039 }
4040
4041 void CallLogWrapper::glUniformMatrix2x3fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4042 {
4043         if (m_enableLog)
4044                 m_log << TestLog::Message << "glUniformMatrix2x3fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 2*3)) << ");" << TestLog::EndMessage;
4045         m_gl.uniformMatrix2x3fv(location, count, transpose, value);
4046 }
4047
4048 void CallLogWrapper::glUniformMatrix2x4dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4049 {
4050         if (m_enableLog)
4051                 m_log << TestLog::Message << "glUniformMatrix2x4dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4052         m_gl.uniformMatrix2x4dv(location, count, transpose, value);
4053 }
4054
4055 void CallLogWrapper::glUniformMatrix2x4fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4056 {
4057         if (m_enableLog)
4058                 m_log << TestLog::Message << "glUniformMatrix2x4fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 2*4)) << ");" << TestLog::EndMessage;
4059         m_gl.uniformMatrix2x4fv(location, count, transpose, value);
4060 }
4061
4062 void CallLogWrapper::glUniformMatrix3dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4063 {
4064         if (m_enableLog)
4065                 m_log << TestLog::Message << "glUniformMatrix3dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4066         m_gl.uniformMatrix3dv(location, count, transpose, value);
4067 }
4068
4069 void CallLogWrapper::glUniformMatrix3fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4070 {
4071         if (m_enableLog)
4072                 m_log << TestLog::Message << "glUniformMatrix3fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 3*3)) << ");" << TestLog::EndMessage;
4073         m_gl.uniformMatrix3fv(location, count, transpose, value);
4074 }
4075
4076 void CallLogWrapper::glUniformMatrix3x2dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4077 {
4078         if (m_enableLog)
4079                 m_log << TestLog::Message << "glUniformMatrix3x2dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4080         m_gl.uniformMatrix3x2dv(location, count, transpose, value);
4081 }
4082
4083 void CallLogWrapper::glUniformMatrix3x2fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4084 {
4085         if (m_enableLog)
4086                 m_log << TestLog::Message << "glUniformMatrix3x2fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 3*2)) << ");" << TestLog::EndMessage;
4087         m_gl.uniformMatrix3x2fv(location, count, transpose, value);
4088 }
4089
4090 void CallLogWrapper::glUniformMatrix3x4dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4091 {
4092         if (m_enableLog)
4093                 m_log << TestLog::Message << "glUniformMatrix3x4dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4094         m_gl.uniformMatrix3x4dv(location, count, transpose, value);
4095 }
4096
4097 void CallLogWrapper::glUniformMatrix3x4fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4098 {
4099         if (m_enableLog)
4100                 m_log << TestLog::Message << "glUniformMatrix3x4fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 3*4)) << ");" << TestLog::EndMessage;
4101         m_gl.uniformMatrix3x4fv(location, count, transpose, value);
4102 }
4103
4104 void CallLogWrapper::glUniformMatrix4dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4105 {
4106         if (m_enableLog)
4107                 m_log << TestLog::Message << "glUniformMatrix4dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4108         m_gl.uniformMatrix4dv(location, count, transpose, value);
4109 }
4110
4111 void CallLogWrapper::glUniformMatrix4fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4112 {
4113         if (m_enableLog)
4114                 m_log << TestLog::Message << "glUniformMatrix4fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 4*4)) << ");" << TestLog::EndMessage;
4115         m_gl.uniformMatrix4fv(location, count, transpose, value);
4116 }
4117
4118 void CallLogWrapper::glUniformMatrix4x2dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4119 {
4120         if (m_enableLog)
4121                 m_log << TestLog::Message << "glUniformMatrix4x2dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4122         m_gl.uniformMatrix4x2dv(location, count, transpose, value);
4123 }
4124
4125 void CallLogWrapper::glUniformMatrix4x2fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4126 {
4127         if (m_enableLog)
4128                 m_log << TestLog::Message << "glUniformMatrix4x2fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 4*2)) << ");" << TestLog::EndMessage;
4129         m_gl.uniformMatrix4x2fv(location, count, transpose, value);
4130 }
4131
4132 void CallLogWrapper::glUniformMatrix4x3dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4133 {
4134         if (m_enableLog)
4135                 m_log << TestLog::Message << "glUniformMatrix4x3dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4136         m_gl.uniformMatrix4x3dv(location, count, transpose, value);
4137 }
4138
4139 void CallLogWrapper::glUniformMatrix4x3fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4140 {
4141         if (m_enableLog)
4142                 m_log << TestLog::Message << "glUniformMatrix4x3fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 4*3)) << ");" << TestLog::EndMessage;
4143         m_gl.uniformMatrix4x3fv(location, count, transpose, value);
4144 }
4145
4146 void CallLogWrapper::glUniformSubroutinesuiv (glw::GLenum shadertype, glw::GLsizei count, const glw::GLuint *indices)
4147 {
4148         if (m_enableLog)
4149                 m_log << TestLog::Message << "glUniformSubroutinesuiv(" << toHex(shadertype) << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(indices))) << ");" << TestLog::EndMessage;
4150         m_gl.uniformSubroutinesuiv(shadertype, count, indices);
4151 }
4152
4153 glw::GLboolean CallLogWrapper::glUnmapBuffer (glw::GLenum target)
4154 {
4155         if (m_enableLog)
4156                 m_log << TestLog::Message << "glUnmapBuffer(" << getBufferTargetStr(target) << ");" << TestLog::EndMessage;
4157         glw::GLboolean returnValue = m_gl.unmapBuffer(target);
4158         if (m_enableLog)
4159                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
4160         return returnValue;
4161 }
4162
4163 glw::GLboolean CallLogWrapper::glUnmapNamedBuffer (glw::GLuint buffer)
4164 {
4165         if (m_enableLog)
4166                 m_log << TestLog::Message << "glUnmapNamedBuffer(" << buffer << ");" << TestLog::EndMessage;
4167         glw::GLboolean returnValue = m_gl.unmapNamedBuffer(buffer);
4168         if (m_enableLog)
4169                 m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
4170         return returnValue;
4171 }
4172
4173 void CallLogWrapper::glUseProgram (glw::GLuint program)
4174 {
4175         if (m_enableLog)
4176                 m_log << TestLog::Message << "glUseProgram(" << program << ");" << TestLog::EndMessage;
4177         m_gl.useProgram(program);
4178 }
4179
4180 void CallLogWrapper::glUseProgramStages (glw::GLuint pipeline, glw::GLbitfield stages, glw::GLuint program)
4181 {
4182         if (m_enableLog)
4183                 m_log << TestLog::Message << "glUseProgramStages(" << pipeline << ", " << getShaderTypeMaskStr(stages) << ", " << program << ");" << TestLog::EndMessage;
4184         m_gl.useProgramStages(pipeline, stages, program);
4185 }
4186
4187 void CallLogWrapper::glValidateProgram (glw::GLuint program)
4188 {
4189         if (m_enableLog)
4190                 m_log << TestLog::Message << "glValidateProgram(" << program << ");" << TestLog::EndMessage;
4191         m_gl.validateProgram(program);
4192 }
4193
4194 void CallLogWrapper::glValidateProgramPipeline (glw::GLuint pipeline)
4195 {
4196         if (m_enableLog)
4197                 m_log << TestLog::Message << "glValidateProgramPipeline(" << pipeline << ");" << TestLog::EndMessage;
4198         m_gl.validateProgramPipeline(pipeline);
4199 }
4200
4201 void CallLogWrapper::glVertexArrayAttribBinding (glw::GLuint vaobj, glw::GLuint attribindex, glw::GLuint bindingindex)
4202 {
4203         if (m_enableLog)
4204                 m_log << TestLog::Message << "glVertexArrayAttribBinding(" << vaobj << ", " << attribindex << ", " << bindingindex << ");" << TestLog::EndMessage;
4205         m_gl.vertexArrayAttribBinding(vaobj, attribindex, bindingindex);
4206 }
4207
4208 void CallLogWrapper::glVertexArrayAttribFormat (glw::GLuint vaobj, glw::GLuint attribindex, glw::GLint size, glw::GLenum type, glw::GLboolean normalized, glw::GLuint relativeoffset)
4209 {
4210         if (m_enableLog)
4211                 m_log << TestLog::Message << "glVertexArrayAttribFormat(" << vaobj << ", " << attribindex << ", " << size << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << relativeoffset << ");" << TestLog::EndMessage;
4212         m_gl.vertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
4213 }
4214
4215 void CallLogWrapper::glVertexArrayAttribIFormat (glw::GLuint vaobj, glw::GLuint attribindex, glw::GLint size, glw::GLenum type, glw::GLuint relativeoffset)
4216 {
4217         if (m_enableLog)
4218                 m_log << TestLog::Message << "glVertexArrayAttribIFormat(" << vaobj << ", " << attribindex << ", " << size << ", " << toHex(type) << ", " << relativeoffset << ");" << TestLog::EndMessage;
4219         m_gl.vertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
4220 }
4221
4222 void CallLogWrapper::glVertexArrayAttribLFormat (glw::GLuint vaobj, glw::GLuint attribindex, glw::GLint size, glw::GLenum type, glw::GLuint relativeoffset)
4223 {
4224         if (m_enableLog)
4225                 m_log << TestLog::Message << "glVertexArrayAttribLFormat(" << vaobj << ", " << attribindex << ", " << size << ", " << toHex(type) << ", " << relativeoffset << ");" << TestLog::EndMessage;
4226         m_gl.vertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
4227 }
4228
4229 void CallLogWrapper::glVertexArrayBindingDivisor (glw::GLuint vaobj, glw::GLuint bindingindex, glw::GLuint divisor)
4230 {
4231         if (m_enableLog)
4232                 m_log << TestLog::Message << "glVertexArrayBindingDivisor(" << vaobj << ", " << bindingindex << ", " << divisor << ");" << TestLog::EndMessage;
4233         m_gl.vertexArrayBindingDivisor(vaobj, bindingindex, divisor);
4234 }
4235
4236 void CallLogWrapper::glVertexArrayElementBuffer (glw::GLuint vaobj, glw::GLuint buffer)
4237 {
4238         if (m_enableLog)
4239                 m_log << TestLog::Message << "glVertexArrayElementBuffer(" << vaobj << ", " << buffer << ");" << TestLog::EndMessage;
4240         m_gl.vertexArrayElementBuffer(vaobj, buffer);
4241 }
4242
4243 void CallLogWrapper::glVertexArrayVertexBuffer (glw::GLuint vaobj, glw::GLuint bindingindex, glw::GLuint buffer, glw::GLintptr offset, glw::GLsizei stride)
4244 {
4245         if (m_enableLog)
4246                 m_log << TestLog::Message << "glVertexArrayVertexBuffer(" << vaobj << ", " << bindingindex << ", " << buffer << ", " << offset << ", " << stride << ");" << TestLog::EndMessage;
4247         m_gl.vertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
4248 }
4249
4250 void CallLogWrapper::glVertexArrayVertexBuffers (glw::GLuint vaobj, glw::GLuint first, glw::GLsizei count, const glw::GLuint *buffers, const glw::GLintptr *offsets, const glw::GLsizei *strides)
4251 {
4252         if (m_enableLog)
4253                 m_log << TestLog::Message << "glVertexArrayVertexBuffers(" << vaobj << ", " << 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;
4254         m_gl.vertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
4255 }
4256
4257 void CallLogWrapper::glVertexAttrib1d (glw::GLuint index, glw::GLdouble x)
4258 {
4259         if (m_enableLog)
4260                 m_log << TestLog::Message << "glVertexAttrib1d(" << index << ", " << x << ");" << TestLog::EndMessage;
4261         m_gl.vertexAttrib1d(index, x);
4262 }
4263
4264 void CallLogWrapper::glVertexAttrib1dv (glw::GLuint index, const glw::GLdouble *v)
4265 {
4266         if (m_enableLog)
4267                 m_log << TestLog::Message << "glVertexAttrib1dv(" << index << ", " << getPointerStr(v, 1) << ");" << TestLog::EndMessage;
4268         m_gl.vertexAttrib1dv(index, v);
4269 }
4270
4271 void CallLogWrapper::glVertexAttrib1f (glw::GLuint index, glw::GLfloat x)
4272 {
4273         if (m_enableLog)
4274                 m_log << TestLog::Message << "glVertexAttrib1f(" << index << ", " << x << ");" << TestLog::EndMessage;
4275         m_gl.vertexAttrib1f(index, x);
4276 }
4277
4278 void CallLogWrapper::glVertexAttrib1fv (glw::GLuint index, const glw::GLfloat *v)
4279 {
4280         if (m_enableLog)
4281                 m_log << TestLog::Message << "glVertexAttrib1fv(" << index << ", " << getPointerStr(v, 1) << ");" << TestLog::EndMessage;
4282         m_gl.vertexAttrib1fv(index, v);
4283 }
4284
4285 void CallLogWrapper::glVertexAttrib1s (glw::GLuint index, glw::GLshort x)
4286 {
4287         if (m_enableLog)
4288                 m_log << TestLog::Message << "glVertexAttrib1s(" << index << ", " << x << ");" << TestLog::EndMessage;
4289         m_gl.vertexAttrib1s(index, x);
4290 }
4291
4292 void CallLogWrapper::glVertexAttrib1sv (glw::GLuint index, const glw::GLshort *v)
4293 {
4294         if (m_enableLog)
4295                 m_log << TestLog::Message << "glVertexAttrib1sv(" << index << ", " << getPointerStr(v, 1) << ");" << TestLog::EndMessage;
4296         m_gl.vertexAttrib1sv(index, v);
4297 }
4298
4299 void CallLogWrapper::glVertexAttrib2d (glw::GLuint index, glw::GLdouble x, glw::GLdouble y)
4300 {
4301         if (m_enableLog)
4302                 m_log << TestLog::Message << "glVertexAttrib2d(" << index << ", " << x << ", " << y << ");" << TestLog::EndMessage;
4303         m_gl.vertexAttrib2d(index, x, y);
4304 }
4305
4306 void CallLogWrapper::glVertexAttrib2dv (glw::GLuint index, const glw::GLdouble *v)
4307 {
4308         if (m_enableLog)
4309                 m_log << TestLog::Message << "glVertexAttrib2dv(" << index << ", " << getPointerStr(v, 2) << ");" << TestLog::EndMessage;
4310         m_gl.vertexAttrib2dv(index, v);
4311 }
4312
4313 void CallLogWrapper::glVertexAttrib2f (glw::GLuint index, glw::GLfloat x, glw::GLfloat y)
4314 {
4315         if (m_enableLog)
4316                 m_log << TestLog::Message << "glVertexAttrib2f(" << index << ", " << x << ", " << y << ");" << TestLog::EndMessage;
4317         m_gl.vertexAttrib2f(index, x, y);
4318 }
4319
4320 void CallLogWrapper::glVertexAttrib2fv (glw::GLuint index, const glw::GLfloat *v)
4321 {
4322         if (m_enableLog)
4323                 m_log << TestLog::Message << "glVertexAttrib2fv(" << index << ", " << getPointerStr(v, 2) << ");" << TestLog::EndMessage;
4324         m_gl.vertexAttrib2fv(index, v);
4325 }
4326
4327 void CallLogWrapper::glVertexAttrib2s (glw::GLuint index, glw::GLshort x, glw::GLshort y)
4328 {
4329         if (m_enableLog)
4330                 m_log << TestLog::Message << "glVertexAttrib2s(" << index << ", " << x << ", " << y << ");" << TestLog::EndMessage;
4331         m_gl.vertexAttrib2s(index, x, y);
4332 }
4333
4334 void CallLogWrapper::glVertexAttrib2sv (glw::GLuint index, const glw::GLshort *v)
4335 {
4336         if (m_enableLog)
4337                 m_log << TestLog::Message << "glVertexAttrib2sv(" << index << ", " << getPointerStr(v, 2) << ");" << TestLog::EndMessage;
4338         m_gl.vertexAttrib2sv(index, v);
4339 }
4340
4341 void CallLogWrapper::glVertexAttrib3d (glw::GLuint index, glw::GLdouble x, glw::GLdouble y, glw::GLdouble z)
4342 {
4343         if (m_enableLog)
4344                 m_log << TestLog::Message << "glVertexAttrib3d(" << index << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
4345         m_gl.vertexAttrib3d(index, x, y, z);
4346 }
4347
4348 void CallLogWrapper::glVertexAttrib3dv (glw::GLuint index, const glw::GLdouble *v)
4349 {
4350         if (m_enableLog)
4351                 m_log << TestLog::Message << "glVertexAttrib3dv(" << index << ", " << getPointerStr(v, 3) << ");" << TestLog::EndMessage;
4352         m_gl.vertexAttrib3dv(index, v);
4353 }
4354
4355 void CallLogWrapper::glVertexAttrib3f (glw::GLuint index, glw::GLfloat x, glw::GLfloat y, glw::GLfloat z)
4356 {
4357         if (m_enableLog)
4358                 m_log << TestLog::Message << "glVertexAttrib3f(" << index << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
4359         m_gl.vertexAttrib3f(index, x, y, z);
4360 }
4361
4362 void CallLogWrapper::glVertexAttrib3fv (glw::GLuint index, const glw::GLfloat *v)
4363 {
4364         if (m_enableLog)
4365                 m_log << TestLog::Message << "glVertexAttrib3fv(" << index << ", " << getPointerStr(v, 3) << ");" << TestLog::EndMessage;
4366         m_gl.vertexAttrib3fv(index, v);
4367 }
4368
4369 void CallLogWrapper::glVertexAttrib3s (glw::GLuint index, glw::GLshort x, glw::GLshort y, glw::GLshort z)
4370 {
4371         if (m_enableLog)
4372                 m_log << TestLog::Message << "glVertexAttrib3s(" << index << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
4373         m_gl.vertexAttrib3s(index, x, y, z);
4374 }
4375
4376 void CallLogWrapper::glVertexAttrib3sv (glw::GLuint index, const glw::GLshort *v)
4377 {
4378         if (m_enableLog)
4379                 m_log << TestLog::Message << "glVertexAttrib3sv(" << index << ", " << getPointerStr(v, 3) << ");" << TestLog::EndMessage;
4380         m_gl.vertexAttrib3sv(index, v);
4381 }
4382
4383 void CallLogWrapper::glVertexAttrib4Nbv (glw::GLuint index, const glw::GLbyte *v)
4384 {
4385         if (m_enableLog)
4386                 m_log << TestLog::Message << "glVertexAttrib4Nbv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4387         m_gl.vertexAttrib4Nbv(index, v);
4388 }
4389
4390 void CallLogWrapper::glVertexAttrib4Niv (glw::GLuint index, const glw::GLint *v)
4391 {
4392         if (m_enableLog)
4393                 m_log << TestLog::Message << "glVertexAttrib4Niv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4394         m_gl.vertexAttrib4Niv(index, v);
4395 }
4396
4397 void CallLogWrapper::glVertexAttrib4Nsv (glw::GLuint index, const glw::GLshort *v)
4398 {
4399         if (m_enableLog)
4400                 m_log << TestLog::Message << "glVertexAttrib4Nsv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4401         m_gl.vertexAttrib4Nsv(index, v);
4402 }
4403
4404 void CallLogWrapper::glVertexAttrib4Nub (glw::GLuint index, glw::GLubyte x, glw::GLubyte y, glw::GLubyte z, glw::GLubyte w)
4405 {
4406         if (m_enableLog)
4407                 m_log << TestLog::Message << "glVertexAttrib4Nub(" << index << ", " << toHex(x) << ", " << toHex(y) << ", " << toHex(z) << ", " << toHex(w) << ");" << TestLog::EndMessage;
4408         m_gl.vertexAttrib4Nub(index, x, y, z, w);
4409 }
4410
4411 void CallLogWrapper::glVertexAttrib4Nubv (glw::GLuint index, const glw::GLubyte *v)
4412 {
4413         if (m_enableLog)
4414                 m_log << TestLog::Message << "glVertexAttrib4Nubv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4415         m_gl.vertexAttrib4Nubv(index, v);
4416 }
4417
4418 void CallLogWrapper::glVertexAttrib4Nuiv (glw::GLuint index, const glw::GLuint *v)
4419 {
4420         if (m_enableLog)
4421                 m_log << TestLog::Message << "glVertexAttrib4Nuiv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4422         m_gl.vertexAttrib4Nuiv(index, v);
4423 }
4424
4425 void CallLogWrapper::glVertexAttrib4Nusv (glw::GLuint index, const glw::GLushort *v)
4426 {
4427         if (m_enableLog)
4428                 m_log << TestLog::Message << "glVertexAttrib4Nusv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4429         m_gl.vertexAttrib4Nusv(index, v);
4430 }
4431
4432 void CallLogWrapper::glVertexAttrib4bv (glw::GLuint index, const glw::GLbyte *v)
4433 {
4434         if (m_enableLog)
4435                 m_log << TestLog::Message << "glVertexAttrib4bv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4436         m_gl.vertexAttrib4bv(index, v);
4437 }
4438
4439 void CallLogWrapper::glVertexAttrib4d (glw::GLuint index, glw::GLdouble x, glw::GLdouble y, glw::GLdouble z, glw::GLdouble w)
4440 {
4441         if (m_enableLog)
4442                 m_log << TestLog::Message << "glVertexAttrib4d(" << index << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
4443         m_gl.vertexAttrib4d(index, x, y, z, w);
4444 }
4445
4446 void CallLogWrapper::glVertexAttrib4dv (glw::GLuint index, const glw::GLdouble *v)
4447 {
4448         if (m_enableLog)
4449                 m_log << TestLog::Message << "glVertexAttrib4dv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4450         m_gl.vertexAttrib4dv(index, v);
4451 }
4452
4453 void CallLogWrapper::glVertexAttrib4f (glw::GLuint index, glw::GLfloat x, glw::GLfloat y, glw::GLfloat z, glw::GLfloat w)
4454 {
4455         if (m_enableLog)
4456                 m_log << TestLog::Message << "glVertexAttrib4f(" << index << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
4457         m_gl.vertexAttrib4f(index, x, y, z, w);
4458 }
4459
4460 void CallLogWrapper::glVertexAttrib4fv (glw::GLuint index, const glw::GLfloat *v)
4461 {
4462         if (m_enableLog)
4463                 m_log << TestLog::Message << "glVertexAttrib4fv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4464         m_gl.vertexAttrib4fv(index, v);
4465 }
4466
4467 void CallLogWrapper::glVertexAttrib4iv (glw::GLuint index, const glw::GLint *v)
4468 {
4469         if (m_enableLog)
4470                 m_log << TestLog::Message << "glVertexAttrib4iv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4471         m_gl.vertexAttrib4iv(index, v);
4472 }
4473
4474 void CallLogWrapper::glVertexAttrib4s (glw::GLuint index, glw::GLshort x, glw::GLshort y, glw::GLshort z, glw::GLshort w)
4475 {
4476         if (m_enableLog)
4477                 m_log << TestLog::Message << "glVertexAttrib4s(" << index << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
4478         m_gl.vertexAttrib4s(index, x, y, z, w);
4479 }
4480
4481 void CallLogWrapper::glVertexAttrib4sv (glw::GLuint index, const glw::GLshort *v)
4482 {
4483         if (m_enableLog)
4484                 m_log << TestLog::Message << "glVertexAttrib4sv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4485         m_gl.vertexAttrib4sv(index, v);
4486 }
4487
4488 void CallLogWrapper::glVertexAttrib4ubv (glw::GLuint index, const glw::GLubyte *v)
4489 {
4490         if (m_enableLog)
4491                 m_log << TestLog::Message << "glVertexAttrib4ubv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4492         m_gl.vertexAttrib4ubv(index, v);
4493 }
4494
4495 void CallLogWrapper::glVertexAttrib4uiv (glw::GLuint index, const glw::GLuint *v)
4496 {
4497         if (m_enableLog)
4498                 m_log << TestLog::Message << "glVertexAttrib4uiv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4499         m_gl.vertexAttrib4uiv(index, v);
4500 }
4501
4502 void CallLogWrapper::glVertexAttrib4usv (glw::GLuint index, const glw::GLushort *v)
4503 {
4504         if (m_enableLog)
4505                 m_log << TestLog::Message << "glVertexAttrib4usv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4506         m_gl.vertexAttrib4usv(index, v);
4507 }
4508
4509 void CallLogWrapper::glVertexAttribBinding (glw::GLuint attribindex, glw::GLuint bindingindex)
4510 {
4511         if (m_enableLog)
4512                 m_log << TestLog::Message << "glVertexAttribBinding(" << attribindex << ", " << bindingindex << ");" << TestLog::EndMessage;
4513         m_gl.vertexAttribBinding(attribindex, bindingindex);
4514 }
4515
4516 void CallLogWrapper::glVertexAttribDivisor (glw::GLuint index, glw::GLuint divisor)
4517 {
4518         if (m_enableLog)
4519                 m_log << TestLog::Message << "glVertexAttribDivisor(" << index << ", " << divisor << ");" << TestLog::EndMessage;
4520         m_gl.vertexAttribDivisor(index, divisor);
4521 }
4522
4523 void CallLogWrapper::glVertexAttribFormat (glw::GLuint attribindex, glw::GLint size, glw::GLenum type, glw::GLboolean normalized, glw::GLuint relativeoffset)
4524 {
4525         if (m_enableLog)
4526                 m_log << TestLog::Message << "glVertexAttribFormat(" << attribindex << ", " << size << ", " << getTypeStr(type) << ", " << getBooleanStr(normalized) << ", " << relativeoffset << ");" << TestLog::EndMessage;
4527         m_gl.vertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
4528 }
4529
4530 void CallLogWrapper::glVertexAttribI1i (glw::GLuint index, glw::GLint x)
4531 {
4532         if (m_enableLog)
4533                 m_log << TestLog::Message << "glVertexAttribI1i(" << index << ", " << x << ");" << TestLog::EndMessage;
4534         m_gl.vertexAttribI1i(index, x);
4535 }
4536
4537 void CallLogWrapper::glVertexAttribI1iv (glw::GLuint index, const glw::GLint *v)
4538 {
4539         if (m_enableLog)
4540                 m_log << TestLog::Message << "glVertexAttribI1iv(" << index << ", " << getPointerStr(v, 1) << ");" << TestLog::EndMessage;
4541         m_gl.vertexAttribI1iv(index, v);
4542 }
4543
4544 void CallLogWrapper::glVertexAttribI1ui (glw::GLuint index, glw::GLuint x)
4545 {
4546         if (m_enableLog)
4547                 m_log << TestLog::Message << "glVertexAttribI1ui(" << index << ", " << x << ");" << TestLog::EndMessage;
4548         m_gl.vertexAttribI1ui(index, x);
4549 }
4550
4551 void CallLogWrapper::glVertexAttribI1uiv (glw::GLuint index, const glw::GLuint *v)
4552 {
4553         if (m_enableLog)
4554                 m_log << TestLog::Message << "glVertexAttribI1uiv(" << index << ", " << getPointerStr(v, 1) << ");" << TestLog::EndMessage;
4555         m_gl.vertexAttribI1uiv(index, v);
4556 }
4557
4558 void CallLogWrapper::glVertexAttribI2i (glw::GLuint index, glw::GLint x, glw::GLint y)
4559 {
4560         if (m_enableLog)
4561                 m_log << TestLog::Message << "glVertexAttribI2i(" << index << ", " << x << ", " << y << ");" << TestLog::EndMessage;
4562         m_gl.vertexAttribI2i(index, x, y);
4563 }
4564
4565 void CallLogWrapper::glVertexAttribI2iv (glw::GLuint index, const glw::GLint *v)
4566 {
4567         if (m_enableLog)
4568                 m_log << TestLog::Message << "glVertexAttribI2iv(" << index << ", " << getPointerStr(v, 2) << ");" << TestLog::EndMessage;
4569         m_gl.vertexAttribI2iv(index, v);
4570 }
4571
4572 void CallLogWrapper::glVertexAttribI2ui (glw::GLuint index, glw::GLuint x, glw::GLuint y)
4573 {
4574         if (m_enableLog)
4575                 m_log << TestLog::Message << "glVertexAttribI2ui(" << index << ", " << x << ", " << y << ");" << TestLog::EndMessage;
4576         m_gl.vertexAttribI2ui(index, x, y);
4577 }
4578
4579 void CallLogWrapper::glVertexAttribI2uiv (glw::GLuint index, const glw::GLuint *v)
4580 {
4581         if (m_enableLog)
4582                 m_log << TestLog::Message << "glVertexAttribI2uiv(" << index << ", " << getPointerStr(v, 2) << ");" << TestLog::EndMessage;
4583         m_gl.vertexAttribI2uiv(index, v);
4584 }
4585
4586 void CallLogWrapper::glVertexAttribI3i (glw::GLuint index, glw::GLint x, glw::GLint y, glw::GLint z)
4587 {
4588         if (m_enableLog)
4589                 m_log << TestLog::Message << "glVertexAttribI3i(" << index << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
4590         m_gl.vertexAttribI3i(index, x, y, z);
4591 }
4592
4593 void CallLogWrapper::glVertexAttribI3iv (glw::GLuint index, const glw::GLint *v)
4594 {
4595         if (m_enableLog)
4596                 m_log << TestLog::Message << "glVertexAttribI3iv(" << index << ", " << getPointerStr(v, 3) << ");" << TestLog::EndMessage;
4597         m_gl.vertexAttribI3iv(index, v);
4598 }
4599
4600 void CallLogWrapper::glVertexAttribI3ui (glw::GLuint index, glw::GLuint x, glw::GLuint y, glw::GLuint z)
4601 {
4602         if (m_enableLog)
4603                 m_log << TestLog::Message << "glVertexAttribI3ui(" << index << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
4604         m_gl.vertexAttribI3ui(index, x, y, z);
4605 }
4606
4607 void CallLogWrapper::glVertexAttribI3uiv (glw::GLuint index, const glw::GLuint *v)
4608 {
4609         if (m_enableLog)
4610                 m_log << TestLog::Message << "glVertexAttribI3uiv(" << index << ", " << getPointerStr(v, 3) << ");" << TestLog::EndMessage;
4611         m_gl.vertexAttribI3uiv(index, v);
4612 }
4613
4614 void CallLogWrapper::glVertexAttribI4bv (glw::GLuint index, const glw::GLbyte *v)
4615 {
4616         if (m_enableLog)
4617                 m_log << TestLog::Message << "glVertexAttribI4bv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4618         m_gl.vertexAttribI4bv(index, v);
4619 }
4620
4621 void CallLogWrapper::glVertexAttribI4i (glw::GLuint index, glw::GLint x, glw::GLint y, glw::GLint z, glw::GLint w)
4622 {
4623         if (m_enableLog)
4624                 m_log << TestLog::Message << "glVertexAttribI4i(" << index << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
4625         m_gl.vertexAttribI4i(index, x, y, z, w);
4626 }
4627
4628 void CallLogWrapper::glVertexAttribI4iv (glw::GLuint index, const glw::GLint *v)
4629 {
4630         if (m_enableLog)
4631                 m_log << TestLog::Message << "glVertexAttribI4iv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4632         m_gl.vertexAttribI4iv(index, v);
4633 }
4634
4635 void CallLogWrapper::glVertexAttribI4sv (glw::GLuint index, const glw::GLshort *v)
4636 {
4637         if (m_enableLog)
4638                 m_log << TestLog::Message << "glVertexAttribI4sv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4639         m_gl.vertexAttribI4sv(index, v);
4640 }
4641
4642 void CallLogWrapper::glVertexAttribI4ubv (glw::GLuint index, const glw::GLubyte *v)
4643 {
4644         if (m_enableLog)
4645                 m_log << TestLog::Message << "glVertexAttribI4ubv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4646         m_gl.vertexAttribI4ubv(index, v);
4647 }
4648
4649 void CallLogWrapper::glVertexAttribI4ui (glw::GLuint index, glw::GLuint x, glw::GLuint y, glw::GLuint z, glw::GLuint w)
4650 {
4651         if (m_enableLog)
4652                 m_log << TestLog::Message << "glVertexAttribI4ui(" << index << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
4653         m_gl.vertexAttribI4ui(index, x, y, z, w);
4654 }
4655
4656 void CallLogWrapper::glVertexAttribI4uiv (glw::GLuint index, const glw::GLuint *v)
4657 {
4658         if (m_enableLog)
4659                 m_log << TestLog::Message << "glVertexAttribI4uiv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4660         m_gl.vertexAttribI4uiv(index, v);
4661 }
4662
4663 void CallLogWrapper::glVertexAttribI4usv (glw::GLuint index, const glw::GLushort *v)
4664 {
4665         if (m_enableLog)
4666                 m_log << TestLog::Message << "glVertexAttribI4usv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4667         m_gl.vertexAttribI4usv(index, v);
4668 }
4669
4670 void CallLogWrapper::glVertexAttribIFormat (glw::GLuint attribindex, glw::GLint size, glw::GLenum type, glw::GLuint relativeoffset)
4671 {
4672         if (m_enableLog)
4673                 m_log << TestLog::Message << "glVertexAttribIFormat(" << attribindex << ", " << size << ", " << getTypeStr(type) << ", " << relativeoffset << ");" << TestLog::EndMessage;
4674         m_gl.vertexAttribIFormat(attribindex, size, type, relativeoffset);
4675 }
4676
4677 void CallLogWrapper::glVertexAttribIPointer (glw::GLuint index, glw::GLint size, glw::GLenum type, glw::GLsizei stride, const void *pointer)
4678 {
4679         if (m_enableLog)
4680                 m_log << TestLog::Message << "glVertexAttribIPointer(" << index << ", " << size << ", " << getTypeStr(type) << ", " << stride << ", " << pointer << ");" << TestLog::EndMessage;
4681         m_gl.vertexAttribIPointer(index, size, type, stride, pointer);
4682 }
4683
4684 void CallLogWrapper::glVertexAttribL1d (glw::GLuint index, glw::GLdouble x)
4685 {
4686         if (m_enableLog)
4687                 m_log << TestLog::Message << "glVertexAttribL1d(" << index << ", " << x << ");" << TestLog::EndMessage;
4688         m_gl.vertexAttribL1d(index, x);
4689 }
4690
4691 void CallLogWrapper::glVertexAttribL1dv (glw::GLuint index, const glw::GLdouble *v)
4692 {
4693         if (m_enableLog)
4694                 m_log << TestLog::Message << "glVertexAttribL1dv(" << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
4695         m_gl.vertexAttribL1dv(index, v);
4696 }
4697
4698 void CallLogWrapper::glVertexAttribL2d (glw::GLuint index, glw::GLdouble x, glw::GLdouble y)
4699 {
4700         if (m_enableLog)
4701                 m_log << TestLog::Message << "glVertexAttribL2d(" << index << ", " << x << ", " << y << ");" << TestLog::EndMessage;
4702         m_gl.vertexAttribL2d(index, x, y);
4703 }
4704
4705 void CallLogWrapper::glVertexAttribL2dv (glw::GLuint index, const glw::GLdouble *v)
4706 {
4707         if (m_enableLog)
4708                 m_log << TestLog::Message << "glVertexAttribL2dv(" << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
4709         m_gl.vertexAttribL2dv(index, v);
4710 }
4711
4712 void CallLogWrapper::glVertexAttribL3d (glw::GLuint index, glw::GLdouble x, glw::GLdouble y, glw::GLdouble z)
4713 {
4714         if (m_enableLog)
4715                 m_log << TestLog::Message << "glVertexAttribL3d(" << index << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
4716         m_gl.vertexAttribL3d(index, x, y, z);
4717 }
4718
4719 void CallLogWrapper::glVertexAttribL3dv (glw::GLuint index, const glw::GLdouble *v)
4720 {
4721         if (m_enableLog)
4722                 m_log << TestLog::Message << "glVertexAttribL3dv(" << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
4723         m_gl.vertexAttribL3dv(index, v);
4724 }
4725
4726 void CallLogWrapper::glVertexAttribL4d (glw::GLuint index, glw::GLdouble x, glw::GLdouble y, glw::GLdouble z, glw::GLdouble w)
4727 {
4728         if (m_enableLog)
4729                 m_log << TestLog::Message << "glVertexAttribL4d(" << index << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
4730         m_gl.vertexAttribL4d(index, x, y, z, w);
4731 }
4732
4733 void CallLogWrapper::glVertexAttribL4dv (glw::GLuint index, const glw::GLdouble *v)
4734 {
4735         if (m_enableLog)
4736                 m_log << TestLog::Message << "glVertexAttribL4dv(" << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
4737         m_gl.vertexAttribL4dv(index, v);
4738 }
4739
4740 void CallLogWrapper::glVertexAttribLFormat (glw::GLuint attribindex, glw::GLint size, glw::GLenum type, glw::GLuint relativeoffset)
4741 {
4742         if (m_enableLog)
4743                 m_log << TestLog::Message << "glVertexAttribLFormat(" << attribindex << ", " << size << ", " << toHex(type) << ", " << relativeoffset << ");" << TestLog::EndMessage;
4744         m_gl.vertexAttribLFormat(attribindex, size, type, relativeoffset);
4745 }
4746
4747 void CallLogWrapper::glVertexAttribLPointer (glw::GLuint index, glw::GLint size, glw::GLenum type, glw::GLsizei stride, const void *pointer)
4748 {
4749         if (m_enableLog)
4750                 m_log << TestLog::Message << "glVertexAttribLPointer(" << index << ", " << size << ", " << toHex(type) << ", " << stride << ", " << pointer << ");" << TestLog::EndMessage;
4751         m_gl.vertexAttribLPointer(index, size, type, stride, pointer);
4752 }
4753
4754 void CallLogWrapper::glVertexAttribP1ui (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, glw::GLuint value)
4755 {
4756         if (m_enableLog)
4757                 m_log << TestLog::Message << "glVertexAttribP1ui(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
4758         m_gl.vertexAttribP1ui(index, type, normalized, value);
4759 }
4760
4761 void CallLogWrapper::glVertexAttribP1uiv (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, const glw::GLuint *value)
4762 {
4763         if (m_enableLog)
4764                 m_log << TestLog::Message << "glVertexAttribP1uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4765         m_gl.vertexAttribP1uiv(index, type, normalized, value);
4766 }
4767
4768 void CallLogWrapper::glVertexAttribP2ui (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, glw::GLuint value)
4769 {
4770         if (m_enableLog)
4771                 m_log << TestLog::Message << "glVertexAttribP2ui(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
4772         m_gl.vertexAttribP2ui(index, type, normalized, value);
4773 }
4774
4775 void CallLogWrapper::glVertexAttribP2uiv (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, const glw::GLuint *value)
4776 {
4777         if (m_enableLog)
4778                 m_log << TestLog::Message << "glVertexAttribP2uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4779         m_gl.vertexAttribP2uiv(index, type, normalized, value);
4780 }
4781
4782 void CallLogWrapper::glVertexAttribP3ui (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, glw::GLuint value)
4783 {
4784         if (m_enableLog)
4785                 m_log << TestLog::Message << "glVertexAttribP3ui(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
4786         m_gl.vertexAttribP3ui(index, type, normalized, value);
4787 }
4788
4789 void CallLogWrapper::glVertexAttribP3uiv (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, const glw::GLuint *value)
4790 {
4791         if (m_enableLog)
4792                 m_log << TestLog::Message << "glVertexAttribP3uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4793         m_gl.vertexAttribP3uiv(index, type, normalized, value);
4794 }
4795
4796 void CallLogWrapper::glVertexAttribP4ui (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, glw::GLuint value)
4797 {
4798         if (m_enableLog)
4799                 m_log << TestLog::Message << "glVertexAttribP4ui(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
4800         m_gl.vertexAttribP4ui(index, type, normalized, value);
4801 }
4802
4803 void CallLogWrapper::glVertexAttribP4uiv (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, const glw::GLuint *value)
4804 {
4805         if (m_enableLog)
4806                 m_log << TestLog::Message << "glVertexAttribP4uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
4807         m_gl.vertexAttribP4uiv(index, type, normalized, value);
4808 }
4809
4810 void CallLogWrapper::glVertexAttribPointer (glw::GLuint index, glw::GLint size, glw::GLenum type, glw::GLboolean normalized, glw::GLsizei stride, const void *pointer)
4811 {
4812         if (m_enableLog)
4813                 m_log << TestLog::Message << "glVertexAttribPointer(" << index << ", " << size << ", " << getTypeStr(type) << ", " << getBooleanStr(normalized) << ", " << stride << ", " << pointer << ");" << TestLog::EndMessage;
4814         m_gl.vertexAttribPointer(index, size, type, normalized, stride, pointer);
4815 }
4816
4817 void CallLogWrapper::glVertexBindingDivisor (glw::GLuint bindingindex, glw::GLuint divisor)
4818 {
4819         if (m_enableLog)
4820                 m_log << TestLog::Message << "glVertexBindingDivisor(" << bindingindex << ", " << divisor << ");" << TestLog::EndMessage;
4821         m_gl.vertexBindingDivisor(bindingindex, divisor);
4822 }
4823
4824 void CallLogWrapper::glViewport (glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
4825 {
4826         if (m_enableLog)
4827                 m_log << TestLog::Message << "glViewport(" << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
4828         m_gl.viewport(x, y, width, height);
4829 }
4830
4831 void CallLogWrapper::glViewportArrayv (glw::GLuint first, glw::GLsizei count, const glw::GLfloat *v)
4832 {
4833         if (m_enableLog)
4834                 m_log << TestLog::Message << "glViewportArrayv(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
4835         m_gl.viewportArrayv(first, count, v);
4836 }
4837
4838 void CallLogWrapper::glViewportIndexedf (glw::GLuint index, glw::GLfloat x, glw::GLfloat y, glw::GLfloat w, glw::GLfloat h)
4839 {
4840         if (m_enableLog)
4841                 m_log << TestLog::Message << "glViewportIndexedf(" << index << ", " << x << ", " << y << ", " << w << ", " << h << ");" << TestLog::EndMessage;
4842         m_gl.viewportIndexedf(index, x, y, w, h);
4843 }
4844
4845 void CallLogWrapper::glViewportIndexedfv (glw::GLuint index, const glw::GLfloat *v)
4846 {
4847         if (m_enableLog)
4848                 m_log << TestLog::Message << "glViewportIndexedfv(" << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
4849         m_gl.viewportIndexedfv(index, v);
4850 }
4851
4852 void CallLogWrapper::glWaitSync (glw::GLsync sync, glw::GLbitfield flags, glw::GLuint64 timeout)
4853 {
4854         if (m_enableLog)
4855                 m_log << TestLog::Message << "glWaitSync(" << sync << ", " << toHex(flags) << ", " << timeout << ");" << TestLog::EndMessage;
4856         m_gl.waitSync(sync, flags, timeout);
4857 }