gluCallLogWrapper.inl revision cb82ed72dcbbfd8a6d07736c3259605227bc984f 
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 29570.
5 */
6
7void 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
14void 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
21void 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
28void 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
35void 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
42void 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
49void 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
56void 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
63void 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
70void 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
77void 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
84void 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 << ", " << buffers << ");" << TestLog::EndMessage;
88	m_gl.bindBuffersBase(target, first, count, buffers);
89}
90
91void 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 << ", " << buffers << ", " << offsets << ", " << sizes << ");" << TestLog::EndMessage;
95	m_gl.bindBuffersRange(target, first, count, buffers, offsets, sizes);
96}
97
98void 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
105void 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
112void 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
119void 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) << ", " << getPixelFormatStr(format) << ");" << TestLog::EndMessage;
123	m_gl.bindImageTexture(unit, texture, level, layered, layer, access, format);
124}
125
126void 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 << ", " << textures << ");" << TestLog::EndMessage;
130	m_gl.bindImageTextures(first, count, textures);
131}
132
133void 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
140void 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
147void 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
154void 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 << ", " << samplers << ");" << TestLog::EndMessage;
158	m_gl.bindSamplers(first, count, samplers);
159}
160
161void 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
168void 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
175void 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 << ", " << textures << ");" << TestLog::EndMessage;
179	m_gl.bindTextures(first, count, textures);
180}
181
182void 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
189void 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
196void 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
203void 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 << ", " << buffers << ", " << offsets << ", " << strides << ");" << TestLog::EndMessage;
207	m_gl.bindVertexBuffers(first, count, buffers, offsets, strides);
208}
209
210void CallLogWrapper::glBlendBarrierKHR (void)
211{
212	if (m_enableLog)
213		m_log << TestLog::Message << "glBlendBarrierKHR(" << ");" << TestLog::EndMessage;
214	m_gl.blendBarrierKHR();
215}
216
217void 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
224void 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
231void 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
238void CallLogWrapper::glBlendEquationSeparatei (glw::GLuint buf, glw::GLenum modeRGB, glw::GLenum modeAlpha)
239{
240	if (m_enableLog)
241		m_log << TestLog::Message << "glBlendEquationSeparatei(" << buf << ", " << toHex(modeRGB) << ", " << toHex(modeAlpha) << ");" << TestLog::EndMessage;
242	m_gl.blendEquationSeparatei(buf, modeRGB, modeAlpha);
243}
244
245void CallLogWrapper::glBlendEquationi (glw::GLuint buf, glw::GLenum mode)
246{
247	if (m_enableLog)
248		m_log << TestLog::Message << "glBlendEquationi(" << buf << ", " << toHex(mode) << ");" << TestLog::EndMessage;
249	m_gl.blendEquationi(buf, mode);
250}
251
252void 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
259void 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
266void 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
273void 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
280void 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
287void 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
294void 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
301void 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
308void 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
315glw::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
325glw::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
335void 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
342void 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
349void 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
356void 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
363void 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
370void 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 << ", " << value << ");" << TestLog::EndMessage;
374	m_gl.clearBufferfv(buffer, drawbuffer, value);
375}
376
377void 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 << ", " << value << ");" << TestLog::EndMessage;
381	m_gl.clearBufferiv(buffer, drawbuffer, value);
382}
383
384void 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 << ", " << value << ");" << TestLog::EndMessage;
388	m_gl.clearBufferuiv(buffer, drawbuffer, value);
389}
390
391void 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
398void 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
405void 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
412void 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
419void 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
426void 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
433void 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 << ", " << value << ");" << TestLog::EndMessage;
437	m_gl.clearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
438}
439
440void 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 << ", " << value << ");" << TestLog::EndMessage;
444	m_gl.clearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
445}
446
447void 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 << ", " << value << ");" << TestLog::EndMessage;
451	m_gl.clearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
452}
453
454void 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
461void 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
468void 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
475glw::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
485void 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
492void 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
499void 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
506void 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
513void 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
520void 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 << ", " << getCompressedTexFormatStr(internalformat) << ", " << width << ", " << height << ", " << border << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
524	m_gl.compressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
525}
526
527void 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(" << toHex(target) << ", " << level << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << border << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
531	m_gl.compressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
532}
533
534void 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
541void 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 << ", " << getCompressedTexFormatStr(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
545	m_gl.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
546}
547
548void 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(" << toHex(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << toHex(format) << ", " << imageSize << ", " << data << ");" << TestLog::EndMessage;
552	m_gl.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
553}
554
555void 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
562void 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
569void 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
576void 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
583void 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
590void 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
597void 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 << ", " << getPixelFormatStr(internalformat) << ", " << x << ", " << y << ", " << width << ", " << border << ");" << TestLog::EndMessage;
601	m_gl.copyTexImage1D(target, level, internalformat, x, y, width, border);
602}
603
604void 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 << ", " << getPixelFormatStr(internalformat) << ", " << x << ", " << y << ", " << width << ", " << height << ", " << border << ");" << TestLog::EndMessage;
608	m_gl.copyTexImage2D(target, level, internalformat, x, y, width, height, border);
609}
610
611void 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
618void 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
625void 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
632void 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
639void 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
646void 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
653void CallLogWrapper::glCreateBuffers (glw::GLsizei n, glw::GLuint *buffers)
654{
655	if (m_enableLog)
656		m_log << TestLog::Message << "glCreateBuffers(" << n << ", " << buffers << ");" << TestLog::EndMessage;
657	m_gl.createBuffers(n, buffers);
658}
659
660void CallLogWrapper::glCreateFramebuffers (glw::GLsizei n, glw::GLuint *framebuffers)
661{
662	if (m_enableLog)
663		m_log << TestLog::Message << "glCreateFramebuffers(" << n << ", " << framebuffers << ");" << TestLog::EndMessage;
664	m_gl.createFramebuffers(n, framebuffers);
665}
666
667glw::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
677void CallLogWrapper::glCreateProgramPipelines (glw::GLsizei n, glw::GLuint *pipelines)
678{
679	if (m_enableLog)
680		m_log << TestLog::Message << "glCreateProgramPipelines(" << n << ", " << pipelines << ");" << TestLog::EndMessage;
681	m_gl.createProgramPipelines(n, pipelines);
682}
683
684void 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 << ", " << ids << ");" << TestLog::EndMessage;
688	m_gl.createQueries(target, n, ids);
689}
690
691void CallLogWrapper::glCreateRenderbuffers (glw::GLsizei n, glw::GLuint *renderbuffers)
692{
693	if (m_enableLog)
694		m_log << TestLog::Message << "glCreateRenderbuffers(" << n << ", " << renderbuffers << ");" << TestLog::EndMessage;
695	m_gl.createRenderbuffers(n, renderbuffers);
696}
697
698void CallLogWrapper::glCreateSamplers (glw::GLsizei n, glw::GLuint *samplers)
699{
700	if (m_enableLog)
701		m_log << TestLog::Message << "glCreateSamplers(" << n << ", " << samplers << ");" << TestLog::EndMessage;
702	m_gl.createSamplers(n, samplers);
703}
704
705glw::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
715glw::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 << ", " << 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
725void 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 << ", " << textures << ");" << TestLog::EndMessage;
729	m_gl.createTextures(target, n, textures);
730}
731
732void CallLogWrapper::glCreateTransformFeedbacks (glw::GLsizei n, glw::GLuint *ids)
733{
734	if (m_enableLog)
735		m_log << TestLog::Message << "glCreateTransformFeedbacks(" << n << ", " << ids << ");" << TestLog::EndMessage;
736	m_gl.createTransformFeedbacks(n, ids);
737}
738
739void CallLogWrapper::glCreateVertexArrays (glw::GLsizei n, glw::GLuint *arrays)
740{
741	if (m_enableLog)
742		m_log << TestLog::Message << "glCreateVertexArrays(" << n << ", " << arrays << ");" << TestLog::EndMessage;
743	m_gl.createVertexArrays(n, arrays);
744}
745
746void 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
753void CallLogWrapper::glDebugMessageCallback (glw::GLDEBUGPROC callback, const void *userParam)
754{
755	if (m_enableLog)
756		m_log << TestLog::Message << "glDebugMessageCallback(" << callback << ", " << userParam << ");" << TestLog::EndMessage;
757	m_gl.debugMessageCallback(callback, userParam);
758}
759
760void 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
767void 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
774void 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
781void 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
788void 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
795void 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
802void 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
809void 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
816void CallLogWrapper::glDeleteSamplers (glw::GLsizei count, const glw::GLuint *samplers)
817{
818	if (m_enableLog)
819		m_log << TestLog::Message << "glDeleteSamplers(" << count << ", " << samplers << ");" << TestLog::EndMessage;
820	m_gl.deleteSamplers(count, samplers);
821}
822
823void 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
830void 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
837void 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
844void CallLogWrapper::glDeleteTransformFeedbacks (glw::GLsizei n, const glw::GLuint *ids)
845{
846	if (m_enableLog)
847		m_log << TestLog::Message << "glDeleteTransformFeedbacks(" << n << ", " << ids << ");" << TestLog::EndMessage;
848	m_gl.deleteTransformFeedbacks(n, ids);
849}
850
851void 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
858void 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
865void 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
872void 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
879void 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 << ", " << v << ");" << TestLog::EndMessage;
883	m_gl.depthRangeArrayv(first, count, v);
884}
885
886void 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
893void 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
900void 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
907void 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
914void 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
921void 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
928void CallLogWrapper::glDisablei (glw::GLenum target, glw::GLuint index)
929{
930	if (m_enableLog)
931		m_log << TestLog::Message << "glDisablei(" << toHex(target) << ", " << index << ");" << TestLog::EndMessage;
932	m_gl.disablei(target, index);
933}
934
935void 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
942void 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
949void 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
956void 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
963void 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
970void 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
977void 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
984void 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
991void 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
998void 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
1005void 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
1012void 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
1019void 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
1026void 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
1033void 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
1040void 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
1047void 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
1054void 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
1061void 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
1068void 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
1075void 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
1082void 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
1089void 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
1096void 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
1103void 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
1110void 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
1117void CallLogWrapper::glEnablei (glw::GLenum target, glw::GLuint index)
1118{
1119	if (m_enableLog)
1120		m_log << TestLog::Message << "glEnablei(" << toHex(target) << ", " << index << ");" << TestLog::EndMessage;
1121	m_gl.enablei(target, index);
1122}
1123
1124void CallLogWrapper::glEndConditionalRender (void)
1125{
1126	if (m_enableLog)
1127		m_log << TestLog::Message << "glEndConditionalRender(" << ");" << TestLog::EndMessage;
1128	m_gl.endConditionalRender();
1129}
1130
1131void 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
1138void 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
1145void CallLogWrapper::glEndTransformFeedback (void)
1146{
1147	if (m_enableLog)
1148		m_log << TestLog::Message << "glEndTransformFeedback(" << ");" << TestLog::EndMessage;
1149	m_gl.endTransformFeedback();
1150}
1151
1152glw::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
1162void CallLogWrapper::glFinish (void)
1163{
1164	if (m_enableLog)
1165		m_log << TestLog::Message << "glFinish(" << ");" << TestLog::EndMessage;
1166	m_gl.finish();
1167}
1168
1169void CallLogWrapper::glFlush (void)
1170{
1171	if (m_enableLog)
1172		m_log << TestLog::Message << "glFlush(" << ");" << TestLog::EndMessage;
1173	m_gl.flush();
1174}
1175
1176void 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
1183void 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
1190void 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
1197void 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
1204void 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
1211void 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
1218void 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
1225void 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
1232void 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
1239void 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
1246void CallLogWrapper::glGenBuffers (glw::GLsizei n, glw::GLuint *buffers)
1247{
1248	if (m_enableLog)
1249		m_log << TestLog::Message << "glGenBuffers(" << n << ", " << 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
1255void CallLogWrapper::glGenFramebuffers (glw::GLsizei n, glw::GLuint *framebuffers)
1256{
1257	if (m_enableLog)
1258		m_log << TestLog::Message << "glGenFramebuffers(" << n << ", " << 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
1264void CallLogWrapper::glGenProgramPipelines (glw::GLsizei n, glw::GLuint *pipelines)
1265{
1266	if (m_enableLog)
1267		m_log << TestLog::Message << "glGenProgramPipelines(" << n << ", " << 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
1273void CallLogWrapper::glGenQueries (glw::GLsizei n, glw::GLuint *ids)
1274{
1275	if (m_enableLog)
1276		m_log << TestLog::Message << "glGenQueries(" << n << ", " << 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
1282void CallLogWrapper::glGenRenderbuffers (glw::GLsizei n, glw::GLuint *renderbuffers)
1283{
1284	if (m_enableLog)
1285		m_log << TestLog::Message << "glGenRenderbuffers(" << n << ", " << 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
1291void CallLogWrapper::glGenSamplers (glw::GLsizei count, glw::GLuint *samplers)
1292{
1293	if (m_enableLog)
1294		m_log << TestLog::Message << "glGenSamplers(" << count << ", " << samplers << ");" << TestLog::EndMessage;
1295	m_gl.genSamplers(count, samplers);
1296}
1297
1298void CallLogWrapper::glGenTextures (glw::GLsizei n, glw::GLuint *textures)
1299{
1300	if (m_enableLog)
1301		m_log << TestLog::Message << "glGenTextures(" << n << ", " << 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
1307void CallLogWrapper::glGenTransformFeedbacks (glw::GLsizei n, glw::GLuint *ids)
1308{
1309	if (m_enableLog)
1310		m_log << TestLog::Message << "glGenTransformFeedbacks(" << n << ", " << 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
1316void CallLogWrapper::glGenVertexArrays (glw::GLsizei n, glw::GLuint *arrays)
1317{
1318	if (m_enableLog)
1319		m_log << TestLog::Message << "glGenVertexArrays(" << n << ", " << 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
1325void 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
1332void 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
1339void 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) << ", " << params << ");" << TestLog::EndMessage;
1343	m_gl.getActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
1344}
1345
1346void 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 << ", " << length << ", " << size << ", " << type << ", " << name << ");" << TestLog::EndMessage;
1350	m_gl.getActiveAttrib(program, index, bufSize, length, size, type, name);
1351}
1352
1353void 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 << ", " << length << ", " << name << ");" << TestLog::EndMessage;
1357	m_gl.getActiveSubroutineName(program, shadertype, index, bufsize, length, name);
1358}
1359
1360void 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 << ", " << length << ", " << name << ");" << TestLog::EndMessage;
1364	m_gl.getActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
1365}
1366
1367void 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) << ", " << values << ");" << TestLog::EndMessage;
1371	m_gl.getActiveSubroutineUniformiv(program, shadertype, index, pname, values);
1372}
1373
1374void 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 << ", " << length << ", " << size << ", " << type << ", " << 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
1388void 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 << ", " << length << ", " << uniformBlockName << ");" << TestLog::EndMessage;
1392	m_gl.getActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
1393}
1394
1395void 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) << ", " << params << ");" << TestLog::EndMessage;
1399	m_gl.getActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
1400}
1401
1402void 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 << ", " << length << ", " << uniformName << ");" << TestLog::EndMessage;
1406	m_gl.getActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
1407}
1408
1409void 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) << ", " << 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
1418void 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 << ", " << count << ", " << shaders << ");" << TestLog::EndMessage;
1422	m_gl.getAttachedShaders(program, maxCount, count, shaders);
1423}
1424
1425glw::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
1435void 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 << ", " << 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, 1) << TestLog::EndMessage;
1442}
1443
1444void CallLogWrapper::glGetBooleanv (glw::GLenum pname, glw::GLboolean *data)
1445{
1446	if (m_enableLog)
1447		m_log << TestLog::Message << "glGetBooleanv(" << getGettableStateStr(pname) << ", " << 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
1453void 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) << ", " << params << ");" << TestLog::EndMessage;
1457	m_gl.getBufferParameteri64v(target, pname, params);
1458}
1459
1460void 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) << ", " << params << ");" << TestLog::EndMessage;
1464	m_gl.getBufferParameteriv(target, pname, params);
1465}
1466
1467void 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) << ", " << params << ");" << TestLog::EndMessage;
1471	m_gl.getBufferPointerv(target, pname, params);
1472}
1473
1474void 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
1481void 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
1488void 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
1495void 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
1502glw::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 << ", " << sources << ", " << types << ", " << ids << ", " << severities << ", " << lengths << ", " << 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
1512void 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 << ", " << data << ");" << TestLog::EndMessage;
1516	m_gl.getDoublei_v(target, index, data);
1517}
1518
1519void CallLogWrapper::glGetDoublev (glw::GLenum pname, glw::GLdouble *data)
1520{
1521	if (m_enableLog)
1522		m_log << TestLog::Message << "glGetDoublev(" << toHex(pname) << ", " << data << ");" << TestLog::EndMessage;
1523	m_gl.getDoublev(pname, data);
1524}
1525
1526glw::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
1536void 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 << ", " << data << ");" << TestLog::EndMessage;
1540	m_gl.getFloati_v(target, index, data);
1541}
1542
1543void CallLogWrapper::glGetFloatv (glw::GLenum pname, glw::GLfloat *data)
1544{
1545	if (m_enableLog)
1546		m_log << TestLog::Message << "glGetFloatv(" << getGettableStateStr(pname) << ", " << 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
1552glw::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
1562glw::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
1572void 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) << ", " << 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
1581void 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) << ", " << 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
1590glw::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
1600void 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 << ", " << data << ");" << TestLog::EndMessage;
1604	m_gl.getInteger64i_v(target, index, data);
1605	if (m_enableLog)
1606		m_log << TestLog::Message << "// data = " << getPointerStr(data, 1) << TestLog::EndMessage;
1607}
1608
1609void CallLogWrapper::glGetInteger64v (glw::GLenum pname, glw::GLint64 *data)
1610{
1611	if (m_enableLog)
1612		m_log << TestLog::Message << "glGetInteger64v(" << getGettableStateStr(pname) << ", " << 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
1618void 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 << ", " << data << ");" << TestLog::EndMessage;
1622	m_gl.getIntegeri_v(target, index, data);
1623	if (m_enableLog)
1624		m_log << TestLog::Message << "// data = " << getPointerStr(data, 1) << TestLog::EndMessage;
1625}
1626
1627void CallLogWrapper::glGetIntegerv (glw::GLenum pname, glw::GLint *data)
1628{
1629	if (m_enableLog)
1630		m_log << TestLog::Message << "glGetIntegerv(" << getGettableStateStr(pname) << ", " << 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
1636void 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 << ", " << params << ");" << TestLog::EndMessage;
1640	m_gl.getInternalformati64v(target, internalformat, pname, bufSize, params);
1641}
1642
1643void 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) << ", " << getPixelFormatStr(internalformat) << ", " << getInternalFormatParameterStr(pname) << ", " << bufSize << ", " << 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
1652void 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 << ", " << 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
1661void 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) << ", " << params << ");" << TestLog::EndMessage;
1665	m_gl.getNamedBufferParameteri64v(buffer, pname, params);
1666}
1667
1668void 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) << ", " << params << ");" << TestLog::EndMessage;
1672	m_gl.getNamedBufferParameteriv(buffer, pname, params);
1673}
1674
1675void CallLogWrapper::glGetNamedBufferPointerv (glw::GLuint buffer, glw::GLenum pname, void **params)
1676{
1677	if (m_enableLog)
1678		m_log << TestLog::Message << "glGetNamedBufferPointerv(" << buffer << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
1679	m_gl.getNamedBufferPointerv(buffer, pname, params);
1680}
1681
1682void 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
1689void 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) << ", " << params << ");" << TestLog::EndMessage;
1693	m_gl.getNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
1694}
1695
1696void 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) << ", " << param << ");" << TestLog::EndMessage;
1700	m_gl.getNamedFramebufferParameteriv(framebuffer, pname, param);
1701}
1702
1703void 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) << ", " << params << ");" << TestLog::EndMessage;
1707	m_gl.getNamedRenderbufferParameteriv(renderbuffer, pname, params);
1708}
1709
1710void 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 << ", " << length << ", " << label << ");" << TestLog::EndMessage;
1714	m_gl.getObjectLabel(identifier, name, bufSize, length, label);
1715}
1716
1717void 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 << ", " << length << ", " << label << ");" << TestLog::EndMessage;
1721	m_gl.getObjectPtrLabel(ptr, bufSize, length, label);
1722}
1723
1724void CallLogWrapper::glGetPointerv (glw::GLenum pname, void **params)
1725{
1726	if (m_enableLog)
1727		m_log << TestLog::Message << "glGetPointerv(" << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
1728	m_gl.getPointerv(pname, params);
1729}
1730
1731void CallLogWrapper::glGetProgramBinary (glw::GLuint program, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLenum *binaryFormat, void *binary)
1732{
1733	if (m_enableLog)
1734		m_log << TestLog::Message << "glGetProgramBinary(" << program << ", " << bufSize << ", " << length << ", " << binaryFormat << ", " << binary << ");" << TestLog::EndMessage;
1735	m_gl.getProgramBinary(program, bufSize, length, binaryFormat, binary);
1736}
1737
1738void CallLogWrapper::glGetProgramInfoLog (glw::GLuint program, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *infoLog)
1739{
1740	if (m_enableLog)
1741		m_log << TestLog::Message << "glGetProgramInfoLog(" << program << ", " << bufSize << ", " << length << ", " << infoLog << ");" << TestLog::EndMessage;
1742	m_gl.getProgramInfoLog(program, bufSize, length, infoLog);
1743}
1744
1745void CallLogWrapper::glGetProgramInterfaceiv (glw::GLuint program, glw::GLenum programInterface, glw::GLenum pname, glw::GLint *params)
1746{
1747	if (m_enableLog)
1748		m_log << TestLog::Message << "glGetProgramInterfaceiv(" << program << ", " << toHex(programInterface) << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
1749	m_gl.getProgramInterfaceiv(program, programInterface, pname, params);
1750}
1751
1752void CallLogWrapper::glGetProgramPipelineInfoLog (glw::GLuint pipeline, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *infoLog)
1753{
1754	if (m_enableLog)
1755		m_log << TestLog::Message << "glGetProgramPipelineInfoLog(" << pipeline << ", " << bufSize << ", " << length << ", " << static_cast<const void*>(infoLog) << ");" << TestLog::EndMessage;
1756	m_gl.getProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
1757	if (m_enableLog)
1758		m_log << TestLog::Message << "// length = " << getPointerStr(length, 1) << TestLog::EndMessage;
1759}
1760
1761void CallLogWrapper::glGetProgramPipelineiv (glw::GLuint pipeline, glw::GLenum pname, glw::GLint *params)
1762{
1763	if (m_enableLog)
1764		m_log << TestLog::Message << "glGetProgramPipelineiv(" << pipeline << ", " << getPipelineParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
1765	m_gl.getProgramPipelineiv(pipeline, pname, params);
1766	if (m_enableLog)
1767		m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1768}
1769
1770glw::GLuint CallLogWrapper::glGetProgramResourceIndex (glw::GLuint program, glw::GLenum programInterface, const glw::GLchar *name)
1771{
1772	if (m_enableLog)
1773		m_log << TestLog::Message << "glGetProgramResourceIndex(" << program << ", " << getProgramInterfaceStr(programInterface) << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
1774	glw::GLuint returnValue = m_gl.getProgramResourceIndex(program, programInterface, name);
1775	if (m_enableLog)
1776		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
1777	return returnValue;
1778}
1779
1780glw::GLint CallLogWrapper::glGetProgramResourceLocation (glw::GLuint program, glw::GLenum programInterface, const glw::GLchar *name)
1781{
1782	if (m_enableLog)
1783		m_log << TestLog::Message << "glGetProgramResourceLocation(" << program << ", " << toHex(programInterface) << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
1784	glw::GLint returnValue = m_gl.getProgramResourceLocation(program, programInterface, name);
1785	if (m_enableLog)
1786		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
1787	return returnValue;
1788}
1789
1790glw::GLint CallLogWrapper::glGetProgramResourceLocationIndex (glw::GLuint program, glw::GLenum programInterface, const glw::GLchar *name)
1791{
1792	if (m_enableLog)
1793		m_log << TestLog::Message << "glGetProgramResourceLocationIndex(" << program << ", " << toHex(programInterface) << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
1794	glw::GLint returnValue = m_gl.getProgramResourceLocationIndex(program, programInterface, name);
1795	if (m_enableLog)
1796		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
1797	return returnValue;
1798}
1799
1800void CallLogWrapper::glGetProgramResourceName (glw::GLuint program, glw::GLenum programInterface, glw::GLuint index, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *name)
1801{
1802	if (m_enableLog)
1803		m_log << TestLog::Message << "glGetProgramResourceName(" << program << ", " << toHex(programInterface) << ", " << index << ", " << bufSize << ", " << length << ", " << name << ");" << TestLog::EndMessage;
1804	m_gl.getProgramResourceName(program, programInterface, index, bufSize, length, name);
1805}
1806
1807void 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)
1808{
1809	if (m_enableLog)
1810		m_log << TestLog::Message << "glGetProgramResourceiv(" << program << ", " << getProgramInterfaceStr(programInterface) << ", " << index << ", " << propCount << ", " << props << ", " << bufSize << ", " << length << ", " << params << ");" << TestLog::EndMessage;
1811	m_gl.getProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
1812}
1813
1814void CallLogWrapper::glGetProgramStageiv (glw::GLuint program, glw::GLenum shadertype, glw::GLenum pname, glw::GLint *values)
1815{
1816	if (m_enableLog)
1817		m_log << TestLog::Message << "glGetProgramStageiv(" << program << ", " << toHex(shadertype) << ", " << toHex(pname) << ", " << values << ");" << TestLog::EndMessage;
1818	m_gl.getProgramStageiv(program, shadertype, pname, values);
1819}
1820
1821void CallLogWrapper::glGetProgramiv (glw::GLuint program, glw::GLenum pname, glw::GLint *params)
1822{
1823	if (m_enableLog)
1824		m_log << TestLog::Message << "glGetProgramiv(" << program << ", " << getProgramParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
1825	m_gl.getProgramiv(program, pname, params);
1826	if (m_enableLog)
1827		m_log << TestLog::Message << "// params = " << getPointerStr(params, getProgramQueryNumArgsOut(pname)) << TestLog::EndMessage;
1828}
1829
1830void CallLogWrapper::glGetQueryBufferObjecti64v (glw::GLuint id, glw::GLuint buffer, glw::GLenum pname, glw::GLintptr offset)
1831{
1832	if (m_enableLog)
1833		m_log << TestLog::Message << "glGetQueryBufferObjecti64v(" << id << ", " << buffer << ", " << toHex(pname) << ", " << offset << ");" << TestLog::EndMessage;
1834	m_gl.getQueryBufferObjecti64v(id, buffer, pname, offset);
1835}
1836
1837void CallLogWrapper::glGetQueryBufferObjectiv (glw::GLuint id, glw::GLuint buffer, glw::GLenum pname, glw::GLintptr offset)
1838{
1839	if (m_enableLog)
1840		m_log << TestLog::Message << "glGetQueryBufferObjectiv(" << id << ", " << buffer << ", " << toHex(pname) << ", " << offset << ");" << TestLog::EndMessage;
1841	m_gl.getQueryBufferObjectiv(id, buffer, pname, offset);
1842}
1843
1844void CallLogWrapper::glGetQueryBufferObjectui64v (glw::GLuint id, glw::GLuint buffer, glw::GLenum pname, glw::GLintptr offset)
1845{
1846	if (m_enableLog)
1847		m_log << TestLog::Message << "glGetQueryBufferObjectui64v(" << id << ", " << buffer << ", " << toHex(pname) << ", " << offset << ");" << TestLog::EndMessage;
1848	m_gl.getQueryBufferObjectui64v(id, buffer, pname, offset);
1849}
1850
1851void CallLogWrapper::glGetQueryBufferObjectuiv (glw::GLuint id, glw::GLuint buffer, glw::GLenum pname, glw::GLintptr offset)
1852{
1853	if (m_enableLog)
1854		m_log << TestLog::Message << "glGetQueryBufferObjectuiv(" << id << ", " << buffer << ", " << toHex(pname) << ", " << offset << ");" << TestLog::EndMessage;
1855	m_gl.getQueryBufferObjectuiv(id, buffer, pname, offset);
1856}
1857
1858void CallLogWrapper::glGetQueryIndexediv (glw::GLenum target, glw::GLuint index, glw::GLenum pname, glw::GLint *params)
1859{
1860	if (m_enableLog)
1861		m_log << TestLog::Message << "glGetQueryIndexediv(" << toHex(target) << ", " << index << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
1862	m_gl.getQueryIndexediv(target, index, pname, params);
1863}
1864
1865void CallLogWrapper::glGetQueryObjecti64v (glw::GLuint id, glw::GLenum pname, glw::GLint64 *params)
1866{
1867	if (m_enableLog)
1868		m_log << TestLog::Message << "glGetQueryObjecti64v(" << id << ", " << getQueryObjectParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
1869	m_gl.getQueryObjecti64v(id, pname, params);
1870	if (m_enableLog)
1871		m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1872}
1873
1874void CallLogWrapper::glGetQueryObjectiv (glw::GLuint id, glw::GLenum pname, glw::GLint *params)
1875{
1876	if (m_enableLog)
1877		m_log << TestLog::Message << "glGetQueryObjectiv(" << id << ", " << getQueryObjectParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
1878	m_gl.getQueryObjectiv(id, pname, params);
1879	if (m_enableLog)
1880		m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1881}
1882
1883void CallLogWrapper::glGetQueryObjectui64v (glw::GLuint id, glw::GLenum pname, glw::GLuint64 *params)
1884{
1885	if (m_enableLog)
1886		m_log << TestLog::Message << "glGetQueryObjectui64v(" << id << ", " << getQueryObjectParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
1887	m_gl.getQueryObjectui64v(id, pname, params);
1888	if (m_enableLog)
1889		m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1890}
1891
1892void CallLogWrapper::glGetQueryObjectuiv (glw::GLuint id, glw::GLenum pname, glw::GLuint *params)
1893{
1894	if (m_enableLog)
1895		m_log << TestLog::Message << "glGetQueryObjectuiv(" << id << ", " << getQueryObjectParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
1896	m_gl.getQueryObjectuiv(id, pname, params);
1897	if (m_enableLog)
1898		m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1899}
1900
1901void CallLogWrapper::glGetQueryiv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
1902{
1903	if (m_enableLog)
1904		m_log << TestLog::Message << "glGetQueryiv(" << getQueryTargetStr(target) << ", " << getQueryParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
1905	m_gl.getQueryiv(target, pname, params);
1906	if (m_enableLog)
1907		m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1908}
1909
1910void CallLogWrapper::glGetRenderbufferParameteriv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
1911{
1912	if (m_enableLog)
1913		m_log << TestLog::Message << "glGetRenderbufferParameteriv(" << getFramebufferTargetStr(target) << ", " << getRenderbufferParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
1914	m_gl.getRenderbufferParameteriv(target, pname, params);
1915}
1916
1917void CallLogWrapper::glGetSamplerParameterIiv (glw::GLuint sampler, glw::GLenum pname, glw::GLint *params)
1918{
1919	if (m_enableLog)
1920		m_log << TestLog::Message << "glGetSamplerParameterIiv(" << sampler << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
1921	m_gl.getSamplerParameterIiv(sampler, pname, params);
1922}
1923
1924void CallLogWrapper::glGetSamplerParameterIuiv (glw::GLuint sampler, glw::GLenum pname, glw::GLuint *params)
1925{
1926	if (m_enableLog)
1927		m_log << TestLog::Message << "glGetSamplerParameterIuiv(" << sampler << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
1928	m_gl.getSamplerParameterIuiv(sampler, pname, params);
1929}
1930
1931void CallLogWrapper::glGetSamplerParameterfv (glw::GLuint sampler, glw::GLenum pname, glw::GLfloat *params)
1932{
1933	if (m_enableLog)
1934		m_log << TestLog::Message << "glGetSamplerParameterfv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
1935	m_gl.getSamplerParameterfv(sampler, pname, params);
1936}
1937
1938void CallLogWrapper::glGetSamplerParameteriv (glw::GLuint sampler, glw::GLenum pname, glw::GLint *params)
1939{
1940	if (m_enableLog)
1941		m_log << TestLog::Message << "glGetSamplerParameteriv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
1942	m_gl.getSamplerParameteriv(sampler, pname, params);
1943}
1944
1945void CallLogWrapper::glGetShaderInfoLog (glw::GLuint shader, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *infoLog)
1946{
1947	if (m_enableLog)
1948		m_log << TestLog::Message << "glGetShaderInfoLog(" << shader << ", " << bufSize << ", " << length << ", " << infoLog << ");" << TestLog::EndMessage;
1949	m_gl.getShaderInfoLog(shader, bufSize, length, infoLog);
1950}
1951
1952void CallLogWrapper::glGetShaderPrecisionFormat (glw::GLenum shadertype, glw::GLenum precisiontype, glw::GLint *range, glw::GLint *precision)
1953{
1954	if (m_enableLog)
1955		m_log << TestLog::Message << "glGetShaderPrecisionFormat(" << getShaderTypeStr(shadertype) << ", " << getPrecisionFormatTypeStr(precisiontype) << ", " << range << ", " << precision << ");" << TestLog::EndMessage;
1956	m_gl.getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
1957}
1958
1959void CallLogWrapper::glGetShaderSource (glw::GLuint shader, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *source)
1960{
1961	if (m_enableLog)
1962		m_log << TestLog::Message << "glGetShaderSource(" << shader << ", " << bufSize << ", " << length << ", " << source << ");" << TestLog::EndMessage;
1963	m_gl.getShaderSource(shader, bufSize, length, source);
1964}
1965
1966void CallLogWrapper::glGetShaderiv (glw::GLuint shader, glw::GLenum pname, glw::GLint *params)
1967{
1968	if (m_enableLog)
1969		m_log << TestLog::Message << "glGetShaderiv(" << shader << ", " << getShaderParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
1970	m_gl.getShaderiv(shader, pname, params);
1971	if (m_enableLog)
1972		m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
1973}
1974
1975const glw::GLubyte * CallLogWrapper::glGetString (glw::GLenum name)
1976{
1977	if (m_enableLog)
1978		m_log << TestLog::Message << "glGetString(" << getGettableStringStr(name) << ");" << TestLog::EndMessage;
1979	const glw::GLubyte * returnValue = m_gl.getString(name);
1980	if (m_enableLog)
1981		m_log << TestLog::Message << "// " << getStringStr(returnValue) << " returned" << TestLog::EndMessage;
1982	return returnValue;
1983}
1984
1985const glw::GLubyte * CallLogWrapper::glGetStringi (glw::GLenum name, glw::GLuint index)
1986{
1987	if (m_enableLog)
1988		m_log << TestLog::Message << "glGetStringi(" << getGettableStringStr(name) << ", " << index << ");" << TestLog::EndMessage;
1989	const glw::GLubyte * returnValue = m_gl.getStringi(name, index);
1990	if (m_enableLog)
1991		m_log << TestLog::Message << "// " << getStringStr(returnValue) << " returned" << TestLog::EndMessage;
1992	return returnValue;
1993}
1994
1995glw::GLuint CallLogWrapper::glGetSubroutineIndex (glw::GLuint program, glw::GLenum shadertype, const glw::GLchar *name)
1996{
1997	if (m_enableLog)
1998		m_log << TestLog::Message << "glGetSubroutineIndex(" << program << ", " << toHex(shadertype) << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
1999	glw::GLuint returnValue = m_gl.getSubroutineIndex(program, shadertype, name);
2000	if (m_enableLog)
2001		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2002	return returnValue;
2003}
2004
2005glw::GLint CallLogWrapper::glGetSubroutineUniformLocation (glw::GLuint program, glw::GLenum shadertype, const glw::GLchar *name)
2006{
2007	if (m_enableLog)
2008		m_log << TestLog::Message << "glGetSubroutineUniformLocation(" << program << ", " << toHex(shadertype) << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
2009	glw::GLint returnValue = m_gl.getSubroutineUniformLocation(program, shadertype, name);
2010	if (m_enableLog)
2011		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2012	return returnValue;
2013}
2014
2015void CallLogWrapper::glGetSynciv (glw::GLsync sync, glw::GLenum pname, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLint *values)
2016{
2017	if (m_enableLog)
2018		m_log << TestLog::Message << "glGetSynciv(" << sync << ", " << toHex(pname) << ", " << bufSize << ", " << length << ", " << values << ");" << TestLog::EndMessage;
2019	m_gl.getSynciv(sync, pname, bufSize, length, values);
2020}
2021
2022void CallLogWrapper::glGetTexImage (glw::GLenum target, glw::GLint level, glw::GLenum format, glw::GLenum type, void *pixels)
2023{
2024	if (m_enableLog)
2025		m_log << TestLog::Message << "glGetTexImage(" << toHex(target) << ", " << level << ", " << toHex(format) << ", " << toHex(type) << ", " << pixels << ");" << TestLog::EndMessage;
2026	m_gl.getTexImage(target, level, format, type, pixels);
2027}
2028
2029void CallLogWrapper::glGetTexLevelParameterfv (glw::GLenum target, glw::GLint level, glw::GLenum pname, glw::GLfloat *params)
2030{
2031	if (m_enableLog)
2032		m_log << TestLog::Message << "glGetTexLevelParameterfv(" << getTextureTargetStr(target) << ", " << level << ", " << getTextureLevelParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
2033	m_gl.getTexLevelParameterfv(target, level, pname, params);
2034	if (m_enableLog)
2035		m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
2036}
2037
2038void CallLogWrapper::glGetTexLevelParameteriv (glw::GLenum target, glw::GLint level, glw::GLenum pname, glw::GLint *params)
2039{
2040	if (m_enableLog)
2041		m_log << TestLog::Message << "glGetTexLevelParameteriv(" << getTextureTargetStr(target) << ", " << level << ", " << getTextureLevelParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
2042	m_gl.getTexLevelParameteriv(target, level, pname, params);
2043	if (m_enableLog)
2044		m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
2045}
2046
2047void CallLogWrapper::glGetTexParameterIiv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
2048{
2049	if (m_enableLog)
2050		m_log << TestLog::Message << "glGetTexParameterIiv(" << toHex(target) << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
2051	m_gl.getTexParameterIiv(target, pname, params);
2052}
2053
2054void CallLogWrapper::glGetTexParameterIuiv (glw::GLenum target, glw::GLenum pname, glw::GLuint *params)
2055{
2056	if (m_enableLog)
2057		m_log << TestLog::Message << "glGetTexParameterIuiv(" << toHex(target) << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
2058	m_gl.getTexParameterIuiv(target, pname, params);
2059}
2060
2061void CallLogWrapper::glGetTexParameterfv (glw::GLenum target, glw::GLenum pname, glw::GLfloat *params)
2062{
2063	if (m_enableLog)
2064		m_log << TestLog::Message << "glGetTexParameterfv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
2065	m_gl.getTexParameterfv(target, pname, params);
2066	if (m_enableLog)
2067		m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
2068}
2069
2070void CallLogWrapper::glGetTexParameteriv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
2071{
2072	if (m_enableLog)
2073		m_log << TestLog::Message << "glGetTexParameteriv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
2074	m_gl.getTexParameteriv(target, pname, params);
2075	if (m_enableLog)
2076		m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
2077}
2078
2079void CallLogWrapper::glGetTextureImage (glw::GLuint texture, glw::GLint level, glw::GLenum format, glw::GLenum type, glw::GLsizei bufSize, void *pixels)
2080{
2081	if (m_enableLog)
2082		m_log << TestLog::Message << "glGetTextureImage(" << texture << ", " << level << ", " << toHex(format) << ", " << toHex(type) << ", " << bufSize << ", " << pixels << ");" << TestLog::EndMessage;
2083	m_gl.getTextureImage(texture, level, format, type, bufSize, pixels);
2084}
2085
2086void CallLogWrapper::glGetTextureLevelParameterfv (glw::GLuint texture, glw::GLint level, glw::GLenum pname, glw::GLfloat *params)
2087{
2088	if (m_enableLog)
2089		m_log << TestLog::Message << "glGetTextureLevelParameterfv(" << texture << ", " << level << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
2090	m_gl.getTextureLevelParameterfv(texture, level, pname, params);
2091}
2092
2093void CallLogWrapper::glGetTextureLevelParameteriv (glw::GLuint texture, glw::GLint level, glw::GLenum pname, glw::GLint *params)
2094{
2095	if (m_enableLog)
2096		m_log << TestLog::Message << "glGetTextureLevelParameteriv(" << texture << ", " << level << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
2097	m_gl.getTextureLevelParameteriv(texture, level, pname, params);
2098}
2099
2100void CallLogWrapper::glGetTextureParameterIiv (glw::GLuint texture, glw::GLenum pname, glw::GLint *params)
2101{
2102	if (m_enableLog)
2103		m_log << TestLog::Message << "glGetTextureParameterIiv(" << texture << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
2104	m_gl.getTextureParameterIiv(texture, pname, params);
2105}
2106
2107void CallLogWrapper::glGetTextureParameterIuiv (glw::GLuint texture, glw::GLenum pname, glw::GLuint *params)
2108{
2109	if (m_enableLog)
2110		m_log << TestLog::Message << "glGetTextureParameterIuiv(" << texture << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
2111	m_gl.getTextureParameterIuiv(texture, pname, params);
2112}
2113
2114void CallLogWrapper::glGetTextureParameterfv (glw::GLuint texture, glw::GLenum pname, glw::GLfloat *params)
2115{
2116	if (m_enableLog)
2117		m_log << TestLog::Message << "glGetTextureParameterfv(" << texture << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
2118	m_gl.getTextureParameterfv(texture, pname, params);
2119}
2120
2121void CallLogWrapper::glGetTextureParameteriv (glw::GLuint texture, glw::GLenum pname, glw::GLint *params)
2122{
2123	if (m_enableLog)
2124		m_log << TestLog::Message << "glGetTextureParameteriv(" << texture << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
2125	m_gl.getTextureParameteriv(texture, pname, params);
2126}
2127
2128void 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)
2129{
2130	if (m_enableLog)
2131		m_log << TestLog::Message << "glGetTextureSubImage(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << toHex(format) << ", " << toHex(type) << ", " << bufSize << ", " << pixels << ");" << TestLog::EndMessage;
2132	m_gl.getTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
2133}
2134
2135void CallLogWrapper::glGetTransformFeedbackVarying (glw::GLuint program, glw::GLuint index, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLsizei *size, glw::GLenum *type, glw::GLchar *name)
2136{
2137	if (m_enableLog)
2138		m_log << TestLog::Message << "glGetTransformFeedbackVarying(" << program << ", " << index << ", " << bufSize << ", " << length << ", " << size << ", " << type << ", " << name << ");" << TestLog::EndMessage;
2139	m_gl.getTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
2140}
2141
2142void CallLogWrapper::glGetTransformFeedbacki64_v (glw::GLuint xfb, glw::GLenum pname, glw::GLuint index, glw::GLint64 *param)
2143{
2144	if (m_enableLog)
2145		m_log << TestLog::Message << "glGetTransformFeedbacki64_v(" << xfb << ", " << toHex(pname) << ", " << index << ", " << param << ");" << TestLog::EndMessage;
2146	m_gl.getTransformFeedbacki64_v(xfb, pname, index, param);
2147}
2148
2149void CallLogWrapper::glGetTransformFeedbacki_v (glw::GLuint xfb, glw::GLenum pname, glw::GLuint index, glw::GLint *param)
2150{
2151	if (m_enableLog)
2152		m_log << TestLog::Message << "glGetTransformFeedbacki_v(" << xfb << ", " << toHex(pname) << ", " << index << ", " << param << ");" << TestLog::EndMessage;
2153	m_gl.getTransformFeedbacki_v(xfb, pname, index, param);
2154}
2155
2156void CallLogWrapper::glGetTransformFeedbackiv (glw::GLuint xfb, glw::GLenum pname, glw::GLint *param)
2157{
2158	if (m_enableLog)
2159		m_log << TestLog::Message << "glGetTransformFeedbackiv(" << xfb << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
2160	m_gl.getTransformFeedbackiv(xfb, pname, param);
2161}
2162
2163glw::GLuint CallLogWrapper::glGetUniformBlockIndex (glw::GLuint program, const glw::GLchar *uniformBlockName)
2164{
2165	if (m_enableLog)
2166		m_log << TestLog::Message << "glGetUniformBlockIndex(" << program << ", " << getStringStr(uniformBlockName) << ");" << TestLog::EndMessage;
2167	glw::GLuint returnValue = m_gl.getUniformBlockIndex(program, uniformBlockName);
2168	if (m_enableLog)
2169		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2170	return returnValue;
2171}
2172
2173void CallLogWrapper::glGetUniformIndices (glw::GLuint program, glw::GLsizei uniformCount, const glw::GLchar *const*uniformNames, glw::GLuint *uniformIndices)
2174{
2175	if (m_enableLog)
2176		m_log << TestLog::Message << "glGetUniformIndices(" << program << ", " << uniformCount << ", " << getPointerStr(uniformNames, uniformCount) << ", " << uniformIndices << ");" << TestLog::EndMessage;
2177	m_gl.getUniformIndices(program, uniformCount, uniformNames, uniformIndices);
2178	if (m_enableLog)
2179		m_log << TestLog::Message << "// uniformIndices = " << getPointerStr(uniformIndices, uniformCount) << TestLog::EndMessage;
2180}
2181
2182glw::GLint CallLogWrapper::glGetUniformLocation (glw::GLuint program, const glw::GLchar *name)
2183{
2184	if (m_enableLog)
2185		m_log << TestLog::Message << "glGetUniformLocation(" << program << ", " << getStringStr(name) << ");" << TestLog::EndMessage;
2186	glw::GLint returnValue = m_gl.getUniformLocation(program, name);
2187	if (m_enableLog)
2188		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2189	return returnValue;
2190}
2191
2192void CallLogWrapper::glGetUniformSubroutineuiv (glw::GLenum shadertype, glw::GLint location, glw::GLuint *params)
2193{
2194	if (m_enableLog)
2195		m_log << TestLog::Message << "glGetUniformSubroutineuiv(" << toHex(shadertype) << ", " << location << ", " << params << ");" << TestLog::EndMessage;
2196	m_gl.getUniformSubroutineuiv(shadertype, location, params);
2197}
2198
2199void CallLogWrapper::glGetUniformdv (glw::GLuint program, glw::GLint location, glw::GLdouble *params)
2200{
2201	if (m_enableLog)
2202		m_log << TestLog::Message << "glGetUniformdv(" << program << ", " << location << ", " << params << ");" << TestLog::EndMessage;
2203	m_gl.getUniformdv(program, location, params);
2204}
2205
2206void CallLogWrapper::glGetUniformfv (glw::GLuint program, glw::GLint location, glw::GLfloat *params)
2207{
2208	if (m_enableLog)
2209		m_log << TestLog::Message << "glGetUniformfv(" << program << ", " << location << ", " << params << ");" << TestLog::EndMessage;
2210	m_gl.getUniformfv(program, location, params);
2211}
2212
2213void CallLogWrapper::glGetUniformiv (glw::GLuint program, glw::GLint location, glw::GLint *params)
2214{
2215	if (m_enableLog)
2216		m_log << TestLog::Message << "glGetUniformiv(" << program << ", " << location << ", " << params << ");" << TestLog::EndMessage;
2217	m_gl.getUniformiv(program, location, params);
2218}
2219
2220void CallLogWrapper::glGetUniformuiv (glw::GLuint program, glw::GLint location, glw::GLuint *params)
2221{
2222	if (m_enableLog)
2223		m_log << TestLog::Message << "glGetUniformuiv(" << program << ", " << location << ", " << params << ");" << TestLog::EndMessage;
2224	m_gl.getUniformuiv(program, location, params);
2225}
2226
2227void CallLogWrapper::glGetVertexArrayIndexed64iv (glw::GLuint vaobj, glw::GLuint index, glw::GLenum pname, glw::GLint64 *param)
2228{
2229	if (m_enableLog)
2230		m_log << TestLog::Message << "glGetVertexArrayIndexed64iv(" << vaobj << ", " << index << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
2231	m_gl.getVertexArrayIndexed64iv(vaobj, index, pname, param);
2232}
2233
2234void CallLogWrapper::glGetVertexArrayIndexediv (glw::GLuint vaobj, glw::GLuint index, glw::GLenum pname, glw::GLint *param)
2235{
2236	if (m_enableLog)
2237		m_log << TestLog::Message << "glGetVertexArrayIndexediv(" << vaobj << ", " << index << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
2238	m_gl.getVertexArrayIndexediv(vaobj, index, pname, param);
2239}
2240
2241void CallLogWrapper::glGetVertexArrayiv (glw::GLuint vaobj, glw::GLenum pname, glw::GLint *param)
2242{
2243	if (m_enableLog)
2244		m_log << TestLog::Message << "glGetVertexArrayiv(" << vaobj << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
2245	m_gl.getVertexArrayiv(vaobj, pname, param);
2246}
2247
2248void CallLogWrapper::glGetVertexAttribIiv (glw::GLuint index, glw::GLenum pname, glw::GLint *params)
2249{
2250	if (m_enableLog)
2251		m_log << TestLog::Message << "glGetVertexAttribIiv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << params << ");" << TestLog::EndMessage;
2252	m_gl.getVertexAttribIiv(index, pname, params);
2253	if (m_enableLog)
2254		m_log << TestLog::Message << "// params = " << getPointerStr(params, getAttributeQueryNumArgsOut(pname)) << TestLog::EndMessage;
2255}
2256
2257void CallLogWrapper::glGetVertexAttribIuiv (glw::GLuint index, glw::GLenum pname, glw::GLuint *params)
2258{
2259	if (m_enableLog)
2260		m_log << TestLog::Message << "glGetVertexAttribIuiv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << params << ");" << TestLog::EndMessage;
2261	m_gl.getVertexAttribIuiv(index, pname, params);
2262	if (m_enableLog)
2263		m_log << TestLog::Message << "// params = " << getPointerStr(params, getAttributeQueryNumArgsOut(pname)) << TestLog::EndMessage;
2264}
2265
2266void CallLogWrapper::glGetVertexAttribLdv (glw::GLuint index, glw::GLenum pname, glw::GLdouble *params)
2267{
2268	if (m_enableLog)
2269		m_log << TestLog::Message << "glGetVertexAttribLdv(" << index << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
2270	m_gl.getVertexAttribLdv(index, pname, params);
2271}
2272
2273void CallLogWrapper::glGetVertexAttribPointerv (glw::GLuint index, glw::GLenum pname, void **pointer)
2274{
2275	if (m_enableLog)
2276		m_log << TestLog::Message << "glGetVertexAttribPointerv(" << index << ", " << toHex(pname) << ", " << pointer << ");" << TestLog::EndMessage;
2277	m_gl.getVertexAttribPointerv(index, pname, pointer);
2278}
2279
2280void CallLogWrapper::glGetVertexAttribdv (glw::GLuint index, glw::GLenum pname, glw::GLdouble *params)
2281{
2282	if (m_enableLog)
2283		m_log << TestLog::Message << "glGetVertexAttribdv(" << index << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
2284	m_gl.getVertexAttribdv(index, pname, params);
2285}
2286
2287void CallLogWrapper::glGetVertexAttribfv (glw::GLuint index, glw::GLenum pname, glw::GLfloat *params)
2288{
2289	if (m_enableLog)
2290		m_log << TestLog::Message << "glGetVertexAttribfv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << params << ");" << TestLog::EndMessage;
2291	m_gl.getVertexAttribfv(index, pname, params);
2292	if (m_enableLog)
2293		m_log << TestLog::Message << "// params = " << getPointerStr(params, getAttributeQueryNumArgsOut(pname)) << TestLog::EndMessage;
2294}
2295
2296void CallLogWrapper::glGetVertexAttribiv (glw::GLuint index, glw::GLenum pname, glw::GLint *params)
2297{
2298	if (m_enableLog)
2299		m_log << TestLog::Message << "glGetVertexAttribiv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << params << ");" << TestLog::EndMessage;
2300	m_gl.getVertexAttribiv(index, pname, params);
2301	if (m_enableLog)
2302		m_log << TestLog::Message << "// params = " << getPointerStr(params, getAttributeQueryNumArgsOut(pname)) << TestLog::EndMessage;
2303}
2304
2305void CallLogWrapper::glGetnCompressedTexImage (glw::GLenum target, glw::GLint lod, glw::GLsizei bufSize, void *pixels)
2306{
2307	if (m_enableLog)
2308		m_log << TestLog::Message << "glGetnCompressedTexImage(" << toHex(target) << ", " << lod << ", " << bufSize << ", " << pixels << ");" << TestLog::EndMessage;
2309	m_gl.getnCompressedTexImage(target, lod, bufSize, pixels);
2310}
2311
2312void CallLogWrapper::glGetnTexImage (glw::GLenum target, glw::GLint level, glw::GLenum format, glw::GLenum type, glw::GLsizei bufSize, void *pixels)
2313{
2314	if (m_enableLog)
2315		m_log << TestLog::Message << "glGetnTexImage(" << toHex(target) << ", " << level << ", " << toHex(format) << ", " << toHex(type) << ", " << bufSize << ", " << pixels << ");" << TestLog::EndMessage;
2316	m_gl.getnTexImage(target, level, format, type, bufSize, pixels);
2317}
2318
2319void CallLogWrapper::glGetnUniformdv (glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, glw::GLdouble *params)
2320{
2321	if (m_enableLog)
2322		m_log << TestLog::Message << "glGetnUniformdv(" << program << ", " << location << ", " << bufSize << ", " << params << ");" << TestLog::EndMessage;
2323	m_gl.getnUniformdv(program, location, bufSize, params);
2324}
2325
2326void CallLogWrapper::glGetnUniformfv (glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, glw::GLfloat *params)
2327{
2328	if (m_enableLog)
2329		m_log << TestLog::Message << "glGetnUniformfv(" << program << ", " << location << ", " << bufSize << ", " << params << ");" << TestLog::EndMessage;
2330	m_gl.getnUniformfv(program, location, bufSize, params);
2331}
2332
2333void CallLogWrapper::glGetnUniformiv (glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, glw::GLint *params)
2334{
2335	if (m_enableLog)
2336		m_log << TestLog::Message << "glGetnUniformiv(" << program << ", " << location << ", " << bufSize << ", " << params << ");" << TestLog::EndMessage;
2337	m_gl.getnUniformiv(program, location, bufSize, params);
2338}
2339
2340void CallLogWrapper::glGetnUniformuiv (glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, glw::GLuint *params)
2341{
2342	if (m_enableLog)
2343		m_log << TestLog::Message << "glGetnUniformuiv(" << program << ", " << location << ", " << bufSize << ", " << params << ");" << TestLog::EndMessage;
2344	m_gl.getnUniformuiv(program, location, bufSize, params);
2345}
2346
2347void CallLogWrapper::glHint (glw::GLenum target, glw::GLenum mode)
2348{
2349	if (m_enableLog)
2350		m_log << TestLog::Message << "glHint(" << getHintStr(target) << ", " << getHintModeStr(mode) << ");" << TestLog::EndMessage;
2351	m_gl.hint(target, mode);
2352}
2353
2354void CallLogWrapper::glInvalidateBufferData (glw::GLuint buffer)
2355{
2356	if (m_enableLog)
2357		m_log << TestLog::Message << "glInvalidateBufferData(" << buffer << ");" << TestLog::EndMessage;
2358	m_gl.invalidateBufferData(buffer);
2359}
2360
2361void CallLogWrapper::glInvalidateBufferSubData (glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr length)
2362{
2363	if (m_enableLog)
2364		m_log << TestLog::Message << "glInvalidateBufferSubData(" << buffer << ", " << offset << ", " << length << ");" << TestLog::EndMessage;
2365	m_gl.invalidateBufferSubData(buffer, offset, length);
2366}
2367
2368void CallLogWrapper::glInvalidateFramebuffer (glw::GLenum target, glw::GLsizei numAttachments, const glw::GLenum *attachments)
2369{
2370	if (m_enableLog)
2371		m_log << TestLog::Message << "glInvalidateFramebuffer(" << getFramebufferTargetStr(target) << ", " << numAttachments << ", " << getEnumPointerStr(attachments, numAttachments, getInvalidateAttachmentName) << ");" << TestLog::EndMessage;
2372	m_gl.invalidateFramebuffer(target, numAttachments, attachments);
2373}
2374
2375void CallLogWrapper::glInvalidateNamedFramebufferData (glw::GLuint framebuffer, glw::GLsizei numAttachments, const glw::GLenum *attachments)
2376{
2377	if (m_enableLog)
2378		m_log << TestLog::Message << "glInvalidateNamedFramebufferData(" << framebuffer << ", " << numAttachments << ", " << attachments << ");" << TestLog::EndMessage;
2379	m_gl.invalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
2380}
2381
2382void CallLogWrapper::glInvalidateNamedFramebufferSubData (glw::GLuint framebuffer, glw::GLsizei numAttachments, const glw::GLenum *attachments, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
2383{
2384	if (m_enableLog)
2385		m_log << TestLog::Message << "glInvalidateNamedFramebufferSubData(" << framebuffer << ", " << numAttachments << ", " << attachments << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
2386	m_gl.invalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
2387}
2388
2389void CallLogWrapper::glInvalidateSubFramebuffer (glw::GLenum target, glw::GLsizei numAttachments, const glw::GLenum *attachments, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
2390{
2391	if (m_enableLog)
2392		m_log << TestLog::Message << "glInvalidateSubFramebuffer(" << getFramebufferTargetStr(target) << ", " << numAttachments << ", " << getEnumPointerStr(attachments, numAttachments, getInvalidateAttachmentName) << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
2393	m_gl.invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
2394}
2395
2396void CallLogWrapper::glInvalidateTexImage (glw::GLuint texture, glw::GLint level)
2397{
2398	if (m_enableLog)
2399		m_log << TestLog::Message << "glInvalidateTexImage(" << texture << ", " << level << ");" << TestLog::EndMessage;
2400	m_gl.invalidateTexImage(texture, level);
2401}
2402
2403void 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)
2404{
2405	if (m_enableLog)
2406		m_log << TestLog::Message << "glInvalidateTexSubImage(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ");" << TestLog::EndMessage;
2407	m_gl.invalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
2408}
2409
2410glw::GLboolean CallLogWrapper::glIsBuffer (glw::GLuint buffer)
2411{
2412	if (m_enableLog)
2413		m_log << TestLog::Message << "glIsBuffer(" << buffer << ");" << TestLog::EndMessage;
2414	glw::GLboolean returnValue = m_gl.isBuffer(buffer);
2415	if (m_enableLog)
2416		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2417	return returnValue;
2418}
2419
2420glw::GLboolean CallLogWrapper::glIsEnabled (glw::GLenum cap)
2421{
2422	if (m_enableLog)
2423		m_log << TestLog::Message << "glIsEnabled(" << getEnableCapStr(cap) << ");" << TestLog::EndMessage;
2424	glw::GLboolean returnValue = m_gl.isEnabled(cap);
2425	if (m_enableLog)
2426		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2427	return returnValue;
2428}
2429
2430glw::GLboolean CallLogWrapper::glIsEnabledi (glw::GLenum target, glw::GLuint index)
2431{
2432	if (m_enableLog)
2433		m_log << TestLog::Message << "glIsEnabledi(" << toHex(target) << ", " << index << ");" << TestLog::EndMessage;
2434	glw::GLboolean returnValue = m_gl.isEnabledi(target, index);
2435	if (m_enableLog)
2436		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2437	return returnValue;
2438}
2439
2440glw::GLboolean CallLogWrapper::glIsFramebuffer (glw::GLuint framebuffer)
2441{
2442	if (m_enableLog)
2443		m_log << TestLog::Message << "glIsFramebuffer(" << framebuffer << ");" << TestLog::EndMessage;
2444	glw::GLboolean returnValue = m_gl.isFramebuffer(framebuffer);
2445	if (m_enableLog)
2446		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2447	return returnValue;
2448}
2449
2450glw::GLboolean CallLogWrapper::glIsProgram (glw::GLuint program)
2451{
2452	if (m_enableLog)
2453		m_log << TestLog::Message << "glIsProgram(" << program << ");" << TestLog::EndMessage;
2454	glw::GLboolean returnValue = m_gl.isProgram(program);
2455	if (m_enableLog)
2456		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2457	return returnValue;
2458}
2459
2460glw::GLboolean CallLogWrapper::glIsProgramPipeline (glw::GLuint pipeline)
2461{
2462	if (m_enableLog)
2463		m_log << TestLog::Message << "glIsProgramPipeline(" << pipeline << ");" << TestLog::EndMessage;
2464	glw::GLboolean returnValue = m_gl.isProgramPipeline(pipeline);
2465	if (m_enableLog)
2466		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2467	return returnValue;
2468}
2469
2470glw::GLboolean CallLogWrapper::glIsQuery (glw::GLuint id)
2471{
2472	if (m_enableLog)
2473		m_log << TestLog::Message << "glIsQuery(" << id << ");" << TestLog::EndMessage;
2474	glw::GLboolean returnValue = m_gl.isQuery(id);
2475	if (m_enableLog)
2476		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2477	return returnValue;
2478}
2479
2480glw::GLboolean CallLogWrapper::glIsRenderbuffer (glw::GLuint renderbuffer)
2481{
2482	if (m_enableLog)
2483		m_log << TestLog::Message << "glIsRenderbuffer(" << renderbuffer << ");" << TestLog::EndMessage;
2484	glw::GLboolean returnValue = m_gl.isRenderbuffer(renderbuffer);
2485	if (m_enableLog)
2486		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2487	return returnValue;
2488}
2489
2490glw::GLboolean CallLogWrapper::glIsSampler (glw::GLuint sampler)
2491{
2492	if (m_enableLog)
2493		m_log << TestLog::Message << "glIsSampler(" << sampler << ");" << TestLog::EndMessage;
2494	glw::GLboolean returnValue = m_gl.isSampler(sampler);
2495	if (m_enableLog)
2496		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2497	return returnValue;
2498}
2499
2500glw::GLboolean CallLogWrapper::glIsShader (glw::GLuint shader)
2501{
2502	if (m_enableLog)
2503		m_log << TestLog::Message << "glIsShader(" << shader << ");" << TestLog::EndMessage;
2504	glw::GLboolean returnValue = m_gl.isShader(shader);
2505	if (m_enableLog)
2506		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2507	return returnValue;
2508}
2509
2510glw::GLboolean CallLogWrapper::glIsSync (glw::GLsync sync)
2511{
2512	if (m_enableLog)
2513		m_log << TestLog::Message << "glIsSync(" << sync << ");" << TestLog::EndMessage;
2514	glw::GLboolean returnValue = m_gl.isSync(sync);
2515	if (m_enableLog)
2516		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2517	return returnValue;
2518}
2519
2520glw::GLboolean CallLogWrapper::glIsTexture (glw::GLuint texture)
2521{
2522	if (m_enableLog)
2523		m_log << TestLog::Message << "glIsTexture(" << texture << ");" << TestLog::EndMessage;
2524	glw::GLboolean returnValue = m_gl.isTexture(texture);
2525	if (m_enableLog)
2526		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2527	return returnValue;
2528}
2529
2530glw::GLboolean CallLogWrapper::glIsTransformFeedback (glw::GLuint id)
2531{
2532	if (m_enableLog)
2533		m_log << TestLog::Message << "glIsTransformFeedback(" << id << ");" << TestLog::EndMessage;
2534	glw::GLboolean returnValue = m_gl.isTransformFeedback(id);
2535	if (m_enableLog)
2536		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2537	return returnValue;
2538}
2539
2540glw::GLboolean CallLogWrapper::glIsVertexArray (glw::GLuint array)
2541{
2542	if (m_enableLog)
2543		m_log << TestLog::Message << "glIsVertexArray(" << array << ");" << TestLog::EndMessage;
2544	glw::GLboolean returnValue = m_gl.isVertexArray(array);
2545	if (m_enableLog)
2546		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2547	return returnValue;
2548}
2549
2550void CallLogWrapper::glLineWidth (glw::GLfloat width)
2551{
2552	if (m_enableLog)
2553		m_log << TestLog::Message << "glLineWidth(" << width << ");" << TestLog::EndMessage;
2554	m_gl.lineWidth(width);
2555}
2556
2557void CallLogWrapper::glLinkProgram (glw::GLuint program)
2558{
2559	if (m_enableLog)
2560		m_log << TestLog::Message << "glLinkProgram(" << program << ");" << TestLog::EndMessage;
2561	m_gl.linkProgram(program);
2562}
2563
2564void CallLogWrapper::glLogicOp (glw::GLenum opcode)
2565{
2566	if (m_enableLog)
2567		m_log << TestLog::Message << "glLogicOp(" << toHex(opcode) << ");" << TestLog::EndMessage;
2568	m_gl.logicOp(opcode);
2569}
2570
2571void * CallLogWrapper::glMapBuffer (glw::GLenum target, glw::GLenum access)
2572{
2573	if (m_enableLog)
2574		m_log << TestLog::Message << "glMapBuffer(" << toHex(target) << ", " << toHex(access) << ");" << TestLog::EndMessage;
2575	void * returnValue = m_gl.mapBuffer(target, access);
2576	if (m_enableLog)
2577		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2578	return returnValue;
2579}
2580
2581void * CallLogWrapper::glMapBufferRange (glw::GLenum target, glw::GLintptr offset, glw::GLsizeiptr length, glw::GLbitfield access)
2582{
2583	if (m_enableLog)
2584		m_log << TestLog::Message << "glMapBufferRange(" << getBufferTargetStr(target) << ", " << offset << ", " << length << ", " << getBufferMapFlagsStr(access) << ");" << TestLog::EndMessage;
2585	void * returnValue = m_gl.mapBufferRange(target, offset, length, access);
2586	if (m_enableLog)
2587		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2588	return returnValue;
2589}
2590
2591void * CallLogWrapper::glMapNamedBuffer (glw::GLuint buffer, glw::GLenum access)
2592{
2593	if (m_enableLog)
2594		m_log << TestLog::Message << "glMapNamedBuffer(" << buffer << ", " << toHex(access) << ");" << TestLog::EndMessage;
2595	void * returnValue = m_gl.mapNamedBuffer(buffer, access);
2596	if (m_enableLog)
2597		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2598	return returnValue;
2599}
2600
2601void * CallLogWrapper::glMapNamedBufferRange (glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr length, glw::GLbitfield access)
2602{
2603	if (m_enableLog)
2604		m_log << TestLog::Message << "glMapNamedBufferRange(" << buffer << ", " << offset << ", " << length << ", " << toHex(access) << ");" << TestLog::EndMessage;
2605	void * returnValue = m_gl.mapNamedBufferRange(buffer, offset, length, access);
2606	if (m_enableLog)
2607		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2608	return returnValue;
2609}
2610
2611void CallLogWrapper::glMemoryBarrier (glw::GLbitfield barriers)
2612{
2613	if (m_enableLog)
2614		m_log << TestLog::Message << "glMemoryBarrier(" << getMemoryBarrierFlagsStr(barriers) << ");" << TestLog::EndMessage;
2615	m_gl.memoryBarrier(barriers);
2616}
2617
2618void CallLogWrapper::glMemoryBarrierByRegion (glw::GLbitfield barriers)
2619{
2620	if (m_enableLog)
2621		m_log << TestLog::Message << "glMemoryBarrierByRegion(" << toHex(barriers) << ");" << TestLog::EndMessage;
2622	m_gl.memoryBarrierByRegion(barriers);
2623}
2624
2625void CallLogWrapper::glMinSampleShading (glw::GLfloat value)
2626{
2627	if (m_enableLog)
2628		m_log << TestLog::Message << "glMinSampleShading(" << value << ");" << TestLog::EndMessage;
2629	m_gl.minSampleShading(value);
2630}
2631
2632void CallLogWrapper::glMultiDrawArrays (glw::GLenum mode, const glw::GLint *first, const glw::GLsizei *count, glw::GLsizei drawcount)
2633{
2634	if (m_enableLog)
2635		m_log << TestLog::Message << "glMultiDrawArrays(" << getPrimitiveTypeStr(mode) << ", " << first << ", " << count << ", " << drawcount << ");" << TestLog::EndMessage;
2636	m_gl.multiDrawArrays(mode, first, count, drawcount);
2637}
2638
2639void CallLogWrapper::glMultiDrawArraysIndirect (glw::GLenum mode, const void *indirect, glw::GLsizei drawcount, glw::GLsizei stride)
2640{
2641	if (m_enableLog)
2642		m_log << TestLog::Message << "glMultiDrawArraysIndirect(" << toHex(mode) << ", " << indirect << ", " << drawcount << ", " << stride << ");" << TestLog::EndMessage;
2643	m_gl.multiDrawArraysIndirect(mode, indirect, drawcount, stride);
2644}
2645
2646void CallLogWrapper::glMultiDrawElements (glw::GLenum mode, const glw::GLsizei *count, glw::GLenum type, const void *const*indices, glw::GLsizei drawcount)
2647{
2648	if (m_enableLog)
2649		m_log << TestLog::Message << "glMultiDrawElements(" << getPrimitiveTypeStr(mode) << ", " << count << ", " << getTypeStr(type) << ", " << indices << ", " << drawcount << ");" << TestLog::EndMessage;
2650	m_gl.multiDrawElements(mode, count, type, indices, drawcount);
2651}
2652
2653void CallLogWrapper::glMultiDrawElementsBaseVertex (glw::GLenum mode, const glw::GLsizei *count, glw::GLenum type, const void *const*indices, glw::GLsizei drawcount, const glw::GLint *basevertex)
2654{
2655	if (m_enableLog)
2656		m_log << TestLog::Message << "glMultiDrawElementsBaseVertex(" << getPrimitiveTypeStr(mode) << ", " << count << ", " << getTypeStr(type) << ", " << indices << ", " << drawcount << ", " << basevertex << ");" << TestLog::EndMessage;
2657	m_gl.multiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
2658}
2659
2660void CallLogWrapper::glMultiDrawElementsIndirect (glw::GLenum mode, glw::GLenum type, const void *indirect, glw::GLsizei drawcount, glw::GLsizei stride)
2661{
2662	if (m_enableLog)
2663		m_log << TestLog::Message << "glMultiDrawElementsIndirect(" << toHex(mode) << ", " << toHex(type) << ", " << indirect << ", " << drawcount << ", " << stride << ");" << TestLog::EndMessage;
2664	m_gl.multiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
2665}
2666
2667void CallLogWrapper::glNamedBufferData (glw::GLuint buffer, glw::GLsizeiptr size, const void *data, glw::GLenum usage)
2668{
2669	if (m_enableLog)
2670		m_log << TestLog::Message << "glNamedBufferData(" << buffer << ", " << size << ", " << data << ", " << toHex(usage) << ");" << TestLog::EndMessage;
2671	m_gl.namedBufferData(buffer, size, data, usage);
2672}
2673
2674void CallLogWrapper::glNamedBufferStorage (glw::GLuint buffer, glw::GLsizeiptr size, const void *data, glw::GLbitfield flags)
2675{
2676	if (m_enableLog)
2677		m_log << TestLog::Message << "glNamedBufferStorage(" << buffer << ", " << size << ", " << data << ", " << toHex(flags) << ");" << TestLog::EndMessage;
2678	m_gl.namedBufferStorage(buffer, size, data, flags);
2679}
2680
2681void CallLogWrapper::glNamedBufferSubData (glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size, const void *data)
2682{
2683	if (m_enableLog)
2684		m_log << TestLog::Message << "glNamedBufferSubData(" << buffer << ", " << offset << ", " << size << ", " << data << ");" << TestLog::EndMessage;
2685	m_gl.namedBufferSubData(buffer, offset, size, data);
2686}
2687
2688void CallLogWrapper::glNamedFramebufferDrawBuffer (glw::GLuint framebuffer, glw::GLenum buf)
2689{
2690	if (m_enableLog)
2691		m_log << TestLog::Message << "glNamedFramebufferDrawBuffer(" << framebuffer << ", " << toHex(buf) << ");" << TestLog::EndMessage;
2692	m_gl.namedFramebufferDrawBuffer(framebuffer, buf);
2693}
2694
2695void CallLogWrapper::glNamedFramebufferDrawBuffers (glw::GLuint framebuffer, glw::GLsizei n, const glw::GLenum *bufs)
2696{
2697	if (m_enableLog)
2698		m_log << TestLog::Message << "glNamedFramebufferDrawBuffers(" << framebuffer << ", " << n << ", " << bufs << ");" << TestLog::EndMessage;
2699	m_gl.namedFramebufferDrawBuffers(framebuffer, n, bufs);
2700}
2701
2702void CallLogWrapper::glNamedFramebufferParameteri (glw::GLuint framebuffer, glw::GLenum pname, glw::GLint param)
2703{
2704	if (m_enableLog)
2705		m_log << TestLog::Message << "glNamedFramebufferParameteri(" << framebuffer << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
2706	m_gl.namedFramebufferParameteri(framebuffer, pname, param);
2707}
2708
2709void CallLogWrapper::glNamedFramebufferReadBuffer (glw::GLuint framebuffer, glw::GLenum src)
2710{
2711	if (m_enableLog)
2712		m_log << TestLog::Message << "glNamedFramebufferReadBuffer(" << framebuffer << ", " << toHex(src) << ");" << TestLog::EndMessage;
2713	m_gl.namedFramebufferReadBuffer(framebuffer, src);
2714}
2715
2716void CallLogWrapper::glNamedFramebufferRenderbuffer (glw::GLuint framebuffer, glw::GLenum attachment, glw::GLenum renderbuffertarget, glw::GLuint renderbuffer)
2717{
2718	if (m_enableLog)
2719		m_log << TestLog::Message << "glNamedFramebufferRenderbuffer(" << framebuffer << ", " << toHex(attachment) << ", " << toHex(renderbuffertarget) << ", " << renderbuffer << ");" << TestLog::EndMessage;
2720	m_gl.namedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
2721}
2722
2723void CallLogWrapper::glNamedFramebufferTexture (glw::GLuint framebuffer, glw::GLenum attachment, glw::GLuint texture, glw::GLint level)
2724{
2725	if (m_enableLog)
2726		m_log << TestLog::Message << "glNamedFramebufferTexture(" << framebuffer << ", " << toHex(attachment) << ", " << texture << ", " << level << ");" << TestLog::EndMessage;
2727	m_gl.namedFramebufferTexture(framebuffer, attachment, texture, level);
2728}
2729
2730void CallLogWrapper::glNamedFramebufferTextureLayer (glw::GLuint framebuffer, glw::GLenum attachment, glw::GLuint texture, glw::GLint level, glw::GLint layer)
2731{
2732	if (m_enableLog)
2733		m_log << TestLog::Message << "glNamedFramebufferTextureLayer(" << framebuffer << ", " << toHex(attachment) << ", " << texture << ", " << level << ", " << layer << ");" << TestLog::EndMessage;
2734	m_gl.namedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
2735}
2736
2737void CallLogWrapper::glNamedRenderbufferStorage (glw::GLuint renderbuffer, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height)
2738{
2739	if (m_enableLog)
2740		m_log << TestLog::Message << "glNamedRenderbufferStorage(" << renderbuffer << ", " << toHex(internalformat) << ", " << width << ", " << height << ");" << TestLog::EndMessage;
2741	m_gl.namedRenderbufferStorage(renderbuffer, internalformat, width, height);
2742}
2743
2744void CallLogWrapper::glNamedRenderbufferStorageMultisample (glw::GLuint renderbuffer, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height)
2745{
2746	if (m_enableLog)
2747		m_log << TestLog::Message << "glNamedRenderbufferStorageMultisample(" << renderbuffer << ", " << samples << ", " << toHex(internalformat) << ", " << width << ", " << height << ");" << TestLog::EndMessage;
2748	m_gl.namedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
2749}
2750
2751void CallLogWrapper::glObjectLabel (glw::GLenum identifier, glw::GLuint name, glw::GLsizei length, const glw::GLchar *label)
2752{
2753	if (m_enableLog)
2754		m_log << TestLog::Message << "glObjectLabel(" << toHex(identifier) << ", " << name << ", " << length << ", " << getStringStr(label) << ");" << TestLog::EndMessage;
2755	m_gl.objectLabel(identifier, name, length, label);
2756}
2757
2758void CallLogWrapper::glObjectPtrLabel (const void *ptr, glw::GLsizei length, const glw::GLchar *label)
2759{
2760	if (m_enableLog)
2761		m_log << TestLog::Message << "glObjectPtrLabel(" << ptr << ", " << length << ", " << getStringStr(label) << ");" << TestLog::EndMessage;
2762	m_gl.objectPtrLabel(ptr, length, label);
2763}
2764
2765void CallLogWrapper::glPatchParameterfv (glw::GLenum pname, const glw::GLfloat *values)
2766{
2767	if (m_enableLog)
2768		m_log << TestLog::Message << "glPatchParameterfv(" << toHex(pname) << ", " << values << ");" << TestLog::EndMessage;
2769	m_gl.patchParameterfv(pname, values);
2770}
2771
2772void CallLogWrapper::glPatchParameteri (glw::GLenum pname, glw::GLint value)
2773{
2774	if (m_enableLog)
2775		m_log << TestLog::Message << "glPatchParameteri(" << toHex(pname) << ", " << value << ");" << TestLog::EndMessage;
2776	m_gl.patchParameteri(pname, value);
2777}
2778
2779void CallLogWrapper::glPauseTransformFeedback (void)
2780{
2781	if (m_enableLog)
2782		m_log << TestLog::Message << "glPauseTransformFeedback(" << ");" << TestLog::EndMessage;
2783	m_gl.pauseTransformFeedback();
2784}
2785
2786void CallLogWrapper::glPixelStoref (glw::GLenum pname, glw::GLfloat param)
2787{
2788	if (m_enableLog)
2789		m_log << TestLog::Message << "glPixelStoref(" << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
2790	m_gl.pixelStoref(pname, param);
2791}
2792
2793void CallLogWrapper::glPixelStorei (glw::GLenum pname, glw::GLint param)
2794{
2795	if (m_enableLog)
2796		m_log << TestLog::Message << "glPixelStorei(" << getPixelStoreParameterStr(pname) << ", " << param << ");" << TestLog::EndMessage;
2797	m_gl.pixelStorei(pname, param);
2798}
2799
2800void CallLogWrapper::glPointParameterf (glw::GLenum pname, glw::GLfloat param)
2801{
2802	if (m_enableLog)
2803		m_log << TestLog::Message << "glPointParameterf(" << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
2804	m_gl.pointParameterf(pname, param);
2805}
2806
2807void CallLogWrapper::glPointParameterfv (glw::GLenum pname, const glw::GLfloat *params)
2808{
2809	if (m_enableLog)
2810		m_log << TestLog::Message << "glPointParameterfv(" << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
2811	m_gl.pointParameterfv(pname, params);
2812}
2813
2814void CallLogWrapper::glPointParameteri (glw::GLenum pname, glw::GLint param)
2815{
2816	if (m_enableLog)
2817		m_log << TestLog::Message << "glPointParameteri(" << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
2818	m_gl.pointParameteri(pname, param);
2819}
2820
2821void CallLogWrapper::glPointParameteriv (glw::GLenum pname, const glw::GLint *params)
2822{
2823	if (m_enableLog)
2824		m_log << TestLog::Message << "glPointParameteriv(" << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
2825	m_gl.pointParameteriv(pname, params);
2826}
2827
2828void CallLogWrapper::glPointSize (glw::GLfloat size)
2829{
2830	if (m_enableLog)
2831		m_log << TestLog::Message << "glPointSize(" << size << ");" << TestLog::EndMessage;
2832	m_gl.pointSize(size);
2833}
2834
2835void CallLogWrapper::glPolygonMode (glw::GLenum face, glw::GLenum mode)
2836{
2837	if (m_enableLog)
2838		m_log << TestLog::Message << "glPolygonMode(" << toHex(face) << ", " << toHex(mode) << ");" << TestLog::EndMessage;
2839	m_gl.polygonMode(face, mode);
2840}
2841
2842void CallLogWrapper::glPolygonOffset (glw::GLfloat factor, glw::GLfloat units)
2843{
2844	if (m_enableLog)
2845		m_log << TestLog::Message << "glPolygonOffset(" << factor << ", " << units << ");" << TestLog::EndMessage;
2846	m_gl.polygonOffset(factor, units);
2847}
2848
2849void CallLogWrapper::glPopDebugGroup (void)
2850{
2851	if (m_enableLog)
2852		m_log << TestLog::Message << "glPopDebugGroup(" << ");" << TestLog::EndMessage;
2853	m_gl.popDebugGroup();
2854}
2855
2856void 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)
2857{
2858	if (m_enableLog)
2859		m_log << TestLog::Message << "glPrimitiveBoundingBoxEXT(" << minX << ", " << minY << ", " << minZ << ", " << minW << ", " << maxX << ", " << maxY << ", " << maxZ << ", " << maxW << ");" << TestLog::EndMessage;
2860	m_gl.primitiveBoundingBoxEXT(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
2861}
2862
2863void CallLogWrapper::glPrimitiveRestartIndex (glw::GLuint index)
2864{
2865	if (m_enableLog)
2866		m_log << TestLog::Message << "glPrimitiveRestartIndex(" << index << ");" << TestLog::EndMessage;
2867	m_gl.primitiveRestartIndex(index);
2868}
2869
2870void CallLogWrapper::glProgramBinary (glw::GLuint program, glw::GLenum binaryFormat, const void *binary, glw::GLsizei length)
2871{
2872	if (m_enableLog)
2873		m_log << TestLog::Message << "glProgramBinary(" << program << ", " << toHex(binaryFormat) << ", " << binary << ", " << length << ");" << TestLog::EndMessage;
2874	m_gl.programBinary(program, binaryFormat, binary, length);
2875}
2876
2877void CallLogWrapper::glProgramParameteri (glw::GLuint program, glw::GLenum pname, glw::GLint value)
2878{
2879	if (m_enableLog)
2880		m_log << TestLog::Message << "glProgramParameteri(" << program << ", " << getProgramParamStr(pname) << ", " << value << ");" << TestLog::EndMessage;
2881	m_gl.programParameteri(program, pname, value);
2882}
2883
2884void CallLogWrapper::glProgramUniform1d (glw::GLuint program, glw::GLint location, glw::GLdouble v0)
2885{
2886	if (m_enableLog)
2887		m_log << TestLog::Message << "glProgramUniform1d(" << program << ", " << location << ", " << v0 << ");" << TestLog::EndMessage;
2888	m_gl.programUniform1d(program, location, v0);
2889}
2890
2891void CallLogWrapper::glProgramUniform1dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
2892{
2893	if (m_enableLog)
2894		m_log << TestLog::Message << "glProgramUniform1dv(" << program << ", " << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
2895	m_gl.programUniform1dv(program, location, count, value);
2896}
2897
2898void CallLogWrapper::glProgramUniform1f (glw::GLuint program, glw::GLint location, glw::GLfloat v0)
2899{
2900	if (m_enableLog)
2901		m_log << TestLog::Message << "glProgramUniform1f(" << program << ", " << location << ", " << v0 << ");" << TestLog::EndMessage;
2902	m_gl.programUniform1f(program, location, v0);
2903}
2904
2905void CallLogWrapper::glProgramUniform1fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
2906{
2907	if (m_enableLog)
2908		m_log << TestLog::Message << "glProgramUniform1fv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 1)) << ");" << TestLog::EndMessage;
2909	m_gl.programUniform1fv(program, location, count, value);
2910}
2911
2912void CallLogWrapper::glProgramUniform1i (glw::GLuint program, glw::GLint location, glw::GLint v0)
2913{
2914	if (m_enableLog)
2915		m_log << TestLog::Message << "glProgramUniform1i(" << program << ", " << location << ", " << v0 << ");" << TestLog::EndMessage;
2916	m_gl.programUniform1i(program, location, v0);
2917}
2918
2919void CallLogWrapper::glProgramUniform1iv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLint *value)
2920{
2921	if (m_enableLog)
2922		m_log << TestLog::Message << "glProgramUniform1iv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 1)) << ");" << TestLog::EndMessage;
2923	m_gl.programUniform1iv(program, location, count, value);
2924}
2925
2926void CallLogWrapper::glProgramUniform1ui (glw::GLuint program, glw::GLint location, glw::GLuint v0)
2927{
2928	if (m_enableLog)
2929		m_log << TestLog::Message << "glProgramUniform1ui(" << program << ", " << location << ", " << v0 << ");" << TestLog::EndMessage;
2930	m_gl.programUniform1ui(program, location, v0);
2931}
2932
2933void CallLogWrapper::glProgramUniform1uiv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
2934{
2935	if (m_enableLog)
2936		m_log << TestLog::Message << "glProgramUniform1uiv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 1)) << ");" << TestLog::EndMessage;
2937	m_gl.programUniform1uiv(program, location, count, value);
2938}
2939
2940void CallLogWrapper::glProgramUniform2d (glw::GLuint program, glw::GLint location, glw::GLdouble v0, glw::GLdouble v1)
2941{
2942	if (m_enableLog)
2943		m_log << TestLog::Message << "glProgramUniform2d(" << program << ", " << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
2944	m_gl.programUniform2d(program, location, v0, v1);
2945}
2946
2947void CallLogWrapper::glProgramUniform2dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
2948{
2949	if (m_enableLog)
2950		m_log << TestLog::Message << "glProgramUniform2dv(" << program << ", " << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
2951	m_gl.programUniform2dv(program, location, count, value);
2952}
2953
2954void CallLogWrapper::glProgramUniform2f (glw::GLuint program, glw::GLint location, glw::GLfloat v0, glw::GLfloat v1)
2955{
2956	if (m_enableLog)
2957		m_log << TestLog::Message << "glProgramUniform2f(" << program << ", " << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
2958	m_gl.programUniform2f(program, location, v0, v1);
2959}
2960
2961void CallLogWrapper::glProgramUniform2fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
2962{
2963	if (m_enableLog)
2964		m_log << TestLog::Message << "glProgramUniform2fv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 2)) << ");" << TestLog::EndMessage;
2965	m_gl.programUniform2fv(program, location, count, value);
2966}
2967
2968void CallLogWrapper::glProgramUniform2i (glw::GLuint program, glw::GLint location, glw::GLint v0, glw::GLint v1)
2969{
2970	if (m_enableLog)
2971		m_log << TestLog::Message << "glProgramUniform2i(" << program << ", " << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
2972	m_gl.programUniform2i(program, location, v0, v1);
2973}
2974
2975void CallLogWrapper::glProgramUniform2iv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLint *value)
2976{
2977	if (m_enableLog)
2978		m_log << TestLog::Message << "glProgramUniform2iv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 2)) << ");" << TestLog::EndMessage;
2979	m_gl.programUniform2iv(program, location, count, value);
2980}
2981
2982void CallLogWrapper::glProgramUniform2ui (glw::GLuint program, glw::GLint location, glw::GLuint v0, glw::GLuint v1)
2983{
2984	if (m_enableLog)
2985		m_log << TestLog::Message << "glProgramUniform2ui(" << program << ", " << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
2986	m_gl.programUniform2ui(program, location, v0, v1);
2987}
2988
2989void CallLogWrapper::glProgramUniform2uiv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
2990{
2991	if (m_enableLog)
2992		m_log << TestLog::Message << "glProgramUniform2uiv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 2)) << ");" << TestLog::EndMessage;
2993	m_gl.programUniform2uiv(program, location, count, value);
2994}
2995
2996void CallLogWrapper::glProgramUniform3d (glw::GLuint program, glw::GLint location, glw::GLdouble v0, glw::GLdouble v1, glw::GLdouble v2)
2997{
2998	if (m_enableLog)
2999		m_log << TestLog::Message << "glProgramUniform3d(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3000	m_gl.programUniform3d(program, location, v0, v1, v2);
3001}
3002
3003void CallLogWrapper::glProgramUniform3dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
3004{
3005	if (m_enableLog)
3006		m_log << TestLog::Message << "glProgramUniform3dv(" << program << ", " << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
3007	m_gl.programUniform3dv(program, location, count, value);
3008}
3009
3010void CallLogWrapper::glProgramUniform3f (glw::GLuint program, glw::GLint location, glw::GLfloat v0, glw::GLfloat v1, glw::GLfloat v2)
3011{
3012	if (m_enableLog)
3013		m_log << TestLog::Message << "glProgramUniform3f(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3014	m_gl.programUniform3f(program, location, v0, v1, v2);
3015}
3016
3017void CallLogWrapper::glProgramUniform3fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
3018{
3019	if (m_enableLog)
3020		m_log << TestLog::Message << "glProgramUniform3fv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 3)) << ");" << TestLog::EndMessage;
3021	m_gl.programUniform3fv(program, location, count, value);
3022}
3023
3024void CallLogWrapper::glProgramUniform3i (glw::GLuint program, glw::GLint location, glw::GLint v0, glw::GLint v1, glw::GLint v2)
3025{
3026	if (m_enableLog)
3027		m_log << TestLog::Message << "glProgramUniform3i(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3028	m_gl.programUniform3i(program, location, v0, v1, v2);
3029}
3030
3031void CallLogWrapper::glProgramUniform3iv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3032{
3033	if (m_enableLog)
3034		m_log << TestLog::Message << "glProgramUniform3iv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 3)) << ");" << TestLog::EndMessage;
3035	m_gl.programUniform3iv(program, location, count, value);
3036}
3037
3038void CallLogWrapper::glProgramUniform3ui (glw::GLuint program, glw::GLint location, glw::GLuint v0, glw::GLuint v1, glw::GLuint v2)
3039{
3040	if (m_enableLog)
3041		m_log << TestLog::Message << "glProgramUniform3ui(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3042	m_gl.programUniform3ui(program, location, v0, v1, v2);
3043}
3044
3045void CallLogWrapper::glProgramUniform3uiv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
3046{
3047	if (m_enableLog)
3048		m_log << TestLog::Message << "glProgramUniform3uiv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 3)) << ");" << TestLog::EndMessage;
3049	m_gl.programUniform3uiv(program, location, count, value);
3050}
3051
3052void CallLogWrapper::glProgramUniform4d (glw::GLuint program, glw::GLint location, glw::GLdouble v0, glw::GLdouble v1, glw::GLdouble v2, glw::GLdouble v3)
3053{
3054	if (m_enableLog)
3055		m_log << TestLog::Message << "glProgramUniform4d(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3056	m_gl.programUniform4d(program, location, v0, v1, v2, v3);
3057}
3058
3059void CallLogWrapper::glProgramUniform4dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
3060{
3061	if (m_enableLog)
3062		m_log << TestLog::Message << "glProgramUniform4dv(" << program << ", " << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
3063	m_gl.programUniform4dv(program, location, count, value);
3064}
3065
3066void CallLogWrapper::glProgramUniform4f (glw::GLuint program, glw::GLint location, glw::GLfloat v0, glw::GLfloat v1, glw::GLfloat v2, glw::GLfloat v3)
3067{
3068	if (m_enableLog)
3069		m_log << TestLog::Message << "glProgramUniform4f(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3070	m_gl.programUniform4f(program, location, v0, v1, v2, v3);
3071}
3072
3073void CallLogWrapper::glProgramUniform4fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
3074{
3075	if (m_enableLog)
3076		m_log << TestLog::Message << "glProgramUniform4fv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 4)) << ");" << TestLog::EndMessage;
3077	m_gl.programUniform4fv(program, location, count, value);
3078}
3079
3080void CallLogWrapper::glProgramUniform4i (glw::GLuint program, glw::GLint location, glw::GLint v0, glw::GLint v1, glw::GLint v2, glw::GLint v3)
3081{
3082	if (m_enableLog)
3083		m_log << TestLog::Message << "glProgramUniform4i(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3084	m_gl.programUniform4i(program, location, v0, v1, v2, v3);
3085}
3086
3087void CallLogWrapper::glProgramUniform4iv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3088{
3089	if (m_enableLog)
3090		m_log << TestLog::Message << "glProgramUniform4iv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 4)) << ");" << TestLog::EndMessage;
3091	m_gl.programUniform4iv(program, location, count, value);
3092}
3093
3094void CallLogWrapper::glProgramUniform4ui (glw::GLuint program, glw::GLint location, glw::GLuint v0, glw::GLuint v1, glw::GLuint v2, glw::GLuint v3)
3095{
3096	if (m_enableLog)
3097		m_log << TestLog::Message << "glProgramUniform4ui(" << program << ", " << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3098	m_gl.programUniform4ui(program, location, v0, v1, v2, v3);
3099}
3100
3101void CallLogWrapper::glProgramUniform4uiv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
3102{
3103	if (m_enableLog)
3104		m_log << TestLog::Message << "glProgramUniform4uiv(" << program << ", " << location << ", " << count << ", " << getPointerStr(value, (count * 4)) << ");" << TestLog::EndMessage;
3105	m_gl.programUniform4uiv(program, location, count, value);
3106}
3107
3108void CallLogWrapper::glProgramUniformMatrix2dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3109{
3110	if (m_enableLog)
3111		m_log << TestLog::Message << "glProgramUniformMatrix2dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
3112	m_gl.programUniformMatrix2dv(program, location, count, transpose, value);
3113}
3114
3115void CallLogWrapper::glProgramUniformMatrix2fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3116{
3117	if (m_enableLog)
3118		m_log << TestLog::Message << "glProgramUniformMatrix2fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 2*2)) << ");" << TestLog::EndMessage;
3119	m_gl.programUniformMatrix2fv(program, location, count, transpose, value);
3120}
3121
3122void CallLogWrapper::glProgramUniformMatrix2x3dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3123{
3124	if (m_enableLog)
3125		m_log << TestLog::Message << "glProgramUniformMatrix2x3dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
3126	m_gl.programUniformMatrix2x3dv(program, location, count, transpose, value);
3127}
3128
3129void CallLogWrapper::glProgramUniformMatrix2x3fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3130{
3131	if (m_enableLog)
3132		m_log << TestLog::Message << "glProgramUniformMatrix2x3fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 2*3)) << ");" << TestLog::EndMessage;
3133	m_gl.programUniformMatrix2x3fv(program, location, count, transpose, value);
3134}
3135
3136void CallLogWrapper::glProgramUniformMatrix2x4dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3137{
3138	if (m_enableLog)
3139		m_log << TestLog::Message << "glProgramUniformMatrix2x4dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
3140	m_gl.programUniformMatrix2x4dv(program, location, count, transpose, value);
3141}
3142
3143void CallLogWrapper::glProgramUniformMatrix2x4fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3144{
3145	if (m_enableLog)
3146		m_log << TestLog::Message << "glProgramUniformMatrix2x4fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 2*4)) << ");" << TestLog::EndMessage;
3147	m_gl.programUniformMatrix2x4fv(program, location, count, transpose, value);
3148}
3149
3150void CallLogWrapper::glProgramUniformMatrix3dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3151{
3152	if (m_enableLog)
3153		m_log << TestLog::Message << "glProgramUniformMatrix3dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
3154	m_gl.programUniformMatrix3dv(program, location, count, transpose, value);
3155}
3156
3157void CallLogWrapper::glProgramUniformMatrix3fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3158{
3159	if (m_enableLog)
3160		m_log << TestLog::Message << "glProgramUniformMatrix3fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 3*3)) << ");" << TestLog::EndMessage;
3161	m_gl.programUniformMatrix3fv(program, location, count, transpose, value);
3162}
3163
3164void CallLogWrapper::glProgramUniformMatrix3x2dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3165{
3166	if (m_enableLog)
3167		m_log << TestLog::Message << "glProgramUniformMatrix3x2dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
3168	m_gl.programUniformMatrix3x2dv(program, location, count, transpose, value);
3169}
3170
3171void CallLogWrapper::glProgramUniformMatrix3x2fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3172{
3173	if (m_enableLog)
3174		m_log << TestLog::Message << "glProgramUniformMatrix3x2fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 3*2)) << ");" << TestLog::EndMessage;
3175	m_gl.programUniformMatrix3x2fv(program, location, count, transpose, value);
3176}
3177
3178void CallLogWrapper::glProgramUniformMatrix3x4dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3179{
3180	if (m_enableLog)
3181		m_log << TestLog::Message << "glProgramUniformMatrix3x4dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
3182	m_gl.programUniformMatrix3x4dv(program, location, count, transpose, value);
3183}
3184
3185void CallLogWrapper::glProgramUniformMatrix3x4fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3186{
3187	if (m_enableLog)
3188		m_log << TestLog::Message << "glProgramUniformMatrix3x4fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 3*4)) << ");" << TestLog::EndMessage;
3189	m_gl.programUniformMatrix3x4fv(program, location, count, transpose, value);
3190}
3191
3192void CallLogWrapper::glProgramUniformMatrix4dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3193{
3194	if (m_enableLog)
3195		m_log << TestLog::Message << "glProgramUniformMatrix4dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
3196	m_gl.programUniformMatrix4dv(program, location, count, transpose, value);
3197}
3198
3199void CallLogWrapper::glProgramUniformMatrix4fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3200{
3201	if (m_enableLog)
3202		m_log << TestLog::Message << "glProgramUniformMatrix4fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 4*4)) << ");" << TestLog::EndMessage;
3203	m_gl.programUniformMatrix4fv(program, location, count, transpose, value);
3204}
3205
3206void CallLogWrapper::glProgramUniformMatrix4x2dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3207{
3208	if (m_enableLog)
3209		m_log << TestLog::Message << "glProgramUniformMatrix4x2dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
3210	m_gl.programUniformMatrix4x2dv(program, location, count, transpose, value);
3211}
3212
3213void CallLogWrapper::glProgramUniformMatrix4x2fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3214{
3215	if (m_enableLog)
3216		m_log << TestLog::Message << "glProgramUniformMatrix4x2fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 4*2)) << ");" << TestLog::EndMessage;
3217	m_gl.programUniformMatrix4x2fv(program, location, count, transpose, value);
3218}
3219
3220void CallLogWrapper::glProgramUniformMatrix4x3dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3221{
3222	if (m_enableLog)
3223		m_log << TestLog::Message << "glProgramUniformMatrix4x3dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
3224	m_gl.programUniformMatrix4x3dv(program, location, count, transpose, value);
3225}
3226
3227void CallLogWrapper::glProgramUniformMatrix4x3fv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3228{
3229	if (m_enableLog)
3230		m_log << TestLog::Message << "glProgramUniformMatrix4x3fv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 4*3)) << ");" << TestLog::EndMessage;
3231	m_gl.programUniformMatrix4x3fv(program, location, count, transpose, value);
3232}
3233
3234void CallLogWrapper::glProvokingVertex (glw::GLenum mode)
3235{
3236	if (m_enableLog)
3237		m_log << TestLog::Message << "glProvokingVertex(" << getProvokingVertexStr(mode) << ");" << TestLog::EndMessage;
3238	m_gl.provokingVertex(mode);
3239}
3240
3241void CallLogWrapper::glPushDebugGroup (glw::GLenum source, glw::GLuint id, glw::GLsizei length, const glw::GLchar *message)
3242{
3243	if (m_enableLog)
3244		m_log << TestLog::Message << "glPushDebugGroup(" << getDebugMessageSourceStr(source) << ", " << id << ", " << length << ", " << getStringStr(message) << ");" << TestLog::EndMessage;
3245	m_gl.pushDebugGroup(source, id, length, message);
3246}
3247
3248void CallLogWrapper::glQueryCounter (glw::GLuint id, glw::GLenum target)
3249{
3250	if (m_enableLog)
3251		m_log << TestLog::Message << "glQueryCounter(" << id << ", " << toHex(target) << ");" << TestLog::EndMessage;
3252	m_gl.queryCounter(id, target);
3253}
3254
3255void CallLogWrapper::glReadBuffer (glw::GLenum src)
3256{
3257	if (m_enableLog)
3258		m_log << TestLog::Message << "glReadBuffer(" << getDrawReadBufferStr(src) << ");" << TestLog::EndMessage;
3259	m_gl.readBuffer(src);
3260}
3261
3262void CallLogWrapper::glReadPixels (glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height, glw::GLenum format, glw::GLenum type, void *pixels)
3263{
3264	if (m_enableLog)
3265		m_log << TestLog::Message << "glReadPixels(" << x << ", " << y << ", " << width << ", " << height << ", " << getPixelFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3266	m_gl.readPixels(x, y, width, height, format, type, pixels);
3267}
3268
3269void 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)
3270{
3271	if (m_enableLog)
3272		m_log << TestLog::Message << "glReadnPixels(" << x << ", " << y << ", " << width << ", " << height << ", " << toHex(format) << ", " << toHex(type) << ", " << bufSize << ", " << data << ");" << TestLog::EndMessage;
3273	m_gl.readnPixels(x, y, width, height, format, type, bufSize, data);
3274}
3275
3276void CallLogWrapper::glReleaseShaderCompiler (void)
3277{
3278	if (m_enableLog)
3279		m_log << TestLog::Message << "glReleaseShaderCompiler(" << ");" << TestLog::EndMessage;
3280	m_gl.releaseShaderCompiler();
3281}
3282
3283void CallLogWrapper::glRenderbufferStorage (glw::GLenum target, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height)
3284{
3285	if (m_enableLog)
3286		m_log << TestLog::Message << "glRenderbufferStorage(" << getFramebufferTargetStr(target) << ", " << getPixelFormatStr(internalformat) << ", " << width << ", " << height << ");" << TestLog::EndMessage;
3287	m_gl.renderbufferStorage(target, internalformat, width, height);
3288}
3289
3290void CallLogWrapper::glRenderbufferStorageMultisample (glw::GLenum target, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height)
3291{
3292	if (m_enableLog)
3293		m_log << TestLog::Message << "glRenderbufferStorageMultisample(" << getFramebufferTargetStr(target) << ", " << samples << ", " << getPixelFormatStr(internalformat) << ", " << width << ", " << height << ");" << TestLog::EndMessage;
3294	m_gl.renderbufferStorageMultisample(target, samples, internalformat, width, height);
3295}
3296
3297void CallLogWrapper::glResumeTransformFeedback (void)
3298{
3299	if (m_enableLog)
3300		m_log << TestLog::Message << "glResumeTransformFeedback(" << ");" << TestLog::EndMessage;
3301	m_gl.resumeTransformFeedback();
3302}
3303
3304void CallLogWrapper::glSampleCoverage (glw::GLfloat value, glw::GLboolean invert)
3305{
3306	if (m_enableLog)
3307		m_log << TestLog::Message << "glSampleCoverage(" << value << ", " << getBooleanStr(invert) << ");" << TestLog::EndMessage;
3308	m_gl.sampleCoverage(value, invert);
3309}
3310
3311void CallLogWrapper::glSampleMaski (glw::GLuint maskNumber, glw::GLbitfield mask)
3312{
3313	if (m_enableLog)
3314		m_log << TestLog::Message << "glSampleMaski(" << maskNumber << ", " << toHex(mask) << ");" << TestLog::EndMessage;
3315	m_gl.sampleMaski(maskNumber, mask);
3316}
3317
3318void CallLogWrapper::glSamplerParameterIiv (glw::GLuint sampler, glw::GLenum pname, const glw::GLint *param)
3319{
3320	if (m_enableLog)
3321		m_log << TestLog::Message << "glSamplerParameterIiv(" << sampler << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
3322	m_gl.samplerParameterIiv(sampler, pname, param);
3323}
3324
3325void CallLogWrapper::glSamplerParameterIuiv (glw::GLuint sampler, glw::GLenum pname, const glw::GLuint *param)
3326{
3327	if (m_enableLog)
3328		m_log << TestLog::Message << "glSamplerParameterIuiv(" << sampler << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
3329	m_gl.samplerParameterIuiv(sampler, pname, param);
3330}
3331
3332void CallLogWrapper::glSamplerParameterf (glw::GLuint sampler, glw::GLenum pname, glw::GLfloat param)
3333{
3334	if (m_enableLog)
3335		m_log << TestLog::Message << "glSamplerParameterf(" << sampler << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
3336	m_gl.samplerParameterf(sampler, pname, param);
3337}
3338
3339void CallLogWrapper::glSamplerParameterfv (glw::GLuint sampler, glw::GLenum pname, const glw::GLfloat *param)
3340{
3341	if (m_enableLog)
3342		m_log << TestLog::Message << "glSamplerParameterfv(" << sampler << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
3343	m_gl.samplerParameterfv(sampler, pname, param);
3344}
3345
3346void CallLogWrapper::glSamplerParameteri (glw::GLuint sampler, glw::GLenum pname, glw::GLint param)
3347{
3348	if (m_enableLog)
3349		m_log << TestLog::Message << "glSamplerParameteri(" << sampler << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
3350	m_gl.samplerParameteri(sampler, pname, param);
3351}
3352
3353void CallLogWrapper::glSamplerParameteriv (glw::GLuint sampler, glw::GLenum pname, const glw::GLint *param)
3354{
3355	if (m_enableLog)
3356		m_log << TestLog::Message << "glSamplerParameteriv(" << sampler << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
3357	m_gl.samplerParameteriv(sampler, pname, param);
3358}
3359
3360void CallLogWrapper::glScissor (glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
3361{
3362	if (m_enableLog)
3363		m_log << TestLog::Message << "glScissor(" << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
3364	m_gl.scissor(x, y, width, height);
3365}
3366
3367void CallLogWrapper::glScissorArrayv (glw::GLuint first, glw::GLsizei count, const glw::GLint *v)
3368{
3369	if (m_enableLog)
3370		m_log << TestLog::Message << "glScissorArrayv(" << first << ", " << count << ", " << v << ");" << TestLog::EndMessage;
3371	m_gl.scissorArrayv(first, count, v);
3372}
3373
3374void CallLogWrapper::glScissorIndexed (glw::GLuint index, glw::GLint left, glw::GLint bottom, glw::GLsizei width, glw::GLsizei height)
3375{
3376	if (m_enableLog)
3377		m_log << TestLog::Message << "glScissorIndexed(" << index << ", " << left << ", " << bottom << ", " << width << ", " << height << ");" << TestLog::EndMessage;
3378	m_gl.scissorIndexed(index, left, bottom, width, height);
3379}
3380
3381void CallLogWrapper::glScissorIndexedv (glw::GLuint index, const glw::GLint *v)
3382{
3383	if (m_enableLog)
3384		m_log << TestLog::Message << "glScissorIndexedv(" << index << ", " << v << ");" << TestLog::EndMessage;
3385	m_gl.scissorIndexedv(index, v);
3386}
3387
3388void CallLogWrapper::glShaderBinary (glw::GLsizei count, const glw::GLuint *shaders, glw::GLenum binaryformat, const void *binary, glw::GLsizei length)
3389{
3390	if (m_enableLog)
3391		m_log << TestLog::Message << "glShaderBinary(" << count << ", " << shaders << ", " << toHex(binaryformat) << ", " << binary << ", " << length << ");" << TestLog::EndMessage;
3392	m_gl.shaderBinary(count, shaders, binaryformat, binary, length);
3393}
3394
3395void CallLogWrapper::glShaderSource (glw::GLuint shader, glw::GLsizei count, const glw::GLchar *const*string, const glw::GLint *length)
3396{
3397	if (m_enableLog)
3398		m_log << TestLog::Message << "glShaderSource(" << shader << ", " << count << ", " << string << ", " << length << ");" << TestLog::EndMessage;
3399	m_gl.shaderSource(shader, count, string, length);
3400}
3401
3402void CallLogWrapper::glShaderStorageBlockBinding (glw::GLuint program, glw::GLuint storageBlockIndex, glw::GLuint storageBlockBinding)
3403{
3404	if (m_enableLog)
3405		m_log << TestLog::Message << "glShaderStorageBlockBinding(" << program << ", " << storageBlockIndex << ", " << storageBlockBinding << ");" << TestLog::EndMessage;
3406	m_gl.shaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
3407}
3408
3409void CallLogWrapper::glStencilFunc (glw::GLenum func, glw::GLint ref, glw::GLuint mask)
3410{
3411	if (m_enableLog)
3412		m_log << TestLog::Message << "glStencilFunc(" << getCompareFuncStr(func) << ", " << ref << ", " << mask << ");" << TestLog::EndMessage;
3413	m_gl.stencilFunc(func, ref, mask);
3414}
3415
3416void CallLogWrapper::glStencilFuncSeparate (glw::GLenum face, glw::GLenum func, glw::GLint ref, glw::GLuint mask)
3417{
3418	if (m_enableLog)
3419		m_log << TestLog::Message << "glStencilFuncSeparate(" << getFaceStr(face) << ", " << getCompareFuncStr(func) << ", " << ref << ", " << mask << ");" << TestLog::EndMessage;
3420	m_gl.stencilFuncSeparate(face, func, ref, mask);
3421}
3422
3423void CallLogWrapper::glStencilMask (glw::GLuint mask)
3424{
3425	if (m_enableLog)
3426		m_log << TestLog::Message << "glStencilMask(" << mask << ");" << TestLog::EndMessage;
3427	m_gl.stencilMask(mask);
3428}
3429
3430void CallLogWrapper::glStencilMaskSeparate (glw::GLenum face, glw::GLuint mask)
3431{
3432	if (m_enableLog)
3433		m_log << TestLog::Message << "glStencilMaskSeparate(" << getFaceStr(face) << ", " << mask << ");" << TestLog::EndMessage;
3434	m_gl.stencilMaskSeparate(face, mask);
3435}
3436
3437void CallLogWrapper::glStencilOp (glw::GLenum fail, glw::GLenum zfail, glw::GLenum zpass)
3438{
3439	if (m_enableLog)
3440		m_log << TestLog::Message << "glStencilOp(" << getStencilOpStr(fail) << ", " << getStencilOpStr(zfail) << ", " << getStencilOpStr(zpass) << ");" << TestLog::EndMessage;
3441	m_gl.stencilOp(fail, zfail, zpass);
3442}
3443
3444void CallLogWrapper::glStencilOpSeparate (glw::GLenum face, glw::GLenum sfail, glw::GLenum dpfail, glw::GLenum dppass)
3445{
3446	if (m_enableLog)
3447		m_log << TestLog::Message << "glStencilOpSeparate(" << getFaceStr(face) << ", " << getStencilOpStr(sfail) << ", " << getStencilOpStr(dpfail) << ", " << getStencilOpStr(dppass) << ");" << TestLog::EndMessage;
3448	m_gl.stencilOpSeparate(face, sfail, dpfail, dppass);
3449}
3450
3451void CallLogWrapper::glTexBuffer (glw::GLenum target, glw::GLenum internalformat, glw::GLuint buffer)
3452{
3453	if (m_enableLog)
3454		m_log << TestLog::Message << "glTexBuffer(" << getBufferTargetStr(target) << ", " << getPixelFormatStr(internalformat) << ", " << buffer << ");" << TestLog::EndMessage;
3455	m_gl.texBuffer(target, internalformat, buffer);
3456}
3457
3458void CallLogWrapper::glTexBufferRange (glw::GLenum target, glw::GLenum internalformat, glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size)
3459{
3460	if (m_enableLog)
3461		m_log << TestLog::Message << "glTexBufferRange(" << getBufferTargetStr(target) << ", " << getPixelFormatStr(internalformat) << ", " << buffer << ", " << offset << ", " << size << ");" << TestLog::EndMessage;
3462	m_gl.texBufferRange(target, internalformat, buffer, offset, size);
3463}
3464
3465void 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)
3466{
3467	if (m_enableLog)
3468		m_log << TestLog::Message << "glTexImage1D(" << getTextureTargetStr(target) << ", " << level << ", " << getPixelFormatStr(internalformat) << ", " << width << ", " << border << ", " << getPixelFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3469	m_gl.texImage1D(target, level, internalformat, width, border, format, type, pixels);
3470}
3471
3472void 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)
3473{
3474	if (m_enableLog)
3475		m_log << TestLog::Message << "glTexImage2D(" << getTextureTargetStr(target) << ", " << level << ", " << getPixelFormatStr(internalformat) << ", " << width << ", " << height << ", " << border << ", " << getPixelFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3476	m_gl.texImage2D(target, level, internalformat, width, height, border, format, type, pixels);
3477}
3478
3479void CallLogWrapper::glTexImage2DMultisample (glw::GLenum target, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLboolean fixedsamplelocations)
3480{
3481	if (m_enableLog)
3482		m_log << TestLog::Message << "glTexImage2DMultisample(" << getTextureTargetStr(target) << ", " << samples << ", " << getPixelFormatStr(internalformat) << ", " << width << ", " << height << ", " << getBooleanStr(fixedsamplelocations) << ");" << TestLog::EndMessage;
3483	m_gl.texImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
3484}
3485
3486void 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)
3487{
3488	if (m_enableLog)
3489		m_log << TestLog::Message << "glTexImage3D(" << getTextureTargetStr(target) << ", " << level << ", " << getPixelFormatStr(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << border << ", " << getPixelFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3490	m_gl.texImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
3491}
3492
3493void CallLogWrapper::glTexImage3DMultisample (glw::GLenum target, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLboolean fixedsamplelocations)
3494{
3495	if (m_enableLog)
3496		m_log << TestLog::Message << "glTexImage3DMultisample(" << toHex(target) << ", " << samples << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << getBooleanStr(fixedsamplelocations) << ");" << TestLog::EndMessage;
3497	m_gl.texImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
3498}
3499
3500void CallLogWrapper::glTexParameterIiv (glw::GLenum target, glw::GLenum pname, const glw::GLint *params)
3501{
3502	if (m_enableLog)
3503		m_log << TestLog::Message << "glTexParameterIiv(" << toHex(target) << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
3504	m_gl.texParameterIiv(target, pname, params);
3505}
3506
3507void CallLogWrapper::glTexParameterIuiv (glw::GLenum target, glw::GLenum pname, const glw::GLuint *params)
3508{
3509	if (m_enableLog)
3510		m_log << TestLog::Message << "glTexParameterIuiv(" << toHex(target) << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
3511	m_gl.texParameterIuiv(target, pname, params);
3512}
3513
3514void CallLogWrapper::glTexParameterf (glw::GLenum target, glw::GLenum pname, glw::GLfloat param)
3515{
3516	if (m_enableLog)
3517		m_log << TestLog::Message << "glTexParameterf(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << param << ");" << TestLog::EndMessage;
3518	m_gl.texParameterf(target, pname, param);
3519}
3520
3521void CallLogWrapper::glTexParameterfv (glw::GLenum target, glw::GLenum pname, const glw::GLfloat *params)
3522{
3523	if (m_enableLog)
3524		m_log << TestLog::Message << "glTexParameterfv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << getPointerStr(params, 1) << ");" << TestLog::EndMessage;
3525	m_gl.texParameterfv(target, pname, params);
3526}
3527
3528void CallLogWrapper::glTexParameteri (glw::GLenum target, glw::GLenum pname, glw::GLint param)
3529{
3530	if (m_enableLog)
3531		m_log << TestLog::Message << "glTexParameteri(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << getTextureParameterValueStr(pname, param) << ");" << TestLog::EndMessage;
3532	m_gl.texParameteri(target, pname, param);
3533}
3534
3535void CallLogWrapper::glTexParameteriv (glw::GLenum target, glw::GLenum pname, const glw::GLint *params)
3536{
3537	if (m_enableLog)
3538		m_log << TestLog::Message << "glTexParameteriv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << getPointerStr(params, 1) << ");" << TestLog::EndMessage;
3539	m_gl.texParameteriv(target, pname, params);
3540}
3541
3542void CallLogWrapper::glTexStorage1D (glw::GLenum target, glw::GLsizei levels, glw::GLenum internalformat, glw::GLsizei width)
3543{
3544	if (m_enableLog)
3545		m_log << TestLog::Message << "glTexStorage1D(" << toHex(target) << ", " << levels << ", " << toHex(internalformat) << ", " << width << ");" << TestLog::EndMessage;
3546	m_gl.texStorage1D(target, levels, internalformat, width);
3547}
3548
3549void CallLogWrapper::glTexStorage2D (glw::GLenum target, glw::GLsizei levels, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height)
3550{
3551	if (m_enableLog)
3552		m_log << TestLog::Message << "glTexStorage2D(" << getTextureTargetStr(target) << ", " << levels << ", " << getPixelFormatStr(internalformat) << ", " << width << ", " << height << ");" << TestLog::EndMessage;
3553	m_gl.texStorage2D(target, levels, internalformat, width, height);
3554}
3555
3556void CallLogWrapper::glTexStorage2DMultisample (glw::GLenum target, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLboolean fixedsamplelocations)
3557{
3558	if (m_enableLog)
3559		m_log << TestLog::Message << "glTexStorage2DMultisample(" << getTextureTargetStr(target) << ", " << samples << ", " << getPixelFormatStr(internalformat) << ", " << width << ", " << height << ", " << getBooleanStr(fixedsamplelocations) << ");" << TestLog::EndMessage;
3560	m_gl.texStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
3561}
3562
3563void CallLogWrapper::glTexStorage3D (glw::GLenum target, glw::GLsizei levels, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth)
3564{
3565	if (m_enableLog)
3566		m_log << TestLog::Message << "glTexStorage3D(" << getTextureTargetStr(target) << ", " << levels << ", " << getPixelFormatStr(internalformat) << ", " << width << ", " << height << ", " << depth << ");" << TestLog::EndMessage;
3567	m_gl.texStorage3D(target, levels, internalformat, width, height, depth);
3568}
3569
3570void CallLogWrapper::glTexStorage3DMultisample (glw::GLenum target, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLboolean fixedsamplelocations)
3571{
3572	if (m_enableLog)
3573		m_log << TestLog::Message << "glTexStorage3DMultisample(" << getTextureTargetStr(target) << ", " << samples << ", " << getPixelFormatStr(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << getBooleanStr(fixedsamplelocations) << ");" << TestLog::EndMessage;
3574	m_gl.texStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
3575}
3576
3577void CallLogWrapper::glTexSubImage1D (glw::GLenum target, glw::GLint level, glw::GLint xoffset, glw::GLsizei width, glw::GLenum format, glw::GLenum type, const void *pixels)
3578{
3579	if (m_enableLog)
3580		m_log << TestLog::Message << "glTexSubImage1D(" << getTextureTargetStr(target) << ", " << level << ", " << xoffset << ", " << width << ", " << getPixelFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3581	m_gl.texSubImage1D(target, level, xoffset, width, format, type, pixels);
3582}
3583
3584void 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)
3585{
3586	if (m_enableLog)
3587		m_log << TestLog::Message << "glTexSubImage2D(" << getTextureTargetStr(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height << ", " << getPixelFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3588	m_gl.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
3589}
3590
3591void 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)
3592{
3593	if (m_enableLog)
3594		m_log << TestLog::Message << "glTexSubImage3D(" << getTextureTargetStr(target) << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << getPixelFormatStr(format) << ", " << getTypeStr(type) << ", " << pixels << ");" << TestLog::EndMessage;
3595	m_gl.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
3596}
3597
3598void CallLogWrapper::glTextureBarrier (void)
3599{
3600	if (m_enableLog)
3601		m_log << TestLog::Message << "glTextureBarrier(" << ");" << TestLog::EndMessage;
3602	m_gl.textureBarrier();
3603}
3604
3605void CallLogWrapper::glTextureBuffer (glw::GLuint texture, glw::GLenum internalformat, glw::GLuint buffer)
3606{
3607	if (m_enableLog)
3608		m_log << TestLog::Message << "glTextureBuffer(" << texture << ", " << toHex(internalformat) << ", " << buffer << ");" << TestLog::EndMessage;
3609	m_gl.textureBuffer(texture, internalformat, buffer);
3610}
3611
3612void CallLogWrapper::glTextureBufferRange (glw::GLuint texture, glw::GLenum internalformat, glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size)
3613{
3614	if (m_enableLog)
3615		m_log << TestLog::Message << "glTextureBufferRange(" << texture << ", " << toHex(internalformat) << ", " << buffer << ", " << offset << ", " << size << ");" << TestLog::EndMessage;
3616	m_gl.textureBufferRange(texture, internalformat, buffer, offset, size);
3617}
3618
3619void CallLogWrapper::glTextureParameterIiv (glw::GLuint texture, glw::GLenum pname, const glw::GLint *params)
3620{
3621	if (m_enableLog)
3622		m_log << TestLog::Message << "glTextureParameterIiv(" << texture << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
3623	m_gl.textureParameterIiv(texture, pname, params);
3624}
3625
3626void CallLogWrapper::glTextureParameterIuiv (glw::GLuint texture, glw::GLenum pname, const glw::GLuint *params)
3627{
3628	if (m_enableLog)
3629		m_log << TestLog::Message << "glTextureParameterIuiv(" << texture << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
3630	m_gl.textureParameterIuiv(texture, pname, params);
3631}
3632
3633void CallLogWrapper::glTextureParameterf (glw::GLuint texture, glw::GLenum pname, glw::GLfloat param)
3634{
3635	if (m_enableLog)
3636		m_log << TestLog::Message << "glTextureParameterf(" << texture << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
3637	m_gl.textureParameterf(texture, pname, param);
3638}
3639
3640void CallLogWrapper::glTextureParameterfv (glw::GLuint texture, glw::GLenum pname, const glw::GLfloat *param)
3641{
3642	if (m_enableLog)
3643		m_log << TestLog::Message << "glTextureParameterfv(" << texture << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
3644	m_gl.textureParameterfv(texture, pname, param);
3645}
3646
3647void CallLogWrapper::glTextureParameteri (glw::GLuint texture, glw::GLenum pname, glw::GLint param)
3648{
3649	if (m_enableLog)
3650		m_log << TestLog::Message << "glTextureParameteri(" << texture << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
3651	m_gl.textureParameteri(texture, pname, param);
3652}
3653
3654void CallLogWrapper::glTextureParameteriv (glw::GLuint texture, glw::GLenum pname, const glw::GLint *param)
3655{
3656	if (m_enableLog)
3657		m_log << TestLog::Message << "glTextureParameteriv(" << texture << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
3658	m_gl.textureParameteriv(texture, pname, param);
3659}
3660
3661void CallLogWrapper::glTextureStorage1D (glw::GLuint texture, glw::GLsizei levels, glw::GLenum internalformat, glw::GLsizei width)
3662{
3663	if (m_enableLog)
3664		m_log << TestLog::Message << "glTextureStorage1D(" << texture << ", " << levels << ", " << toHex(internalformat) << ", " << width << ");" << TestLog::EndMessage;
3665	m_gl.textureStorage1D(texture, levels, internalformat, width);
3666}
3667
3668void CallLogWrapper::glTextureStorage2D (glw::GLuint texture, glw::GLsizei levels, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height)
3669{
3670	if (m_enableLog)
3671		m_log << TestLog::Message << "glTextureStorage2D(" << texture << ", " << levels << ", " << toHex(internalformat) << ", " << width << ", " << height << ");" << TestLog::EndMessage;
3672	m_gl.textureStorage2D(texture, levels, internalformat, width, height);
3673}
3674
3675void CallLogWrapper::glTextureStorage2DMultisample (glw::GLuint texture, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLboolean fixedsamplelocations)
3676{
3677	if (m_enableLog)
3678		m_log << TestLog::Message << "glTextureStorage2DMultisample(" << texture << ", " << samples << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << getBooleanStr(fixedsamplelocations) << ");" << TestLog::EndMessage;
3679	m_gl.textureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
3680}
3681
3682void CallLogWrapper::glTextureStorage3D (glw::GLuint texture, glw::GLsizei levels, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth)
3683{
3684	if (m_enableLog)
3685		m_log << TestLog::Message << "glTextureStorage3D(" << texture << ", " << levels << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << depth << ");" << TestLog::EndMessage;
3686	m_gl.textureStorage3D(texture, levels, internalformat, width, height, depth);
3687}
3688
3689void CallLogWrapper::glTextureStorage3DMultisample (glw::GLuint texture, glw::GLsizei samples, glw::GLenum internalformat, glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth, glw::GLboolean fixedsamplelocations)
3690{
3691	if (m_enableLog)
3692		m_log << TestLog::Message << "glTextureStorage3DMultisample(" << texture << ", " << samples << ", " << toHex(internalformat) << ", " << width << ", " << height << ", " << depth << ", " << getBooleanStr(fixedsamplelocations) << ");" << TestLog::EndMessage;
3693	m_gl.textureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
3694}
3695
3696void CallLogWrapper::glTextureSubImage1D (glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLsizei width, glw::GLenum format, glw::GLenum type, const void *pixels)
3697{
3698	if (m_enableLog)
3699		m_log << TestLog::Message << "glTextureSubImage1D(" << texture << ", " << level << ", " << xoffset << ", " << width << ", " << toHex(format) << ", " << toHex(type) << ", " << pixels << ");" << TestLog::EndMessage;
3700	m_gl.textureSubImage1D(texture, level, xoffset, width, format, type, pixels);
3701}
3702
3703void 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)
3704{
3705	if (m_enableLog)
3706		m_log << TestLog::Message << "glTextureSubImage2D(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height << ", " << toHex(format) << ", " << toHex(type) << ", " << pixels << ");" << TestLog::EndMessage;
3707	m_gl.textureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
3708}
3709
3710void 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)
3711{
3712	if (m_enableLog)
3713		m_log << TestLog::Message << "glTextureSubImage3D(" << texture << ", " << level << ", " << xoffset << ", " << yoffset << ", " << zoffset << ", " << width << ", " << height << ", " << depth << ", " << toHex(format) << ", " << toHex(type) << ", " << pixels << ");" << TestLog::EndMessage;
3714	m_gl.textureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
3715}
3716
3717void 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)
3718{
3719	if (m_enableLog)
3720		m_log << TestLog::Message << "glTextureView(" << texture << ", " << toHex(target) << ", " << origtexture << ", " << toHex(internalformat) << ", " << minlevel << ", " << numlevels << ", " << minlayer << ", " << numlayers << ");" << TestLog::EndMessage;
3721	m_gl.textureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
3722}
3723
3724void CallLogWrapper::glTransformFeedbackBufferBase (glw::GLuint xfb, glw::GLuint index, glw::GLuint buffer)
3725{
3726	if (m_enableLog)
3727		m_log << TestLog::Message << "glTransformFeedbackBufferBase(" << xfb << ", " << index << ", " << buffer << ");" << TestLog::EndMessage;
3728	m_gl.transformFeedbackBufferBase(xfb, index, buffer);
3729}
3730
3731void CallLogWrapper::glTransformFeedbackBufferRange (glw::GLuint xfb, glw::GLuint index, glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size)
3732{
3733	if (m_enableLog)
3734		m_log << TestLog::Message << "glTransformFeedbackBufferRange(" << xfb << ", " << index << ", " << buffer << ", " << offset << ", " << size << ");" << TestLog::EndMessage;
3735	m_gl.transformFeedbackBufferRange(xfb, index, buffer, offset, size);
3736}
3737
3738void CallLogWrapper::glTransformFeedbackVaryings (glw::GLuint program, glw::GLsizei count, const glw::GLchar *const*varyings, glw::GLenum bufferMode)
3739{
3740	if (m_enableLog)
3741		m_log << TestLog::Message << "glTransformFeedbackVaryings(" << program << ", " << count << ", " << varyings << ", " << toHex(bufferMode) << ");" << TestLog::EndMessage;
3742	m_gl.transformFeedbackVaryings(program, count, varyings, bufferMode);
3743}
3744
3745void CallLogWrapper::glUniform1d (glw::GLint location, glw::GLdouble x)
3746{
3747	if (m_enableLog)
3748		m_log << TestLog::Message << "glUniform1d(" << location << ", " << x << ");" << TestLog::EndMessage;
3749	m_gl.uniform1d(location, x);
3750}
3751
3752void CallLogWrapper::glUniform1dv (glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
3753{
3754	if (m_enableLog)
3755		m_log << TestLog::Message << "glUniform1dv(" << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
3756	m_gl.uniform1dv(location, count, value);
3757}
3758
3759void CallLogWrapper::glUniform1f (glw::GLint location, glw::GLfloat v0)
3760{
3761	if (m_enableLog)
3762		m_log << TestLog::Message << "glUniform1f(" << location << ", " << v0 << ");" << TestLog::EndMessage;
3763	m_gl.uniform1f(location, v0);
3764}
3765
3766void CallLogWrapper::glUniform1fv (glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
3767{
3768	if (m_enableLog)
3769		m_log << TestLog::Message << "glUniform1fv(" << location << ", " << count << ", " << getPointerStr(value, (count * 1)) << ");" << TestLog::EndMessage;
3770	m_gl.uniform1fv(location, count, value);
3771}
3772
3773void CallLogWrapper::glUniform1i (glw::GLint location, glw::GLint v0)
3774{
3775	if (m_enableLog)
3776		m_log << TestLog::Message << "glUniform1i(" << location << ", " << v0 << ");" << TestLog::EndMessage;
3777	m_gl.uniform1i(location, v0);
3778}
3779
3780void CallLogWrapper::glUniform1iv (glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3781{
3782	if (m_enableLog)
3783		m_log << TestLog::Message << "glUniform1iv(" << location << ", " << count << ", " << getPointerStr(value, (count * 1)) << ");" << TestLog::EndMessage;
3784	m_gl.uniform1iv(location, count, value);
3785}
3786
3787void CallLogWrapper::glUniform1ui (glw::GLint location, glw::GLuint v0)
3788{
3789	if (m_enableLog)
3790		m_log << TestLog::Message << "glUniform1ui(" << location << ", " << v0 << ");" << TestLog::EndMessage;
3791	m_gl.uniform1ui(location, v0);
3792}
3793
3794void CallLogWrapper::glUniform1uiv (glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
3795{
3796	if (m_enableLog)
3797		m_log << TestLog::Message << "glUniform1uiv(" << location << ", " << count << ", " << getPointerStr(value, (count * 1)) << ");" << TestLog::EndMessage;
3798	m_gl.uniform1uiv(location, count, value);
3799}
3800
3801void CallLogWrapper::glUniform2d (glw::GLint location, glw::GLdouble x, glw::GLdouble y)
3802{
3803	if (m_enableLog)
3804		m_log << TestLog::Message << "glUniform2d(" << location << ", " << x << ", " << y << ");" << TestLog::EndMessage;
3805	m_gl.uniform2d(location, x, y);
3806}
3807
3808void CallLogWrapper::glUniform2dv (glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
3809{
3810	if (m_enableLog)
3811		m_log << TestLog::Message << "glUniform2dv(" << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
3812	m_gl.uniform2dv(location, count, value);
3813}
3814
3815void CallLogWrapper::glUniform2f (glw::GLint location, glw::GLfloat v0, glw::GLfloat v1)
3816{
3817	if (m_enableLog)
3818		m_log << TestLog::Message << "glUniform2f(" << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
3819	m_gl.uniform2f(location, v0, v1);
3820}
3821
3822void CallLogWrapper::glUniform2fv (glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
3823{
3824	if (m_enableLog)
3825		m_log << TestLog::Message << "glUniform2fv(" << location << ", " << count << ", " << getPointerStr(value, (count * 2)) << ");" << TestLog::EndMessage;
3826	m_gl.uniform2fv(location, count, value);
3827}
3828
3829void CallLogWrapper::glUniform2i (glw::GLint location, glw::GLint v0, glw::GLint v1)
3830{
3831	if (m_enableLog)
3832		m_log << TestLog::Message << "glUniform2i(" << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
3833	m_gl.uniform2i(location, v0, v1);
3834}
3835
3836void CallLogWrapper::glUniform2iv (glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3837{
3838	if (m_enableLog)
3839		m_log << TestLog::Message << "glUniform2iv(" << location << ", " << count << ", " << getPointerStr(value, (count * 2)) << ");" << TestLog::EndMessage;
3840	m_gl.uniform2iv(location, count, value);
3841}
3842
3843void CallLogWrapper::glUniform2ui (glw::GLint location, glw::GLuint v0, glw::GLuint v1)
3844{
3845	if (m_enableLog)
3846		m_log << TestLog::Message << "glUniform2ui(" << location << ", " << v0 << ", " << v1 << ");" << TestLog::EndMessage;
3847	m_gl.uniform2ui(location, v0, v1);
3848}
3849
3850void CallLogWrapper::glUniform2uiv (glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
3851{
3852	if (m_enableLog)
3853		m_log << TestLog::Message << "glUniform2uiv(" << location << ", " << count << ", " << getPointerStr(value, (count * 2)) << ");" << TestLog::EndMessage;
3854	m_gl.uniform2uiv(location, count, value);
3855}
3856
3857void CallLogWrapper::glUniform3d (glw::GLint location, glw::GLdouble x, glw::GLdouble y, glw::GLdouble z)
3858{
3859	if (m_enableLog)
3860		m_log << TestLog::Message << "glUniform3d(" << location << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
3861	m_gl.uniform3d(location, x, y, z);
3862}
3863
3864void CallLogWrapper::glUniform3dv (glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
3865{
3866	if (m_enableLog)
3867		m_log << TestLog::Message << "glUniform3dv(" << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
3868	m_gl.uniform3dv(location, count, value);
3869}
3870
3871void CallLogWrapper::glUniform3f (glw::GLint location, glw::GLfloat v0, glw::GLfloat v1, glw::GLfloat v2)
3872{
3873	if (m_enableLog)
3874		m_log << TestLog::Message << "glUniform3f(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3875	m_gl.uniform3f(location, v0, v1, v2);
3876}
3877
3878void CallLogWrapper::glUniform3fv (glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
3879{
3880	if (m_enableLog)
3881		m_log << TestLog::Message << "glUniform3fv(" << location << ", " << count << ", " << getPointerStr(value, (count * 3)) << ");" << TestLog::EndMessage;
3882	m_gl.uniform3fv(location, count, value);
3883}
3884
3885void CallLogWrapper::glUniform3i (glw::GLint location, glw::GLint v0, glw::GLint v1, glw::GLint v2)
3886{
3887	if (m_enableLog)
3888		m_log << TestLog::Message << "glUniform3i(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3889	m_gl.uniform3i(location, v0, v1, v2);
3890}
3891
3892void CallLogWrapper::glUniform3iv (glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3893{
3894	if (m_enableLog)
3895		m_log << TestLog::Message << "glUniform3iv(" << location << ", " << count << ", " << getPointerStr(value, (count * 3)) << ");" << TestLog::EndMessage;
3896	m_gl.uniform3iv(location, count, value);
3897}
3898
3899void CallLogWrapper::glUniform3ui (glw::GLint location, glw::GLuint v0, glw::GLuint v1, glw::GLuint v2)
3900{
3901	if (m_enableLog)
3902		m_log << TestLog::Message << "glUniform3ui(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ");" << TestLog::EndMessage;
3903	m_gl.uniform3ui(location, v0, v1, v2);
3904}
3905
3906void CallLogWrapper::glUniform3uiv (glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
3907{
3908	if (m_enableLog)
3909		m_log << TestLog::Message << "glUniform3uiv(" << location << ", " << count << ", " << getPointerStr(value, (count * 3)) << ");" << TestLog::EndMessage;
3910	m_gl.uniform3uiv(location, count, value);
3911}
3912
3913void CallLogWrapper::glUniform4d (glw::GLint location, glw::GLdouble x, glw::GLdouble y, glw::GLdouble z, glw::GLdouble w)
3914{
3915	if (m_enableLog)
3916		m_log << TestLog::Message << "glUniform4d(" << location << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
3917	m_gl.uniform4d(location, x, y, z, w);
3918}
3919
3920void CallLogWrapper::glUniform4dv (glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
3921{
3922	if (m_enableLog)
3923		m_log << TestLog::Message << "glUniform4dv(" << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
3924	m_gl.uniform4dv(location, count, value);
3925}
3926
3927void CallLogWrapper::glUniform4f (glw::GLint location, glw::GLfloat v0, glw::GLfloat v1, glw::GLfloat v2, glw::GLfloat v3)
3928{
3929	if (m_enableLog)
3930		m_log << TestLog::Message << "glUniform4f(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3931	m_gl.uniform4f(location, v0, v1, v2, v3);
3932}
3933
3934void CallLogWrapper::glUniform4fv (glw::GLint location, glw::GLsizei count, const glw::GLfloat *value)
3935{
3936	if (m_enableLog)
3937		m_log << TestLog::Message << "glUniform4fv(" << location << ", " << count << ", " << getPointerStr(value, (count * 4)) << ");" << TestLog::EndMessage;
3938	m_gl.uniform4fv(location, count, value);
3939}
3940
3941void CallLogWrapper::glUniform4i (glw::GLint location, glw::GLint v0, glw::GLint v1, glw::GLint v2, glw::GLint v3)
3942{
3943	if (m_enableLog)
3944		m_log << TestLog::Message << "glUniform4i(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3945	m_gl.uniform4i(location, v0, v1, v2, v3);
3946}
3947
3948void CallLogWrapper::glUniform4iv (glw::GLint location, glw::GLsizei count, const glw::GLint *value)
3949{
3950	if (m_enableLog)
3951		m_log << TestLog::Message << "glUniform4iv(" << location << ", " << count << ", " << getPointerStr(value, (count * 4)) << ");" << TestLog::EndMessage;
3952	m_gl.uniform4iv(location, count, value);
3953}
3954
3955void CallLogWrapper::glUniform4ui (glw::GLint location, glw::GLuint v0, glw::GLuint v1, glw::GLuint v2, glw::GLuint v3)
3956{
3957	if (m_enableLog)
3958		m_log << TestLog::Message << "glUniform4ui(" << location << ", " << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ");" << TestLog::EndMessage;
3959	m_gl.uniform4ui(location, v0, v1, v2, v3);
3960}
3961
3962void CallLogWrapper::glUniform4uiv (glw::GLint location, glw::GLsizei count, const glw::GLuint *value)
3963{
3964	if (m_enableLog)
3965		m_log << TestLog::Message << "glUniform4uiv(" << location << ", " << count << ", " << getPointerStr(value, (count * 4)) << ");" << TestLog::EndMessage;
3966	m_gl.uniform4uiv(location, count, value);
3967}
3968
3969void CallLogWrapper::glUniformBlockBinding (glw::GLuint program, glw::GLuint uniformBlockIndex, glw::GLuint uniformBlockBinding)
3970{
3971	if (m_enableLog)
3972		m_log << TestLog::Message << "glUniformBlockBinding(" << program << ", " << uniformBlockIndex << ", " << uniformBlockBinding << ");" << TestLog::EndMessage;
3973	m_gl.uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
3974}
3975
3976void CallLogWrapper::glUniformMatrix2dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3977{
3978	if (m_enableLog)
3979		m_log << TestLog::Message << "glUniformMatrix2dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
3980	m_gl.uniformMatrix2dv(location, count, transpose, value);
3981}
3982
3983void CallLogWrapper::glUniformMatrix2fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3984{
3985	if (m_enableLog)
3986		m_log << TestLog::Message << "glUniformMatrix2fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 2*2)) << ");" << TestLog::EndMessage;
3987	m_gl.uniformMatrix2fv(location, count, transpose, value);
3988}
3989
3990void CallLogWrapper::glUniformMatrix2x3dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
3991{
3992	if (m_enableLog)
3993		m_log << TestLog::Message << "glUniformMatrix2x3dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
3994	m_gl.uniformMatrix2x3dv(location, count, transpose, value);
3995}
3996
3997void CallLogWrapper::glUniformMatrix2x3fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
3998{
3999	if (m_enableLog)
4000		m_log << TestLog::Message << "glUniformMatrix2x3fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 2*3)) << ");" << TestLog::EndMessage;
4001	m_gl.uniformMatrix2x3fv(location, count, transpose, value);
4002}
4003
4004void CallLogWrapper::glUniformMatrix2x4dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4005{
4006	if (m_enableLog)
4007		m_log << TestLog::Message << "glUniformMatrix2x4dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
4008	m_gl.uniformMatrix2x4dv(location, count, transpose, value);
4009}
4010
4011void CallLogWrapper::glUniformMatrix2x4fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4012{
4013	if (m_enableLog)
4014		m_log << TestLog::Message << "glUniformMatrix2x4fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 2*4)) << ");" << TestLog::EndMessage;
4015	m_gl.uniformMatrix2x4fv(location, count, transpose, value);
4016}
4017
4018void CallLogWrapper::glUniformMatrix3dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4019{
4020	if (m_enableLog)
4021		m_log << TestLog::Message << "glUniformMatrix3dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
4022	m_gl.uniformMatrix3dv(location, count, transpose, value);
4023}
4024
4025void CallLogWrapper::glUniformMatrix3fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4026{
4027	if (m_enableLog)
4028		m_log << TestLog::Message << "glUniformMatrix3fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 3*3)) << ");" << TestLog::EndMessage;
4029	m_gl.uniformMatrix3fv(location, count, transpose, value);
4030}
4031
4032void CallLogWrapper::glUniformMatrix3x2dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4033{
4034	if (m_enableLog)
4035		m_log << TestLog::Message << "glUniformMatrix3x2dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
4036	m_gl.uniformMatrix3x2dv(location, count, transpose, value);
4037}
4038
4039void CallLogWrapper::glUniformMatrix3x2fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4040{
4041	if (m_enableLog)
4042		m_log << TestLog::Message << "glUniformMatrix3x2fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 3*2)) << ");" << TestLog::EndMessage;
4043	m_gl.uniformMatrix3x2fv(location, count, transpose, value);
4044}
4045
4046void CallLogWrapper::glUniformMatrix3x4dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4047{
4048	if (m_enableLog)
4049		m_log << TestLog::Message << "glUniformMatrix3x4dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
4050	m_gl.uniformMatrix3x4dv(location, count, transpose, value);
4051}
4052
4053void CallLogWrapper::glUniformMatrix3x4fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4054{
4055	if (m_enableLog)
4056		m_log << TestLog::Message << "glUniformMatrix3x4fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 3*4)) << ");" << TestLog::EndMessage;
4057	m_gl.uniformMatrix3x4fv(location, count, transpose, value);
4058}
4059
4060void CallLogWrapper::glUniformMatrix4dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4061{
4062	if (m_enableLog)
4063		m_log << TestLog::Message << "glUniformMatrix4dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
4064	m_gl.uniformMatrix4dv(location, count, transpose, value);
4065}
4066
4067void CallLogWrapper::glUniformMatrix4fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4068{
4069	if (m_enableLog)
4070		m_log << TestLog::Message << "glUniformMatrix4fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 4*4)) << ");" << TestLog::EndMessage;
4071	m_gl.uniformMatrix4fv(location, count, transpose, value);
4072}
4073
4074void CallLogWrapper::glUniformMatrix4x2dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4075{
4076	if (m_enableLog)
4077		m_log << TestLog::Message << "glUniformMatrix4x2dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
4078	m_gl.uniformMatrix4x2dv(location, count, transpose, value);
4079}
4080
4081void CallLogWrapper::glUniformMatrix4x2fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4082{
4083	if (m_enableLog)
4084		m_log << TestLog::Message << "glUniformMatrix4x2fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 4*2)) << ");" << TestLog::EndMessage;
4085	m_gl.uniformMatrix4x2fv(location, count, transpose, value);
4086}
4087
4088void CallLogWrapper::glUniformMatrix4x3dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
4089{
4090	if (m_enableLog)
4091		m_log << TestLog::Message << "glUniformMatrix4x3dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
4092	m_gl.uniformMatrix4x3dv(location, count, transpose, value);
4093}
4094
4095void CallLogWrapper::glUniformMatrix4x3fv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLfloat *value)
4096{
4097	if (m_enableLog)
4098		m_log << TestLog::Message << "glUniformMatrix4x3fv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << getPointerStr(value, (count * 4*3)) << ");" << TestLog::EndMessage;
4099	m_gl.uniformMatrix4x3fv(location, count, transpose, value);
4100}
4101
4102void CallLogWrapper::glUniformSubroutinesuiv (glw::GLenum shadertype, glw::GLsizei count, const glw::GLuint *indices)
4103{
4104	if (m_enableLog)
4105		m_log << TestLog::Message << "glUniformSubroutinesuiv(" << toHex(shadertype) << ", " << count << ", " << indices << ");" << TestLog::EndMessage;
4106	m_gl.uniformSubroutinesuiv(shadertype, count, indices);
4107}
4108
4109glw::GLboolean CallLogWrapper::glUnmapBuffer (glw::GLenum target)
4110{
4111	if (m_enableLog)
4112		m_log << TestLog::Message << "glUnmapBuffer(" << getBufferTargetStr(target) << ");" << TestLog::EndMessage;
4113	glw::GLboolean returnValue = m_gl.unmapBuffer(target);
4114	if (m_enableLog)
4115		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
4116	return returnValue;
4117}
4118
4119glw::GLboolean CallLogWrapper::glUnmapNamedBuffer (glw::GLuint buffer)
4120{
4121	if (m_enableLog)
4122		m_log << TestLog::Message << "glUnmapNamedBuffer(" << buffer << ");" << TestLog::EndMessage;
4123	glw::GLboolean returnValue = m_gl.unmapNamedBuffer(buffer);
4124	if (m_enableLog)
4125		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
4126	return returnValue;
4127}
4128
4129void CallLogWrapper::glUseProgram (glw::GLuint program)
4130{
4131	if (m_enableLog)
4132		m_log << TestLog::Message << "glUseProgram(" << program << ");" << TestLog::EndMessage;
4133	m_gl.useProgram(program);
4134}
4135
4136void CallLogWrapper::glUseProgramStages (glw::GLuint pipeline, glw::GLbitfield stages, glw::GLuint program)
4137{
4138	if (m_enableLog)
4139		m_log << TestLog::Message << "glUseProgramStages(" << pipeline << ", " << getShaderTypeMaskStr(stages) << ", " << program << ");" << TestLog::EndMessage;
4140	m_gl.useProgramStages(pipeline, stages, program);
4141}
4142
4143void CallLogWrapper::glValidateProgram (glw::GLuint program)
4144{
4145	if (m_enableLog)
4146		m_log << TestLog::Message << "glValidateProgram(" << program << ");" << TestLog::EndMessage;
4147	m_gl.validateProgram(program);
4148}
4149
4150void CallLogWrapper::glValidateProgramPipeline (glw::GLuint pipeline)
4151{
4152	if (m_enableLog)
4153		m_log << TestLog::Message << "glValidateProgramPipeline(" << pipeline << ");" << TestLog::EndMessage;
4154	m_gl.validateProgramPipeline(pipeline);
4155}
4156
4157void CallLogWrapper::glVertexArrayAttribBinding (glw::GLuint vaobj, glw::GLuint attribindex, glw::GLuint bindingindex)
4158{
4159	if (m_enableLog)
4160		m_log << TestLog::Message << "glVertexArrayAttribBinding(" << vaobj << ", " << attribindex << ", " << bindingindex << ");" << TestLog::EndMessage;
4161	m_gl.vertexArrayAttribBinding(vaobj, attribindex, bindingindex);
4162}
4163
4164void CallLogWrapper::glVertexArrayAttribFormat (glw::GLuint vaobj, glw::GLuint attribindex, glw::GLint size, glw::GLenum type, glw::GLboolean normalized, glw::GLuint relativeoffset)
4165{
4166	if (m_enableLog)
4167		m_log << TestLog::Message << "glVertexArrayAttribFormat(" << vaobj << ", " << attribindex << ", " << size << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << relativeoffset << ");" << TestLog::EndMessage;
4168	m_gl.vertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
4169}
4170
4171void CallLogWrapper::glVertexArrayAttribIFormat (glw::GLuint vaobj, glw::GLuint attribindex, glw::GLint size, glw::GLenum type, glw::GLuint relativeoffset)
4172{
4173	if (m_enableLog)
4174		m_log << TestLog::Message << "glVertexArrayAttribIFormat(" << vaobj << ", " << attribindex << ", " << size << ", " << toHex(type) << ", " << relativeoffset << ");" << TestLog::EndMessage;
4175	m_gl.vertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
4176}
4177
4178void CallLogWrapper::glVertexArrayAttribLFormat (glw::GLuint vaobj, glw::GLuint attribindex, glw::GLint size, glw::GLenum type, glw::GLuint relativeoffset)
4179{
4180	if (m_enableLog)
4181		m_log << TestLog::Message << "glVertexArrayAttribLFormat(" << vaobj << ", " << attribindex << ", " << size << ", " << toHex(type) << ", " << relativeoffset << ");" << TestLog::EndMessage;
4182	m_gl.vertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
4183}
4184
4185void CallLogWrapper::glVertexArrayBindingDivisor (glw::GLuint vaobj, glw::GLuint bindingindex, glw::GLuint divisor)
4186{
4187	if (m_enableLog)
4188		m_log << TestLog::Message << "glVertexArrayBindingDivisor(" << vaobj << ", " << bindingindex << ", " << divisor << ");" << TestLog::EndMessage;
4189	m_gl.vertexArrayBindingDivisor(vaobj, bindingindex, divisor);
4190}
4191
4192void CallLogWrapper::glVertexArrayElementBuffer (glw::GLuint vaobj, glw::GLuint buffer)
4193{
4194	if (m_enableLog)
4195		m_log << TestLog::Message << "glVertexArrayElementBuffer(" << vaobj << ", " << buffer << ");" << TestLog::EndMessage;
4196	m_gl.vertexArrayElementBuffer(vaobj, buffer);
4197}
4198
4199void CallLogWrapper::glVertexArrayVertexBuffer (glw::GLuint vaobj, glw::GLuint bindingindex, glw::GLuint buffer, glw::GLintptr offset, glw::GLsizei stride)
4200{
4201	if (m_enableLog)
4202		m_log << TestLog::Message << "glVertexArrayVertexBuffer(" << vaobj << ", " << bindingindex << ", " << buffer << ", " << offset << ", " << stride << ");" << TestLog::EndMessage;
4203	m_gl.vertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
4204}
4205
4206void CallLogWrapper::glVertexArrayVertexBuffers (glw::GLuint vaobj, glw::GLuint first, glw::GLsizei count, const glw::GLuint *buffers, const glw::GLintptr *offsets, const glw::GLsizei *strides)
4207{
4208	if (m_enableLog)
4209		m_log << TestLog::Message << "glVertexArrayVertexBuffers(" << vaobj << ", " << first << ", " << count << ", " << buffers << ", " << offsets << ", " << strides << ");" << TestLog::EndMessage;
4210	m_gl.vertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
4211}
4212
4213void CallLogWrapper::glVertexAttrib1d (glw::GLuint index, glw::GLdouble x)
4214{
4215	if (m_enableLog)
4216		m_log << TestLog::Message << "glVertexAttrib1d(" << index << ", " << x << ");" << TestLog::EndMessage;
4217	m_gl.vertexAttrib1d(index, x);
4218}
4219
4220void CallLogWrapper::glVertexAttrib1dv (glw::GLuint index, const glw::GLdouble *v)
4221{
4222	if (m_enableLog)
4223		m_log << TestLog::Message << "glVertexAttrib1dv(" << index << ", " << getPointerStr(v, 1) << ");" << TestLog::EndMessage;
4224	m_gl.vertexAttrib1dv(index, v);
4225}
4226
4227void CallLogWrapper::glVertexAttrib1f (glw::GLuint index, glw::GLfloat x)
4228{
4229	if (m_enableLog)
4230		m_log << TestLog::Message << "glVertexAttrib1f(" << index << ", " << x << ");" << TestLog::EndMessage;
4231	m_gl.vertexAttrib1f(index, x);
4232}
4233
4234void CallLogWrapper::glVertexAttrib1fv (glw::GLuint index, const glw::GLfloat *v)
4235{
4236	if (m_enableLog)
4237		m_log << TestLog::Message << "glVertexAttrib1fv(" << index << ", " << getPointerStr(v, 1) << ");" << TestLog::EndMessage;
4238	m_gl.vertexAttrib1fv(index, v);
4239}
4240
4241void CallLogWrapper::glVertexAttrib1s (glw::GLuint index, glw::GLshort x)
4242{
4243	if (m_enableLog)
4244		m_log << TestLog::Message << "glVertexAttrib1s(" << index << ", " << x << ");" << TestLog::EndMessage;
4245	m_gl.vertexAttrib1s(index, x);
4246}
4247
4248void CallLogWrapper::glVertexAttrib1sv (glw::GLuint index, const glw::GLshort *v)
4249{
4250	if (m_enableLog)
4251		m_log << TestLog::Message << "glVertexAttrib1sv(" << index << ", " << getPointerStr(v, 1) << ");" << TestLog::EndMessage;
4252	m_gl.vertexAttrib1sv(index, v);
4253}
4254
4255void CallLogWrapper::glVertexAttrib2d (glw::GLuint index, glw::GLdouble x, glw::GLdouble y)
4256{
4257	if (m_enableLog)
4258		m_log << TestLog::Message << "glVertexAttrib2d(" << index << ", " << x << ", " << y << ");" << TestLog::EndMessage;
4259	m_gl.vertexAttrib2d(index, x, y);
4260}
4261
4262void CallLogWrapper::glVertexAttrib2dv (glw::GLuint index, const glw::GLdouble *v)
4263{
4264	if (m_enableLog)
4265		m_log << TestLog::Message << "glVertexAttrib2dv(" << index << ", " << getPointerStr(v, 2) << ");" << TestLog::EndMessage;
4266	m_gl.vertexAttrib2dv(index, v);
4267}
4268
4269void CallLogWrapper::glVertexAttrib2f (glw::GLuint index, glw::GLfloat x, glw::GLfloat y)
4270{
4271	if (m_enableLog)
4272		m_log << TestLog::Message << "glVertexAttrib2f(" << index << ", " << x << ", " << y << ");" << TestLog::EndMessage;
4273	m_gl.vertexAttrib2f(index, x, y);
4274}
4275
4276void CallLogWrapper::glVertexAttrib2fv (glw::GLuint index, const glw::GLfloat *v)
4277{
4278	if (m_enableLog)
4279		m_log << TestLog::Message << "glVertexAttrib2fv(" << index << ", " << getPointerStr(v, 2) << ");" << TestLog::EndMessage;
4280	m_gl.vertexAttrib2fv(index, v);
4281}
4282
4283void CallLogWrapper::glVertexAttrib2s (glw::GLuint index, glw::GLshort x, glw::GLshort y)
4284{
4285	if (m_enableLog)
4286		m_log << TestLog::Message << "glVertexAttrib2s(" << index << ", " << x << ", " << y << ");" << TestLog::EndMessage;
4287	m_gl.vertexAttrib2s(index, x, y);
4288}
4289
4290void CallLogWrapper::glVertexAttrib2sv (glw::GLuint index, const glw::GLshort *v)
4291{
4292	if (m_enableLog)
4293		m_log << TestLog::Message << "glVertexAttrib2sv(" << index << ", " << getPointerStr(v, 2) << ");" << TestLog::EndMessage;
4294	m_gl.vertexAttrib2sv(index, v);
4295}
4296
4297void CallLogWrapper::glVertexAttrib3d (glw::GLuint index, glw::GLdouble x, glw::GLdouble y, glw::GLdouble z)
4298{
4299	if (m_enableLog)
4300		m_log << TestLog::Message << "glVertexAttrib3d(" << index << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
4301	m_gl.vertexAttrib3d(index, x, y, z);
4302}
4303
4304void CallLogWrapper::glVertexAttrib3dv (glw::GLuint index, const glw::GLdouble *v)
4305{
4306	if (m_enableLog)
4307		m_log << TestLog::Message << "glVertexAttrib3dv(" << index << ", " << getPointerStr(v, 3) << ");" << TestLog::EndMessage;
4308	m_gl.vertexAttrib3dv(index, v);
4309}
4310
4311void CallLogWrapper::glVertexAttrib3f (glw::GLuint index, glw::GLfloat x, glw::GLfloat y, glw::GLfloat z)
4312{
4313	if (m_enableLog)
4314		m_log << TestLog::Message << "glVertexAttrib3f(" << index << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
4315	m_gl.vertexAttrib3f(index, x, y, z);
4316}
4317
4318void CallLogWrapper::glVertexAttrib3fv (glw::GLuint index, const glw::GLfloat *v)
4319{
4320	if (m_enableLog)
4321		m_log << TestLog::Message << "glVertexAttrib3fv(" << index << ", " << getPointerStr(v, 3) << ");" << TestLog::EndMessage;
4322	m_gl.vertexAttrib3fv(index, v);
4323}
4324
4325void CallLogWrapper::glVertexAttrib3s (glw::GLuint index, glw::GLshort x, glw::GLshort y, glw::GLshort z)
4326{
4327	if (m_enableLog)
4328		m_log << TestLog::Message << "glVertexAttrib3s(" << index << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
4329	m_gl.vertexAttrib3s(index, x, y, z);
4330}
4331
4332void CallLogWrapper::glVertexAttrib3sv (glw::GLuint index, const glw::GLshort *v)
4333{
4334	if (m_enableLog)
4335		m_log << TestLog::Message << "glVertexAttrib3sv(" << index << ", " << getPointerStr(v, 3) << ");" << TestLog::EndMessage;
4336	m_gl.vertexAttrib3sv(index, v);
4337}
4338
4339void CallLogWrapper::glVertexAttrib4Nbv (glw::GLuint index, const glw::GLbyte *v)
4340{
4341	if (m_enableLog)
4342		m_log << TestLog::Message << "glVertexAttrib4Nbv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4343	m_gl.vertexAttrib4Nbv(index, v);
4344}
4345
4346void CallLogWrapper::glVertexAttrib4Niv (glw::GLuint index, const glw::GLint *v)
4347{
4348	if (m_enableLog)
4349		m_log << TestLog::Message << "glVertexAttrib4Niv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4350	m_gl.vertexAttrib4Niv(index, v);
4351}
4352
4353void CallLogWrapper::glVertexAttrib4Nsv (glw::GLuint index, const glw::GLshort *v)
4354{
4355	if (m_enableLog)
4356		m_log << TestLog::Message << "glVertexAttrib4Nsv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4357	m_gl.vertexAttrib4Nsv(index, v);
4358}
4359
4360void CallLogWrapper::glVertexAttrib4Nub (glw::GLuint index, glw::GLubyte x, glw::GLubyte y, glw::GLubyte z, glw::GLubyte w)
4361{
4362	if (m_enableLog)
4363		m_log << TestLog::Message << "glVertexAttrib4Nub(" << index << ", " << toHex(x) << ", " << toHex(y) << ", " << toHex(z) << ", " << toHex(w) << ");" << TestLog::EndMessage;
4364	m_gl.vertexAttrib4Nub(index, x, y, z, w);
4365}
4366
4367void CallLogWrapper::glVertexAttrib4Nubv (glw::GLuint index, const glw::GLubyte *v)
4368{
4369	if (m_enableLog)
4370		m_log << TestLog::Message << "glVertexAttrib4Nubv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4371	m_gl.vertexAttrib4Nubv(index, v);
4372}
4373
4374void CallLogWrapper::glVertexAttrib4Nuiv (glw::GLuint index, const glw::GLuint *v)
4375{
4376	if (m_enableLog)
4377		m_log << TestLog::Message << "glVertexAttrib4Nuiv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4378	m_gl.vertexAttrib4Nuiv(index, v);
4379}
4380
4381void CallLogWrapper::glVertexAttrib4Nusv (glw::GLuint index, const glw::GLushort *v)
4382{
4383	if (m_enableLog)
4384		m_log << TestLog::Message << "glVertexAttrib4Nusv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4385	m_gl.vertexAttrib4Nusv(index, v);
4386}
4387
4388void CallLogWrapper::glVertexAttrib4bv (glw::GLuint index, const glw::GLbyte *v)
4389{
4390	if (m_enableLog)
4391		m_log << TestLog::Message << "glVertexAttrib4bv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4392	m_gl.vertexAttrib4bv(index, v);
4393}
4394
4395void CallLogWrapper::glVertexAttrib4d (glw::GLuint index, glw::GLdouble x, glw::GLdouble y, glw::GLdouble z, glw::GLdouble w)
4396{
4397	if (m_enableLog)
4398		m_log << TestLog::Message << "glVertexAttrib4d(" << index << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
4399	m_gl.vertexAttrib4d(index, x, y, z, w);
4400}
4401
4402void CallLogWrapper::glVertexAttrib4dv (glw::GLuint index, const glw::GLdouble *v)
4403{
4404	if (m_enableLog)
4405		m_log << TestLog::Message << "glVertexAttrib4dv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4406	m_gl.vertexAttrib4dv(index, v);
4407}
4408
4409void CallLogWrapper::glVertexAttrib4f (glw::GLuint index, glw::GLfloat x, glw::GLfloat y, glw::GLfloat z, glw::GLfloat w)
4410{
4411	if (m_enableLog)
4412		m_log << TestLog::Message << "glVertexAttrib4f(" << index << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
4413	m_gl.vertexAttrib4f(index, x, y, z, w);
4414}
4415
4416void CallLogWrapper::glVertexAttrib4fv (glw::GLuint index, const glw::GLfloat *v)
4417{
4418	if (m_enableLog)
4419		m_log << TestLog::Message << "glVertexAttrib4fv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4420	m_gl.vertexAttrib4fv(index, v);
4421}
4422
4423void CallLogWrapper::glVertexAttrib4iv (glw::GLuint index, const glw::GLint *v)
4424{
4425	if (m_enableLog)
4426		m_log << TestLog::Message << "glVertexAttrib4iv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4427	m_gl.vertexAttrib4iv(index, v);
4428}
4429
4430void CallLogWrapper::glVertexAttrib4s (glw::GLuint index, glw::GLshort x, glw::GLshort y, glw::GLshort z, glw::GLshort w)
4431{
4432	if (m_enableLog)
4433		m_log << TestLog::Message << "glVertexAttrib4s(" << index << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
4434	m_gl.vertexAttrib4s(index, x, y, z, w);
4435}
4436
4437void CallLogWrapper::glVertexAttrib4sv (glw::GLuint index, const glw::GLshort *v)
4438{
4439	if (m_enableLog)
4440		m_log << TestLog::Message << "glVertexAttrib4sv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4441	m_gl.vertexAttrib4sv(index, v);
4442}
4443
4444void CallLogWrapper::glVertexAttrib4ubv (glw::GLuint index, const glw::GLubyte *v)
4445{
4446	if (m_enableLog)
4447		m_log << TestLog::Message << "glVertexAttrib4ubv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4448	m_gl.vertexAttrib4ubv(index, v);
4449}
4450
4451void CallLogWrapper::glVertexAttrib4uiv (glw::GLuint index, const glw::GLuint *v)
4452{
4453	if (m_enableLog)
4454		m_log << TestLog::Message << "glVertexAttrib4uiv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4455	m_gl.vertexAttrib4uiv(index, v);
4456}
4457
4458void CallLogWrapper::glVertexAttrib4usv (glw::GLuint index, const glw::GLushort *v)
4459{
4460	if (m_enableLog)
4461		m_log << TestLog::Message << "glVertexAttrib4usv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4462	m_gl.vertexAttrib4usv(index, v);
4463}
4464
4465void CallLogWrapper::glVertexAttribBinding (glw::GLuint attribindex, glw::GLuint bindingindex)
4466{
4467	if (m_enableLog)
4468		m_log << TestLog::Message << "glVertexAttribBinding(" << attribindex << ", " << bindingindex << ");" << TestLog::EndMessage;
4469	m_gl.vertexAttribBinding(attribindex, bindingindex);
4470}
4471
4472void CallLogWrapper::glVertexAttribDivisor (glw::GLuint index, glw::GLuint divisor)
4473{
4474	if (m_enableLog)
4475		m_log << TestLog::Message << "glVertexAttribDivisor(" << index << ", " << divisor << ");" << TestLog::EndMessage;
4476	m_gl.vertexAttribDivisor(index, divisor);
4477}
4478
4479void CallLogWrapper::glVertexAttribFormat (glw::GLuint attribindex, glw::GLint size, glw::GLenum type, glw::GLboolean normalized, glw::GLuint relativeoffset)
4480{
4481	if (m_enableLog)
4482		m_log << TestLog::Message << "glVertexAttribFormat(" << attribindex << ", " << size << ", " << getTypeStr(type) << ", " << getBooleanStr(normalized) << ", " << relativeoffset << ");" << TestLog::EndMessage;
4483	m_gl.vertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
4484}
4485
4486void CallLogWrapper::glVertexAttribI1i (glw::GLuint index, glw::GLint x)
4487{
4488	if (m_enableLog)
4489		m_log << TestLog::Message << "glVertexAttribI1i(" << index << ", " << x << ");" << TestLog::EndMessage;
4490	m_gl.vertexAttribI1i(index, x);
4491}
4492
4493void CallLogWrapper::glVertexAttribI1iv (glw::GLuint index, const glw::GLint *v)
4494{
4495	if (m_enableLog)
4496		m_log << TestLog::Message << "glVertexAttribI1iv(" << index << ", " << getPointerStr(v, 1) << ");" << TestLog::EndMessage;
4497	m_gl.vertexAttribI1iv(index, v);
4498}
4499
4500void CallLogWrapper::glVertexAttribI1ui (glw::GLuint index, glw::GLuint x)
4501{
4502	if (m_enableLog)
4503		m_log << TestLog::Message << "glVertexAttribI1ui(" << index << ", " << x << ");" << TestLog::EndMessage;
4504	m_gl.vertexAttribI1ui(index, x);
4505}
4506
4507void CallLogWrapper::glVertexAttribI1uiv (glw::GLuint index, const glw::GLuint *v)
4508{
4509	if (m_enableLog)
4510		m_log << TestLog::Message << "glVertexAttribI1uiv(" << index << ", " << getPointerStr(v, 1) << ");" << TestLog::EndMessage;
4511	m_gl.vertexAttribI1uiv(index, v);
4512}
4513
4514void CallLogWrapper::glVertexAttribI2i (glw::GLuint index, glw::GLint x, glw::GLint y)
4515{
4516	if (m_enableLog)
4517		m_log << TestLog::Message << "glVertexAttribI2i(" << index << ", " << x << ", " << y << ");" << TestLog::EndMessage;
4518	m_gl.vertexAttribI2i(index, x, y);
4519}
4520
4521void CallLogWrapper::glVertexAttribI2iv (glw::GLuint index, const glw::GLint *v)
4522{
4523	if (m_enableLog)
4524		m_log << TestLog::Message << "glVertexAttribI2iv(" << index << ", " << getPointerStr(v, 2) << ");" << TestLog::EndMessage;
4525	m_gl.vertexAttribI2iv(index, v);
4526}
4527
4528void CallLogWrapper::glVertexAttribI2ui (glw::GLuint index, glw::GLuint x, glw::GLuint y)
4529{
4530	if (m_enableLog)
4531		m_log << TestLog::Message << "glVertexAttribI2ui(" << index << ", " << x << ", " << y << ");" << TestLog::EndMessage;
4532	m_gl.vertexAttribI2ui(index, x, y);
4533}
4534
4535void CallLogWrapper::glVertexAttribI2uiv (glw::GLuint index, const glw::GLuint *v)
4536{
4537	if (m_enableLog)
4538		m_log << TestLog::Message << "glVertexAttribI2uiv(" << index << ", " << getPointerStr(v, 2) << ");" << TestLog::EndMessage;
4539	m_gl.vertexAttribI2uiv(index, v);
4540}
4541
4542void CallLogWrapper::glVertexAttribI3i (glw::GLuint index, glw::GLint x, glw::GLint y, glw::GLint z)
4543{
4544	if (m_enableLog)
4545		m_log << TestLog::Message << "glVertexAttribI3i(" << index << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
4546	m_gl.vertexAttribI3i(index, x, y, z);
4547}
4548
4549void CallLogWrapper::glVertexAttribI3iv (glw::GLuint index, const glw::GLint *v)
4550{
4551	if (m_enableLog)
4552		m_log << TestLog::Message << "glVertexAttribI3iv(" << index << ", " << getPointerStr(v, 3) << ");" << TestLog::EndMessage;
4553	m_gl.vertexAttribI3iv(index, v);
4554}
4555
4556void CallLogWrapper::glVertexAttribI3ui (glw::GLuint index, glw::GLuint x, glw::GLuint y, glw::GLuint z)
4557{
4558	if (m_enableLog)
4559		m_log << TestLog::Message << "glVertexAttribI3ui(" << index << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
4560	m_gl.vertexAttribI3ui(index, x, y, z);
4561}
4562
4563void CallLogWrapper::glVertexAttribI3uiv (glw::GLuint index, const glw::GLuint *v)
4564{
4565	if (m_enableLog)
4566		m_log << TestLog::Message << "glVertexAttribI3uiv(" << index << ", " << getPointerStr(v, 3) << ");" << TestLog::EndMessage;
4567	m_gl.vertexAttribI3uiv(index, v);
4568}
4569
4570void CallLogWrapper::glVertexAttribI4bv (glw::GLuint index, const glw::GLbyte *v)
4571{
4572	if (m_enableLog)
4573		m_log << TestLog::Message << "glVertexAttribI4bv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4574	m_gl.vertexAttribI4bv(index, v);
4575}
4576
4577void CallLogWrapper::glVertexAttribI4i (glw::GLuint index, glw::GLint x, glw::GLint y, glw::GLint z, glw::GLint w)
4578{
4579	if (m_enableLog)
4580		m_log << TestLog::Message << "glVertexAttribI4i(" << index << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
4581	m_gl.vertexAttribI4i(index, x, y, z, w);
4582}
4583
4584void CallLogWrapper::glVertexAttribI4iv (glw::GLuint index, const glw::GLint *v)
4585{
4586	if (m_enableLog)
4587		m_log << TestLog::Message << "glVertexAttribI4iv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4588	m_gl.vertexAttribI4iv(index, v);
4589}
4590
4591void CallLogWrapper::glVertexAttribI4sv (glw::GLuint index, const glw::GLshort *v)
4592{
4593	if (m_enableLog)
4594		m_log << TestLog::Message << "glVertexAttribI4sv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4595	m_gl.vertexAttribI4sv(index, v);
4596}
4597
4598void CallLogWrapper::glVertexAttribI4ubv (glw::GLuint index, const glw::GLubyte *v)
4599{
4600	if (m_enableLog)
4601		m_log << TestLog::Message << "glVertexAttribI4ubv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4602	m_gl.vertexAttribI4ubv(index, v);
4603}
4604
4605void CallLogWrapper::glVertexAttribI4ui (glw::GLuint index, glw::GLuint x, glw::GLuint y, glw::GLuint z, glw::GLuint w)
4606{
4607	if (m_enableLog)
4608		m_log << TestLog::Message << "glVertexAttribI4ui(" << index << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
4609	m_gl.vertexAttribI4ui(index, x, y, z, w);
4610}
4611
4612void CallLogWrapper::glVertexAttribI4uiv (glw::GLuint index, const glw::GLuint *v)
4613{
4614	if (m_enableLog)
4615		m_log << TestLog::Message << "glVertexAttribI4uiv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4616	m_gl.vertexAttribI4uiv(index, v);
4617}
4618
4619void CallLogWrapper::glVertexAttribI4usv (glw::GLuint index, const glw::GLushort *v)
4620{
4621	if (m_enableLog)
4622		m_log << TestLog::Message << "glVertexAttribI4usv(" << index << ", " << getPointerStr(v, 4) << ");" << TestLog::EndMessage;
4623	m_gl.vertexAttribI4usv(index, v);
4624}
4625
4626void CallLogWrapper::glVertexAttribIFormat (glw::GLuint attribindex, glw::GLint size, glw::GLenum type, glw::GLuint relativeoffset)
4627{
4628	if (m_enableLog)
4629		m_log << TestLog::Message << "glVertexAttribIFormat(" << attribindex << ", " << size << ", " << getTypeStr(type) << ", " << relativeoffset << ");" << TestLog::EndMessage;
4630	m_gl.vertexAttribIFormat(attribindex, size, type, relativeoffset);
4631}
4632
4633void CallLogWrapper::glVertexAttribIPointer (glw::GLuint index, glw::GLint size, glw::GLenum type, glw::GLsizei stride, const void *pointer)
4634{
4635	if (m_enableLog)
4636		m_log << TestLog::Message << "glVertexAttribIPointer(" << index << ", " << size << ", " << getTypeStr(type) << ", " << stride << ", " << pointer << ");" << TestLog::EndMessage;
4637	m_gl.vertexAttribIPointer(index, size, type, stride, pointer);
4638}
4639
4640void CallLogWrapper::glVertexAttribL1d (glw::GLuint index, glw::GLdouble x)
4641{
4642	if (m_enableLog)
4643		m_log << TestLog::Message << "glVertexAttribL1d(" << index << ", " << x << ");" << TestLog::EndMessage;
4644	m_gl.vertexAttribL1d(index, x);
4645}
4646
4647void CallLogWrapper::glVertexAttribL1dv (glw::GLuint index, const glw::GLdouble *v)
4648{
4649	if (m_enableLog)
4650		m_log << TestLog::Message << "glVertexAttribL1dv(" << index << ", " << v << ");" << TestLog::EndMessage;
4651	m_gl.vertexAttribL1dv(index, v);
4652}
4653
4654void CallLogWrapper::glVertexAttribL2d (glw::GLuint index, glw::GLdouble x, glw::GLdouble y)
4655{
4656	if (m_enableLog)
4657		m_log << TestLog::Message << "glVertexAttribL2d(" << index << ", " << x << ", " << y << ");" << TestLog::EndMessage;
4658	m_gl.vertexAttribL2d(index, x, y);
4659}
4660
4661void CallLogWrapper::glVertexAttribL2dv (glw::GLuint index, const glw::GLdouble *v)
4662{
4663	if (m_enableLog)
4664		m_log << TestLog::Message << "glVertexAttribL2dv(" << index << ", " << v << ");" << TestLog::EndMessage;
4665	m_gl.vertexAttribL2dv(index, v);
4666}
4667
4668void CallLogWrapper::glVertexAttribL3d (glw::GLuint index, glw::GLdouble x, glw::GLdouble y, glw::GLdouble z)
4669{
4670	if (m_enableLog)
4671		m_log << TestLog::Message << "glVertexAttribL3d(" << index << ", " << x << ", " << y << ", " << z << ");" << TestLog::EndMessage;
4672	m_gl.vertexAttribL3d(index, x, y, z);
4673}
4674
4675void CallLogWrapper::glVertexAttribL3dv (glw::GLuint index, const glw::GLdouble *v)
4676{
4677	if (m_enableLog)
4678		m_log << TestLog::Message << "glVertexAttribL3dv(" << index << ", " << v << ");" << TestLog::EndMessage;
4679	m_gl.vertexAttribL3dv(index, v);
4680}
4681
4682void CallLogWrapper::glVertexAttribL4d (glw::GLuint index, glw::GLdouble x, glw::GLdouble y, glw::GLdouble z, glw::GLdouble w)
4683{
4684	if (m_enableLog)
4685		m_log << TestLog::Message << "glVertexAttribL4d(" << index << ", " << x << ", " << y << ", " << z << ", " << w << ");" << TestLog::EndMessage;
4686	m_gl.vertexAttribL4d(index, x, y, z, w);
4687}
4688
4689void CallLogWrapper::glVertexAttribL4dv (glw::GLuint index, const glw::GLdouble *v)
4690{
4691	if (m_enableLog)
4692		m_log << TestLog::Message << "glVertexAttribL4dv(" << index << ", " << v << ");" << TestLog::EndMessage;
4693	m_gl.vertexAttribL4dv(index, v);
4694}
4695
4696void CallLogWrapper::glVertexAttribLFormat (glw::GLuint attribindex, glw::GLint size, glw::GLenum type, glw::GLuint relativeoffset)
4697{
4698	if (m_enableLog)
4699		m_log << TestLog::Message << "glVertexAttribLFormat(" << attribindex << ", " << size << ", " << toHex(type) << ", " << relativeoffset << ");" << TestLog::EndMessage;
4700	m_gl.vertexAttribLFormat(attribindex, size, type, relativeoffset);
4701}
4702
4703void CallLogWrapper::glVertexAttribLPointer (glw::GLuint index, glw::GLint size, glw::GLenum type, glw::GLsizei stride, const void *pointer)
4704{
4705	if (m_enableLog)
4706		m_log << TestLog::Message << "glVertexAttribLPointer(" << index << ", " << size << ", " << toHex(type) << ", " << stride << ", " << pointer << ");" << TestLog::EndMessage;
4707	m_gl.vertexAttribLPointer(index, size, type, stride, pointer);
4708}
4709
4710void CallLogWrapper::glVertexAttribP1ui (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, glw::GLuint value)
4711{
4712	if (m_enableLog)
4713		m_log << TestLog::Message << "glVertexAttribP1ui(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
4714	m_gl.vertexAttribP1ui(index, type, normalized, value);
4715}
4716
4717void CallLogWrapper::glVertexAttribP1uiv (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, const glw::GLuint *value)
4718{
4719	if (m_enableLog)
4720		m_log << TestLog::Message << "glVertexAttribP1uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
4721	m_gl.vertexAttribP1uiv(index, type, normalized, value);
4722}
4723
4724void CallLogWrapper::glVertexAttribP2ui (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, glw::GLuint value)
4725{
4726	if (m_enableLog)
4727		m_log << TestLog::Message << "glVertexAttribP2ui(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
4728	m_gl.vertexAttribP2ui(index, type, normalized, value);
4729}
4730
4731void CallLogWrapper::glVertexAttribP2uiv (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, const glw::GLuint *value)
4732{
4733	if (m_enableLog)
4734		m_log << TestLog::Message << "glVertexAttribP2uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
4735	m_gl.vertexAttribP2uiv(index, type, normalized, value);
4736}
4737
4738void CallLogWrapper::glVertexAttribP3ui (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, glw::GLuint value)
4739{
4740	if (m_enableLog)
4741		m_log << TestLog::Message << "glVertexAttribP3ui(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
4742	m_gl.vertexAttribP3ui(index, type, normalized, value);
4743}
4744
4745void CallLogWrapper::glVertexAttribP3uiv (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, const glw::GLuint *value)
4746{
4747	if (m_enableLog)
4748		m_log << TestLog::Message << "glVertexAttribP3uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
4749	m_gl.vertexAttribP3uiv(index, type, normalized, value);
4750}
4751
4752void CallLogWrapper::glVertexAttribP4ui (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, glw::GLuint value)
4753{
4754	if (m_enableLog)
4755		m_log << TestLog::Message << "glVertexAttribP4ui(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
4756	m_gl.vertexAttribP4ui(index, type, normalized, value);
4757}
4758
4759void CallLogWrapper::glVertexAttribP4uiv (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, const glw::GLuint *value)
4760{
4761	if (m_enableLog)
4762		m_log << TestLog::Message << "glVertexAttribP4uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
4763	m_gl.vertexAttribP4uiv(index, type, normalized, value);
4764}
4765
4766void CallLogWrapper::glVertexAttribPointer (glw::GLuint index, glw::GLint size, glw::GLenum type, glw::GLboolean normalized, glw::GLsizei stride, const void *pointer)
4767{
4768	if (m_enableLog)
4769		m_log << TestLog::Message << "glVertexAttribPointer(" << index << ", " << size << ", " << getTypeStr(type) << ", " << getBooleanStr(normalized) << ", " << stride << ", " << pointer << ");" << TestLog::EndMessage;
4770	m_gl.vertexAttribPointer(index, size, type, normalized, stride, pointer);
4771}
4772
4773void CallLogWrapper::glVertexBindingDivisor (glw::GLuint bindingindex, glw::GLuint divisor)
4774{
4775	if (m_enableLog)
4776		m_log << TestLog::Message << "glVertexBindingDivisor(" << bindingindex << ", " << divisor << ");" << TestLog::EndMessage;
4777	m_gl.vertexBindingDivisor(bindingindex, divisor);
4778}
4779
4780void CallLogWrapper::glViewport (glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
4781{
4782	if (m_enableLog)
4783		m_log << TestLog::Message << "glViewport(" << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
4784	m_gl.viewport(x, y, width, height);
4785}
4786
4787void CallLogWrapper::glViewportArrayv (glw::GLuint first, glw::GLsizei count, const glw::GLfloat *v)
4788{
4789	if (m_enableLog)
4790		m_log << TestLog::Message << "glViewportArrayv(" << first << ", " << count << ", " << v << ");" << TestLog::EndMessage;
4791	m_gl.viewportArrayv(first, count, v);
4792}
4793
4794void CallLogWrapper::glViewportIndexedf (glw::GLuint index, glw::GLfloat x, glw::GLfloat y, glw::GLfloat w, glw::GLfloat h)
4795{
4796	if (m_enableLog)
4797		m_log << TestLog::Message << "glViewportIndexedf(" << index << ", " << x << ", " << y << ", " << w << ", " << h << ");" << TestLog::EndMessage;
4798	m_gl.viewportIndexedf(index, x, y, w, h);
4799}
4800
4801void CallLogWrapper::glViewportIndexedfv (glw::GLuint index, const glw::GLfloat *v)
4802{
4803	if (m_enableLog)
4804		m_log << TestLog::Message << "glViewportIndexedfv(" << index << ", " << v << ");" << TestLog::EndMessage;
4805	m_gl.viewportIndexedfv(index, v);
4806}
4807
4808void CallLogWrapper::glWaitSync (glw::GLsync sync, glw::GLbitfield flags, glw::GLuint64 timeout)
4809{
4810	if (m_enableLog)
4811		m_log << TestLog::Message << "glWaitSync(" << sync << ", " << toHex(flags) << ", " << timeout << ");" << TestLog::EndMessage;
4812	m_gl.waitSync(sync, flags, timeout);
4813}
4814