1/* WARNING: This is auto-generated file. Do not modify, since changes will
2 * be lost! Modify the generating script instead.
3 */
4
5glw::GLsync CallLogWrapper::glCreateSyncFromCLeventARB (struct _cl_context* param0, struct _cl_event* param1, glw::GLbitfield param2)
6{
7	if (m_enableLog)
8		m_log << TestLog::Message << "glCreateSyncFromCLeventARB(" << toHex(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
9	glw::GLsync returnValue = m_gl.createSyncFromCLeventARB(param0, param1, param2);
10	if (m_enableLog)
11		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
12	return returnValue;
13}
14
15void CallLogWrapper::glBlendBarrierKHR ()
16{
17	if (m_enableLog)
18		m_log << TestLog::Message << "glBlendBarrierKHR(" << ");" << TestLog::EndMessage;
19	m_gl.blendBarrierKHR();
20}
21
22void CallLogWrapper::glCullFace (glw::GLenum param0)
23{
24	if (m_enableLog)
25		m_log << TestLog::Message << "glCullFace(" << getFaceStr(param0) << ");" << TestLog::EndMessage;
26	m_gl.cullFace(param0);
27}
28
29void CallLogWrapper::glFrontFace (glw::GLenum param0)
30{
31	if (m_enableLog)
32		m_log << TestLog::Message << "glFrontFace(" << getWindingStr(param0) << ");" << TestLog::EndMessage;
33	m_gl.frontFace(param0);
34}
35
36void CallLogWrapper::glHint (glw::GLenum param0, glw::GLenum param1)
37{
38	if (m_enableLog)
39		m_log << TestLog::Message << "glHint(" << getHintStr(param0) << ", " << getHintModeStr(param1) << ");" << TestLog::EndMessage;
40	m_gl.hint(param0, param1);
41}
42
43void CallLogWrapper::glLineWidth (glw::GLfloat param0)
44{
45	if (m_enableLog)
46		m_log << TestLog::Message << "glLineWidth(" << param0 << ");" << TestLog::EndMessage;
47	m_gl.lineWidth(param0);
48}
49
50void CallLogWrapper::glPointSize (glw::GLfloat param0)
51{
52	if (m_enableLog)
53		m_log << TestLog::Message << "glPointSize(" << param0 << ");" << TestLog::EndMessage;
54	m_gl.pointSize(param0);
55}
56
57void CallLogWrapper::glPolygonMode (glw::GLenum param0, glw::GLenum param1)
58{
59	if (m_enableLog)
60		m_log << TestLog::Message << "glPolygonMode(" << toHex(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
61	m_gl.polygonMode(param0, param1);
62}
63
64void CallLogWrapper::glScissor (glw::GLint param0, glw::GLint param1, glw::GLsizei param2, glw::GLsizei param3)
65{
66	if (m_enableLog)
67		m_log << TestLog::Message << "glScissor(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
68	m_gl.scissor(param0, param1, param2, param3);
69}
70
71void CallLogWrapper::glTexParameterf (glw::GLenum param0, glw::GLenum param1, glw::GLfloat param2)
72{
73	if (m_enableLog)
74		m_log << TestLog::Message << "glTexParameterf(" << getTextureTargetStr(param0) << ", " << getTextureParameterStr(param1) << ", " << param2 << ");" << TestLog::EndMessage;
75	m_gl.texParameterf(param0, param1, param2);
76}
77
78void CallLogWrapper::glTexParameterfv (glw::GLenum param0, glw::GLenum param1, const glw::GLfloat* param2)
79{
80	if (m_enableLog)
81		m_log << TestLog::Message << "glTexParameterfv(" << getTextureTargetStr(param0) << ", " << getTextureParameterStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
82	m_gl.texParameterfv(param0, param1, param2);
83}
84
85void CallLogWrapper::glTexParameteri (glw::GLenum param0, glw::GLenum param1, glw::GLint param2)
86{
87	if (m_enableLog)
88		m_log << TestLog::Message << "glTexParameteri(" << getTextureTargetStr(param0) << ", " << getTextureParameterStr(param1) << ", " << getTextureParameterValueStr(param1, param2) << ");" << TestLog::EndMessage;
89	m_gl.texParameteri(param0, param1, param2);
90}
91
92void CallLogWrapper::glTexParameteriv (glw::GLenum param0, glw::GLenum param1, const glw::GLint* param2)
93{
94	if (m_enableLog)
95		m_log << TestLog::Message << "glTexParameteriv(" << getTextureTargetStr(param0) << ", " << getTextureParameterStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
96	m_gl.texParameteriv(param0, param1, param2);
97}
98
99void CallLogWrapper::glTexImage1D (glw::GLenum param0, glw::GLint param1, glw::GLint param2, glw::GLsizei param3, glw::GLint param4, glw::GLenum param5, glw::GLenum param6, const glw::GLvoid* param7)
100{
101	if (m_enableLog)
102		m_log << TestLog::Message << "glTexImage1D(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getPixelFormatStr(param2) << ", " << param3 << ", " << param4 << ", " << getPixelFormatStr(param5) << ", " << getTypeStr(param6) << ", " << toHex(param7) << ");" << TestLog::EndMessage;
103	m_gl.texImage1D(param0, param1, param2, param3, param4, param5, param6, param7);
104}
105
106void CallLogWrapper::glTexImage2D (glw::GLenum param0, glw::GLint param1, glw::GLint param2, glw::GLsizei param3, glw::GLsizei param4, glw::GLint param5, glw::GLenum param6, glw::GLenum param7, const glw::GLvoid* param8)
107{
108	if (m_enableLog)
109		m_log << TestLog::Message << "glTexImage2D(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getPixelFormatStr(param2) << ", " << param3 << ", " << param4 << ", " << param5 << ", " << getPixelFormatStr(param6) << ", " << getTypeStr(param7) << ", " << toHex(param8) << ");" << TestLog::EndMessage;
110	m_gl.texImage2D(param0, param1, param2, param3, param4, param5, param6, param7, param8);
111}
112
113void CallLogWrapper::glDrawBuffer (glw::GLenum param0)
114{
115	if (m_enableLog)
116		m_log << TestLog::Message << "glDrawBuffer(" << toHex(param0) << ");" << TestLog::EndMessage;
117	m_gl.drawBuffer(param0);
118}
119
120void CallLogWrapper::glClear (glw::GLbitfield param0)
121{
122	if (m_enableLog)
123		m_log << TestLog::Message << "glClear(" << getBufferMaskStr(param0) << ");" << TestLog::EndMessage;
124	m_gl.clear(param0);
125}
126
127void CallLogWrapper::glClearColor (glw::GLfloat param0, glw::GLfloat param1, glw::GLfloat param2, glw::GLfloat param3)
128{
129	if (m_enableLog)
130		m_log << TestLog::Message << "glClearColor(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
131	m_gl.clearColor(param0, param1, param2, param3);
132}
133
134void CallLogWrapper::glClearStencil (glw::GLint param0)
135{
136	if (m_enableLog)
137		m_log << TestLog::Message << "glClearStencil(" << param0 << ");" << TestLog::EndMessage;
138	m_gl.clearStencil(param0);
139}
140
141void CallLogWrapper::glClearDepth (glw::GLdouble param0)
142{
143	if (m_enableLog)
144		m_log << TestLog::Message << "glClearDepth(" << param0 << ");" << TestLog::EndMessage;
145	m_gl.clearDepth(param0);
146}
147
148void CallLogWrapper::glStencilMask (glw::GLuint param0)
149{
150	if (m_enableLog)
151		m_log << TestLog::Message << "glStencilMask(" << param0 << ");" << TestLog::EndMessage;
152	m_gl.stencilMask(param0);
153}
154
155void CallLogWrapper::glColorMask (glw::GLboolean param0, glw::GLboolean param1, glw::GLboolean param2, glw::GLboolean param3)
156{
157	if (m_enableLog)
158		m_log << TestLog::Message << "glColorMask(" << getBooleanStr(param0) << ", " << getBooleanStr(param1) << ", " << getBooleanStr(param2) << ", " << getBooleanStr(param3) << ");" << TestLog::EndMessage;
159	m_gl.colorMask(param0, param1, param2, param3);
160}
161
162void CallLogWrapper::glDepthMask (glw::GLboolean param0)
163{
164	if (m_enableLog)
165		m_log << TestLog::Message << "glDepthMask(" << getBooleanStr(param0) << ");" << TestLog::EndMessage;
166	m_gl.depthMask(param0);
167}
168
169void CallLogWrapper::glDisable (glw::GLenum param0)
170{
171	if (m_enableLog)
172		m_log << TestLog::Message << "glDisable(" << getEnableCapStr(param0) << ");" << TestLog::EndMessage;
173	m_gl.disable(param0);
174}
175
176void CallLogWrapper::glEnable (glw::GLenum param0)
177{
178	if (m_enableLog)
179		m_log << TestLog::Message << "glEnable(" << getEnableCapStr(param0) << ");" << TestLog::EndMessage;
180	m_gl.enable(param0);
181}
182
183void CallLogWrapper::glFinish ()
184{
185	if (m_enableLog)
186		m_log << TestLog::Message << "glFinish(" << ");" << TestLog::EndMessage;
187	m_gl.finish();
188}
189
190void CallLogWrapper::glFlush ()
191{
192	if (m_enableLog)
193		m_log << TestLog::Message << "glFlush(" << ");" << TestLog::EndMessage;
194	m_gl.flush();
195}
196
197void CallLogWrapper::glBlendFunc (glw::GLenum param0, glw::GLenum param1)
198{
199	if (m_enableLog)
200		m_log << TestLog::Message << "glBlendFunc(" << getBlendFactorStr(param0) << ", " << getBlendFactorStr(param1) << ");" << TestLog::EndMessage;
201	m_gl.blendFunc(param0, param1);
202}
203
204void CallLogWrapper::glLogicOp (glw::GLenum param0)
205{
206	if (m_enableLog)
207		m_log << TestLog::Message << "glLogicOp(" << toHex(param0) << ");" << TestLog::EndMessage;
208	m_gl.logicOp(param0);
209}
210
211void CallLogWrapper::glStencilFunc (glw::GLenum param0, glw::GLint param1, glw::GLuint param2)
212{
213	if (m_enableLog)
214		m_log << TestLog::Message << "glStencilFunc(" << getCompareFuncStr(param0) << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
215	m_gl.stencilFunc(param0, param1, param2);
216}
217
218void CallLogWrapper::glStencilOp (glw::GLenum param0, glw::GLenum param1, glw::GLenum param2)
219{
220	if (m_enableLog)
221		m_log << TestLog::Message << "glStencilOp(" << getStencilOpStr(param0) << ", " << getStencilOpStr(param1) << ", " << getStencilOpStr(param2) << ");" << TestLog::EndMessage;
222	m_gl.stencilOp(param0, param1, param2);
223}
224
225void CallLogWrapper::glDepthFunc (glw::GLenum param0)
226{
227	if (m_enableLog)
228		m_log << TestLog::Message << "glDepthFunc(" << getCompareFuncStr(param0) << ");" << TestLog::EndMessage;
229	m_gl.depthFunc(param0);
230}
231
232void CallLogWrapper::glPixelStoref (glw::GLenum param0, glw::GLfloat param1)
233{
234	if (m_enableLog)
235		m_log << TestLog::Message << "glPixelStoref(" << toHex(param0) << ", " << param1 << ");" << TestLog::EndMessage;
236	m_gl.pixelStoref(param0, param1);
237}
238
239void CallLogWrapper::glPixelStorei (glw::GLenum param0, glw::GLint param1)
240{
241	if (m_enableLog)
242		m_log << TestLog::Message << "glPixelStorei(" << getPixelStoreParameterStr(param0) << ", " << param1 << ");" << TestLog::EndMessage;
243	m_gl.pixelStorei(param0, param1);
244}
245
246void CallLogWrapper::glReadBuffer (glw::GLenum param0)
247{
248	if (m_enableLog)
249		m_log << TestLog::Message << "glReadBuffer(" << getDrawReadBufferStr(param0) << ");" << TestLog::EndMessage;
250	m_gl.readBuffer(param0);
251}
252
253void CallLogWrapper::glReadPixels (glw::GLint param0, glw::GLint param1, glw::GLsizei param2, glw::GLsizei param3, glw::GLenum param4, glw::GLenum param5, glw::GLvoid* param6)
254{
255	if (m_enableLog)
256		m_log << TestLog::Message << "glReadPixels(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << getPixelFormatStr(param4) << ", " << getTypeStr(param5) << ", " << toHex(param6) << ");" << TestLog::EndMessage;
257	m_gl.readPixels(param0, param1, param2, param3, param4, param5, param6);
258}
259
260void CallLogWrapper::glGetBooleanv (glw::GLenum param0, glw::GLboolean* param1)
261{
262	if (m_enableLog)
263		m_log << TestLog::Message << "glGetBooleanv(" << getGettableStateStr(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
264	m_gl.getBooleanv(param0, param1);
265}
266
267void CallLogWrapper::glGetDoublev (glw::GLenum param0, glw::GLdouble* param1)
268{
269	if (m_enableLog)
270		m_log << TestLog::Message << "glGetDoublev(" << toHex(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
271	m_gl.getDoublev(param0, param1);
272}
273
274glw::GLenum CallLogWrapper::glGetError ()
275{
276	if (m_enableLog)
277		m_log << TestLog::Message << "glGetError(" << ");" << TestLog::EndMessage;
278	glw::GLenum returnValue = m_gl.getError();
279	if (m_enableLog)
280		m_log << TestLog::Message << "// " << getErrorStr(returnValue) << " returned" << TestLog::EndMessage;
281	return returnValue;
282}
283
284void CallLogWrapper::glGetFloatv (glw::GLenum param0, glw::GLfloat* param1)
285{
286	if (m_enableLog)
287		m_log << TestLog::Message << "glGetFloatv(" << getGettableStateStr(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
288	m_gl.getFloatv(param0, param1);
289}
290
291void CallLogWrapper::glGetIntegerv (glw::GLenum param0, glw::GLint* param1)
292{
293	if (m_enableLog)
294		m_log << TestLog::Message << "glGetIntegerv(" << getGettableStateStr(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
295	m_gl.getIntegerv(param0, param1);
296}
297
298const glw::GLubyte* CallLogWrapper::glGetString (glw::GLenum param0)
299{
300	if (m_enableLog)
301		m_log << TestLog::Message << "glGetString(" << getGettableStringStr(param0) << ");" << TestLog::EndMessage;
302	const glw::GLubyte* returnValue = m_gl.getString(param0);
303	if (m_enableLog)
304		m_log << TestLog::Message << "// " << getStringStr(returnValue) << " returned" << TestLog::EndMessage;
305	return returnValue;
306}
307
308void CallLogWrapper::glGetTexImage (glw::GLenum param0, glw::GLint param1, glw::GLenum param2, glw::GLenum param3, glw::GLvoid* param4)
309{
310	if (m_enableLog)
311		m_log << TestLog::Message << "glGetTexImage(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
312	m_gl.getTexImage(param0, param1, param2, param3, param4);
313}
314
315void CallLogWrapper::glGetTexParameterfv (glw::GLenum param0, glw::GLenum param1, glw::GLfloat* param2)
316{
317	if (m_enableLog)
318		m_log << TestLog::Message << "glGetTexParameterfv(" << getTextureTargetStr(param0) << ", " << getTextureParameterStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
319	m_gl.getTexParameterfv(param0, param1, param2);
320}
321
322void CallLogWrapper::glGetTexParameteriv (glw::GLenum param0, glw::GLenum param1, glw::GLint* param2)
323{
324	if (m_enableLog)
325		m_log << TestLog::Message << "glGetTexParameteriv(" << getTextureTargetStr(param0) << ", " << getTextureParameterStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
326	m_gl.getTexParameteriv(param0, param1, param2);
327}
328
329void CallLogWrapper::glGetTexLevelParameterfv (glw::GLenum param0, glw::GLint param1, glw::GLenum param2, glw::GLfloat* param3)
330{
331	if (m_enableLog)
332		m_log << TestLog::Message << "glGetTexLevelParameterfv(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getTextureLevelParameterStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
333	m_gl.getTexLevelParameterfv(param0, param1, param2, param3);
334}
335
336void CallLogWrapper::glGetTexLevelParameteriv (glw::GLenum param0, glw::GLint param1, glw::GLenum param2, glw::GLint* param3)
337{
338	if (m_enableLog)
339		m_log << TestLog::Message << "glGetTexLevelParameteriv(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getTextureLevelParameterStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
340	m_gl.getTexLevelParameteriv(param0, param1, param2, param3);
341}
342
343glw::GLboolean CallLogWrapper::glIsEnabled (glw::GLenum param0)
344{
345	if (m_enableLog)
346		m_log << TestLog::Message << "glIsEnabled(" << getEnableCapStr(param0) << ");" << TestLog::EndMessage;
347	glw::GLboolean returnValue = m_gl.isEnabled(param0);
348	if (m_enableLog)
349		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
350	return returnValue;
351}
352
353void CallLogWrapper::glDepthRange (glw::GLdouble param0, glw::GLdouble param1)
354{
355	if (m_enableLog)
356		m_log << TestLog::Message << "glDepthRange(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
357	m_gl.depthRange(param0, param1);
358}
359
360void CallLogWrapper::glViewport (glw::GLint param0, glw::GLint param1, glw::GLsizei param2, glw::GLsizei param3)
361{
362	if (m_enableLog)
363		m_log << TestLog::Message << "glViewport(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
364	m_gl.viewport(param0, param1, param2, param3);
365}
366
367void CallLogWrapper::glDrawArrays (glw::GLenum param0, glw::GLint param1, glw::GLsizei param2)
368{
369	if (m_enableLog)
370		m_log << TestLog::Message << "glDrawArrays(" << getPrimitiveTypeStr(param0) << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
371	m_gl.drawArrays(param0, param1, param2);
372}
373
374void CallLogWrapper::glDrawElements (glw::GLenum param0, glw::GLsizei param1, glw::GLenum param2, const glw::GLvoid* param3)
375{
376	if (m_enableLog)
377		m_log << TestLog::Message << "glDrawElements(" << getPrimitiveTypeStr(param0) << ", " << param1 << ", " << getTypeStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
378	m_gl.drawElements(param0, param1, param2, param3);
379}
380
381void CallLogWrapper::glGetPointerv (glw::GLenum param0, glw::GLvoid** param1)
382{
383	if (m_enableLog)
384		m_log << TestLog::Message << "glGetPointerv(" << toHex(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
385	m_gl.getPointerv(param0, param1);
386}
387
388void CallLogWrapper::glPolygonOffset (glw::GLfloat param0, glw::GLfloat param1)
389{
390	if (m_enableLog)
391		m_log << TestLog::Message << "glPolygonOffset(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
392	m_gl.polygonOffset(param0, param1);
393}
394
395void CallLogWrapper::glCopyTexImage1D (glw::GLenum param0, glw::GLint param1, glw::GLenum param2, glw::GLint param3, glw::GLint param4, glw::GLsizei param5, glw::GLint param6)
396{
397	if (m_enableLog)
398		m_log << TestLog::Message << "glCopyTexImage1D(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getPixelFormatStr(param2) << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ");" << TestLog::EndMessage;
399	m_gl.copyTexImage1D(param0, param1, param2, param3, param4, param5, param6);
400}
401
402void CallLogWrapper::glCopyTexImage2D (glw::GLenum param0, glw::GLint param1, glw::GLenum param2, glw::GLint param3, glw::GLint param4, glw::GLsizei param5, glw::GLsizei param6, glw::GLint param7)
403{
404	if (m_enableLog)
405		m_log << TestLog::Message << "glCopyTexImage2D(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getPixelFormatStr(param2) << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ", " << param7 << ");" << TestLog::EndMessage;
406	m_gl.copyTexImage2D(param0, param1, param2, param3, param4, param5, param6, param7);
407}
408
409void CallLogWrapper::glCopyTexSubImage1D (glw::GLenum param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLint param4, glw::GLsizei param5)
410{
411	if (m_enableLog)
412		m_log << TestLog::Message << "glCopyTexSubImage1D(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ");" << TestLog::EndMessage;
413	m_gl.copyTexSubImage1D(param0, param1, param2, param3, param4, param5);
414}
415
416void CallLogWrapper::glCopyTexSubImage2D (glw::GLenum param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLint param4, glw::GLint param5, glw::GLsizei param6, glw::GLsizei param7)
417{
418	if (m_enableLog)
419		m_log << TestLog::Message << "glCopyTexSubImage2D(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ", " << param7 << ");" << TestLog::EndMessage;
420	m_gl.copyTexSubImage2D(param0, param1, param2, param3, param4, param5, param6, param7);
421}
422
423void CallLogWrapper::glTexSubImage1D (glw::GLenum param0, glw::GLint param1, glw::GLint param2, glw::GLsizei param3, glw::GLenum param4, glw::GLenum param5, const glw::GLvoid* param6)
424{
425	if (m_enableLog)
426		m_log << TestLog::Message << "glTexSubImage1D(" << getTextureTargetStr(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << getPixelFormatStr(param4) << ", " << getTypeStr(param5) << ", " << toHex(param6) << ");" << TestLog::EndMessage;
427	m_gl.texSubImage1D(param0, param1, param2, param3, param4, param5, param6);
428}
429
430void CallLogWrapper::glTexSubImage2D (glw::GLenum param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLsizei param4, glw::GLsizei param5, glw::GLenum param6, glw::GLenum param7, const glw::GLvoid* param8)
431{
432	if (m_enableLog)
433		m_log << TestLog::Message << "glTexSubImage2D(" << getTextureTargetStr(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ", " << getPixelFormatStr(param6) << ", " << getTypeStr(param7) << ", " << toHex(param8) << ");" << TestLog::EndMessage;
434	m_gl.texSubImage2D(param0, param1, param2, param3, param4, param5, param6, param7, param8);
435}
436
437void CallLogWrapper::glBindTexture (glw::GLenum param0, glw::GLuint param1)
438{
439	if (m_enableLog)
440		m_log << TestLog::Message << "glBindTexture(" << getTextureTargetStr(param0) << ", " << param1 << ");" << TestLog::EndMessage;
441	m_gl.bindTexture(param0, param1);
442}
443
444void CallLogWrapper::glDeleteTextures (glw::GLsizei param0, const glw::GLuint* param1)
445{
446	if (m_enableLog)
447		m_log << TestLog::Message << "glDeleteTextures(" << param0 << ", " << getPointerStr(param1, param0) << ");" << TestLog::EndMessage;
448	m_gl.deleteTextures(param0, param1);
449}
450
451void CallLogWrapper::glGenTextures (glw::GLsizei param0, glw::GLuint* param1)
452{
453	if (m_enableLog)
454		m_log << TestLog::Message << "glGenTextures(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
455	m_gl.genTextures(param0, param1);
456	if (m_enableLog)
457	{
458		m_log << TestLog::Message << "// param 1 = " << getPointerStr(param1, param0) << TestLog::EndMessage;
459	}
460}
461
462glw::GLboolean CallLogWrapper::glIsTexture (glw::GLuint param0)
463{
464	if (m_enableLog)
465		m_log << TestLog::Message << "glIsTexture(" << param0 << ");" << TestLog::EndMessage;
466	glw::GLboolean returnValue = m_gl.isTexture(param0);
467	if (m_enableLog)
468		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
469	return returnValue;
470}
471
472void CallLogWrapper::glBlendColor (glw::GLfloat param0, glw::GLfloat param1, glw::GLfloat param2, glw::GLfloat param3)
473{
474	if (m_enableLog)
475		m_log << TestLog::Message << "glBlendColor(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
476	m_gl.blendColor(param0, param1, param2, param3);
477}
478
479void CallLogWrapper::glBlendEquation (glw::GLenum param0)
480{
481	if (m_enableLog)
482		m_log << TestLog::Message << "glBlendEquation(" << getBlendEquationStr(param0) << ");" << TestLog::EndMessage;
483	m_gl.blendEquation(param0);
484}
485
486void CallLogWrapper::glDrawRangeElements (glw::GLenum param0, glw::GLuint param1, glw::GLuint param2, glw::GLsizei param3, glw::GLenum param4, const glw::GLvoid* param5)
487{
488	if (m_enableLog)
489		m_log << TestLog::Message << "glDrawRangeElements(" << getPrimitiveTypeStr(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << getTypeStr(param4) << ", " << toHex(param5) << ");" << TestLog::EndMessage;
490	m_gl.drawRangeElements(param0, param1, param2, param3, param4, param5);
491}
492
493void CallLogWrapper::glTexImage3D (glw::GLenum param0, glw::GLint param1, glw::GLint param2, glw::GLsizei param3, glw::GLsizei param4, glw::GLsizei param5, glw::GLint param6, glw::GLenum param7, glw::GLenum param8, const glw::GLvoid* param9)
494{
495	if (m_enableLog)
496		m_log << TestLog::Message << "glTexImage3D(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getPixelFormatStr(param2) << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ", " << getPixelFormatStr(param7) << ", " << getTypeStr(param8) << ", " << toHex(param9) << ");" << TestLog::EndMessage;
497	m_gl.texImage3D(param0, param1, param2, param3, param4, param5, param6, param7, param8, param9);
498}
499
500void CallLogWrapper::glTexSubImage3D (glw::GLenum param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLint param4, glw::GLsizei param5, glw::GLsizei param6, glw::GLsizei param7, glw::GLenum param8, glw::GLenum param9, const glw::GLvoid* param10)
501{
502	if (m_enableLog)
503		m_log << TestLog::Message << "glTexSubImage3D(" << getTextureTargetStr(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ", " << param7 << ", " << getPixelFormatStr(param8) << ", " << getTypeStr(param9) << ", " << toHex(param10) << ");" << TestLog::EndMessage;
504	m_gl.texSubImage3D(param0, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
505}
506
507void CallLogWrapper::glCopyTexSubImage3D (glw::GLenum param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLint param4, glw::GLint param5, glw::GLint param6, glw::GLsizei param7, glw::GLsizei param8)
508{
509	if (m_enableLog)
510		m_log << TestLog::Message << "glCopyTexSubImage3D(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ", " << param7 << ", " << param8 << ");" << TestLog::EndMessage;
511	m_gl.copyTexSubImage3D(param0, param1, param2, param3, param4, param5, param6, param7, param8);
512}
513
514void CallLogWrapper::glActiveTexture (glw::GLenum param0)
515{
516	if (m_enableLog)
517		m_log << TestLog::Message << "glActiveTexture(" << getTextureUnitStr(param0) << ");" << TestLog::EndMessage;
518	m_gl.activeTexture(param0);
519}
520
521void CallLogWrapper::glSampleCoverage (glw::GLfloat param0, glw::GLboolean param1)
522{
523	if (m_enableLog)
524		m_log << TestLog::Message << "glSampleCoverage(" << param0 << ", " << getBooleanStr(param1) << ");" << TestLog::EndMessage;
525	m_gl.sampleCoverage(param0, param1);
526}
527
528void CallLogWrapper::glCompressedTexImage3D (glw::GLenum param0, glw::GLint param1, glw::GLenum param2, glw::GLsizei param3, glw::GLsizei param4, glw::GLsizei param5, glw::GLint param6, glw::GLsizei param7, const glw::GLvoid* param8)
529{
530	if (m_enableLog)
531		m_log << TestLog::Message << "glCompressedTexImage3D(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ", " << param7 << ", " << toHex(param8) << ");" << TestLog::EndMessage;
532	m_gl.compressedTexImage3D(param0, param1, param2, param3, param4, param5, param6, param7, param8);
533}
534
535void CallLogWrapper::glCompressedTexImage2D (glw::GLenum param0, glw::GLint param1, glw::GLenum param2, glw::GLsizei param3, glw::GLsizei param4, glw::GLint param5, glw::GLsizei param6, const glw::GLvoid* param7)
536{
537	if (m_enableLog)
538		m_log << TestLog::Message << "glCompressedTexImage2D(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getPixelFormatStr(param2) << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ", " << toHex(param7) << ");" << TestLog::EndMessage;
539	m_gl.compressedTexImage2D(param0, param1, param2, param3, param4, param5, param6, param7);
540}
541
542void CallLogWrapper::glCompressedTexImage1D (glw::GLenum param0, glw::GLint param1, glw::GLenum param2, glw::GLsizei param3, glw::GLint param4, glw::GLsizei param5, const glw::GLvoid* param6)
543{
544	if (m_enableLog)
545		m_log << TestLog::Message << "glCompressedTexImage1D(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ", " << param3 << ", " << param4 << ", " << param5 << ", " << toHex(param6) << ");" << TestLog::EndMessage;
546	m_gl.compressedTexImage1D(param0, param1, param2, param3, param4, param5, param6);
547}
548
549void CallLogWrapper::glCompressedTexSubImage3D (glw::GLenum param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLint param4, glw::GLsizei param5, glw::GLsizei param6, glw::GLsizei param7, glw::GLenum param8, glw::GLsizei param9, const glw::GLvoid* param10)
550{
551	if (m_enableLog)
552		m_log << TestLog::Message << "glCompressedTexSubImage3D(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ", " << param7 << ", " << toHex(param8) << ", " << param9 << ", " << toHex(param10) << ");" << TestLog::EndMessage;
553	m_gl.compressedTexSubImage3D(param0, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
554}
555
556void CallLogWrapper::glCompressedTexSubImage2D (glw::GLenum param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLsizei param4, glw::GLsizei param5, glw::GLenum param6, glw::GLsizei param7, const glw::GLvoid* param8)
557{
558	if (m_enableLog)
559		m_log << TestLog::Message << "glCompressedTexSubImage2D(" << getTextureTargetStr(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ", " << getPixelFormatStr(param6) << ", " << param7 << ", " << toHex(param8) << ");" << TestLog::EndMessage;
560	m_gl.compressedTexSubImage2D(param0, param1, param2, param3, param4, param5, param6, param7, param8);
561}
562
563void CallLogWrapper::glCompressedTexSubImage1D (glw::GLenum param0, glw::GLint param1, glw::GLint param2, glw::GLsizei param3, glw::GLenum param4, glw::GLsizei param5, const glw::GLvoid* param6)
564{
565	if (m_enableLog)
566		m_log << TestLog::Message << "glCompressedTexSubImage1D(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << toHex(param4) << ", " << param5 << ", " << toHex(param6) << ");" << TestLog::EndMessage;
567	m_gl.compressedTexSubImage1D(param0, param1, param2, param3, param4, param5, param6);
568}
569
570void CallLogWrapper::glGetCompressedTexImage (glw::GLenum param0, glw::GLint param1, glw::GLvoid* param2)
571{
572	if (m_enableLog)
573		m_log << TestLog::Message << "glGetCompressedTexImage(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
574	m_gl.getCompressedTexImage(param0, param1, param2);
575}
576
577void CallLogWrapper::glBlendFuncSeparate (glw::GLenum param0, glw::GLenum param1, glw::GLenum param2, glw::GLenum param3)
578{
579	if (m_enableLog)
580		m_log << TestLog::Message << "glBlendFuncSeparate(" << getBlendFactorStr(param0) << ", " << getBlendFactorStr(param1) << ", " << getBlendFactorStr(param2) << ", " << getBlendFactorStr(param3) << ");" << TestLog::EndMessage;
581	m_gl.blendFuncSeparate(param0, param1, param2, param3);
582}
583
584void CallLogWrapper::glMultiDrawArrays (glw::GLenum param0, const glw::GLint* param1, const glw::GLsizei* param2, glw::GLsizei param3)
585{
586	if (m_enableLog)
587		m_log << TestLog::Message << "glMultiDrawArrays(" << getPrimitiveTypeStr(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ", " << param3 << ");" << TestLog::EndMessage;
588	m_gl.multiDrawArrays(param0, param1, param2, param3);
589}
590
591void CallLogWrapper::glMultiDrawElements (glw::GLenum param0, const glw::GLsizei* param1, glw::GLenum param2, const glw::GLvoid* const* param3, glw::GLsizei param4)
592{
593	if (m_enableLog)
594		m_log << TestLog::Message << "glMultiDrawElements(" << getPrimitiveTypeStr(param0) << ", " << toHex(param1) << ", " << getTypeStr(param2) << ", " << toHex(param3) << ", " << param4 << ");" << TestLog::EndMessage;
595	m_gl.multiDrawElements(param0, param1, param2, param3, param4);
596}
597
598void CallLogWrapper::glPointParameterf (glw::GLenum param0, glw::GLfloat param1)
599{
600	if (m_enableLog)
601		m_log << TestLog::Message << "glPointParameterf(" << toHex(param0) << ", " << param1 << ");" << TestLog::EndMessage;
602	m_gl.pointParameterf(param0, param1);
603}
604
605void CallLogWrapper::glPointParameterfv (glw::GLenum param0, const glw::GLfloat* param1)
606{
607	if (m_enableLog)
608		m_log << TestLog::Message << "glPointParameterfv(" << toHex(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
609	m_gl.pointParameterfv(param0, param1);
610}
611
612void CallLogWrapper::glPointParameteri (glw::GLenum param0, glw::GLint param1)
613{
614	if (m_enableLog)
615		m_log << TestLog::Message << "glPointParameteri(" << toHex(param0) << ", " << param1 << ");" << TestLog::EndMessage;
616	m_gl.pointParameteri(param0, param1);
617}
618
619void CallLogWrapper::glPointParameteriv (glw::GLenum param0, const glw::GLint* param1)
620{
621	if (m_enableLog)
622		m_log << TestLog::Message << "glPointParameteriv(" << toHex(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
623	m_gl.pointParameteriv(param0, param1);
624}
625
626void CallLogWrapper::glGenQueries (glw::GLsizei param0, glw::GLuint* param1)
627{
628	if (m_enableLog)
629		m_log << TestLog::Message << "glGenQueries(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
630	m_gl.genQueries(param0, param1);
631	if (m_enableLog)
632	{
633		m_log << TestLog::Message << "// param 1 = " << getPointerStr(param1, param0) << TestLog::EndMessage;
634	}
635}
636
637void CallLogWrapper::glDeleteQueries (glw::GLsizei param0, const glw::GLuint* param1)
638{
639	if (m_enableLog)
640		m_log << TestLog::Message << "glDeleteQueries(" << param0 << ", " << getPointerStr(param1, param0) << ");" << TestLog::EndMessage;
641	m_gl.deleteQueries(param0, param1);
642}
643
644glw::GLboolean CallLogWrapper::glIsQuery (glw::GLuint param0)
645{
646	if (m_enableLog)
647		m_log << TestLog::Message << "glIsQuery(" << param0 << ");" << TestLog::EndMessage;
648	glw::GLboolean returnValue = m_gl.isQuery(param0);
649	if (m_enableLog)
650		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
651	return returnValue;
652}
653
654void CallLogWrapper::glBeginQuery (glw::GLenum param0, glw::GLuint param1)
655{
656	if (m_enableLog)
657		m_log << TestLog::Message << "glBeginQuery(" << getQueryTargetStr(param0) << ", " << param1 << ");" << TestLog::EndMessage;
658	m_gl.beginQuery(param0, param1);
659}
660
661void CallLogWrapper::glEndQuery (glw::GLenum param0)
662{
663	if (m_enableLog)
664		m_log << TestLog::Message << "glEndQuery(" << getQueryTargetStr(param0) << ");" << TestLog::EndMessage;
665	m_gl.endQuery(param0);
666}
667
668void CallLogWrapper::glGetQueryiv (glw::GLenum param0, glw::GLenum param1, glw::GLint* param2)
669{
670	if (m_enableLog)
671		m_log << TestLog::Message << "glGetQueryiv(" << getQueryTargetStr(param0) << ", " << getQueryParamStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
672	m_gl.getQueryiv(param0, param1, param2);
673	if (m_enableLog)
674	{
675		m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, 1) << TestLog::EndMessage;
676	}
677}
678
679void CallLogWrapper::glGetQueryObjectiv (glw::GLuint param0, glw::GLenum param1, glw::GLint* param2)
680{
681	if (m_enableLog)
682		m_log << TestLog::Message << "glGetQueryObjectiv(" << param0 << ", " << getQueryObjectParamStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
683	m_gl.getQueryObjectiv(param0, param1, param2);
684	if (m_enableLog)
685	{
686		m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, 1) << TestLog::EndMessage;
687	}
688}
689
690void CallLogWrapper::glGetQueryObjectuiv (glw::GLuint param0, glw::GLenum param1, glw::GLuint* param2)
691{
692	if (m_enableLog)
693		m_log << TestLog::Message << "glGetQueryObjectuiv(" << param0 << ", " << getQueryObjectParamStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
694	m_gl.getQueryObjectuiv(param0, param1, param2);
695	if (m_enableLog)
696	{
697		m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, 1) << TestLog::EndMessage;
698	}
699}
700
701void CallLogWrapper::glBindBuffer (glw::GLenum param0, glw::GLuint param1)
702{
703	if (m_enableLog)
704		m_log << TestLog::Message << "glBindBuffer(" << getBufferTargetStr(param0) << ", " << param1 << ");" << TestLog::EndMessage;
705	m_gl.bindBuffer(param0, param1);
706}
707
708void CallLogWrapper::glDeleteBuffers (glw::GLsizei param0, const glw::GLuint* param1)
709{
710	if (m_enableLog)
711		m_log << TestLog::Message << "glDeleteBuffers(" << param0 << ", " << getPointerStr(param1, param0) << ");" << TestLog::EndMessage;
712	m_gl.deleteBuffers(param0, param1);
713}
714
715void CallLogWrapper::glGenBuffers (glw::GLsizei param0, glw::GLuint* param1)
716{
717	if (m_enableLog)
718		m_log << TestLog::Message << "glGenBuffers(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
719	m_gl.genBuffers(param0, param1);
720	if (m_enableLog)
721	{
722		m_log << TestLog::Message << "// param 1 = " << getPointerStr(param1, param0) << TestLog::EndMessage;
723	}
724}
725
726glw::GLboolean CallLogWrapper::glIsBuffer (glw::GLuint param0)
727{
728	if (m_enableLog)
729		m_log << TestLog::Message << "glIsBuffer(" << param0 << ");" << TestLog::EndMessage;
730	glw::GLboolean returnValue = m_gl.isBuffer(param0);
731	if (m_enableLog)
732		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
733	return returnValue;
734}
735
736void CallLogWrapper::glBufferData (glw::GLenum param0, glw::GLsizeiptr param1, const glw::GLvoid* param2, glw::GLenum param3)
737{
738	if (m_enableLog)
739		m_log << TestLog::Message << "glBufferData(" << getBufferTargetStr(param0) << ", " << param1 << ", " << toHex(param2) << ", " << getUsageStr(param3) << ");" << TestLog::EndMessage;
740	m_gl.bufferData(param0, param1, param2, param3);
741}
742
743void CallLogWrapper::glBufferSubData (glw::GLenum param0, glw::GLintptr param1, glw::GLsizeiptr param2, const glw::GLvoid* param3)
744{
745	if (m_enableLog)
746		m_log << TestLog::Message << "glBufferSubData(" << getBufferTargetStr(param0) << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ");" << TestLog::EndMessage;
747	m_gl.bufferSubData(param0, param1, param2, param3);
748}
749
750void CallLogWrapper::glGetBufferSubData (glw::GLenum param0, glw::GLintptr param1, glw::GLsizeiptr param2, glw::GLvoid* param3)
751{
752	if (m_enableLog)
753		m_log << TestLog::Message << "glGetBufferSubData(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ");" << TestLog::EndMessage;
754	m_gl.getBufferSubData(param0, param1, param2, param3);
755}
756
757glw::GLvoid* CallLogWrapper::glMapBuffer (glw::GLenum param0, glw::GLenum param1)
758{
759	if (m_enableLog)
760		m_log << TestLog::Message << "glMapBuffer(" << toHex(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
761	glw::GLvoid* returnValue = m_gl.mapBuffer(param0, param1);
762	if (m_enableLog)
763		m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
764	return returnValue;
765}
766
767glw::GLboolean CallLogWrapper::glUnmapBuffer (glw::GLenum param0)
768{
769	if (m_enableLog)
770		m_log << TestLog::Message << "glUnmapBuffer(" << getBufferTargetStr(param0) << ");" << TestLog::EndMessage;
771	glw::GLboolean returnValue = m_gl.unmapBuffer(param0);
772	if (m_enableLog)
773		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
774	return returnValue;
775}
776
777void CallLogWrapper::glGetBufferParameteriv (glw::GLenum param0, glw::GLenum param1, glw::GLint* param2)
778{
779	if (m_enableLog)
780		m_log << TestLog::Message << "glGetBufferParameteriv(" << getBufferTargetStr(param0) << ", " << getBufferQueryStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
781	m_gl.getBufferParameteriv(param0, param1, param2);
782}
783
784void CallLogWrapper::glGetBufferPointerv (glw::GLenum param0, glw::GLenum param1, glw::GLvoid** param2)
785{
786	if (m_enableLog)
787		m_log << TestLog::Message << "glGetBufferPointerv(" << toHex(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
788	m_gl.getBufferPointerv(param0, param1, param2);
789}
790
791void CallLogWrapper::glBlendEquationSeparate (glw::GLenum param0, glw::GLenum param1)
792{
793	if (m_enableLog)
794		m_log << TestLog::Message << "glBlendEquationSeparate(" << getBlendEquationStr(param0) << ", " << getBlendEquationStr(param1) << ");" << TestLog::EndMessage;
795	m_gl.blendEquationSeparate(param0, param1);
796}
797
798void CallLogWrapper::glDrawBuffers (glw::GLsizei param0, const glw::GLenum* param1)
799{
800	if (m_enableLog)
801		m_log << TestLog::Message << "glDrawBuffers(" << param0 << ", " << getEnumPointerStr(param1, param0, getDrawReadBufferName) << ");" << TestLog::EndMessage;
802	m_gl.drawBuffers(param0, param1);
803}
804
805void CallLogWrapper::glStencilOpSeparate (glw::GLenum param0, glw::GLenum param1, glw::GLenum param2, glw::GLenum param3)
806{
807	if (m_enableLog)
808		m_log << TestLog::Message << "glStencilOpSeparate(" << getFaceStr(param0) << ", " << getStencilOpStr(param1) << ", " << getStencilOpStr(param2) << ", " << getStencilOpStr(param3) << ");" << TestLog::EndMessage;
809	m_gl.stencilOpSeparate(param0, param1, param2, param3);
810}
811
812void CallLogWrapper::glStencilFuncSeparate (glw::GLenum param0, glw::GLenum param1, glw::GLint param2, glw::GLuint param3)
813{
814	if (m_enableLog)
815		m_log << TestLog::Message << "glStencilFuncSeparate(" << getFaceStr(param0) << ", " << getCompareFuncStr(param1) << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
816	m_gl.stencilFuncSeparate(param0, param1, param2, param3);
817}
818
819void CallLogWrapper::glStencilMaskSeparate (glw::GLenum param0, glw::GLuint param1)
820{
821	if (m_enableLog)
822		m_log << TestLog::Message << "glStencilMaskSeparate(" << getFaceStr(param0) << ", " << param1 << ");" << TestLog::EndMessage;
823	m_gl.stencilMaskSeparate(param0, param1);
824}
825
826void CallLogWrapper::glAttachShader (glw::GLuint param0, glw::GLuint param1)
827{
828	if (m_enableLog)
829		m_log << TestLog::Message << "glAttachShader(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
830	m_gl.attachShader(param0, param1);
831}
832
833void CallLogWrapper::glBindAttribLocation (glw::GLuint param0, glw::GLuint param1, const glw::GLchar* param2)
834{
835	if (m_enableLog)
836		m_log << TestLog::Message << "glBindAttribLocation(" << param0 << ", " << param1 << ", " << getStringStr(param2) << ");" << TestLog::EndMessage;
837	m_gl.bindAttribLocation(param0, param1, param2);
838}
839
840void CallLogWrapper::glCompileShader (glw::GLuint param0)
841{
842	if (m_enableLog)
843		m_log << TestLog::Message << "glCompileShader(" << param0 << ");" << TestLog::EndMessage;
844	m_gl.compileShader(param0);
845}
846
847glw::GLuint CallLogWrapper::glCreateProgram ()
848{
849	if (m_enableLog)
850		m_log << TestLog::Message << "glCreateProgram(" << ");" << TestLog::EndMessage;
851	glw::GLuint returnValue = m_gl.createProgram();
852	if (m_enableLog)
853		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
854	return returnValue;
855}
856
857glw::GLuint CallLogWrapper::glCreateShader (glw::GLenum param0)
858{
859	if (m_enableLog)
860		m_log << TestLog::Message << "glCreateShader(" << getShaderTypeStr(param0) << ");" << TestLog::EndMessage;
861	glw::GLuint returnValue = m_gl.createShader(param0);
862	if (m_enableLog)
863		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
864	return returnValue;
865}
866
867void CallLogWrapper::glDeleteProgram (glw::GLuint param0)
868{
869	if (m_enableLog)
870		m_log << TestLog::Message << "glDeleteProgram(" << param0 << ");" << TestLog::EndMessage;
871	m_gl.deleteProgram(param0);
872}
873
874void CallLogWrapper::glDeleteShader (glw::GLuint param0)
875{
876	if (m_enableLog)
877		m_log << TestLog::Message << "glDeleteShader(" << param0 << ");" << TestLog::EndMessage;
878	m_gl.deleteShader(param0);
879}
880
881void CallLogWrapper::glDetachShader (glw::GLuint param0, glw::GLuint param1)
882{
883	if (m_enableLog)
884		m_log << TestLog::Message << "glDetachShader(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
885	m_gl.detachShader(param0, param1);
886}
887
888void CallLogWrapper::glDisableVertexAttribArray (glw::GLuint param0)
889{
890	if (m_enableLog)
891		m_log << TestLog::Message << "glDisableVertexAttribArray(" << param0 << ");" << TestLog::EndMessage;
892	m_gl.disableVertexAttribArray(param0);
893}
894
895void CallLogWrapper::glEnableVertexAttribArray (glw::GLuint param0)
896{
897	if (m_enableLog)
898		m_log << TestLog::Message << "glEnableVertexAttribArray(" << param0 << ");" << TestLog::EndMessage;
899	m_gl.enableVertexAttribArray(param0);
900}
901
902void CallLogWrapper::glGetActiveAttrib (glw::GLuint param0, glw::GLuint param1, glw::GLsizei param2, glw::GLsizei* param3, glw::GLint* param4, glw::GLenum* param5, glw::GLchar* param6)
903{
904	if (m_enableLog)
905		m_log << TestLog::Message << "glGetActiveAttrib(" << param0 << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ", " << toHex(param4) << ", " << toHex(param5) << ", " << toHex(param6) << ");" << TestLog::EndMessage;
906	m_gl.getActiveAttrib(param0, param1, param2, param3, param4, param5, param6);
907}
908
909void CallLogWrapper::glGetActiveUniform (glw::GLuint param0, glw::GLuint param1, glw::GLsizei param2, glw::GLsizei* param3, glw::GLint* param4, glw::GLenum* param5, glw::GLchar* param6)
910{
911	if (m_enableLog)
912		m_log << TestLog::Message << "glGetActiveUniform(" << param0 << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ", " << toHex(param4) << ", " << toHex(param5) << ", " << toHex(param6) << ");" << TestLog::EndMessage;
913	m_gl.getActiveUniform(param0, param1, param2, param3, param4, param5, param6);
914	if (m_enableLog)
915	{
916		m_log << TestLog::Message << "// param 3 = " << getPointerStr(param3, 1) << TestLog::EndMessage;
917		m_log << TestLog::Message << "// param 4 = " << getPointerStr(param4, 1) << TestLog::EndMessage;
918		m_log << TestLog::Message << "// param 5 = " << getEnumPointerStr(param5, 1, getShaderVarTypeName) << TestLog::EndMessage;
919		m_log << TestLog::Message << "// param 6 = " << getStringStr(param6) << TestLog::EndMessage;
920	}
921}
922
923void CallLogWrapper::glGetAttachedShaders (glw::GLuint param0, glw::GLsizei param1, glw::GLsizei* param2, glw::GLuint* param3)
924{
925	if (m_enableLog)
926		m_log << TestLog::Message << "glGetAttachedShaders(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
927	m_gl.getAttachedShaders(param0, param1, param2, param3);
928}
929
930glw::GLint CallLogWrapper::glGetAttribLocation (glw::GLuint param0, const glw::GLchar* param1)
931{
932	if (m_enableLog)
933		m_log << TestLog::Message << "glGetAttribLocation(" << param0 << ", " << getStringStr(param1) << ");" << TestLog::EndMessage;
934	glw::GLint returnValue = m_gl.getAttribLocation(param0, param1);
935	if (m_enableLog)
936		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
937	return returnValue;
938}
939
940void CallLogWrapper::glGetProgramiv (glw::GLuint param0, glw::GLenum param1, glw::GLint* param2)
941{
942	if (m_enableLog)
943		m_log << TestLog::Message << "glGetProgramiv(" << param0 << ", " << getProgramParamStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
944	m_gl.getProgramiv(param0, param1, param2);
945	if (m_enableLog)
946	{
947		m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, 1) << TestLog::EndMessage;
948	}
949}
950
951void CallLogWrapper::glGetProgramInfoLog (glw::GLuint param0, glw::GLsizei param1, glw::GLsizei* param2, glw::GLchar* param3)
952{
953	if (m_enableLog)
954		m_log << TestLog::Message << "glGetProgramInfoLog(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
955	m_gl.getProgramInfoLog(param0, param1, param2, param3);
956}
957
958void CallLogWrapper::glGetShaderiv (glw::GLuint param0, glw::GLenum param1, glw::GLint* param2)
959{
960	if (m_enableLog)
961		m_log << TestLog::Message << "glGetShaderiv(" << param0 << ", " << getShaderParamStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
962	m_gl.getShaderiv(param0, param1, param2);
963	if (m_enableLog)
964	{
965		m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, 1) << TestLog::EndMessage;
966	}
967}
968
969void CallLogWrapper::glGetShaderInfoLog (glw::GLuint param0, glw::GLsizei param1, glw::GLsizei* param2, glw::GLchar* param3)
970{
971	if (m_enableLog)
972		m_log << TestLog::Message << "glGetShaderInfoLog(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
973	m_gl.getShaderInfoLog(param0, param1, param2, param3);
974}
975
976void CallLogWrapper::glGetShaderSource (glw::GLuint param0, glw::GLsizei param1, glw::GLsizei* param2, glw::GLchar* param3)
977{
978	if (m_enableLog)
979		m_log << TestLog::Message << "glGetShaderSource(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
980	m_gl.getShaderSource(param0, param1, param2, param3);
981}
982
983glw::GLint CallLogWrapper::glGetUniformLocation (glw::GLuint param0, const glw::GLchar* param1)
984{
985	if (m_enableLog)
986		m_log << TestLog::Message << "glGetUniformLocation(" << param0 << ", " << getStringStr(param1) << ");" << TestLog::EndMessage;
987	glw::GLint returnValue = m_gl.getUniformLocation(param0, param1);
988	if (m_enableLog)
989		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
990	return returnValue;
991}
992
993void CallLogWrapper::glGetUniformfv (glw::GLuint param0, glw::GLint param1, glw::GLfloat* param2)
994{
995	if (m_enableLog)
996		m_log << TestLog::Message << "glGetUniformfv(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
997	m_gl.getUniformfv(param0, param1, param2);
998}
999
1000void CallLogWrapper::glGetUniformiv (glw::GLuint param0, glw::GLint param1, glw::GLint* param2)
1001{
1002	if (m_enableLog)
1003		m_log << TestLog::Message << "glGetUniformiv(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1004	m_gl.getUniformiv(param0, param1, param2);
1005}
1006
1007void CallLogWrapper::glGetVertexAttribdv (glw::GLuint param0, glw::GLenum param1, glw::GLdouble* param2)
1008{
1009	if (m_enableLog)
1010		m_log << TestLog::Message << "glGetVertexAttribdv(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1011	m_gl.getVertexAttribdv(param0, param1, param2);
1012}
1013
1014void CallLogWrapper::glGetVertexAttribfv (glw::GLuint param0, glw::GLenum param1, glw::GLfloat* param2)
1015{
1016	if (m_enableLog)
1017		m_log << TestLog::Message << "glGetVertexAttribfv(" << param0 << ", " << getVertexAttribParameterNameStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1018	m_gl.getVertexAttribfv(param0, param1, param2);
1019	if (m_enableLog)
1020	{
1021		m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, (param1 == GL_CURRENT_VERTEX_ATTRIB ? 4 : 1)) << TestLog::EndMessage;
1022	}
1023}
1024
1025void CallLogWrapper::glGetVertexAttribiv (glw::GLuint param0, glw::GLenum param1, glw::GLint* param2)
1026{
1027	if (m_enableLog)
1028		m_log << TestLog::Message << "glGetVertexAttribiv(" << param0 << ", " << getVertexAttribParameterNameStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1029	m_gl.getVertexAttribiv(param0, param1, param2);
1030	if (m_enableLog)
1031	{
1032		m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, (param1 == GL_CURRENT_VERTEX_ATTRIB ? 4 : 1)) << TestLog::EndMessage;
1033	}
1034}
1035
1036void CallLogWrapper::glGetVertexAttribPointerv (glw::GLuint param0, glw::GLenum param1, glw::GLvoid** param2)
1037{
1038	if (m_enableLog)
1039		m_log << TestLog::Message << "glGetVertexAttribPointerv(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1040	m_gl.getVertexAttribPointerv(param0, param1, param2);
1041}
1042
1043glw::GLboolean CallLogWrapper::glIsProgram (glw::GLuint param0)
1044{
1045	if (m_enableLog)
1046		m_log << TestLog::Message << "glIsProgram(" << param0 << ");" << TestLog::EndMessage;
1047	glw::GLboolean returnValue = m_gl.isProgram(param0);
1048	if (m_enableLog)
1049		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
1050	return returnValue;
1051}
1052
1053glw::GLboolean CallLogWrapper::glIsShader (glw::GLuint param0)
1054{
1055	if (m_enableLog)
1056		m_log << TestLog::Message << "glIsShader(" << param0 << ");" << TestLog::EndMessage;
1057	glw::GLboolean returnValue = m_gl.isShader(param0);
1058	if (m_enableLog)
1059		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
1060	return returnValue;
1061}
1062
1063void CallLogWrapper::glLinkProgram (glw::GLuint param0)
1064{
1065	if (m_enableLog)
1066		m_log << TestLog::Message << "glLinkProgram(" << param0 << ");" << TestLog::EndMessage;
1067	m_gl.linkProgram(param0);
1068}
1069
1070void CallLogWrapper::glShaderSource (glw::GLuint param0, glw::GLsizei param1, const glw::GLchar* const* param2, const glw::GLint* param3)
1071{
1072	if (m_enableLog)
1073		m_log << TestLog::Message << "glShaderSource(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
1074	m_gl.shaderSource(param0, param1, param2, param3);
1075}
1076
1077void CallLogWrapper::glUseProgram (glw::GLuint param0)
1078{
1079	if (m_enableLog)
1080		m_log << TestLog::Message << "glUseProgram(" << param0 << ");" << TestLog::EndMessage;
1081	m_gl.useProgram(param0);
1082}
1083
1084void CallLogWrapper::glUniform1f (glw::GLint param0, glw::GLfloat param1)
1085{
1086	if (m_enableLog)
1087		m_log << TestLog::Message << "glUniform1f(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
1088	m_gl.uniform1f(param0, param1);
1089}
1090
1091void CallLogWrapper::glUniform2f (glw::GLint param0, glw::GLfloat param1, glw::GLfloat param2)
1092{
1093	if (m_enableLog)
1094		m_log << TestLog::Message << "glUniform2f(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
1095	m_gl.uniform2f(param0, param1, param2);
1096}
1097
1098void CallLogWrapper::glUniform3f (glw::GLint param0, glw::GLfloat param1, glw::GLfloat param2, glw::GLfloat param3)
1099{
1100	if (m_enableLog)
1101		m_log << TestLog::Message << "glUniform3f(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
1102	m_gl.uniform3f(param0, param1, param2, param3);
1103}
1104
1105void CallLogWrapper::glUniform4f (glw::GLint param0, glw::GLfloat param1, glw::GLfloat param2, glw::GLfloat param3, glw::GLfloat param4)
1106{
1107	if (m_enableLog)
1108		m_log << TestLog::Message << "glUniform4f(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
1109	m_gl.uniform4f(param0, param1, param2, param3, param4);
1110}
1111
1112void CallLogWrapper::glUniform1i (glw::GLint param0, glw::GLint param1)
1113{
1114	if (m_enableLog)
1115		m_log << TestLog::Message << "glUniform1i(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
1116	m_gl.uniform1i(param0, param1);
1117}
1118
1119void CallLogWrapper::glUniform2i (glw::GLint param0, glw::GLint param1, glw::GLint param2)
1120{
1121	if (m_enableLog)
1122		m_log << TestLog::Message << "glUniform2i(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
1123	m_gl.uniform2i(param0, param1, param2);
1124}
1125
1126void CallLogWrapper::glUniform3i (glw::GLint param0, glw::GLint param1, glw::GLint param2, glw::GLint param3)
1127{
1128	if (m_enableLog)
1129		m_log << TestLog::Message << "glUniform3i(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
1130	m_gl.uniform3i(param0, param1, param2, param3);
1131}
1132
1133void CallLogWrapper::glUniform4i (glw::GLint param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLint param4)
1134{
1135	if (m_enableLog)
1136		m_log << TestLog::Message << "glUniform4i(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
1137	m_gl.uniform4i(param0, param1, param2, param3, param4);
1138}
1139
1140void CallLogWrapper::glUniform1fv (glw::GLint param0, glw::GLsizei param1, const glw::GLfloat* param2)
1141{
1142	if (m_enableLog)
1143		m_log << TestLog::Message << "glUniform1fv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, (param1 * 1)) << ");" << TestLog::EndMessage;
1144	m_gl.uniform1fv(param0, param1, param2);
1145}
1146
1147void CallLogWrapper::glUniform2fv (glw::GLint param0, glw::GLsizei param1, const glw::GLfloat* param2)
1148{
1149	if (m_enableLog)
1150		m_log << TestLog::Message << "glUniform2fv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, (param1 * 2)) << ");" << TestLog::EndMessage;
1151	m_gl.uniform2fv(param0, param1, param2);
1152}
1153
1154void CallLogWrapper::glUniform3fv (glw::GLint param0, glw::GLsizei param1, const glw::GLfloat* param2)
1155{
1156	if (m_enableLog)
1157		m_log << TestLog::Message << "glUniform3fv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, (param1 * 3)) << ");" << TestLog::EndMessage;
1158	m_gl.uniform3fv(param0, param1, param2);
1159}
1160
1161void CallLogWrapper::glUniform4fv (glw::GLint param0, glw::GLsizei param1, const glw::GLfloat* param2)
1162{
1163	if (m_enableLog)
1164		m_log << TestLog::Message << "glUniform4fv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, (param1 * 4)) << ");" << TestLog::EndMessage;
1165	m_gl.uniform4fv(param0, param1, param2);
1166}
1167
1168void CallLogWrapper::glUniform1iv (glw::GLint param0, glw::GLsizei param1, const glw::GLint* param2)
1169{
1170	if (m_enableLog)
1171		m_log << TestLog::Message << "glUniform1iv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, (param1 * 1)) << ");" << TestLog::EndMessage;
1172	m_gl.uniform1iv(param0, param1, param2);
1173}
1174
1175void CallLogWrapper::glUniform2iv (glw::GLint param0, glw::GLsizei param1, const glw::GLint* param2)
1176{
1177	if (m_enableLog)
1178		m_log << TestLog::Message << "glUniform2iv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, (param1 * 2)) << ");" << TestLog::EndMessage;
1179	m_gl.uniform2iv(param0, param1, param2);
1180}
1181
1182void CallLogWrapper::glUniform3iv (glw::GLint param0, glw::GLsizei param1, const glw::GLint* param2)
1183{
1184	if (m_enableLog)
1185		m_log << TestLog::Message << "glUniform3iv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, (param1 * 3)) << ");" << TestLog::EndMessage;
1186	m_gl.uniform3iv(param0, param1, param2);
1187}
1188
1189void CallLogWrapper::glUniform4iv (glw::GLint param0, glw::GLsizei param1, const glw::GLint* param2)
1190{
1191	if (m_enableLog)
1192		m_log << TestLog::Message << "glUniform4iv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, (param1 * 4)) << ");" << TestLog::EndMessage;
1193	m_gl.uniform4iv(param0, param1, param2);
1194}
1195
1196void CallLogWrapper::glUniformMatrix2fv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLfloat* param3)
1197{
1198	if (m_enableLog)
1199		m_log << TestLog::Message << "glUniformMatrix2fv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << getPointerStr(param3, (param1 * 2*2)) << ");" << TestLog::EndMessage;
1200	m_gl.uniformMatrix2fv(param0, param1, param2, param3);
1201}
1202
1203void CallLogWrapper::glUniformMatrix3fv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLfloat* param3)
1204{
1205	if (m_enableLog)
1206		m_log << TestLog::Message << "glUniformMatrix3fv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << getPointerStr(param3, (param1 * 3*3)) << ");" << TestLog::EndMessage;
1207	m_gl.uniformMatrix3fv(param0, param1, param2, param3);
1208}
1209
1210void CallLogWrapper::glUniformMatrix4fv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLfloat* param3)
1211{
1212	if (m_enableLog)
1213		m_log << TestLog::Message << "glUniformMatrix4fv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << getPointerStr(param3, (param1 * 4*4)) << ");" << TestLog::EndMessage;
1214	m_gl.uniformMatrix4fv(param0, param1, param2, param3);
1215}
1216
1217void CallLogWrapper::glValidateProgram (glw::GLuint param0)
1218{
1219	if (m_enableLog)
1220		m_log << TestLog::Message << "glValidateProgram(" << param0 << ");" << TestLog::EndMessage;
1221	m_gl.validateProgram(param0);
1222}
1223
1224void CallLogWrapper::glVertexAttrib1d (glw::GLuint param0, glw::GLdouble param1)
1225{
1226	if (m_enableLog)
1227		m_log << TestLog::Message << "glVertexAttrib1d(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
1228	m_gl.vertexAttrib1d(param0, param1);
1229}
1230
1231void CallLogWrapper::glVertexAttrib1dv (glw::GLuint param0, const glw::GLdouble* param1)
1232{
1233	if (m_enableLog)
1234		m_log << TestLog::Message << "glVertexAttrib1dv(" << param0 << ", " << getPointerStr(param1, 1) << ");" << TestLog::EndMessage;
1235	m_gl.vertexAttrib1dv(param0, param1);
1236}
1237
1238void CallLogWrapper::glVertexAttrib1f (glw::GLuint param0, glw::GLfloat param1)
1239{
1240	if (m_enableLog)
1241		m_log << TestLog::Message << "glVertexAttrib1f(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
1242	m_gl.vertexAttrib1f(param0, param1);
1243}
1244
1245void CallLogWrapper::glVertexAttrib1fv (glw::GLuint param0, const glw::GLfloat* param1)
1246{
1247	if (m_enableLog)
1248		m_log << TestLog::Message << "glVertexAttrib1fv(" << param0 << ", " << getPointerStr(param1, 1) << ");" << TestLog::EndMessage;
1249	m_gl.vertexAttrib1fv(param0, param1);
1250}
1251
1252void CallLogWrapper::glVertexAttrib1s (glw::GLuint param0, glw::GLshort param1)
1253{
1254	if (m_enableLog)
1255		m_log << TestLog::Message << "glVertexAttrib1s(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
1256	m_gl.vertexAttrib1s(param0, param1);
1257}
1258
1259void CallLogWrapper::glVertexAttrib1sv (glw::GLuint param0, const glw::GLshort* param1)
1260{
1261	if (m_enableLog)
1262		m_log << TestLog::Message << "glVertexAttrib1sv(" << param0 << ", " << getPointerStr(param1, 1) << ");" << TestLog::EndMessage;
1263	m_gl.vertexAttrib1sv(param0, param1);
1264}
1265
1266void CallLogWrapper::glVertexAttrib2d (glw::GLuint param0, glw::GLdouble param1, glw::GLdouble param2)
1267{
1268	if (m_enableLog)
1269		m_log << TestLog::Message << "glVertexAttrib2d(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
1270	m_gl.vertexAttrib2d(param0, param1, param2);
1271}
1272
1273void CallLogWrapper::glVertexAttrib2dv (glw::GLuint param0, const glw::GLdouble* param1)
1274{
1275	if (m_enableLog)
1276		m_log << TestLog::Message << "glVertexAttrib2dv(" << param0 << ", " << getPointerStr(param1, 2) << ");" << TestLog::EndMessage;
1277	m_gl.vertexAttrib2dv(param0, param1);
1278}
1279
1280void CallLogWrapper::glVertexAttrib2f (glw::GLuint param0, glw::GLfloat param1, glw::GLfloat param2)
1281{
1282	if (m_enableLog)
1283		m_log << TestLog::Message << "glVertexAttrib2f(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
1284	m_gl.vertexAttrib2f(param0, param1, param2);
1285}
1286
1287void CallLogWrapper::glVertexAttrib2fv (glw::GLuint param0, const glw::GLfloat* param1)
1288{
1289	if (m_enableLog)
1290		m_log << TestLog::Message << "glVertexAttrib2fv(" << param0 << ", " << getPointerStr(param1, 2) << ");" << TestLog::EndMessage;
1291	m_gl.vertexAttrib2fv(param0, param1);
1292}
1293
1294void CallLogWrapper::glVertexAttrib2s (glw::GLuint param0, glw::GLshort param1, glw::GLshort param2)
1295{
1296	if (m_enableLog)
1297		m_log << TestLog::Message << "glVertexAttrib2s(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
1298	m_gl.vertexAttrib2s(param0, param1, param2);
1299}
1300
1301void CallLogWrapper::glVertexAttrib2sv (glw::GLuint param0, const glw::GLshort* param1)
1302{
1303	if (m_enableLog)
1304		m_log << TestLog::Message << "glVertexAttrib2sv(" << param0 << ", " << getPointerStr(param1, 2) << ");" << TestLog::EndMessage;
1305	m_gl.vertexAttrib2sv(param0, param1);
1306}
1307
1308void CallLogWrapper::glVertexAttrib3d (glw::GLuint param0, glw::GLdouble param1, glw::GLdouble param2, glw::GLdouble param3)
1309{
1310	if (m_enableLog)
1311		m_log << TestLog::Message << "glVertexAttrib3d(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
1312	m_gl.vertexAttrib3d(param0, param1, param2, param3);
1313}
1314
1315void CallLogWrapper::glVertexAttrib3dv (glw::GLuint param0, const glw::GLdouble* param1)
1316{
1317	if (m_enableLog)
1318		m_log << TestLog::Message << "glVertexAttrib3dv(" << param0 << ", " << getPointerStr(param1, 3) << ");" << TestLog::EndMessage;
1319	m_gl.vertexAttrib3dv(param0, param1);
1320}
1321
1322void CallLogWrapper::glVertexAttrib3f (glw::GLuint param0, glw::GLfloat param1, glw::GLfloat param2, glw::GLfloat param3)
1323{
1324	if (m_enableLog)
1325		m_log << TestLog::Message << "glVertexAttrib3f(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
1326	m_gl.vertexAttrib3f(param0, param1, param2, param3);
1327}
1328
1329void CallLogWrapper::glVertexAttrib3fv (glw::GLuint param0, const glw::GLfloat* param1)
1330{
1331	if (m_enableLog)
1332		m_log << TestLog::Message << "glVertexAttrib3fv(" << param0 << ", " << getPointerStr(param1, 3) << ");" << TestLog::EndMessage;
1333	m_gl.vertexAttrib3fv(param0, param1);
1334}
1335
1336void CallLogWrapper::glVertexAttrib3s (glw::GLuint param0, glw::GLshort param1, glw::GLshort param2, glw::GLshort param3)
1337{
1338	if (m_enableLog)
1339		m_log << TestLog::Message << "glVertexAttrib3s(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
1340	m_gl.vertexAttrib3s(param0, param1, param2, param3);
1341}
1342
1343void CallLogWrapper::glVertexAttrib3sv (glw::GLuint param0, const glw::GLshort* param1)
1344{
1345	if (m_enableLog)
1346		m_log << TestLog::Message << "glVertexAttrib3sv(" << param0 << ", " << getPointerStr(param1, 3) << ");" << TestLog::EndMessage;
1347	m_gl.vertexAttrib3sv(param0, param1);
1348}
1349
1350void CallLogWrapper::glVertexAttrib4Nbv (glw::GLuint param0, const glw::GLbyte* param1)
1351{
1352	if (m_enableLog)
1353		m_log << TestLog::Message << "glVertexAttrib4Nbv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1354	m_gl.vertexAttrib4Nbv(param0, param1);
1355}
1356
1357void CallLogWrapper::glVertexAttrib4Niv (glw::GLuint param0, const glw::GLint* param1)
1358{
1359	if (m_enableLog)
1360		m_log << TestLog::Message << "glVertexAttrib4Niv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1361	m_gl.vertexAttrib4Niv(param0, param1);
1362}
1363
1364void CallLogWrapper::glVertexAttrib4Nsv (glw::GLuint param0, const glw::GLshort* param1)
1365{
1366	if (m_enableLog)
1367		m_log << TestLog::Message << "glVertexAttrib4Nsv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1368	m_gl.vertexAttrib4Nsv(param0, param1);
1369}
1370
1371void CallLogWrapper::glVertexAttrib4Nub (glw::GLuint param0, glw::GLubyte param1, glw::GLubyte param2, glw::GLubyte param3, glw::GLubyte param4)
1372{
1373	if (m_enableLog)
1374		m_log << TestLog::Message << "glVertexAttrib4Nub(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
1375	m_gl.vertexAttrib4Nub(param0, param1, param2, param3, param4);
1376}
1377
1378void CallLogWrapper::glVertexAttrib4Nubv (glw::GLuint param0, const glw::GLubyte* param1)
1379{
1380	if (m_enableLog)
1381		m_log << TestLog::Message << "glVertexAttrib4Nubv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1382	m_gl.vertexAttrib4Nubv(param0, param1);
1383}
1384
1385void CallLogWrapper::glVertexAttrib4Nuiv (glw::GLuint param0, const glw::GLuint* param1)
1386{
1387	if (m_enableLog)
1388		m_log << TestLog::Message << "glVertexAttrib4Nuiv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1389	m_gl.vertexAttrib4Nuiv(param0, param1);
1390}
1391
1392void CallLogWrapper::glVertexAttrib4Nusv (glw::GLuint param0, const glw::GLushort* param1)
1393{
1394	if (m_enableLog)
1395		m_log << TestLog::Message << "glVertexAttrib4Nusv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1396	m_gl.vertexAttrib4Nusv(param0, param1);
1397}
1398
1399void CallLogWrapper::glVertexAttrib4bv (glw::GLuint param0, const glw::GLbyte* param1)
1400{
1401	if (m_enableLog)
1402		m_log << TestLog::Message << "glVertexAttrib4bv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1403	m_gl.vertexAttrib4bv(param0, param1);
1404}
1405
1406void CallLogWrapper::glVertexAttrib4d (glw::GLuint param0, glw::GLdouble param1, glw::GLdouble param2, glw::GLdouble param3, glw::GLdouble param4)
1407{
1408	if (m_enableLog)
1409		m_log << TestLog::Message << "glVertexAttrib4d(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
1410	m_gl.vertexAttrib4d(param0, param1, param2, param3, param4);
1411}
1412
1413void CallLogWrapper::glVertexAttrib4dv (glw::GLuint param0, const glw::GLdouble* param1)
1414{
1415	if (m_enableLog)
1416		m_log << TestLog::Message << "glVertexAttrib4dv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1417	m_gl.vertexAttrib4dv(param0, param1);
1418}
1419
1420void CallLogWrapper::glVertexAttrib4f (glw::GLuint param0, glw::GLfloat param1, glw::GLfloat param2, glw::GLfloat param3, glw::GLfloat param4)
1421{
1422	if (m_enableLog)
1423		m_log << TestLog::Message << "glVertexAttrib4f(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
1424	m_gl.vertexAttrib4f(param0, param1, param2, param3, param4);
1425}
1426
1427void CallLogWrapper::glVertexAttrib4fv (glw::GLuint param0, const glw::GLfloat* param1)
1428{
1429	if (m_enableLog)
1430		m_log << TestLog::Message << "glVertexAttrib4fv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1431	m_gl.vertexAttrib4fv(param0, param1);
1432}
1433
1434void CallLogWrapper::glVertexAttrib4iv (glw::GLuint param0, const glw::GLint* param1)
1435{
1436	if (m_enableLog)
1437		m_log << TestLog::Message << "glVertexAttrib4iv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1438	m_gl.vertexAttrib4iv(param0, param1);
1439}
1440
1441void CallLogWrapper::glVertexAttrib4s (glw::GLuint param0, glw::GLshort param1, glw::GLshort param2, glw::GLshort param3, glw::GLshort param4)
1442{
1443	if (m_enableLog)
1444		m_log << TestLog::Message << "glVertexAttrib4s(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
1445	m_gl.vertexAttrib4s(param0, param1, param2, param3, param4);
1446}
1447
1448void CallLogWrapper::glVertexAttrib4sv (glw::GLuint param0, const glw::GLshort* param1)
1449{
1450	if (m_enableLog)
1451		m_log << TestLog::Message << "glVertexAttrib4sv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1452	m_gl.vertexAttrib4sv(param0, param1);
1453}
1454
1455void CallLogWrapper::glVertexAttrib4ubv (glw::GLuint param0, const glw::GLubyte* param1)
1456{
1457	if (m_enableLog)
1458		m_log << TestLog::Message << "glVertexAttrib4ubv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1459	m_gl.vertexAttrib4ubv(param0, param1);
1460}
1461
1462void CallLogWrapper::glVertexAttrib4uiv (glw::GLuint param0, const glw::GLuint* param1)
1463{
1464	if (m_enableLog)
1465		m_log << TestLog::Message << "glVertexAttrib4uiv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1466	m_gl.vertexAttrib4uiv(param0, param1);
1467}
1468
1469void CallLogWrapper::glVertexAttrib4usv (glw::GLuint param0, const glw::GLushort* param1)
1470{
1471	if (m_enableLog)
1472		m_log << TestLog::Message << "glVertexAttrib4usv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1473	m_gl.vertexAttrib4usv(param0, param1);
1474}
1475
1476void CallLogWrapper::glVertexAttribPointer (glw::GLuint param0, glw::GLint param1, glw::GLenum param2, glw::GLboolean param3, glw::GLsizei param4, const glw::GLvoid* param5)
1477{
1478	if (m_enableLog)
1479		m_log << TestLog::Message << "glVertexAttribPointer(" << param0 << ", " << param1 << ", " << getTypeStr(param2) << ", " << getBooleanStr(param3) << ", " << param4 << ", " << toHex(param5) << ");" << TestLog::EndMessage;
1480	m_gl.vertexAttribPointer(param0, param1, param2, param3, param4, param5);
1481}
1482
1483void CallLogWrapper::glUniformMatrix2x3fv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLfloat* param3)
1484{
1485	if (m_enableLog)
1486		m_log << TestLog::Message << "glUniformMatrix2x3fv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << getPointerStr(param3, (param1 * 2*3)) << ");" << TestLog::EndMessage;
1487	m_gl.uniformMatrix2x3fv(param0, param1, param2, param3);
1488}
1489
1490void CallLogWrapper::glUniformMatrix3x2fv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLfloat* param3)
1491{
1492	if (m_enableLog)
1493		m_log << TestLog::Message << "glUniformMatrix3x2fv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << getPointerStr(param3, (param1 * 3*2)) << ");" << TestLog::EndMessage;
1494	m_gl.uniformMatrix3x2fv(param0, param1, param2, param3);
1495}
1496
1497void CallLogWrapper::glUniformMatrix2x4fv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLfloat* param3)
1498{
1499	if (m_enableLog)
1500		m_log << TestLog::Message << "glUniformMatrix2x4fv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << getPointerStr(param3, (param1 * 2*4)) << ");" << TestLog::EndMessage;
1501	m_gl.uniformMatrix2x4fv(param0, param1, param2, param3);
1502}
1503
1504void CallLogWrapper::glUniformMatrix4x2fv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLfloat* param3)
1505{
1506	if (m_enableLog)
1507		m_log << TestLog::Message << "glUniformMatrix4x2fv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << getPointerStr(param3, (param1 * 4*2)) << ");" << TestLog::EndMessage;
1508	m_gl.uniformMatrix4x2fv(param0, param1, param2, param3);
1509}
1510
1511void CallLogWrapper::glUniformMatrix3x4fv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLfloat* param3)
1512{
1513	if (m_enableLog)
1514		m_log << TestLog::Message << "glUniformMatrix3x4fv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << getPointerStr(param3, (param1 * 3*4)) << ");" << TestLog::EndMessage;
1515	m_gl.uniformMatrix3x4fv(param0, param1, param2, param3);
1516}
1517
1518void CallLogWrapper::glUniformMatrix4x3fv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLfloat* param3)
1519{
1520	if (m_enableLog)
1521		m_log << TestLog::Message << "glUniformMatrix4x3fv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << getPointerStr(param3, (param1 * 4*3)) << ");" << TestLog::EndMessage;
1522	m_gl.uniformMatrix4x3fv(param0, param1, param2, param3);
1523}
1524
1525void CallLogWrapper::glColorMaski (glw::GLuint param0, glw::GLboolean param1, glw::GLboolean param2, glw::GLboolean param3, glw::GLboolean param4)
1526{
1527	if (m_enableLog)
1528		m_log << TestLog::Message << "glColorMaski(" << param0 << ", " << getBooleanStr(param1) << ", " << getBooleanStr(param2) << ", " << getBooleanStr(param3) << ", " << getBooleanStr(param4) << ");" << TestLog::EndMessage;
1529	m_gl.colorMaski(param0, param1, param2, param3, param4);
1530}
1531
1532void CallLogWrapper::glGetBooleani_v (glw::GLenum param0, glw::GLuint param1, glw::GLboolean* param2)
1533{
1534	if (m_enableLog)
1535		m_log << TestLog::Message << "glGetBooleani_v(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1536	m_gl.getBooleani_v(param0, param1, param2);
1537}
1538
1539void CallLogWrapper::glGetIntegeri_v (glw::GLenum param0, glw::GLuint param1, glw::GLint* param2)
1540{
1541	if (m_enableLog)
1542		m_log << TestLog::Message << "glGetIntegeri_v(" << getGettableIndexedStateStr(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1543	m_gl.getIntegeri_v(param0, param1, param2);
1544}
1545
1546void CallLogWrapper::glEnablei (glw::GLenum param0, glw::GLuint param1)
1547{
1548	if (m_enableLog)
1549		m_log << TestLog::Message << "glEnablei(" << toHex(param0) << ", " << param1 << ");" << TestLog::EndMessage;
1550	m_gl.enablei(param0, param1);
1551}
1552
1553void CallLogWrapper::glDisablei (glw::GLenum param0, glw::GLuint param1)
1554{
1555	if (m_enableLog)
1556		m_log << TestLog::Message << "glDisablei(" << toHex(param0) << ", " << param1 << ");" << TestLog::EndMessage;
1557	m_gl.disablei(param0, param1);
1558}
1559
1560glw::GLboolean CallLogWrapper::glIsEnabledi (glw::GLenum param0, glw::GLuint param1)
1561{
1562	if (m_enableLog)
1563		m_log << TestLog::Message << "glIsEnabledi(" << toHex(param0) << ", " << param1 << ");" << TestLog::EndMessage;
1564	glw::GLboolean returnValue = m_gl.isEnabledi(param0, param1);
1565	if (m_enableLog)
1566		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
1567	return returnValue;
1568}
1569
1570void CallLogWrapper::glBeginTransformFeedback (glw::GLenum param0)
1571{
1572	if (m_enableLog)
1573		m_log << TestLog::Message << "glBeginTransformFeedback(" << getPrimitiveTypeStr(param0) << ");" << TestLog::EndMessage;
1574	m_gl.beginTransformFeedback(param0);
1575}
1576
1577void CallLogWrapper::glEndTransformFeedback ()
1578{
1579	if (m_enableLog)
1580		m_log << TestLog::Message << "glEndTransformFeedback(" << ");" << TestLog::EndMessage;
1581	m_gl.endTransformFeedback();
1582}
1583
1584void CallLogWrapper::glBindBufferRange (glw::GLenum param0, glw::GLuint param1, glw::GLuint param2, glw::GLintptr param3, glw::GLsizeiptr param4)
1585{
1586	if (m_enableLog)
1587		m_log << TestLog::Message << "glBindBufferRange(" << getBufferTargetStr(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
1588	m_gl.bindBufferRange(param0, param1, param2, param3, param4);
1589}
1590
1591void CallLogWrapper::glBindBufferBase (glw::GLenum param0, glw::GLuint param1, glw::GLuint param2)
1592{
1593	if (m_enableLog)
1594		m_log << TestLog::Message << "glBindBufferBase(" << getBufferTargetStr(param0) << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
1595	m_gl.bindBufferBase(param0, param1, param2);
1596}
1597
1598void CallLogWrapper::glTransformFeedbackVaryings (glw::GLuint param0, glw::GLsizei param1, const glw::GLchar* const* param2, glw::GLenum param3)
1599{
1600	if (m_enableLog)
1601		m_log << TestLog::Message << "glTransformFeedbackVaryings(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
1602	m_gl.transformFeedbackVaryings(param0, param1, param2, param3);
1603}
1604
1605void CallLogWrapper::glGetTransformFeedbackVarying (glw::GLuint param0, glw::GLuint param1, glw::GLsizei param2, glw::GLsizei* param3, glw::GLsizei* param4, glw::GLenum* param5, glw::GLchar* param6)
1606{
1607	if (m_enableLog)
1608		m_log << TestLog::Message << "glGetTransformFeedbackVarying(" << param0 << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ", " << toHex(param4) << ", " << toHex(param5) << ", " << toHex(param6) << ");" << TestLog::EndMessage;
1609	m_gl.getTransformFeedbackVarying(param0, param1, param2, param3, param4, param5, param6);
1610}
1611
1612void CallLogWrapper::glClampColor (glw::GLenum param0, glw::GLenum param1)
1613{
1614	if (m_enableLog)
1615		m_log << TestLog::Message << "glClampColor(" << toHex(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
1616	m_gl.clampColor(param0, param1);
1617}
1618
1619void CallLogWrapper::glBeginConditionalRender (glw::GLuint param0, glw::GLenum param1)
1620{
1621	if (m_enableLog)
1622		m_log << TestLog::Message << "glBeginConditionalRender(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
1623	m_gl.beginConditionalRender(param0, param1);
1624}
1625
1626void CallLogWrapper::glEndConditionalRender ()
1627{
1628	if (m_enableLog)
1629		m_log << TestLog::Message << "glEndConditionalRender(" << ");" << TestLog::EndMessage;
1630	m_gl.endConditionalRender();
1631}
1632
1633void CallLogWrapper::glVertexAttribIPointer (glw::GLuint param0, glw::GLint param1, glw::GLenum param2, glw::GLsizei param3, const glw::GLvoid* param4)
1634{
1635	if (m_enableLog)
1636		m_log << TestLog::Message << "glVertexAttribIPointer(" << param0 << ", " << param1 << ", " << getTypeStr(param2) << ", " << param3 << ", " << toHex(param4) << ");" << TestLog::EndMessage;
1637	m_gl.vertexAttribIPointer(param0, param1, param2, param3, param4);
1638}
1639
1640void CallLogWrapper::glGetVertexAttribIiv (glw::GLuint param0, glw::GLenum param1, glw::GLint* param2)
1641{
1642	if (m_enableLog)
1643		m_log << TestLog::Message << "glGetVertexAttribIiv(" << param0 << ", " << getVertexAttribParameterNameStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1644	m_gl.getVertexAttribIiv(param0, param1, param2);
1645	if (m_enableLog)
1646	{
1647		m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, (param1 == GL_CURRENT_VERTEX_ATTRIB ? 4 : 1)) << TestLog::EndMessage;
1648	}
1649}
1650
1651void CallLogWrapper::glGetVertexAttribIuiv (glw::GLuint param0, glw::GLenum param1, glw::GLuint* param2)
1652{
1653	if (m_enableLog)
1654		m_log << TestLog::Message << "glGetVertexAttribIuiv(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1655	m_gl.getVertexAttribIuiv(param0, param1, param2);
1656}
1657
1658void CallLogWrapper::glVertexAttribI1i (glw::GLuint param0, glw::GLint param1)
1659{
1660	if (m_enableLog)
1661		m_log << TestLog::Message << "glVertexAttribI1i(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
1662	m_gl.vertexAttribI1i(param0, param1);
1663}
1664
1665void CallLogWrapper::glVertexAttribI2i (glw::GLuint param0, glw::GLint param1, glw::GLint param2)
1666{
1667	if (m_enableLog)
1668		m_log << TestLog::Message << "glVertexAttribI2i(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
1669	m_gl.vertexAttribI2i(param0, param1, param2);
1670}
1671
1672void CallLogWrapper::glVertexAttribI3i (glw::GLuint param0, glw::GLint param1, glw::GLint param2, glw::GLint param3)
1673{
1674	if (m_enableLog)
1675		m_log << TestLog::Message << "glVertexAttribI3i(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
1676	m_gl.vertexAttribI3i(param0, param1, param2, param3);
1677}
1678
1679void CallLogWrapper::glVertexAttribI4i (glw::GLuint param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLint param4)
1680{
1681	if (m_enableLog)
1682		m_log << TestLog::Message << "glVertexAttribI4i(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
1683	m_gl.vertexAttribI4i(param0, param1, param2, param3, param4);
1684}
1685
1686void CallLogWrapper::glVertexAttribI1ui (glw::GLuint param0, glw::GLuint param1)
1687{
1688	if (m_enableLog)
1689		m_log << TestLog::Message << "glVertexAttribI1ui(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
1690	m_gl.vertexAttribI1ui(param0, param1);
1691}
1692
1693void CallLogWrapper::glVertexAttribI2ui (glw::GLuint param0, glw::GLuint param1, glw::GLuint param2)
1694{
1695	if (m_enableLog)
1696		m_log << TestLog::Message << "glVertexAttribI2ui(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
1697	m_gl.vertexAttribI2ui(param0, param1, param2);
1698}
1699
1700void CallLogWrapper::glVertexAttribI3ui (glw::GLuint param0, glw::GLuint param1, glw::GLuint param2, glw::GLuint param3)
1701{
1702	if (m_enableLog)
1703		m_log << TestLog::Message << "glVertexAttribI3ui(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
1704	m_gl.vertexAttribI3ui(param0, param1, param2, param3);
1705}
1706
1707void CallLogWrapper::glVertexAttribI4ui (glw::GLuint param0, glw::GLuint param1, glw::GLuint param2, glw::GLuint param3, glw::GLuint param4)
1708{
1709	if (m_enableLog)
1710		m_log << TestLog::Message << "glVertexAttribI4ui(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
1711	m_gl.vertexAttribI4ui(param0, param1, param2, param3, param4);
1712}
1713
1714void CallLogWrapper::glVertexAttribI1iv (glw::GLuint param0, const glw::GLint* param1)
1715{
1716	if (m_enableLog)
1717		m_log << TestLog::Message << "glVertexAttribI1iv(" << param0 << ", " << getPointerStr(param1, 1) << ");" << TestLog::EndMessage;
1718	m_gl.vertexAttribI1iv(param0, param1);
1719}
1720
1721void CallLogWrapper::glVertexAttribI2iv (glw::GLuint param0, const glw::GLint* param1)
1722{
1723	if (m_enableLog)
1724		m_log << TestLog::Message << "glVertexAttribI2iv(" << param0 << ", " << getPointerStr(param1, 2) << ");" << TestLog::EndMessage;
1725	m_gl.vertexAttribI2iv(param0, param1);
1726}
1727
1728void CallLogWrapper::glVertexAttribI3iv (glw::GLuint param0, const glw::GLint* param1)
1729{
1730	if (m_enableLog)
1731		m_log << TestLog::Message << "glVertexAttribI3iv(" << param0 << ", " << getPointerStr(param1, 3) << ");" << TestLog::EndMessage;
1732	m_gl.vertexAttribI3iv(param0, param1);
1733}
1734
1735void CallLogWrapper::glVertexAttribI4iv (glw::GLuint param0, const glw::GLint* param1)
1736{
1737	if (m_enableLog)
1738		m_log << TestLog::Message << "glVertexAttribI4iv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1739	m_gl.vertexAttribI4iv(param0, param1);
1740}
1741
1742void CallLogWrapper::glVertexAttribI1uiv (glw::GLuint param0, const glw::GLuint* param1)
1743{
1744	if (m_enableLog)
1745		m_log << TestLog::Message << "glVertexAttribI1uiv(" << param0 << ", " << getPointerStr(param1, 1) << ");" << TestLog::EndMessage;
1746	m_gl.vertexAttribI1uiv(param0, param1);
1747}
1748
1749void CallLogWrapper::glVertexAttribI2uiv (glw::GLuint param0, const glw::GLuint* param1)
1750{
1751	if (m_enableLog)
1752		m_log << TestLog::Message << "glVertexAttribI2uiv(" << param0 << ", " << getPointerStr(param1, 2) << ");" << TestLog::EndMessage;
1753	m_gl.vertexAttribI2uiv(param0, param1);
1754}
1755
1756void CallLogWrapper::glVertexAttribI3uiv (glw::GLuint param0, const glw::GLuint* param1)
1757{
1758	if (m_enableLog)
1759		m_log << TestLog::Message << "glVertexAttribI3uiv(" << param0 << ", " << getPointerStr(param1, 3) << ");" << TestLog::EndMessage;
1760	m_gl.vertexAttribI3uiv(param0, param1);
1761}
1762
1763void CallLogWrapper::glVertexAttribI4uiv (glw::GLuint param0, const glw::GLuint* param1)
1764{
1765	if (m_enableLog)
1766		m_log << TestLog::Message << "glVertexAttribI4uiv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1767	m_gl.vertexAttribI4uiv(param0, param1);
1768}
1769
1770void CallLogWrapper::glVertexAttribI4bv (glw::GLuint param0, const glw::GLbyte* param1)
1771{
1772	if (m_enableLog)
1773		m_log << TestLog::Message << "glVertexAttribI4bv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1774	m_gl.vertexAttribI4bv(param0, param1);
1775}
1776
1777void CallLogWrapper::glVertexAttribI4sv (glw::GLuint param0, const glw::GLshort* param1)
1778{
1779	if (m_enableLog)
1780		m_log << TestLog::Message << "glVertexAttribI4sv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1781	m_gl.vertexAttribI4sv(param0, param1);
1782}
1783
1784void CallLogWrapper::glVertexAttribI4ubv (glw::GLuint param0, const glw::GLubyte* param1)
1785{
1786	if (m_enableLog)
1787		m_log << TestLog::Message << "glVertexAttribI4ubv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1788	m_gl.vertexAttribI4ubv(param0, param1);
1789}
1790
1791void CallLogWrapper::glVertexAttribI4usv (glw::GLuint param0, const glw::GLushort* param1)
1792{
1793	if (m_enableLog)
1794		m_log << TestLog::Message << "glVertexAttribI4usv(" << param0 << ", " << getPointerStr(param1, 4) << ");" << TestLog::EndMessage;
1795	m_gl.vertexAttribI4usv(param0, param1);
1796}
1797
1798void CallLogWrapper::glGetUniformuiv (glw::GLuint param0, glw::GLint param1, glw::GLuint* param2)
1799{
1800	if (m_enableLog)
1801		m_log << TestLog::Message << "glGetUniformuiv(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1802	m_gl.getUniformuiv(param0, param1, param2);
1803}
1804
1805void CallLogWrapper::glBindFragDataLocation (glw::GLuint param0, glw::GLuint param1, const glw::GLchar* param2)
1806{
1807	if (m_enableLog)
1808		m_log << TestLog::Message << "glBindFragDataLocation(" << param0 << ", " << param1 << ", " << getStringStr(param2) << ");" << TestLog::EndMessage;
1809	m_gl.bindFragDataLocation(param0, param1, param2);
1810}
1811
1812glw::GLint CallLogWrapper::glGetFragDataLocation (glw::GLuint param0, const glw::GLchar* param1)
1813{
1814	if (m_enableLog)
1815		m_log << TestLog::Message << "glGetFragDataLocation(" << param0 << ", " << getStringStr(param1) << ");" << TestLog::EndMessage;
1816	glw::GLint returnValue = m_gl.getFragDataLocation(param0, param1);
1817	if (m_enableLog)
1818		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
1819	return returnValue;
1820}
1821
1822void CallLogWrapper::glUniform1ui (glw::GLint param0, glw::GLuint param1)
1823{
1824	if (m_enableLog)
1825		m_log << TestLog::Message << "glUniform1ui(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
1826	m_gl.uniform1ui(param0, param1);
1827}
1828
1829void CallLogWrapper::glUniform2ui (glw::GLint param0, glw::GLuint param1, glw::GLuint param2)
1830{
1831	if (m_enableLog)
1832		m_log << TestLog::Message << "glUniform2ui(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
1833	m_gl.uniform2ui(param0, param1, param2);
1834}
1835
1836void CallLogWrapper::glUniform3ui (glw::GLint param0, glw::GLuint param1, glw::GLuint param2, glw::GLuint param3)
1837{
1838	if (m_enableLog)
1839		m_log << TestLog::Message << "glUniform3ui(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
1840	m_gl.uniform3ui(param0, param1, param2, param3);
1841}
1842
1843void CallLogWrapper::glUniform4ui (glw::GLint param0, glw::GLuint param1, glw::GLuint param2, glw::GLuint param3, glw::GLuint param4)
1844{
1845	if (m_enableLog)
1846		m_log << TestLog::Message << "glUniform4ui(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
1847	m_gl.uniform4ui(param0, param1, param2, param3, param4);
1848}
1849
1850void CallLogWrapper::glUniform1uiv (glw::GLint param0, glw::GLsizei param1, const glw::GLuint* param2)
1851{
1852	if (m_enableLog)
1853		m_log << TestLog::Message << "glUniform1uiv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, (param1 * 1)) << ");" << TestLog::EndMessage;
1854	m_gl.uniform1uiv(param0, param1, param2);
1855}
1856
1857void CallLogWrapper::glUniform2uiv (glw::GLint param0, glw::GLsizei param1, const glw::GLuint* param2)
1858{
1859	if (m_enableLog)
1860		m_log << TestLog::Message << "glUniform2uiv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, (param1 * 2)) << ");" << TestLog::EndMessage;
1861	m_gl.uniform2uiv(param0, param1, param2);
1862}
1863
1864void CallLogWrapper::glUniform3uiv (glw::GLint param0, glw::GLsizei param1, const glw::GLuint* param2)
1865{
1866	if (m_enableLog)
1867		m_log << TestLog::Message << "glUniform3uiv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, (param1 * 3)) << ");" << TestLog::EndMessage;
1868	m_gl.uniform3uiv(param0, param1, param2);
1869}
1870
1871void CallLogWrapper::glUniform4uiv (glw::GLint param0, glw::GLsizei param1, const glw::GLuint* param2)
1872{
1873	if (m_enableLog)
1874		m_log << TestLog::Message << "glUniform4uiv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, (param1 * 4)) << ");" << TestLog::EndMessage;
1875	m_gl.uniform4uiv(param0, param1, param2);
1876}
1877
1878void CallLogWrapper::glTexParameterIiv (glw::GLenum param0, glw::GLenum param1, const glw::GLint* param2)
1879{
1880	if (m_enableLog)
1881		m_log << TestLog::Message << "glTexParameterIiv(" << toHex(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1882	m_gl.texParameterIiv(param0, param1, param2);
1883}
1884
1885void CallLogWrapper::glTexParameterIuiv (glw::GLenum param0, glw::GLenum param1, const glw::GLuint* param2)
1886{
1887	if (m_enableLog)
1888		m_log << TestLog::Message << "glTexParameterIuiv(" << toHex(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1889	m_gl.texParameterIuiv(param0, param1, param2);
1890}
1891
1892void CallLogWrapper::glGetTexParameterIiv (glw::GLenum param0, glw::GLenum param1, glw::GLint* param2)
1893{
1894	if (m_enableLog)
1895		m_log << TestLog::Message << "glGetTexParameterIiv(" << toHex(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1896	m_gl.getTexParameterIiv(param0, param1, param2);
1897}
1898
1899void CallLogWrapper::glGetTexParameterIuiv (glw::GLenum param0, glw::GLenum param1, glw::GLuint* param2)
1900{
1901	if (m_enableLog)
1902		m_log << TestLog::Message << "glGetTexParameterIuiv(" << toHex(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1903	m_gl.getTexParameterIuiv(param0, param1, param2);
1904}
1905
1906void CallLogWrapper::glClearBufferiv (glw::GLenum param0, glw::GLint param1, const glw::GLint* param2)
1907{
1908	if (m_enableLog)
1909		m_log << TestLog::Message << "glClearBufferiv(" << getBufferStr(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1910	m_gl.clearBufferiv(param0, param1, param2);
1911}
1912
1913void CallLogWrapper::glClearBufferuiv (glw::GLenum param0, glw::GLint param1, const glw::GLuint* param2)
1914{
1915	if (m_enableLog)
1916		m_log << TestLog::Message << "glClearBufferuiv(" << getBufferStr(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1917	m_gl.clearBufferuiv(param0, param1, param2);
1918}
1919
1920void CallLogWrapper::glClearBufferfv (glw::GLenum param0, glw::GLint param1, const glw::GLfloat* param2)
1921{
1922	if (m_enableLog)
1923		m_log << TestLog::Message << "glClearBufferfv(" << getBufferStr(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1924	m_gl.clearBufferfv(param0, param1, param2);
1925}
1926
1927void CallLogWrapper::glClearBufferfi (glw::GLenum param0, glw::GLint param1, glw::GLfloat param2, glw::GLint param3)
1928{
1929	if (m_enableLog)
1930		m_log << TestLog::Message << "glClearBufferfi(" << getBufferStr(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
1931	m_gl.clearBufferfi(param0, param1, param2, param3);
1932}
1933
1934const glw::GLubyte* CallLogWrapper::glGetStringi (glw::GLenum param0, glw::GLuint param1)
1935{
1936	if (m_enableLog)
1937		m_log << TestLog::Message << "glGetStringi(" << getGettableStringStr(param0) << ", " << param1 << ");" << TestLog::EndMessage;
1938	const glw::GLubyte* returnValue = m_gl.getStringi(param0, param1);
1939	if (m_enableLog)
1940		m_log << TestLog::Message << "// " << getStringStr(returnValue) << " returned" << TestLog::EndMessage;
1941	return returnValue;
1942}
1943
1944glw::GLboolean CallLogWrapper::glIsRenderbuffer (glw::GLuint param0)
1945{
1946	if (m_enableLog)
1947		m_log << TestLog::Message << "glIsRenderbuffer(" << param0 << ");" << TestLog::EndMessage;
1948	glw::GLboolean returnValue = m_gl.isRenderbuffer(param0);
1949	if (m_enableLog)
1950		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
1951	return returnValue;
1952}
1953
1954void CallLogWrapper::glBindRenderbuffer (glw::GLenum param0, glw::GLuint param1)
1955{
1956	if (m_enableLog)
1957		m_log << TestLog::Message << "glBindRenderbuffer(" << getFramebufferTargetStr(param0) << ", " << param1 << ");" << TestLog::EndMessage;
1958	m_gl.bindRenderbuffer(param0, param1);
1959}
1960
1961void CallLogWrapper::glDeleteRenderbuffers (glw::GLsizei param0, const glw::GLuint* param1)
1962{
1963	if (m_enableLog)
1964		m_log << TestLog::Message << "glDeleteRenderbuffers(" << param0 << ", " << getPointerStr(param1, param0) << ");" << TestLog::EndMessage;
1965	m_gl.deleteRenderbuffers(param0, param1);
1966}
1967
1968void CallLogWrapper::glGenRenderbuffers (glw::GLsizei param0, glw::GLuint* param1)
1969{
1970	if (m_enableLog)
1971		m_log << TestLog::Message << "glGenRenderbuffers(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
1972	m_gl.genRenderbuffers(param0, param1);
1973	if (m_enableLog)
1974	{
1975		m_log << TestLog::Message << "// param 1 = " << getPointerStr(param1, param0) << TestLog::EndMessage;
1976	}
1977}
1978
1979void CallLogWrapper::glRenderbufferStorage (glw::GLenum param0, glw::GLenum param1, glw::GLsizei param2, glw::GLsizei param3)
1980{
1981	if (m_enableLog)
1982		m_log << TestLog::Message << "glRenderbufferStorage(" << getFramebufferTargetStr(param0) << ", " << getPixelFormatStr(param1) << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
1983	m_gl.renderbufferStorage(param0, param1, param2, param3);
1984}
1985
1986void CallLogWrapper::glGetRenderbufferParameteriv (glw::GLenum param0, glw::GLenum param1, glw::GLint* param2)
1987{
1988	if (m_enableLog)
1989		m_log << TestLog::Message << "glGetRenderbufferParameteriv(" << getFramebufferTargetStr(param0) << ", " << getRenderbufferParameterStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
1990	m_gl.getRenderbufferParameteriv(param0, param1, param2);
1991}
1992
1993glw::GLboolean CallLogWrapper::glIsFramebuffer (glw::GLuint param0)
1994{
1995	if (m_enableLog)
1996		m_log << TestLog::Message << "glIsFramebuffer(" << param0 << ");" << TestLog::EndMessage;
1997	glw::GLboolean returnValue = m_gl.isFramebuffer(param0);
1998	if (m_enableLog)
1999		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2000	return returnValue;
2001}
2002
2003void CallLogWrapper::glBindFramebuffer (glw::GLenum param0, glw::GLuint param1)
2004{
2005	if (m_enableLog)
2006		m_log << TestLog::Message << "glBindFramebuffer(" << getFramebufferTargetStr(param0) << ", " << param1 << ");" << TestLog::EndMessage;
2007	m_gl.bindFramebuffer(param0, param1);
2008}
2009
2010void CallLogWrapper::glDeleteFramebuffers (glw::GLsizei param0, const glw::GLuint* param1)
2011{
2012	if (m_enableLog)
2013		m_log << TestLog::Message << "glDeleteFramebuffers(" << param0 << ", " << getPointerStr(param1, param0) << ");" << TestLog::EndMessage;
2014	m_gl.deleteFramebuffers(param0, param1);
2015}
2016
2017void CallLogWrapper::glGenFramebuffers (glw::GLsizei param0, glw::GLuint* param1)
2018{
2019	if (m_enableLog)
2020		m_log << TestLog::Message << "glGenFramebuffers(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2021	m_gl.genFramebuffers(param0, param1);
2022	if (m_enableLog)
2023	{
2024		m_log << TestLog::Message << "// param 1 = " << getPointerStr(param1, param0) << TestLog::EndMessage;
2025	}
2026}
2027
2028glw::GLenum CallLogWrapper::glCheckFramebufferStatus (glw::GLenum param0)
2029{
2030	if (m_enableLog)
2031		m_log << TestLog::Message << "glCheckFramebufferStatus(" << getFramebufferTargetStr(param0) << ");" << TestLog::EndMessage;
2032	glw::GLenum returnValue = m_gl.checkFramebufferStatus(param0);
2033	if (m_enableLog)
2034		m_log << TestLog::Message << "// " << getFramebufferStatusStr(returnValue) << " returned" << TestLog::EndMessage;
2035	return returnValue;
2036}
2037
2038void CallLogWrapper::glFramebufferTexture1D (glw::GLenum param0, glw::GLenum param1, glw::GLenum param2, glw::GLuint param3, glw::GLint param4)
2039{
2040	if (m_enableLog)
2041		m_log << TestLog::Message << "glFramebufferTexture1D(" << toHex(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
2042	m_gl.framebufferTexture1D(param0, param1, param2, param3, param4);
2043}
2044
2045void CallLogWrapper::glFramebufferTexture2D (glw::GLenum param0, glw::GLenum param1, glw::GLenum param2, glw::GLuint param3, glw::GLint param4)
2046{
2047	if (m_enableLog)
2048		m_log << TestLog::Message << "glFramebufferTexture2D(" << getFramebufferTargetStr(param0) << ", " << getFramebufferAttachmentStr(param1) << ", " << getTextureTargetStr(param2) << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
2049	m_gl.framebufferTexture2D(param0, param1, param2, param3, param4);
2050}
2051
2052void CallLogWrapper::glFramebufferTexture3D (glw::GLenum param0, glw::GLenum param1, glw::GLenum param2, glw::GLuint param3, glw::GLint param4, glw::GLint param5)
2053{
2054	if (m_enableLog)
2055		m_log << TestLog::Message << "glFramebufferTexture3D(" << toHex(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ", " << param3 << ", " << param4 << ", " << param5 << ");" << TestLog::EndMessage;
2056	m_gl.framebufferTexture3D(param0, param1, param2, param3, param4, param5);
2057}
2058
2059void CallLogWrapper::glFramebufferRenderbuffer (glw::GLenum param0, glw::GLenum param1, glw::GLenum param2, glw::GLuint param3)
2060{
2061	if (m_enableLog)
2062		m_log << TestLog::Message << "glFramebufferRenderbuffer(" << getFramebufferTargetStr(param0) << ", " << getFramebufferAttachmentStr(param1) << ", " << getFramebufferTargetStr(param2) << ", " << param3 << ");" << TestLog::EndMessage;
2063	m_gl.framebufferRenderbuffer(param0, param1, param2, param3);
2064}
2065
2066void CallLogWrapper::glGetFramebufferAttachmentParameteriv (glw::GLenum param0, glw::GLenum param1, glw::GLenum param2, glw::GLint* param3)
2067{
2068	if (m_enableLog)
2069		m_log << TestLog::Message << "glGetFramebufferAttachmentParameteriv(" << getFramebufferTargetStr(param0) << ", " << getFramebufferAttachmentStr(param1) << ", " << getFramebufferAttachmentParameterStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2070	m_gl.getFramebufferAttachmentParameteriv(param0, param1, param2, param3);
2071	if (m_enableLog)
2072	{
2073		m_log << TestLog::Message << "// param 3 = " << getFramebufferAttachmentParameterValueStr(param2, param3) << TestLog::EndMessage;
2074	}
2075}
2076
2077void CallLogWrapper::glGenerateMipmap (glw::GLenum param0)
2078{
2079	if (m_enableLog)
2080		m_log << TestLog::Message << "glGenerateMipmap(" << getTextureTargetStr(param0) << ");" << TestLog::EndMessage;
2081	m_gl.generateMipmap(param0);
2082}
2083
2084void CallLogWrapper::glBlitFramebuffer (glw::GLint param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLint param4, glw::GLint param5, glw::GLint param6, glw::GLint param7, glw::GLbitfield param8, glw::GLenum param9)
2085{
2086	if (m_enableLog)
2087		m_log << TestLog::Message << "glBlitFramebuffer(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ", " << param7 << ", " << getBufferMaskStr(param8) << ", " << getTextureFilterStr(param9) << ");" << TestLog::EndMessage;
2088	m_gl.blitFramebuffer(param0, param1, param2, param3, param4, param5, param6, param7, param8, param9);
2089}
2090
2091void CallLogWrapper::glRenderbufferStorageMultisample (glw::GLenum param0, glw::GLsizei param1, glw::GLenum param2, glw::GLsizei param3, glw::GLsizei param4)
2092{
2093	if (m_enableLog)
2094		m_log << TestLog::Message << "glRenderbufferStorageMultisample(" << getFramebufferTargetStr(param0) << ", " << param1 << ", " << getPixelFormatStr(param2) << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
2095	m_gl.renderbufferStorageMultisample(param0, param1, param2, param3, param4);
2096}
2097
2098void CallLogWrapper::glFramebufferTextureLayer (glw::GLenum param0, glw::GLenum param1, glw::GLuint param2, glw::GLint param3, glw::GLint param4)
2099{
2100	if (m_enableLog)
2101		m_log << TestLog::Message << "glFramebufferTextureLayer(" << getFramebufferTargetStr(param0) << ", " << getFramebufferAttachmentStr(param1) << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
2102	m_gl.framebufferTextureLayer(param0, param1, param2, param3, param4);
2103}
2104
2105glw::GLvoid* CallLogWrapper::glMapBufferRange (glw::GLenum param0, glw::GLintptr param1, glw::GLsizeiptr param2, glw::GLbitfield param3)
2106{
2107	if (m_enableLog)
2108		m_log << TestLog::Message << "glMapBufferRange(" << getBufferTargetStr(param0) << ", " << param1 << ", " << param2 << ", " << getBufferMapFlagsStr(param3) << ");" << TestLog::EndMessage;
2109	glw::GLvoid* returnValue = m_gl.mapBufferRange(param0, param1, param2, param3);
2110	if (m_enableLog)
2111		m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
2112	return returnValue;
2113}
2114
2115void CallLogWrapper::glFlushMappedBufferRange (glw::GLenum param0, glw::GLintptr param1, glw::GLsizeiptr param2)
2116{
2117	if (m_enableLog)
2118		m_log << TestLog::Message << "glFlushMappedBufferRange(" << getBufferTargetStr(param0) << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
2119	m_gl.flushMappedBufferRange(param0, param1, param2);
2120}
2121
2122void CallLogWrapper::glBindVertexArray (glw::GLuint param0)
2123{
2124	if (m_enableLog)
2125		m_log << TestLog::Message << "glBindVertexArray(" << param0 << ");" << TestLog::EndMessage;
2126	m_gl.bindVertexArray(param0);
2127}
2128
2129void CallLogWrapper::glDeleteVertexArrays (glw::GLsizei param0, const glw::GLuint* param1)
2130{
2131	if (m_enableLog)
2132		m_log << TestLog::Message << "glDeleteVertexArrays(" << param0 << ", " << getPointerStr(param1, param0) << ");" << TestLog::EndMessage;
2133	m_gl.deleteVertexArrays(param0, param1);
2134}
2135
2136void CallLogWrapper::glGenVertexArrays (glw::GLsizei param0, glw::GLuint* param1)
2137{
2138	if (m_enableLog)
2139		m_log << TestLog::Message << "glGenVertexArrays(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2140	m_gl.genVertexArrays(param0, param1);
2141	if (m_enableLog)
2142	{
2143		m_log << TestLog::Message << "// param 1 = " << getPointerStr(param1, param0) << TestLog::EndMessage;
2144	}
2145}
2146
2147glw::GLboolean CallLogWrapper::glIsVertexArray (glw::GLuint param0)
2148{
2149	if (m_enableLog)
2150		m_log << TestLog::Message << "glIsVertexArray(" << param0 << ");" << TestLog::EndMessage;
2151	glw::GLboolean returnValue = m_gl.isVertexArray(param0);
2152	if (m_enableLog)
2153		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2154	return returnValue;
2155}
2156
2157void CallLogWrapper::glTexBuffer (glw::GLenum param0, glw::GLenum param1, glw::GLuint param2)
2158{
2159	if (m_enableLog)
2160		m_log << TestLog::Message << "glTexBuffer(" << getBufferTargetStr(param0) << ", " << getPixelFormatStr(param1) << ", " << param2 << ");" << TestLog::EndMessage;
2161	m_gl.texBuffer(param0, param1, param2);
2162}
2163
2164void CallLogWrapper::glPrimitiveRestartIndex (glw::GLuint param0)
2165{
2166	if (m_enableLog)
2167		m_log << TestLog::Message << "glPrimitiveRestartIndex(" << param0 << ");" << TestLog::EndMessage;
2168	m_gl.primitiveRestartIndex(param0);
2169}
2170
2171void CallLogWrapper::glCopyBufferSubData (glw::GLenum param0, glw::GLenum param1, glw::GLintptr param2, glw::GLintptr param3, glw::GLsizeiptr param4)
2172{
2173	if (m_enableLog)
2174		m_log << TestLog::Message << "glCopyBufferSubData(" << toHex(param0) << ", " << toHex(param1) << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
2175	m_gl.copyBufferSubData(param0, param1, param2, param3, param4);
2176}
2177
2178void CallLogWrapper::glDrawArraysInstanced (glw::GLenum param0, glw::GLint param1, glw::GLsizei param2, glw::GLsizei param3)
2179{
2180	if (m_enableLog)
2181		m_log << TestLog::Message << "glDrawArraysInstanced(" << getPrimitiveTypeStr(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
2182	m_gl.drawArraysInstanced(param0, param1, param2, param3);
2183}
2184
2185void CallLogWrapper::glDrawElementsInstanced (glw::GLenum param0, glw::GLsizei param1, glw::GLenum param2, const glw::GLvoid* param3, glw::GLsizei param4)
2186{
2187	if (m_enableLog)
2188		m_log << TestLog::Message << "glDrawElementsInstanced(" << getPrimitiveTypeStr(param0) << ", " << param1 << ", " << getTypeStr(param2) << ", " << toHex(param3) << ", " << param4 << ");" << TestLog::EndMessage;
2189	m_gl.drawElementsInstanced(param0, param1, param2, param3, param4);
2190}
2191
2192void CallLogWrapper::glGetUniformIndices (glw::GLuint param0, glw::GLsizei param1, const glw::GLchar* const* param2, glw::GLuint* param3)
2193{
2194	if (m_enableLog)
2195		m_log << TestLog::Message << "glGetUniformIndices(" << param0 << ", " << param1 << ", " << getPointerStr(param2, param1) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2196	m_gl.getUniformIndices(param0, param1, param2, param3);
2197	if (m_enableLog)
2198	{
2199		m_log << TestLog::Message << "// param 3 = " << getPointerStr(param3, param1) << TestLog::EndMessage;
2200	}
2201}
2202
2203void CallLogWrapper::glGetActiveUniformsiv (glw::GLuint param0, glw::GLsizei param1, const glw::GLuint* param2, glw::GLenum param3, glw::GLint* param4)
2204{
2205	if (m_enableLog)
2206		m_log << TestLog::Message << "glGetActiveUniformsiv(" << param0 << ", " << param1 << ", " << getPointerStr(param2, param1) << ", " << getUniformParamStr(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
2207	m_gl.getActiveUniformsiv(param0, param1, param2, param3, param4);
2208	if (m_enableLog)
2209	{
2210		m_log << TestLog::Message << "// param 4 = " << getPointerStr(param4, param1) << TestLog::EndMessage;
2211	}
2212}
2213
2214void CallLogWrapper::glGetActiveUniformName (glw::GLuint param0, glw::GLuint param1, glw::GLsizei param2, glw::GLsizei* param3, glw::GLchar* param4)
2215{
2216	if (m_enableLog)
2217		m_log << TestLog::Message << "glGetActiveUniformName(" << param0 << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
2218	m_gl.getActiveUniformName(param0, param1, param2, param3, param4);
2219}
2220
2221glw::GLuint CallLogWrapper::glGetUniformBlockIndex (glw::GLuint param0, const glw::GLchar* param1)
2222{
2223	if (m_enableLog)
2224		m_log << TestLog::Message << "glGetUniformBlockIndex(" << param0 << ", " << getStringStr(param1) << ");" << TestLog::EndMessage;
2225	glw::GLuint returnValue = m_gl.getUniformBlockIndex(param0, param1);
2226	if (m_enableLog)
2227		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2228	return returnValue;
2229}
2230
2231void CallLogWrapper::glGetActiveUniformBlockiv (glw::GLuint param0, glw::GLuint param1, glw::GLenum param2, glw::GLint* param3)
2232{
2233	if (m_enableLog)
2234		m_log << TestLog::Message << "glGetActiveUniformBlockiv(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2235	m_gl.getActiveUniformBlockiv(param0, param1, param2, param3);
2236}
2237
2238void CallLogWrapper::glGetActiveUniformBlockName (glw::GLuint param0, glw::GLuint param1, glw::GLsizei param2, glw::GLsizei* param3, glw::GLchar* param4)
2239{
2240	if (m_enableLog)
2241		m_log << TestLog::Message << "glGetActiveUniformBlockName(" << param0 << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
2242	m_gl.getActiveUniformBlockName(param0, param1, param2, param3, param4);
2243}
2244
2245void CallLogWrapper::glUniformBlockBinding (glw::GLuint param0, glw::GLuint param1, glw::GLuint param2)
2246{
2247	if (m_enableLog)
2248		m_log << TestLog::Message << "glUniformBlockBinding(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
2249	m_gl.uniformBlockBinding(param0, param1, param2);
2250}
2251
2252void CallLogWrapper::glGetInteger64i_v (glw::GLenum param0, glw::GLuint param1, glw::GLint64* param2)
2253{
2254	if (m_enableLog)
2255		m_log << TestLog::Message << "glGetInteger64i_v(" << getGettableIndexedStateStr(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2256	m_gl.getInteger64i_v(param0, param1, param2);
2257}
2258
2259void CallLogWrapper::glGetBufferParameteri64v (glw::GLenum param0, glw::GLenum param1, glw::GLint64* param2)
2260{
2261	if (m_enableLog)
2262		m_log << TestLog::Message << "glGetBufferParameteri64v(" << getBufferTargetStr(param0) << ", " << getBufferQueryStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2263	m_gl.getBufferParameteri64v(param0, param1, param2);
2264}
2265
2266void CallLogWrapper::glFramebufferTexture (glw::GLenum param0, glw::GLenum param1, glw::GLuint param2, glw::GLint param3)
2267{
2268	if (m_enableLog)
2269		m_log << TestLog::Message << "glFramebufferTexture(" << getFramebufferTargetStr(param0) << ", " << getFramebufferAttachmentStr(param1) << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
2270	m_gl.framebufferTexture(param0, param1, param2, param3);
2271}
2272
2273void CallLogWrapper::glDrawElementsBaseVertex (glw::GLenum param0, glw::GLsizei param1, glw::GLenum param2, const glw::GLvoid* param3, glw::GLint param4)
2274{
2275	if (m_enableLog)
2276		m_log << TestLog::Message << "glDrawElementsBaseVertex(" << getPrimitiveTypeStr(param0) << ", " << param1 << ", " << getTypeStr(param2) << ", " << toHex(param3) << ", " << param4 << ");" << TestLog::EndMessage;
2277	m_gl.drawElementsBaseVertex(param0, param1, param2, param3, param4);
2278}
2279
2280void CallLogWrapper::glDrawRangeElementsBaseVertex (glw::GLenum param0, glw::GLuint param1, glw::GLuint param2, glw::GLsizei param3, glw::GLenum param4, const glw::GLvoid* param5, glw::GLint param6)
2281{
2282	if (m_enableLog)
2283		m_log << TestLog::Message << "glDrawRangeElementsBaseVertex(" << getPrimitiveTypeStr(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << getTypeStr(param4) << ", " << toHex(param5) << ", " << param6 << ");" << TestLog::EndMessage;
2284	m_gl.drawRangeElementsBaseVertex(param0, param1, param2, param3, param4, param5, param6);
2285}
2286
2287void CallLogWrapper::glDrawElementsInstancedBaseVertex (glw::GLenum param0, glw::GLsizei param1, glw::GLenum param2, const glw::GLvoid* param3, glw::GLsizei param4, glw::GLint param5)
2288{
2289	if (m_enableLog)
2290		m_log << TestLog::Message << "glDrawElementsInstancedBaseVertex(" << getPrimitiveTypeStr(param0) << ", " << param1 << ", " << getTypeStr(param2) << ", " << toHex(param3) << ", " << param4 << ", " << param5 << ");" << TestLog::EndMessage;
2291	m_gl.drawElementsInstancedBaseVertex(param0, param1, param2, param3, param4, param5);
2292}
2293
2294void CallLogWrapper::glMultiDrawElementsBaseVertex (glw::GLenum param0, const glw::GLsizei* param1, glw::GLenum param2, const glw::GLvoid* const* param3, glw::GLsizei param4, const glw::GLint* param5)
2295{
2296	if (m_enableLog)
2297		m_log << TestLog::Message << "glMultiDrawElementsBaseVertex(" << getPrimitiveTypeStr(param0) << ", " << toHex(param1) << ", " << getTypeStr(param2) << ", " << toHex(param3) << ", " << param4 << ", " << toHex(param5) << ");" << TestLog::EndMessage;
2298	m_gl.multiDrawElementsBaseVertex(param0, param1, param2, param3, param4, param5);
2299}
2300
2301void CallLogWrapper::glProvokingVertex (glw::GLenum param0)
2302{
2303	if (m_enableLog)
2304		m_log << TestLog::Message << "glProvokingVertex(" << getProvokingVertexStr(param0) << ");" << TestLog::EndMessage;
2305	m_gl.provokingVertex(param0);
2306}
2307
2308glw::GLsync CallLogWrapper::glFenceSync (glw::GLenum param0, glw::GLbitfield param1)
2309{
2310	if (m_enableLog)
2311		m_log << TestLog::Message << "glFenceSync(" << toHex(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2312	glw::GLsync returnValue = m_gl.fenceSync(param0, param1);
2313	if (m_enableLog)
2314		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2315	return returnValue;
2316}
2317
2318glw::GLboolean CallLogWrapper::glIsSync (glw::GLsync param0)
2319{
2320	if (m_enableLog)
2321		m_log << TestLog::Message << "glIsSync(" << param0 << ");" << TestLog::EndMessage;
2322	glw::GLboolean returnValue = m_gl.isSync(param0);
2323	if (m_enableLog)
2324		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2325	return returnValue;
2326}
2327
2328void CallLogWrapper::glDeleteSync (glw::GLsync param0)
2329{
2330	if (m_enableLog)
2331		m_log << TestLog::Message << "glDeleteSync(" << param0 << ");" << TestLog::EndMessage;
2332	m_gl.deleteSync(param0);
2333}
2334
2335glw::GLenum CallLogWrapper::glClientWaitSync (glw::GLsync param0, glw::GLbitfield param1, glw::GLuint64 param2)
2336{
2337	if (m_enableLog)
2338		m_log << TestLog::Message << "glClientWaitSync(" << param0 << ", " << toHex(param1) << ", " << param2 << ");" << TestLog::EndMessage;
2339	glw::GLenum returnValue = m_gl.clientWaitSync(param0, param1, param2);
2340	if (m_enableLog)
2341		m_log << TestLog::Message << "// " << toHex(returnValue) << " returned" << TestLog::EndMessage;
2342	return returnValue;
2343}
2344
2345void CallLogWrapper::glWaitSync (glw::GLsync param0, glw::GLbitfield param1, glw::GLuint64 param2)
2346{
2347	if (m_enableLog)
2348		m_log << TestLog::Message << "glWaitSync(" << param0 << ", " << toHex(param1) << ", " << param2 << ");" << TestLog::EndMessage;
2349	m_gl.waitSync(param0, param1, param2);
2350}
2351
2352void CallLogWrapper::glGetInteger64v (glw::GLenum param0, glw::GLint64* param1)
2353{
2354	if (m_enableLog)
2355		m_log << TestLog::Message << "glGetInteger64v(" << getGettableStateStr(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2356	m_gl.getInteger64v(param0, param1);
2357}
2358
2359void CallLogWrapper::glGetSynciv (glw::GLsync param0, glw::GLenum param1, glw::GLsizei param2, glw::GLsizei* param3, glw::GLint* param4)
2360{
2361	if (m_enableLog)
2362		m_log << TestLog::Message << "glGetSynciv(" << param0 << ", " << toHex(param1) << ", " << param2 << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
2363	m_gl.getSynciv(param0, param1, param2, param3, param4);
2364}
2365
2366void CallLogWrapper::glTexImage2DMultisample (glw::GLenum param0, glw::GLsizei param1, glw::GLint param2, glw::GLsizei param3, glw::GLsizei param4, glw::GLboolean param5)
2367{
2368	if (m_enableLog)
2369		m_log << TestLog::Message << "glTexImage2DMultisample(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getPixelFormatStr(param2) << ", " << param3 << ", " << param4 << ", " << getBooleanStr(param5) << ");" << TestLog::EndMessage;
2370	m_gl.texImage2DMultisample(param0, param1, param2, param3, param4, param5);
2371}
2372
2373void CallLogWrapper::glTexImage3DMultisample (glw::GLenum param0, glw::GLsizei param1, glw::GLint param2, glw::GLsizei param3, glw::GLsizei param4, glw::GLsizei param5, glw::GLboolean param6)
2374{
2375	if (m_enableLog)
2376		m_log << TestLog::Message << "glTexImage3DMultisample(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ", " << getBooleanStr(param6) << ");" << TestLog::EndMessage;
2377	m_gl.texImage3DMultisample(param0, param1, param2, param3, param4, param5, param6);
2378}
2379
2380void CallLogWrapper::glGetMultisamplefv (glw::GLenum param0, glw::GLuint param1, glw::GLfloat* param2)
2381{
2382	if (m_enableLog)
2383		m_log << TestLog::Message << "glGetMultisamplefv(" << getMultisampleParameterStr(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2384	m_gl.getMultisamplefv(param0, param1, param2);
2385	if (m_enableLog)
2386	{
2387		m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, 2) << TestLog::EndMessage;
2388	}
2389}
2390
2391void CallLogWrapper::glSampleMaski (glw::GLuint param0, glw::GLbitfield param1)
2392{
2393	if (m_enableLog)
2394		m_log << TestLog::Message << "glSampleMaski(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2395	m_gl.sampleMaski(param0, param1);
2396}
2397
2398void CallLogWrapper::glVertexAttribDivisor (glw::GLuint param0, glw::GLuint param1)
2399{
2400	if (m_enableLog)
2401		m_log << TestLog::Message << "glVertexAttribDivisor(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
2402	m_gl.vertexAttribDivisor(param0, param1);
2403}
2404
2405void CallLogWrapper::glBindFragDataLocationIndexed (glw::GLuint param0, glw::GLuint param1, glw::GLuint param2, const glw::GLchar* param3)
2406{
2407	if (m_enableLog)
2408		m_log << TestLog::Message << "glBindFragDataLocationIndexed(" << param0 << ", " << param1 << ", " << param2 << ", " << getStringStr(param3) << ");" << TestLog::EndMessage;
2409	m_gl.bindFragDataLocationIndexed(param0, param1, param2, param3);
2410}
2411
2412glw::GLint CallLogWrapper::glGetFragDataIndex (glw::GLuint param0, const glw::GLchar* param1)
2413{
2414	if (m_enableLog)
2415		m_log << TestLog::Message << "glGetFragDataIndex(" << param0 << ", " << getStringStr(param1) << ");" << TestLog::EndMessage;
2416	glw::GLint returnValue = m_gl.getFragDataIndex(param0, param1);
2417	if (m_enableLog)
2418		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2419	return returnValue;
2420}
2421
2422void CallLogWrapper::glGenSamplers (glw::GLsizei param0, glw::GLuint* param1)
2423{
2424	if (m_enableLog)
2425		m_log << TestLog::Message << "glGenSamplers(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2426	m_gl.genSamplers(param0, param1);
2427}
2428
2429void CallLogWrapper::glDeleteSamplers (glw::GLsizei param0, const glw::GLuint* param1)
2430{
2431	if (m_enableLog)
2432		m_log << TestLog::Message << "glDeleteSamplers(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2433	m_gl.deleteSamplers(param0, param1);
2434}
2435
2436glw::GLboolean CallLogWrapper::glIsSampler (glw::GLuint param0)
2437{
2438	if (m_enableLog)
2439		m_log << TestLog::Message << "glIsSampler(" << param0 << ");" << TestLog::EndMessage;
2440	glw::GLboolean returnValue = m_gl.isSampler(param0);
2441	if (m_enableLog)
2442		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2443	return returnValue;
2444}
2445
2446void CallLogWrapper::glBindSampler (glw::GLuint param0, glw::GLuint param1)
2447{
2448	if (m_enableLog)
2449		m_log << TestLog::Message << "glBindSampler(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
2450	m_gl.bindSampler(param0, param1);
2451}
2452
2453void CallLogWrapper::glSamplerParameteri (glw::GLuint param0, glw::GLenum param1, glw::GLint param2)
2454{
2455	if (m_enableLog)
2456		m_log << TestLog::Message << "glSamplerParameteri(" << param0 << ", " << toHex(param1) << ", " << param2 << ");" << TestLog::EndMessage;
2457	m_gl.samplerParameteri(param0, param1, param2);
2458}
2459
2460void CallLogWrapper::glSamplerParameteriv (glw::GLuint param0, glw::GLenum param1, const glw::GLint* param2)
2461{
2462	if (m_enableLog)
2463		m_log << TestLog::Message << "glSamplerParameteriv(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2464	m_gl.samplerParameteriv(param0, param1, param2);
2465}
2466
2467void CallLogWrapper::glSamplerParameterf (glw::GLuint param0, glw::GLenum param1, glw::GLfloat param2)
2468{
2469	if (m_enableLog)
2470		m_log << TestLog::Message << "glSamplerParameterf(" << param0 << ", " << toHex(param1) << ", " << param2 << ");" << TestLog::EndMessage;
2471	m_gl.samplerParameterf(param0, param1, param2);
2472}
2473
2474void CallLogWrapper::glSamplerParameterfv (glw::GLuint param0, glw::GLenum param1, const glw::GLfloat* param2)
2475{
2476	if (m_enableLog)
2477		m_log << TestLog::Message << "glSamplerParameterfv(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2478	m_gl.samplerParameterfv(param0, param1, param2);
2479}
2480
2481void CallLogWrapper::glSamplerParameterIiv (glw::GLuint param0, glw::GLenum param1, const glw::GLint* param2)
2482{
2483	if (m_enableLog)
2484		m_log << TestLog::Message << "glSamplerParameterIiv(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2485	m_gl.samplerParameterIiv(param0, param1, param2);
2486}
2487
2488void CallLogWrapper::glSamplerParameterIuiv (glw::GLuint param0, glw::GLenum param1, const glw::GLuint* param2)
2489{
2490	if (m_enableLog)
2491		m_log << TestLog::Message << "glSamplerParameterIuiv(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2492	m_gl.samplerParameterIuiv(param0, param1, param2);
2493}
2494
2495void CallLogWrapper::glGetSamplerParameteriv (glw::GLuint param0, glw::GLenum param1, glw::GLint* param2)
2496{
2497	if (m_enableLog)
2498		m_log << TestLog::Message << "glGetSamplerParameteriv(" << param0 << ", " << getTextureParameterStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2499	m_gl.getSamplerParameteriv(param0, param1, param2);
2500}
2501
2502void CallLogWrapper::glGetSamplerParameterIiv (glw::GLuint param0, glw::GLenum param1, glw::GLint* param2)
2503{
2504	if (m_enableLog)
2505		m_log << TestLog::Message << "glGetSamplerParameterIiv(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2506	m_gl.getSamplerParameterIiv(param0, param1, param2);
2507}
2508
2509void CallLogWrapper::glGetSamplerParameterfv (glw::GLuint param0, glw::GLenum param1, glw::GLfloat* param2)
2510{
2511	if (m_enableLog)
2512		m_log << TestLog::Message << "glGetSamplerParameterfv(" << param0 << ", " << getTextureParameterStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2513	m_gl.getSamplerParameterfv(param0, param1, param2);
2514}
2515
2516void CallLogWrapper::glGetSamplerParameterIuiv (glw::GLuint param0, glw::GLenum param1, glw::GLuint* param2)
2517{
2518	if (m_enableLog)
2519		m_log << TestLog::Message << "glGetSamplerParameterIuiv(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2520	m_gl.getSamplerParameterIuiv(param0, param1, param2);
2521}
2522
2523void CallLogWrapper::glQueryCounter (glw::GLuint param0, glw::GLenum param1)
2524{
2525	if (m_enableLog)
2526		m_log << TestLog::Message << "glQueryCounter(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2527	m_gl.queryCounter(param0, param1);
2528}
2529
2530void CallLogWrapper::glGetQueryObjecti64v (glw::GLuint param0, glw::GLenum param1, glw::GLint64* param2)
2531{
2532	if (m_enableLog)
2533		m_log << TestLog::Message << "glGetQueryObjecti64v(" << param0 << ", " << getQueryObjectParamStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2534	m_gl.getQueryObjecti64v(param0, param1, param2);
2535	if (m_enableLog)
2536	{
2537		m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, 1) << TestLog::EndMessage;
2538	}
2539}
2540
2541void CallLogWrapper::glGetQueryObjectui64v (glw::GLuint param0, glw::GLenum param1, glw::GLuint64* param2)
2542{
2543	if (m_enableLog)
2544		m_log << TestLog::Message << "glGetQueryObjectui64v(" << param0 << ", " << getQueryObjectParamStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2545	m_gl.getQueryObjectui64v(param0, param1, param2);
2546	if (m_enableLog)
2547	{
2548		m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, 1) << TestLog::EndMessage;
2549	}
2550}
2551
2552void CallLogWrapper::glVertexAttribP1ui (glw::GLuint param0, glw::GLenum param1, glw::GLboolean param2, glw::GLuint param3)
2553{
2554	if (m_enableLog)
2555		m_log << TestLog::Message << "glVertexAttribP1ui(" << param0 << ", " << toHex(param1) << ", " << getBooleanStr(param2) << ", " << param3 << ");" << TestLog::EndMessage;
2556	m_gl.vertexAttribP1ui(param0, param1, param2, param3);
2557}
2558
2559void CallLogWrapper::glVertexAttribP1uiv (glw::GLuint param0, glw::GLenum param1, glw::GLboolean param2, const glw::GLuint* param3)
2560{
2561	if (m_enableLog)
2562		m_log << TestLog::Message << "glVertexAttribP1uiv(" << param0 << ", " << toHex(param1) << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2563	m_gl.vertexAttribP1uiv(param0, param1, param2, param3);
2564}
2565
2566void CallLogWrapper::glVertexAttribP2ui (glw::GLuint param0, glw::GLenum param1, glw::GLboolean param2, glw::GLuint param3)
2567{
2568	if (m_enableLog)
2569		m_log << TestLog::Message << "glVertexAttribP2ui(" << param0 << ", " << toHex(param1) << ", " << getBooleanStr(param2) << ", " << param3 << ");" << TestLog::EndMessage;
2570	m_gl.vertexAttribP2ui(param0, param1, param2, param3);
2571}
2572
2573void CallLogWrapper::glVertexAttribP2uiv (glw::GLuint param0, glw::GLenum param1, glw::GLboolean param2, const glw::GLuint* param3)
2574{
2575	if (m_enableLog)
2576		m_log << TestLog::Message << "glVertexAttribP2uiv(" << param0 << ", " << toHex(param1) << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2577	m_gl.vertexAttribP2uiv(param0, param1, param2, param3);
2578}
2579
2580void CallLogWrapper::glVertexAttribP3ui (glw::GLuint param0, glw::GLenum param1, glw::GLboolean param2, glw::GLuint param3)
2581{
2582	if (m_enableLog)
2583		m_log << TestLog::Message << "glVertexAttribP3ui(" << param0 << ", " << toHex(param1) << ", " << getBooleanStr(param2) << ", " << param3 << ");" << TestLog::EndMessage;
2584	m_gl.vertexAttribP3ui(param0, param1, param2, param3);
2585}
2586
2587void CallLogWrapper::glVertexAttribP3uiv (glw::GLuint param0, glw::GLenum param1, glw::GLboolean param2, const glw::GLuint* param3)
2588{
2589	if (m_enableLog)
2590		m_log << TestLog::Message << "glVertexAttribP3uiv(" << param0 << ", " << toHex(param1) << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2591	m_gl.vertexAttribP3uiv(param0, param1, param2, param3);
2592}
2593
2594void CallLogWrapper::glVertexAttribP4ui (glw::GLuint param0, glw::GLenum param1, glw::GLboolean param2, glw::GLuint param3)
2595{
2596	if (m_enableLog)
2597		m_log << TestLog::Message << "glVertexAttribP4ui(" << param0 << ", " << toHex(param1) << ", " << getBooleanStr(param2) << ", " << param3 << ");" << TestLog::EndMessage;
2598	m_gl.vertexAttribP4ui(param0, param1, param2, param3);
2599}
2600
2601void CallLogWrapper::glVertexAttribP4uiv (glw::GLuint param0, glw::GLenum param1, glw::GLboolean param2, const glw::GLuint* param3)
2602{
2603	if (m_enableLog)
2604		m_log << TestLog::Message << "glVertexAttribP4uiv(" << param0 << ", " << toHex(param1) << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2605	m_gl.vertexAttribP4uiv(param0, param1, param2, param3);
2606}
2607
2608void CallLogWrapper::glBlendEquationi (glw::GLuint param0, glw::GLenum param1)
2609{
2610	if (m_enableLog)
2611		m_log << TestLog::Message << "glBlendEquationi(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2612	m_gl.blendEquationi(param0, param1);
2613}
2614
2615void CallLogWrapper::glBlendEquationSeparatei (glw::GLuint param0, glw::GLenum param1, glw::GLenum param2)
2616{
2617	if (m_enableLog)
2618		m_log << TestLog::Message << "glBlendEquationSeparatei(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2619	m_gl.blendEquationSeparatei(param0, param1, param2);
2620}
2621
2622void CallLogWrapper::glBlendFunci (glw::GLuint param0, glw::GLenum param1, glw::GLenum param2)
2623{
2624	if (m_enableLog)
2625		m_log << TestLog::Message << "glBlendFunci(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2626	m_gl.blendFunci(param0, param1, param2);
2627}
2628
2629void CallLogWrapper::glBlendFuncSeparatei (glw::GLuint param0, glw::GLenum param1, glw::GLenum param2, glw::GLenum param3, glw::GLenum param4)
2630{
2631	if (m_enableLog)
2632		m_log << TestLog::Message << "glBlendFuncSeparatei(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
2633	m_gl.blendFuncSeparatei(param0, param1, param2, param3, param4);
2634}
2635
2636void CallLogWrapper::glDrawArraysIndirect (glw::GLenum param0, const glw::GLvoid* param1)
2637{
2638	if (m_enableLog)
2639		m_log << TestLog::Message << "glDrawArraysIndirect(" << getPrimitiveTypeStr(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2640	m_gl.drawArraysIndirect(param0, param1);
2641}
2642
2643void CallLogWrapper::glDrawElementsIndirect (glw::GLenum param0, glw::GLenum param1, const glw::GLvoid* param2)
2644{
2645	if (m_enableLog)
2646		m_log << TestLog::Message << "glDrawElementsIndirect(" << getPrimitiveTypeStr(param0) << ", " << getTypeStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2647	m_gl.drawElementsIndirect(param0, param1, param2);
2648}
2649
2650void CallLogWrapper::glUniform1d (glw::GLint param0, glw::GLdouble param1)
2651{
2652	if (m_enableLog)
2653		m_log << TestLog::Message << "glUniform1d(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
2654	m_gl.uniform1d(param0, param1);
2655}
2656
2657void CallLogWrapper::glUniform2d (glw::GLint param0, glw::GLdouble param1, glw::GLdouble param2)
2658{
2659	if (m_enableLog)
2660		m_log << TestLog::Message << "glUniform2d(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
2661	m_gl.uniform2d(param0, param1, param2);
2662}
2663
2664void CallLogWrapper::glUniform3d (glw::GLint param0, glw::GLdouble param1, glw::GLdouble param2, glw::GLdouble param3)
2665{
2666	if (m_enableLog)
2667		m_log << TestLog::Message << "glUniform3d(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
2668	m_gl.uniform3d(param0, param1, param2, param3);
2669}
2670
2671void CallLogWrapper::glUniform4d (glw::GLint param0, glw::GLdouble param1, glw::GLdouble param2, glw::GLdouble param3, glw::GLdouble param4)
2672{
2673	if (m_enableLog)
2674		m_log << TestLog::Message << "glUniform4d(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
2675	m_gl.uniform4d(param0, param1, param2, param3, param4);
2676}
2677
2678void CallLogWrapper::glUniform1dv (glw::GLint param0, glw::GLsizei param1, const glw::GLdouble* param2)
2679{
2680	if (m_enableLog)
2681		m_log << TestLog::Message << "glUniform1dv(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2682	m_gl.uniform1dv(param0, param1, param2);
2683}
2684
2685void CallLogWrapper::glUniform2dv (glw::GLint param0, glw::GLsizei param1, const glw::GLdouble* param2)
2686{
2687	if (m_enableLog)
2688		m_log << TestLog::Message << "glUniform2dv(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2689	m_gl.uniform2dv(param0, param1, param2);
2690}
2691
2692void CallLogWrapper::glUniform3dv (glw::GLint param0, glw::GLsizei param1, const glw::GLdouble* param2)
2693{
2694	if (m_enableLog)
2695		m_log << TestLog::Message << "glUniform3dv(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2696	m_gl.uniform3dv(param0, param1, param2);
2697}
2698
2699void CallLogWrapper::glUniform4dv (glw::GLint param0, glw::GLsizei param1, const glw::GLdouble* param2)
2700{
2701	if (m_enableLog)
2702		m_log << TestLog::Message << "glUniform4dv(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2703	m_gl.uniform4dv(param0, param1, param2);
2704}
2705
2706void CallLogWrapper::glUniformMatrix2dv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLdouble* param3)
2707{
2708	if (m_enableLog)
2709		m_log << TestLog::Message << "glUniformMatrix2dv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2710	m_gl.uniformMatrix2dv(param0, param1, param2, param3);
2711}
2712
2713void CallLogWrapper::glUniformMatrix3dv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLdouble* param3)
2714{
2715	if (m_enableLog)
2716		m_log << TestLog::Message << "glUniformMatrix3dv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2717	m_gl.uniformMatrix3dv(param0, param1, param2, param3);
2718}
2719
2720void CallLogWrapper::glUniformMatrix4dv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLdouble* param3)
2721{
2722	if (m_enableLog)
2723		m_log << TestLog::Message << "glUniformMatrix4dv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2724	m_gl.uniformMatrix4dv(param0, param1, param2, param3);
2725}
2726
2727void CallLogWrapper::glUniformMatrix2x3dv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLdouble* param3)
2728{
2729	if (m_enableLog)
2730		m_log << TestLog::Message << "glUniformMatrix2x3dv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2731	m_gl.uniformMatrix2x3dv(param0, param1, param2, param3);
2732}
2733
2734void CallLogWrapper::glUniformMatrix2x4dv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLdouble* param3)
2735{
2736	if (m_enableLog)
2737		m_log << TestLog::Message << "glUniformMatrix2x4dv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2738	m_gl.uniformMatrix2x4dv(param0, param1, param2, param3);
2739}
2740
2741void CallLogWrapper::glUniformMatrix3x2dv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLdouble* param3)
2742{
2743	if (m_enableLog)
2744		m_log << TestLog::Message << "glUniformMatrix3x2dv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2745	m_gl.uniformMatrix3x2dv(param0, param1, param2, param3);
2746}
2747
2748void CallLogWrapper::glUniformMatrix3x4dv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLdouble* param3)
2749{
2750	if (m_enableLog)
2751		m_log << TestLog::Message << "glUniformMatrix3x4dv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2752	m_gl.uniformMatrix3x4dv(param0, param1, param2, param3);
2753}
2754
2755void CallLogWrapper::glUniformMatrix4x2dv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLdouble* param3)
2756{
2757	if (m_enableLog)
2758		m_log << TestLog::Message << "glUniformMatrix4x2dv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2759	m_gl.uniformMatrix4x2dv(param0, param1, param2, param3);
2760}
2761
2762void CallLogWrapper::glUniformMatrix4x3dv (glw::GLint param0, glw::GLsizei param1, glw::GLboolean param2, const glw::GLdouble* param3)
2763{
2764	if (m_enableLog)
2765		m_log << TestLog::Message << "glUniformMatrix4x3dv(" << param0 << ", " << param1 << ", " << getBooleanStr(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2766	m_gl.uniformMatrix4x3dv(param0, param1, param2, param3);
2767}
2768
2769void CallLogWrapper::glGetUniformdv (glw::GLuint param0, glw::GLint param1, glw::GLdouble* param2)
2770{
2771	if (m_enableLog)
2772		m_log << TestLog::Message << "glGetUniformdv(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2773	m_gl.getUniformdv(param0, param1, param2);
2774}
2775
2776void CallLogWrapper::glMinSampleShading (glw::GLfloat param0)
2777{
2778	if (m_enableLog)
2779		m_log << TestLog::Message << "glMinSampleShading(" << param0 << ");" << TestLog::EndMessage;
2780	m_gl.minSampleShading(param0);
2781}
2782
2783glw::GLint CallLogWrapper::glGetSubroutineUniformLocation (glw::GLuint param0, glw::GLenum param1, const glw::GLchar* param2)
2784{
2785	if (m_enableLog)
2786		m_log << TestLog::Message << "glGetSubroutineUniformLocation(" << param0 << ", " << toHex(param1) << ", " << getStringStr(param2) << ");" << TestLog::EndMessage;
2787	glw::GLint returnValue = m_gl.getSubroutineUniformLocation(param0, param1, param2);
2788	if (m_enableLog)
2789		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2790	return returnValue;
2791}
2792
2793glw::GLuint CallLogWrapper::glGetSubroutineIndex (glw::GLuint param0, glw::GLenum param1, const glw::GLchar* param2)
2794{
2795	if (m_enableLog)
2796		m_log << TestLog::Message << "glGetSubroutineIndex(" << param0 << ", " << toHex(param1) << ", " << getStringStr(param2) << ");" << TestLog::EndMessage;
2797	glw::GLuint returnValue = m_gl.getSubroutineIndex(param0, param1, param2);
2798	if (m_enableLog)
2799		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
2800	return returnValue;
2801}
2802
2803void CallLogWrapper::glGetActiveSubroutineUniformiv (glw::GLuint param0, glw::GLenum param1, glw::GLuint param2, glw::GLenum param3, glw::GLint* param4)
2804{
2805	if (m_enableLog)
2806		m_log << TestLog::Message << "glGetActiveSubroutineUniformiv(" << param0 << ", " << toHex(param1) << ", " << param2 << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
2807	m_gl.getActiveSubroutineUniformiv(param0, param1, param2, param3, param4);
2808}
2809
2810void CallLogWrapper::glGetActiveSubroutineUniformName (glw::GLuint param0, glw::GLenum param1, glw::GLuint param2, glw::GLsizei param3, glw::GLsizei* param4, glw::GLchar* param5)
2811{
2812	if (m_enableLog)
2813		m_log << TestLog::Message << "glGetActiveSubroutineUniformName(" << param0 << ", " << toHex(param1) << ", " << param2 << ", " << param3 << ", " << toHex(param4) << ", " << toHex(param5) << ");" << TestLog::EndMessage;
2814	m_gl.getActiveSubroutineUniformName(param0, param1, param2, param3, param4, param5);
2815}
2816
2817void CallLogWrapper::glGetActiveSubroutineName (glw::GLuint param0, glw::GLenum param1, glw::GLuint param2, glw::GLsizei param3, glw::GLsizei* param4, glw::GLchar* param5)
2818{
2819	if (m_enableLog)
2820		m_log << TestLog::Message << "glGetActiveSubroutineName(" << param0 << ", " << toHex(param1) << ", " << param2 << ", " << param3 << ", " << toHex(param4) << ", " << toHex(param5) << ");" << TestLog::EndMessage;
2821	m_gl.getActiveSubroutineName(param0, param1, param2, param3, param4, param5);
2822}
2823
2824void CallLogWrapper::glUniformSubroutinesuiv (glw::GLenum param0, glw::GLsizei param1, const glw::GLuint* param2)
2825{
2826	if (m_enableLog)
2827		m_log << TestLog::Message << "glUniformSubroutinesuiv(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2828	m_gl.uniformSubroutinesuiv(param0, param1, param2);
2829}
2830
2831void CallLogWrapper::glGetUniformSubroutineuiv (glw::GLenum param0, glw::GLint param1, glw::GLuint* param2)
2832{
2833	if (m_enableLog)
2834		m_log << TestLog::Message << "glGetUniformSubroutineuiv(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
2835	m_gl.getUniformSubroutineuiv(param0, param1, param2);
2836}
2837
2838void CallLogWrapper::glGetProgramStageiv (glw::GLuint param0, glw::GLenum param1, glw::GLenum param2, glw::GLint* param3)
2839{
2840	if (m_enableLog)
2841		m_log << TestLog::Message << "glGetProgramStageiv(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2842	m_gl.getProgramStageiv(param0, param1, param2, param3);
2843}
2844
2845void CallLogWrapper::glPatchParameteri (glw::GLenum param0, glw::GLint param1)
2846{
2847	if (m_enableLog)
2848		m_log << TestLog::Message << "glPatchParameteri(" << toHex(param0) << ", " << param1 << ");" << TestLog::EndMessage;
2849	m_gl.patchParameteri(param0, param1);
2850}
2851
2852void CallLogWrapper::glPatchParameterfv (glw::GLenum param0, const glw::GLfloat* param1)
2853{
2854	if (m_enableLog)
2855		m_log << TestLog::Message << "glPatchParameterfv(" << toHex(param0) << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2856	m_gl.patchParameterfv(param0, param1);
2857}
2858
2859void CallLogWrapper::glBindTransformFeedback (glw::GLenum param0, glw::GLuint param1)
2860{
2861	if (m_enableLog)
2862		m_log << TestLog::Message << "glBindTransformFeedback(" << getTransformFeedbackTargetStr(param0) << ", " << param1 << ");" << TestLog::EndMessage;
2863	m_gl.bindTransformFeedback(param0, param1);
2864}
2865
2866void CallLogWrapper::glDeleteTransformFeedbacks (glw::GLsizei param0, const glw::GLuint* param1)
2867{
2868	if (m_enableLog)
2869		m_log << TestLog::Message << "glDeleteTransformFeedbacks(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2870	m_gl.deleteTransformFeedbacks(param0, param1);
2871}
2872
2873void CallLogWrapper::glGenTransformFeedbacks (glw::GLsizei param0, glw::GLuint* param1)
2874{
2875	if (m_enableLog)
2876		m_log << TestLog::Message << "glGenTransformFeedbacks(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
2877	m_gl.genTransformFeedbacks(param0, param1);
2878	if (m_enableLog)
2879	{
2880		m_log << TestLog::Message << "// param 1 = " << getPointerStr(param1, param0) << TestLog::EndMessage;
2881	}
2882}
2883
2884glw::GLboolean CallLogWrapper::glIsTransformFeedback (glw::GLuint param0)
2885{
2886	if (m_enableLog)
2887		m_log << TestLog::Message << "glIsTransformFeedback(" << param0 << ");" << TestLog::EndMessage;
2888	glw::GLboolean returnValue = m_gl.isTransformFeedback(param0);
2889	if (m_enableLog)
2890		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
2891	return returnValue;
2892}
2893
2894void CallLogWrapper::glPauseTransformFeedback ()
2895{
2896	if (m_enableLog)
2897		m_log << TestLog::Message << "glPauseTransformFeedback(" << ");" << TestLog::EndMessage;
2898	m_gl.pauseTransformFeedback();
2899}
2900
2901void CallLogWrapper::glResumeTransformFeedback ()
2902{
2903	if (m_enableLog)
2904		m_log << TestLog::Message << "glResumeTransformFeedback(" << ");" << TestLog::EndMessage;
2905	m_gl.resumeTransformFeedback();
2906}
2907
2908void CallLogWrapper::glDrawTransformFeedback (glw::GLenum param0, glw::GLuint param1)
2909{
2910	if (m_enableLog)
2911		m_log << TestLog::Message << "glDrawTransformFeedback(" << toHex(param0) << ", " << param1 << ");" << TestLog::EndMessage;
2912	m_gl.drawTransformFeedback(param0, param1);
2913}
2914
2915void CallLogWrapper::glDrawTransformFeedbackStream (glw::GLenum param0, glw::GLuint param1, glw::GLuint param2)
2916{
2917	if (m_enableLog)
2918		m_log << TestLog::Message << "glDrawTransformFeedbackStream(" << toHex(param0) << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
2919	m_gl.drawTransformFeedbackStream(param0, param1, param2);
2920}
2921
2922void CallLogWrapper::glBeginQueryIndexed (glw::GLenum param0, glw::GLuint param1, glw::GLuint param2)
2923{
2924	if (m_enableLog)
2925		m_log << TestLog::Message << "glBeginQueryIndexed(" << toHex(param0) << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
2926	m_gl.beginQueryIndexed(param0, param1, param2);
2927}
2928
2929void CallLogWrapper::glEndQueryIndexed (glw::GLenum param0, glw::GLuint param1)
2930{
2931	if (m_enableLog)
2932		m_log << TestLog::Message << "glEndQueryIndexed(" << toHex(param0) << ", " << param1 << ");" << TestLog::EndMessage;
2933	m_gl.endQueryIndexed(param0, param1);
2934}
2935
2936void CallLogWrapper::glGetQueryIndexediv (glw::GLenum param0, glw::GLuint param1, glw::GLenum param2, glw::GLint* param3)
2937{
2938	if (m_enableLog)
2939		m_log << TestLog::Message << "glGetQueryIndexediv(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2940	m_gl.getQueryIndexediv(param0, param1, param2, param3);
2941}
2942
2943void CallLogWrapper::glReleaseShaderCompiler ()
2944{
2945	if (m_enableLog)
2946		m_log << TestLog::Message << "glReleaseShaderCompiler(" << ");" << TestLog::EndMessage;
2947	m_gl.releaseShaderCompiler();
2948}
2949
2950void CallLogWrapper::glShaderBinary (glw::GLsizei param0, const glw::GLuint* param1, glw::GLenum param2, const glw::GLvoid* param3, glw::GLsizei param4)
2951{
2952	if (m_enableLog)
2953		m_log << TestLog::Message << "glShaderBinary(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ", " << toHex(param3) << ", " << param4 << ");" << TestLog::EndMessage;
2954	m_gl.shaderBinary(param0, param1, param2, param3, param4);
2955}
2956
2957void CallLogWrapper::glGetShaderPrecisionFormat (glw::GLenum param0, glw::GLenum param1, glw::GLint* param2, glw::GLint* param3)
2958{
2959	if (m_enableLog)
2960		m_log << TestLog::Message << "glGetShaderPrecisionFormat(" << getShaderTypeStr(param0) << ", " << getPrecisionFormatTypeStr(param1) << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
2961	m_gl.getShaderPrecisionFormat(param0, param1, param2, param3);
2962}
2963
2964void CallLogWrapper::glDepthRangef (glw::GLfloat param0, glw::GLfloat param1)
2965{
2966	if (m_enableLog)
2967		m_log << TestLog::Message << "glDepthRangef(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
2968	m_gl.depthRangef(param0, param1);
2969}
2970
2971void CallLogWrapper::glClearDepthf (glw::GLfloat param0)
2972{
2973	if (m_enableLog)
2974		m_log << TestLog::Message << "glClearDepthf(" << param0 << ");" << TestLog::EndMessage;
2975	m_gl.clearDepthf(param0);
2976}
2977
2978void CallLogWrapper::glGetProgramBinary (glw::GLuint param0, glw::GLsizei param1, glw::GLsizei* param2, glw::GLenum* param3, glw::GLvoid* param4)
2979{
2980	if (m_enableLog)
2981		m_log << TestLog::Message << "glGetProgramBinary(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
2982	m_gl.getProgramBinary(param0, param1, param2, param3, param4);
2983}
2984
2985void CallLogWrapper::glProgramBinary (glw::GLuint param0, glw::GLenum param1, const glw::GLvoid* param2, glw::GLsizei param3)
2986{
2987	if (m_enableLog)
2988		m_log << TestLog::Message << "glProgramBinary(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ", " << param3 << ");" << TestLog::EndMessage;
2989	m_gl.programBinary(param0, param1, param2, param3);
2990}
2991
2992void CallLogWrapper::glProgramParameteri (glw::GLuint param0, glw::GLenum param1, glw::GLint param2)
2993{
2994	if (m_enableLog)
2995		m_log << TestLog::Message << "glProgramParameteri(" << param0 << ", " << toHex(param1) << ", " << param2 << ");" << TestLog::EndMessage;
2996	m_gl.programParameteri(param0, param1, param2);
2997}
2998
2999void CallLogWrapper::glUseProgramStages (glw::GLuint param0, glw::GLbitfield param1, glw::GLuint param2)
3000{
3001	if (m_enableLog)
3002		m_log << TestLog::Message << "glUseProgramStages(" << param0 << ", " << toHex(param1) << ", " << param2 << ");" << TestLog::EndMessage;
3003	m_gl.useProgramStages(param0, param1, param2);
3004}
3005
3006void CallLogWrapper::glActiveShaderProgram (glw::GLuint param0, glw::GLuint param1)
3007{
3008	if (m_enableLog)
3009		m_log << TestLog::Message << "glActiveShaderProgram(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
3010	m_gl.activeShaderProgram(param0, param1);
3011}
3012
3013glw::GLuint CallLogWrapper::glCreateShaderProgramv (glw::GLenum param0, glw::GLsizei param1, const glw::GLchar* const* param2)
3014{
3015	if (m_enableLog)
3016		m_log << TestLog::Message << "glCreateShaderProgramv(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
3017	glw::GLuint returnValue = m_gl.createShaderProgramv(param0, param1, param2);
3018	if (m_enableLog)
3019		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
3020	return returnValue;
3021}
3022
3023void CallLogWrapper::glBindProgramPipeline (glw::GLuint param0)
3024{
3025	if (m_enableLog)
3026		m_log << TestLog::Message << "glBindProgramPipeline(" << param0 << ");" << TestLog::EndMessage;
3027	m_gl.bindProgramPipeline(param0);
3028}
3029
3030void CallLogWrapper::glDeleteProgramPipelines (glw::GLsizei param0, const glw::GLuint* param1)
3031{
3032	if (m_enableLog)
3033		m_log << TestLog::Message << "glDeleteProgramPipelines(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
3034	m_gl.deleteProgramPipelines(param0, param1);
3035}
3036
3037void CallLogWrapper::glGenProgramPipelines (glw::GLsizei param0, glw::GLuint* param1)
3038{
3039	if (m_enableLog)
3040		m_log << TestLog::Message << "glGenProgramPipelines(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
3041	m_gl.genProgramPipelines(param0, param1);
3042}
3043
3044glw::GLboolean CallLogWrapper::glIsProgramPipeline (glw::GLuint param0)
3045{
3046	if (m_enableLog)
3047		m_log << TestLog::Message << "glIsProgramPipeline(" << param0 << ");" << TestLog::EndMessage;
3048	glw::GLboolean returnValue = m_gl.isProgramPipeline(param0);
3049	if (m_enableLog)
3050		m_log << TestLog::Message << "// " << getBooleanStr(returnValue) << " returned" << TestLog::EndMessage;
3051	return returnValue;
3052}
3053
3054void CallLogWrapper::glGetProgramPipelineiv (glw::GLuint param0, glw::GLenum param1, glw::GLint* param2)
3055{
3056	if (m_enableLog)
3057		m_log << TestLog::Message << "glGetProgramPipelineiv(" << param0 << ", " << getPipelineParamStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
3058	m_gl.getProgramPipelineiv(param0, param1, param2);
3059	if (m_enableLog)
3060	{
3061		m_log << TestLog::Message << "// param 2 = " << getPointerStr(param2, 1) << TestLog::EndMessage;
3062	}
3063}
3064
3065void CallLogWrapper::glProgramUniform1i (glw::GLuint param0, glw::GLint param1, glw::GLint param2)
3066{
3067	if (m_enableLog)
3068		m_log << TestLog::Message << "glProgramUniform1i(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
3069	m_gl.programUniform1i(param0, param1, param2);
3070}
3071
3072void CallLogWrapper::glProgramUniform1iv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLint* param3)
3073{
3074	if (m_enableLog)
3075		m_log << TestLog::Message << "glProgramUniform1iv(" << param0 << ", " << param1 << ", " << param2 << ", " << getPointerStr(param3, (param2 * 1)) << ");" << TestLog::EndMessage;
3076	m_gl.programUniform1iv(param0, param1, param2, param3);
3077}
3078
3079void CallLogWrapper::glProgramUniform1f (glw::GLuint param0, glw::GLint param1, glw::GLfloat param2)
3080{
3081	if (m_enableLog)
3082		m_log << TestLog::Message << "glProgramUniform1f(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
3083	m_gl.programUniform1f(param0, param1, param2);
3084}
3085
3086void CallLogWrapper::glProgramUniform1fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLfloat* param3)
3087{
3088	if (m_enableLog)
3089		m_log << TestLog::Message << "glProgramUniform1fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getPointerStr(param3, (param2 * 1)) << ");" << TestLog::EndMessage;
3090	m_gl.programUniform1fv(param0, param1, param2, param3);
3091}
3092
3093void CallLogWrapper::glProgramUniform1d (glw::GLuint param0, glw::GLint param1, glw::GLdouble param2)
3094{
3095	if (m_enableLog)
3096		m_log << TestLog::Message << "glProgramUniform1d(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
3097	m_gl.programUniform1d(param0, param1, param2);
3098}
3099
3100void CallLogWrapper::glProgramUniform1dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLdouble* param3)
3101{
3102	if (m_enableLog)
3103		m_log << TestLog::Message << "glProgramUniform1dv(" << param0 << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ");" << TestLog::EndMessage;
3104	m_gl.programUniform1dv(param0, param1, param2, param3);
3105}
3106
3107void CallLogWrapper::glProgramUniform1ui (glw::GLuint param0, glw::GLint param1, glw::GLuint param2)
3108{
3109	if (m_enableLog)
3110		m_log << TestLog::Message << "glProgramUniform1ui(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
3111	m_gl.programUniform1ui(param0, param1, param2);
3112}
3113
3114void CallLogWrapper::glProgramUniform1uiv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLuint* param3)
3115{
3116	if (m_enableLog)
3117		m_log << TestLog::Message << "glProgramUniform1uiv(" << param0 << ", " << param1 << ", " << param2 << ", " << getPointerStr(param3, (param2 * 1)) << ");" << TestLog::EndMessage;
3118	m_gl.programUniform1uiv(param0, param1, param2, param3);
3119}
3120
3121void CallLogWrapper::glProgramUniform2i (glw::GLuint param0, glw::GLint param1, glw::GLint param2, glw::GLint param3)
3122{
3123	if (m_enableLog)
3124		m_log << TestLog::Message << "glProgramUniform2i(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
3125	m_gl.programUniform2i(param0, param1, param2, param3);
3126}
3127
3128void CallLogWrapper::glProgramUniform2iv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLint* param3)
3129{
3130	if (m_enableLog)
3131		m_log << TestLog::Message << "glProgramUniform2iv(" << param0 << ", " << param1 << ", " << param2 << ", " << getPointerStr(param3, (param2 * 2)) << ");" << TestLog::EndMessage;
3132	m_gl.programUniform2iv(param0, param1, param2, param3);
3133}
3134
3135void CallLogWrapper::glProgramUniform2f (glw::GLuint param0, glw::GLint param1, glw::GLfloat param2, glw::GLfloat param3)
3136{
3137	if (m_enableLog)
3138		m_log << TestLog::Message << "glProgramUniform2f(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
3139	m_gl.programUniform2f(param0, param1, param2, param3);
3140}
3141
3142void CallLogWrapper::glProgramUniform2fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLfloat* param3)
3143{
3144	if (m_enableLog)
3145		m_log << TestLog::Message << "glProgramUniform2fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getPointerStr(param3, (param2 * 2)) << ");" << TestLog::EndMessage;
3146	m_gl.programUniform2fv(param0, param1, param2, param3);
3147}
3148
3149void CallLogWrapper::glProgramUniform2d (glw::GLuint param0, glw::GLint param1, glw::GLdouble param2, glw::GLdouble param3)
3150{
3151	if (m_enableLog)
3152		m_log << TestLog::Message << "glProgramUniform2d(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
3153	m_gl.programUniform2d(param0, param1, param2, param3);
3154}
3155
3156void CallLogWrapper::glProgramUniform2dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLdouble* param3)
3157{
3158	if (m_enableLog)
3159		m_log << TestLog::Message << "glProgramUniform2dv(" << param0 << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ");" << TestLog::EndMessage;
3160	m_gl.programUniform2dv(param0, param1, param2, param3);
3161}
3162
3163void CallLogWrapper::glProgramUniform2ui (glw::GLuint param0, glw::GLint param1, glw::GLuint param2, glw::GLuint param3)
3164{
3165	if (m_enableLog)
3166		m_log << TestLog::Message << "glProgramUniform2ui(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
3167	m_gl.programUniform2ui(param0, param1, param2, param3);
3168}
3169
3170void CallLogWrapper::glProgramUniform2uiv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLuint* param3)
3171{
3172	if (m_enableLog)
3173		m_log << TestLog::Message << "glProgramUniform2uiv(" << param0 << ", " << param1 << ", " << param2 << ", " << getPointerStr(param3, (param2 * 2)) << ");" << TestLog::EndMessage;
3174	m_gl.programUniform2uiv(param0, param1, param2, param3);
3175}
3176
3177void CallLogWrapper::glProgramUniform3i (glw::GLuint param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLint param4)
3178{
3179	if (m_enableLog)
3180		m_log << TestLog::Message << "glProgramUniform3i(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
3181	m_gl.programUniform3i(param0, param1, param2, param3, param4);
3182}
3183
3184void CallLogWrapper::glProgramUniform3iv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLint* param3)
3185{
3186	if (m_enableLog)
3187		m_log << TestLog::Message << "glProgramUniform3iv(" << param0 << ", " << param1 << ", " << param2 << ", " << getPointerStr(param3, (param2 * 3)) << ");" << TestLog::EndMessage;
3188	m_gl.programUniform3iv(param0, param1, param2, param3);
3189}
3190
3191void CallLogWrapper::glProgramUniform3f (glw::GLuint param0, glw::GLint param1, glw::GLfloat param2, glw::GLfloat param3, glw::GLfloat param4)
3192{
3193	if (m_enableLog)
3194		m_log << TestLog::Message << "glProgramUniform3f(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
3195	m_gl.programUniform3f(param0, param1, param2, param3, param4);
3196}
3197
3198void CallLogWrapper::glProgramUniform3fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLfloat* param3)
3199{
3200	if (m_enableLog)
3201		m_log << TestLog::Message << "glProgramUniform3fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getPointerStr(param3, (param2 * 3)) << ");" << TestLog::EndMessage;
3202	m_gl.programUniform3fv(param0, param1, param2, param3);
3203}
3204
3205void CallLogWrapper::glProgramUniform3d (glw::GLuint param0, glw::GLint param1, glw::GLdouble param2, glw::GLdouble param3, glw::GLdouble param4)
3206{
3207	if (m_enableLog)
3208		m_log << TestLog::Message << "glProgramUniform3d(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
3209	m_gl.programUniform3d(param0, param1, param2, param3, param4);
3210}
3211
3212void CallLogWrapper::glProgramUniform3dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLdouble* param3)
3213{
3214	if (m_enableLog)
3215		m_log << TestLog::Message << "glProgramUniform3dv(" << param0 << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ");" << TestLog::EndMessage;
3216	m_gl.programUniform3dv(param0, param1, param2, param3);
3217}
3218
3219void CallLogWrapper::glProgramUniform3ui (glw::GLuint param0, glw::GLint param1, glw::GLuint param2, glw::GLuint param3, glw::GLuint param4)
3220{
3221	if (m_enableLog)
3222		m_log << TestLog::Message << "glProgramUniform3ui(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
3223	m_gl.programUniform3ui(param0, param1, param2, param3, param4);
3224}
3225
3226void CallLogWrapper::glProgramUniform3uiv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLuint* param3)
3227{
3228	if (m_enableLog)
3229		m_log << TestLog::Message << "glProgramUniform3uiv(" << param0 << ", " << param1 << ", " << param2 << ", " << getPointerStr(param3, (param2 * 3)) << ");" << TestLog::EndMessage;
3230	m_gl.programUniform3uiv(param0, param1, param2, param3);
3231}
3232
3233void CallLogWrapper::glProgramUniform4i (glw::GLuint param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLint param4, glw::GLint param5)
3234{
3235	if (m_enableLog)
3236		m_log << TestLog::Message << "glProgramUniform4i(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ");" << TestLog::EndMessage;
3237	m_gl.programUniform4i(param0, param1, param2, param3, param4, param5);
3238}
3239
3240void CallLogWrapper::glProgramUniform4iv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLint* param3)
3241{
3242	if (m_enableLog)
3243		m_log << TestLog::Message << "glProgramUniform4iv(" << param0 << ", " << param1 << ", " << param2 << ", " << getPointerStr(param3, (param2 * 4)) << ");" << TestLog::EndMessage;
3244	m_gl.programUniform4iv(param0, param1, param2, param3);
3245}
3246
3247void CallLogWrapper::glProgramUniform4f (glw::GLuint param0, glw::GLint param1, glw::GLfloat param2, glw::GLfloat param3, glw::GLfloat param4, glw::GLfloat param5)
3248{
3249	if (m_enableLog)
3250		m_log << TestLog::Message << "glProgramUniform4f(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ");" << TestLog::EndMessage;
3251	m_gl.programUniform4f(param0, param1, param2, param3, param4, param5);
3252}
3253
3254void CallLogWrapper::glProgramUniform4fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLfloat* param3)
3255{
3256	if (m_enableLog)
3257		m_log << TestLog::Message << "glProgramUniform4fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getPointerStr(param3, (param2 * 4)) << ");" << TestLog::EndMessage;
3258	m_gl.programUniform4fv(param0, param1, param2, param3);
3259}
3260
3261void CallLogWrapper::glProgramUniform4d (glw::GLuint param0, glw::GLint param1, glw::GLdouble param2, glw::GLdouble param3, glw::GLdouble param4, glw::GLdouble param5)
3262{
3263	if (m_enableLog)
3264		m_log << TestLog::Message << "glProgramUniform4d(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ");" << TestLog::EndMessage;
3265	m_gl.programUniform4d(param0, param1, param2, param3, param4, param5);
3266}
3267
3268void CallLogWrapper::glProgramUniform4dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLdouble* param3)
3269{
3270	if (m_enableLog)
3271		m_log << TestLog::Message << "glProgramUniform4dv(" << param0 << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ");" << TestLog::EndMessage;
3272	m_gl.programUniform4dv(param0, param1, param2, param3);
3273}
3274
3275void CallLogWrapper::glProgramUniform4ui (glw::GLuint param0, glw::GLint param1, glw::GLuint param2, glw::GLuint param3, glw::GLuint param4, glw::GLuint param5)
3276{
3277	if (m_enableLog)
3278		m_log << TestLog::Message << "glProgramUniform4ui(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ");" << TestLog::EndMessage;
3279	m_gl.programUniform4ui(param0, param1, param2, param3, param4, param5);
3280}
3281
3282void CallLogWrapper::glProgramUniform4uiv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, const glw::GLuint* param3)
3283{
3284	if (m_enableLog)
3285		m_log << TestLog::Message << "glProgramUniform4uiv(" << param0 << ", " << param1 << ", " << param2 << ", " << getPointerStr(param3, (param2 * 4)) << ");" << TestLog::EndMessage;
3286	m_gl.programUniform4uiv(param0, param1, param2, param3);
3287}
3288
3289void CallLogWrapper::glProgramUniformMatrix2fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLfloat* param4)
3290{
3291	if (m_enableLog)
3292		m_log << TestLog::Message << "glProgramUniformMatrix2fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << getPointerStr(param4, (param2 * 2*2)) << ");" << TestLog::EndMessage;
3293	m_gl.programUniformMatrix2fv(param0, param1, param2, param3, param4);
3294}
3295
3296void CallLogWrapper::glProgramUniformMatrix3fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLfloat* param4)
3297{
3298	if (m_enableLog)
3299		m_log << TestLog::Message << "glProgramUniformMatrix3fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << getPointerStr(param4, (param2 * 3*3)) << ");" << TestLog::EndMessage;
3300	m_gl.programUniformMatrix3fv(param0, param1, param2, param3, param4);
3301}
3302
3303void CallLogWrapper::glProgramUniformMatrix4fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLfloat* param4)
3304{
3305	if (m_enableLog)
3306		m_log << TestLog::Message << "glProgramUniformMatrix4fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << getPointerStr(param4, (param2 * 4*4)) << ");" << TestLog::EndMessage;
3307	m_gl.programUniformMatrix4fv(param0, param1, param2, param3, param4);
3308}
3309
3310void CallLogWrapper::glProgramUniformMatrix2dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLdouble* param4)
3311{
3312	if (m_enableLog)
3313		m_log << TestLog::Message << "glProgramUniformMatrix2dv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3314	m_gl.programUniformMatrix2dv(param0, param1, param2, param3, param4);
3315}
3316
3317void CallLogWrapper::glProgramUniformMatrix3dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLdouble* param4)
3318{
3319	if (m_enableLog)
3320		m_log << TestLog::Message << "glProgramUniformMatrix3dv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3321	m_gl.programUniformMatrix3dv(param0, param1, param2, param3, param4);
3322}
3323
3324void CallLogWrapper::glProgramUniformMatrix4dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLdouble* param4)
3325{
3326	if (m_enableLog)
3327		m_log << TestLog::Message << "glProgramUniformMatrix4dv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3328	m_gl.programUniformMatrix4dv(param0, param1, param2, param3, param4);
3329}
3330
3331void CallLogWrapper::glProgramUniformMatrix2x3fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLfloat* param4)
3332{
3333	if (m_enableLog)
3334		m_log << TestLog::Message << "glProgramUniformMatrix2x3fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << getPointerStr(param4, (param2 * 2*3)) << ");" << TestLog::EndMessage;
3335	m_gl.programUniformMatrix2x3fv(param0, param1, param2, param3, param4);
3336}
3337
3338void CallLogWrapper::glProgramUniformMatrix3x2fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLfloat* param4)
3339{
3340	if (m_enableLog)
3341		m_log << TestLog::Message << "glProgramUniformMatrix3x2fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << getPointerStr(param4, (param2 * 3*2)) << ");" << TestLog::EndMessage;
3342	m_gl.programUniformMatrix3x2fv(param0, param1, param2, param3, param4);
3343}
3344
3345void CallLogWrapper::glProgramUniformMatrix2x4fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLfloat* param4)
3346{
3347	if (m_enableLog)
3348		m_log << TestLog::Message << "glProgramUniformMatrix2x4fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << getPointerStr(param4, (param2 * 2*4)) << ");" << TestLog::EndMessage;
3349	m_gl.programUniformMatrix2x4fv(param0, param1, param2, param3, param4);
3350}
3351
3352void CallLogWrapper::glProgramUniformMatrix4x2fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLfloat* param4)
3353{
3354	if (m_enableLog)
3355		m_log << TestLog::Message << "glProgramUniformMatrix4x2fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << getPointerStr(param4, (param2 * 4*2)) << ");" << TestLog::EndMessage;
3356	m_gl.programUniformMatrix4x2fv(param0, param1, param2, param3, param4);
3357}
3358
3359void CallLogWrapper::glProgramUniformMatrix3x4fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLfloat* param4)
3360{
3361	if (m_enableLog)
3362		m_log << TestLog::Message << "glProgramUniformMatrix3x4fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << getPointerStr(param4, (param2 * 3*4)) << ");" << TestLog::EndMessage;
3363	m_gl.programUniformMatrix3x4fv(param0, param1, param2, param3, param4);
3364}
3365
3366void CallLogWrapper::glProgramUniformMatrix4x3fv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLfloat* param4)
3367{
3368	if (m_enableLog)
3369		m_log << TestLog::Message << "glProgramUniformMatrix4x3fv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << getPointerStr(param4, (param2 * 4*3)) << ");" << TestLog::EndMessage;
3370	m_gl.programUniformMatrix4x3fv(param0, param1, param2, param3, param4);
3371}
3372
3373void CallLogWrapper::glProgramUniformMatrix2x3dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLdouble* param4)
3374{
3375	if (m_enableLog)
3376		m_log << TestLog::Message << "glProgramUniformMatrix2x3dv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3377	m_gl.programUniformMatrix2x3dv(param0, param1, param2, param3, param4);
3378}
3379
3380void CallLogWrapper::glProgramUniformMatrix3x2dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLdouble* param4)
3381{
3382	if (m_enableLog)
3383		m_log << TestLog::Message << "glProgramUniformMatrix3x2dv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3384	m_gl.programUniformMatrix3x2dv(param0, param1, param2, param3, param4);
3385}
3386
3387void CallLogWrapper::glProgramUniformMatrix2x4dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLdouble* param4)
3388{
3389	if (m_enableLog)
3390		m_log << TestLog::Message << "glProgramUniformMatrix2x4dv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3391	m_gl.programUniformMatrix2x4dv(param0, param1, param2, param3, param4);
3392}
3393
3394void CallLogWrapper::glProgramUniformMatrix4x2dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLdouble* param4)
3395{
3396	if (m_enableLog)
3397		m_log << TestLog::Message << "glProgramUniformMatrix4x2dv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3398	m_gl.programUniformMatrix4x2dv(param0, param1, param2, param3, param4);
3399}
3400
3401void CallLogWrapper::glProgramUniformMatrix3x4dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLdouble* param4)
3402{
3403	if (m_enableLog)
3404		m_log << TestLog::Message << "glProgramUniformMatrix3x4dv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3405	m_gl.programUniformMatrix3x4dv(param0, param1, param2, param3, param4);
3406}
3407
3408void CallLogWrapper::glProgramUniformMatrix4x3dv (glw::GLuint param0, glw::GLint param1, glw::GLsizei param2, glw::GLboolean param3, const glw::GLdouble* param4)
3409{
3410	if (m_enableLog)
3411		m_log << TestLog::Message << "glProgramUniformMatrix4x3dv(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3412	m_gl.programUniformMatrix4x3dv(param0, param1, param2, param3, param4);
3413}
3414
3415void CallLogWrapper::glValidateProgramPipeline (glw::GLuint param0)
3416{
3417	if (m_enableLog)
3418		m_log << TestLog::Message << "glValidateProgramPipeline(" << param0 << ");" << TestLog::EndMessage;
3419	m_gl.validateProgramPipeline(param0);
3420}
3421
3422void CallLogWrapper::glGetProgramPipelineInfoLog (glw::GLuint param0, glw::GLsizei param1, glw::GLsizei* param2, glw::GLchar* param3)
3423{
3424	if (m_enableLog)
3425		m_log << TestLog::Message << "glGetProgramPipelineInfoLog(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
3426	m_gl.getProgramPipelineInfoLog(param0, param1, param2, param3);
3427}
3428
3429void CallLogWrapper::glVertexAttribL1d (glw::GLuint param0, glw::GLdouble param1)
3430{
3431	if (m_enableLog)
3432		m_log << TestLog::Message << "glVertexAttribL1d(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
3433	m_gl.vertexAttribL1d(param0, param1);
3434}
3435
3436void CallLogWrapper::glVertexAttribL2d (glw::GLuint param0, glw::GLdouble param1, glw::GLdouble param2)
3437{
3438	if (m_enableLog)
3439		m_log << TestLog::Message << "glVertexAttribL2d(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
3440	m_gl.vertexAttribL2d(param0, param1, param2);
3441}
3442
3443void CallLogWrapper::glVertexAttribL3d (glw::GLuint param0, glw::GLdouble param1, glw::GLdouble param2, glw::GLdouble param3)
3444{
3445	if (m_enableLog)
3446		m_log << TestLog::Message << "glVertexAttribL3d(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
3447	m_gl.vertexAttribL3d(param0, param1, param2, param3);
3448}
3449
3450void CallLogWrapper::glVertexAttribL4d (glw::GLuint param0, glw::GLdouble param1, glw::GLdouble param2, glw::GLdouble param3, glw::GLdouble param4)
3451{
3452	if (m_enableLog)
3453		m_log << TestLog::Message << "glVertexAttribL4d(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
3454	m_gl.vertexAttribL4d(param0, param1, param2, param3, param4);
3455}
3456
3457void CallLogWrapper::glVertexAttribL1dv (glw::GLuint param0, const glw::GLdouble* param1)
3458{
3459	if (m_enableLog)
3460		m_log << TestLog::Message << "glVertexAttribL1dv(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
3461	m_gl.vertexAttribL1dv(param0, param1);
3462}
3463
3464void CallLogWrapper::glVertexAttribL2dv (glw::GLuint param0, const glw::GLdouble* param1)
3465{
3466	if (m_enableLog)
3467		m_log << TestLog::Message << "glVertexAttribL2dv(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
3468	m_gl.vertexAttribL2dv(param0, param1);
3469}
3470
3471void CallLogWrapper::glVertexAttribL3dv (glw::GLuint param0, const glw::GLdouble* param1)
3472{
3473	if (m_enableLog)
3474		m_log << TestLog::Message << "glVertexAttribL3dv(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
3475	m_gl.vertexAttribL3dv(param0, param1);
3476}
3477
3478void CallLogWrapper::glVertexAttribL4dv (glw::GLuint param0, const glw::GLdouble* param1)
3479{
3480	if (m_enableLog)
3481		m_log << TestLog::Message << "glVertexAttribL4dv(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
3482	m_gl.vertexAttribL4dv(param0, param1);
3483}
3484
3485void CallLogWrapper::glVertexAttribLPointer (glw::GLuint param0, glw::GLint param1, glw::GLenum param2, glw::GLsizei param3, const glw::GLvoid* param4)
3486{
3487	if (m_enableLog)
3488		m_log << TestLog::Message << "glVertexAttribLPointer(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << param3 << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3489	m_gl.vertexAttribLPointer(param0, param1, param2, param3, param4);
3490}
3491
3492void CallLogWrapper::glGetVertexAttribLdv (glw::GLuint param0, glw::GLenum param1, glw::GLdouble* param2)
3493{
3494	if (m_enableLog)
3495		m_log << TestLog::Message << "glGetVertexAttribLdv(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
3496	m_gl.getVertexAttribLdv(param0, param1, param2);
3497}
3498
3499void CallLogWrapper::glViewportArrayv (glw::GLuint param0, glw::GLsizei param1, const glw::GLfloat* param2)
3500{
3501	if (m_enableLog)
3502		m_log << TestLog::Message << "glViewportArrayv(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
3503	m_gl.viewportArrayv(param0, param1, param2);
3504}
3505
3506void CallLogWrapper::glViewportIndexedf (glw::GLuint param0, glw::GLfloat param1, glw::GLfloat param2, glw::GLfloat param3, glw::GLfloat param4)
3507{
3508	if (m_enableLog)
3509		m_log << TestLog::Message << "glViewportIndexedf(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
3510	m_gl.viewportIndexedf(param0, param1, param2, param3, param4);
3511}
3512
3513void CallLogWrapper::glViewportIndexedfv (glw::GLuint param0, const glw::GLfloat* param1)
3514{
3515	if (m_enableLog)
3516		m_log << TestLog::Message << "glViewportIndexedfv(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
3517	m_gl.viewportIndexedfv(param0, param1);
3518}
3519
3520void CallLogWrapper::glScissorArrayv (glw::GLuint param0, glw::GLsizei param1, const glw::GLint* param2)
3521{
3522	if (m_enableLog)
3523		m_log << TestLog::Message << "glScissorArrayv(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
3524	m_gl.scissorArrayv(param0, param1, param2);
3525}
3526
3527void CallLogWrapper::glScissorIndexed (glw::GLuint param0, glw::GLint param1, glw::GLint param2, glw::GLsizei param3, glw::GLsizei param4)
3528{
3529	if (m_enableLog)
3530		m_log << TestLog::Message << "glScissorIndexed(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
3531	m_gl.scissorIndexed(param0, param1, param2, param3, param4);
3532}
3533
3534void CallLogWrapper::glScissorIndexedv (glw::GLuint param0, const glw::GLint* param1)
3535{
3536	if (m_enableLog)
3537		m_log << TestLog::Message << "glScissorIndexedv(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
3538	m_gl.scissorIndexedv(param0, param1);
3539}
3540
3541void CallLogWrapper::glDepthRangeArrayv (glw::GLuint param0, glw::GLsizei param1, const glw::GLdouble* param2)
3542{
3543	if (m_enableLog)
3544		m_log << TestLog::Message << "glDepthRangeArrayv(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
3545	m_gl.depthRangeArrayv(param0, param1, param2);
3546}
3547
3548void CallLogWrapper::glDepthRangeIndexed (glw::GLuint param0, glw::GLdouble param1, glw::GLdouble param2)
3549{
3550	if (m_enableLog)
3551		m_log << TestLog::Message << "glDepthRangeIndexed(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
3552	m_gl.depthRangeIndexed(param0, param1, param2);
3553}
3554
3555void CallLogWrapper::glGetFloati_v (glw::GLenum param0, glw::GLuint param1, glw::GLfloat* param2)
3556{
3557	if (m_enableLog)
3558		m_log << TestLog::Message << "glGetFloati_v(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
3559	m_gl.getFloati_v(param0, param1, param2);
3560}
3561
3562void CallLogWrapper::glGetDoublei_v (glw::GLenum param0, glw::GLuint param1, glw::GLdouble* param2)
3563{
3564	if (m_enableLog)
3565		m_log << TestLog::Message << "glGetDoublei_v(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
3566	m_gl.getDoublei_v(param0, param1, param2);
3567}
3568
3569void CallLogWrapper::glDrawArraysInstancedBaseInstance (glw::GLenum param0, glw::GLint param1, glw::GLsizei param2, glw::GLsizei param3, glw::GLuint param4)
3570{
3571	if (m_enableLog)
3572		m_log << TestLog::Message << "glDrawArraysInstancedBaseInstance(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
3573	m_gl.drawArraysInstancedBaseInstance(param0, param1, param2, param3, param4);
3574}
3575
3576void CallLogWrapper::glDrawElementsInstancedBaseInstance (glw::GLenum param0, glw::GLsizei param1, glw::GLenum param2, const void* param3, glw::GLsizei param4, glw::GLuint param5)
3577{
3578	if (m_enableLog)
3579		m_log << TestLog::Message << "glDrawElementsInstancedBaseInstance(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ", " << param4 << ", " << param5 << ");" << TestLog::EndMessage;
3580	m_gl.drawElementsInstancedBaseInstance(param0, param1, param2, param3, param4, param5);
3581}
3582
3583void CallLogWrapper::glDrawElementsInstancedBaseVertexBaseInstance (glw::GLenum param0, glw::GLsizei param1, glw::GLenum param2, const void* param3, glw::GLsizei param4, glw::GLint param5, glw::GLuint param6)
3584{
3585	if (m_enableLog)
3586		m_log << TestLog::Message << "glDrawElementsInstancedBaseVertexBaseInstance(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ", " << param4 << ", " << param5 << ", " << param6 << ");" << TestLog::EndMessage;
3587	m_gl.drawElementsInstancedBaseVertexBaseInstance(param0, param1, param2, param3, param4, param5, param6);
3588}
3589
3590void CallLogWrapper::glDrawTransformFeedbackInstanced (glw::GLenum param0, glw::GLuint param1, glw::GLsizei param2)
3591{
3592	if (m_enableLog)
3593		m_log << TestLog::Message << "glDrawTransformFeedbackInstanced(" << toHex(param0) << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
3594	m_gl.drawTransformFeedbackInstanced(param0, param1, param2);
3595}
3596
3597void CallLogWrapper::glDrawTransformFeedbackStreamInstanced (glw::GLenum param0, glw::GLuint param1, glw::GLuint param2, glw::GLsizei param3)
3598{
3599	if (m_enableLog)
3600		m_log << TestLog::Message << "glDrawTransformFeedbackStreamInstanced(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
3601	m_gl.drawTransformFeedbackStreamInstanced(param0, param1, param2, param3);
3602}
3603
3604void CallLogWrapper::glGetInternalformativ (glw::GLenum param0, glw::GLenum param1, glw::GLenum param2, glw::GLsizei param3, glw::GLint* param4)
3605{
3606	if (m_enableLog)
3607		m_log << TestLog::Message << "glGetInternalformativ(" << getInternalFormatTargetStr(param0) << ", " << getPixelFormatStr(param1) << ", " << getInternalFormatParameterStr(param2) << ", " << param3 << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3608	m_gl.getInternalformativ(param0, param1, param2, param3, param4);
3609	if (m_enableLog)
3610	{
3611		m_log << TestLog::Message << "// param 4 = " << getPointerStr(param4, param3) << TestLog::EndMessage;
3612	}
3613}
3614
3615void CallLogWrapper::glGetActiveAtomicCounterBufferiv (glw::GLuint param0, glw::GLuint param1, glw::GLenum param2, glw::GLint* param3)
3616{
3617	if (m_enableLog)
3618		m_log << TestLog::Message << "glGetActiveAtomicCounterBufferiv(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
3619	m_gl.getActiveAtomicCounterBufferiv(param0, param1, param2, param3);
3620}
3621
3622void CallLogWrapper::glBindImageTexture (glw::GLuint param0, glw::GLuint param1, glw::GLint param2, glw::GLboolean param3, glw::GLint param4, glw::GLenum param5, glw::GLenum param6)
3623{
3624	if (m_enableLog)
3625		m_log << TestLog::Message << "glBindImageTexture(" << param0 << ", " << param1 << ", " << param2 << ", " << getBooleanStr(param3) << ", " << param4 << ", " << getImageAccessStr(param5) << ", " << getPixelFormatStr(param6) << ");" << TestLog::EndMessage;
3626	m_gl.bindImageTexture(param0, param1, param2, param3, param4, param5, param6);
3627}
3628
3629void CallLogWrapper::glMemoryBarrier (glw::GLbitfield param0)
3630{
3631	if (m_enableLog)
3632		m_log << TestLog::Message << "glMemoryBarrier(" << getMemoryBarrierFlagsStr(param0) << ");" << TestLog::EndMessage;
3633	m_gl.memoryBarrier(param0);
3634}
3635
3636void CallLogWrapper::glTexStorage1D (glw::GLenum param0, glw::GLsizei param1, glw::GLenum param2, glw::GLsizei param3)
3637{
3638	if (m_enableLog)
3639		m_log << TestLog::Message << "glTexStorage1D(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ", " << param3 << ");" << TestLog::EndMessage;
3640	m_gl.texStorage1D(param0, param1, param2, param3);
3641}
3642
3643void CallLogWrapper::glTexStorage2D (glw::GLenum param0, glw::GLsizei param1, glw::GLenum param2, glw::GLsizei param3, glw::GLsizei param4)
3644{
3645	if (m_enableLog)
3646		m_log << TestLog::Message << "glTexStorage2D(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getPixelFormatStr(param2) << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
3647	m_gl.texStorage2D(param0, param1, param2, param3, param4);
3648}
3649
3650void CallLogWrapper::glTexStorage3D (glw::GLenum param0, glw::GLsizei param1, glw::GLenum param2, glw::GLsizei param3, glw::GLsizei param4, glw::GLsizei param5)
3651{
3652	if (m_enableLog)
3653		m_log << TestLog::Message << "glTexStorage3D(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getPixelFormatStr(param2) << ", " << param3 << ", " << param4 << ", " << param5 << ");" << TestLog::EndMessage;
3654	m_gl.texStorage3D(param0, param1, param2, param3, param4, param5);
3655}
3656
3657void CallLogWrapper::glClearBufferData (glw::GLenum param0, glw::GLenum param1, glw::GLenum param2, glw::GLenum param3, const void* param4)
3658{
3659	if (m_enableLog)
3660		m_log << TestLog::Message << "glClearBufferData(" << toHex(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3661	m_gl.clearBufferData(param0, param1, param2, param3, param4);
3662}
3663
3664void CallLogWrapper::glClearBufferSubData (glw::GLenum param0, glw::GLenum param1, glw::GLintptr param2, glw::GLsizeiptr param3, glw::GLenum param4, glw::GLenum param5, const void* param6)
3665{
3666	if (m_enableLog)
3667		m_log << TestLog::Message << "glClearBufferSubData(" << toHex(param0) << ", " << toHex(param1) << ", " << param2 << ", " << param3 << ", " << toHex(param4) << ", " << toHex(param5) << ", " << toHex(param6) << ");" << TestLog::EndMessage;
3668	m_gl.clearBufferSubData(param0, param1, param2, param3, param4, param5, param6);
3669}
3670
3671void CallLogWrapper::glDispatchCompute (glw::GLuint param0, glw::GLuint param1, glw::GLuint param2)
3672{
3673	if (m_enableLog)
3674		m_log << TestLog::Message << "glDispatchCompute(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
3675	m_gl.dispatchCompute(param0, param1, param2);
3676}
3677
3678void CallLogWrapper::glDispatchComputeIndirect (glw::GLintptr param0)
3679{
3680	if (m_enableLog)
3681		m_log << TestLog::Message << "glDispatchComputeIndirect(" << param0 << ");" << TestLog::EndMessage;
3682	m_gl.dispatchComputeIndirect(param0);
3683}
3684
3685void CallLogWrapper::glCopyImageSubData (glw::GLuint param0, glw::GLenum param1, glw::GLint param2, glw::GLint param3, glw::GLint param4, glw::GLint param5, glw::GLuint param6, glw::GLenum param7, glw::GLint param8, glw::GLint param9, glw::GLint param10, glw::GLint param11, glw::GLsizei param12, glw::GLsizei param13, glw::GLsizei param14)
3686{
3687	if (m_enableLog)
3688		m_log << TestLog::Message << "glCopyImageSubData(" << param0 << ", " << toHex(param1) << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ", " << toHex(param7) << ", " << param8 << ", " << param9 << ", " << param10 << ", " << param11 << ", " << param12 << ", " << param13 << ", " << param14 << ");" << TestLog::EndMessage;
3689	m_gl.copyImageSubData(param0, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14);
3690}
3691
3692void CallLogWrapper::glDebugMessageControl (glw::GLenum param0, glw::GLenum param1, glw::GLenum param2, glw::GLsizei param3, const glw::GLuint* param4, glw::GLboolean param5)
3693{
3694	if (m_enableLog)
3695		m_log << TestLog::Message << "glDebugMessageControl(" << getDebugMessageSourceStr(param0) << ", " << getDebugMessageTypeStr(param1) << ", " << getDebugMessageSeverityStr(param2) << ", " << param3 << ", " << getPointerStr(param4, (param3)) << ", " << getBooleanStr(param5) << ");" << TestLog::EndMessage;
3696	m_gl.debugMessageControl(param0, param1, param2, param3, param4, param5);
3697}
3698
3699void CallLogWrapper::glDebugMessageInsert (glw::GLenum param0, glw::GLenum param1, glw::GLuint param2, glw::GLenum param3, glw::GLsizei param4, const glw::GLchar* param5)
3700{
3701	if (m_enableLog)
3702		m_log << TestLog::Message << "glDebugMessageInsert(" << getDebugMessageSourceStr(param0) << ", " << getDebugMessageTypeStr(param1) << ", " << param2 << ", " << getDebugMessageSeverityStr(param3) << ", " << param4 << ", " << getStringStr(param5) << ");" << TestLog::EndMessage;
3703	m_gl.debugMessageInsert(param0, param1, param2, param3, param4, param5);
3704}
3705
3706void CallLogWrapper::glDebugMessageCallback (glw::GLDEBUGPROC param0, const void* param1)
3707{
3708	if (m_enableLog)
3709		m_log << TestLog::Message << "glDebugMessageCallback(" << param0 << ", " << toHex(param1) << ");" << TestLog::EndMessage;
3710	m_gl.debugMessageCallback(param0, param1);
3711}
3712
3713glw::GLuint CallLogWrapper::glGetDebugMessageLog (glw::GLuint param0, glw::GLsizei param1, glw::GLenum* param2, glw::GLenum* param3, glw::GLuint* param4, glw::GLenum* param5, glw::GLsizei* param6, glw::GLchar* param7)
3714{
3715	if (m_enableLog)
3716		m_log << TestLog::Message << "glGetDebugMessageLog(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ", " << toHex(param4) << ", " << toHex(param5) << ", " << toHex(param6) << ", " << toHex(param7) << ");" << TestLog::EndMessage;
3717	glw::GLuint returnValue = m_gl.getDebugMessageLog(param0, param1, param2, param3, param4, param5, param6, param7);
3718	if (m_enableLog)
3719		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
3720	return returnValue;
3721}
3722
3723void CallLogWrapper::glPushDebugGroup (glw::GLenum param0, glw::GLuint param1, glw::GLsizei param2, const glw::GLchar* param3)
3724{
3725	if (m_enableLog)
3726		m_log << TestLog::Message << "glPushDebugGroup(" << getDebugMessageSourceStr(param0) << ", " << param1 << ", " << param2 << ", " << getStringStr(param3) << ");" << TestLog::EndMessage;
3727	m_gl.pushDebugGroup(param0, param1, param2, param3);
3728}
3729
3730void CallLogWrapper::glPopDebugGroup ()
3731{
3732	if (m_enableLog)
3733		m_log << TestLog::Message << "glPopDebugGroup(" << ");" << TestLog::EndMessage;
3734	m_gl.popDebugGroup();
3735}
3736
3737void CallLogWrapper::glObjectLabel (glw::GLenum param0, glw::GLuint param1, glw::GLsizei param2, const glw::GLchar* param3)
3738{
3739	if (m_enableLog)
3740		m_log << TestLog::Message << "glObjectLabel(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << getStringStr(param3) << ");" << TestLog::EndMessage;
3741	m_gl.objectLabel(param0, param1, param2, param3);
3742}
3743
3744void CallLogWrapper::glGetObjectLabel (glw::GLenum param0, glw::GLuint param1, glw::GLsizei param2, glw::GLsizei* param3, glw::GLchar* param4)
3745{
3746	if (m_enableLog)
3747		m_log << TestLog::Message << "glGetObjectLabel(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3748	m_gl.getObjectLabel(param0, param1, param2, param3, param4);
3749}
3750
3751void CallLogWrapper::glObjectPtrLabel (const void* param0, glw::GLsizei param1, const glw::GLchar* param2)
3752{
3753	if (m_enableLog)
3754		m_log << TestLog::Message << "glObjectPtrLabel(" << toHex(param0) << ", " << param1 << ", " << getStringStr(param2) << ");" << TestLog::EndMessage;
3755	m_gl.objectPtrLabel(param0, param1, param2);
3756}
3757
3758void CallLogWrapper::glGetObjectPtrLabel (const void* param0, glw::GLsizei param1, glw::GLsizei* param2, glw::GLchar* param3)
3759{
3760	if (m_enableLog)
3761		m_log << TestLog::Message << "glGetObjectPtrLabel(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
3762	m_gl.getObjectPtrLabel(param0, param1, param2, param3);
3763}
3764
3765void CallLogWrapper::glFramebufferParameteri (glw::GLenum param0, glw::GLenum param1, glw::GLint param2)
3766{
3767	if (m_enableLog)
3768		m_log << TestLog::Message << "glFramebufferParameteri(" << getFramebufferTargetStr(param0) << ", " << getFramebufferParameterStr(param1) << ", " << param2 << ");" << TestLog::EndMessage;
3769	m_gl.framebufferParameteri(param0, param1, param2);
3770}
3771
3772void CallLogWrapper::glGetFramebufferParameteriv (glw::GLenum param0, glw::GLenum param1, glw::GLint* param2)
3773{
3774	if (m_enableLog)
3775		m_log << TestLog::Message << "glGetFramebufferParameteriv(" << getFramebufferTargetStr(param0) << ", " << getFramebufferParameterStr(param1) << ", " << toHex(param2) << ");" << TestLog::EndMessage;
3776	m_gl.getFramebufferParameteriv(param0, param1, param2);
3777}
3778
3779void CallLogWrapper::glGetInternalformati64v (glw::GLenum param0, glw::GLenum param1, glw::GLenum param2, glw::GLsizei param3, glw::GLint64* param4)
3780{
3781	if (m_enableLog)
3782		m_log << TestLog::Message << "glGetInternalformati64v(" << toHex(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ", " << param3 << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3783	m_gl.getInternalformati64v(param0, param1, param2, param3, param4);
3784}
3785
3786void CallLogWrapper::glInvalidateTexSubImage (glw::GLuint param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLint param4, glw::GLsizei param5, glw::GLsizei param6, glw::GLsizei param7)
3787{
3788	if (m_enableLog)
3789		m_log << TestLog::Message << "glInvalidateTexSubImage(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ", " << param7 << ");" << TestLog::EndMessage;
3790	m_gl.invalidateTexSubImage(param0, param1, param2, param3, param4, param5, param6, param7);
3791}
3792
3793void CallLogWrapper::glInvalidateTexImage (glw::GLuint param0, glw::GLint param1)
3794{
3795	if (m_enableLog)
3796		m_log << TestLog::Message << "glInvalidateTexImage(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
3797	m_gl.invalidateTexImage(param0, param1);
3798}
3799
3800void CallLogWrapper::glInvalidateBufferSubData (glw::GLuint param0, glw::GLintptr param1, glw::GLsizeiptr param2)
3801{
3802	if (m_enableLog)
3803		m_log << TestLog::Message << "glInvalidateBufferSubData(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
3804	m_gl.invalidateBufferSubData(param0, param1, param2);
3805}
3806
3807void CallLogWrapper::glInvalidateBufferData (glw::GLuint param0)
3808{
3809	if (m_enableLog)
3810		m_log << TestLog::Message << "glInvalidateBufferData(" << param0 << ");" << TestLog::EndMessage;
3811	m_gl.invalidateBufferData(param0);
3812}
3813
3814void CallLogWrapper::glInvalidateFramebuffer (glw::GLenum param0, glw::GLsizei param1, const glw::GLenum* param2)
3815{
3816	if (m_enableLog)
3817		m_log << TestLog::Message << "glInvalidateFramebuffer(" << getFramebufferTargetStr(param0) << ", " << param1 << ", " << getEnumPointerStr(param2, param1, getInvalidateAttachmentName) << ");" << TestLog::EndMessage;
3818	m_gl.invalidateFramebuffer(param0, param1, param2);
3819}
3820
3821void CallLogWrapper::glInvalidateSubFramebuffer (glw::GLenum param0, glw::GLsizei param1, const glw::GLenum* param2, glw::GLint param3, glw::GLint param4, glw::GLsizei param5, glw::GLsizei param6)
3822{
3823	if (m_enableLog)
3824		m_log << TestLog::Message << "glInvalidateSubFramebuffer(" << getFramebufferTargetStr(param0) << ", " << param1 << ", " << getEnumPointerStr(param2, param1, getInvalidateAttachmentName) << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ");" << TestLog::EndMessage;
3825	m_gl.invalidateSubFramebuffer(param0, param1, param2, param3, param4, param5, param6);
3826}
3827
3828void CallLogWrapper::glMultiDrawArraysIndirect (glw::GLenum param0, const void* param1, glw::GLsizei param2, glw::GLsizei param3)
3829{
3830	if (m_enableLog)
3831		m_log << TestLog::Message << "glMultiDrawArraysIndirect(" << toHex(param0) << ", " << toHex(param1) << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
3832	m_gl.multiDrawArraysIndirect(param0, param1, param2, param3);
3833}
3834
3835void CallLogWrapper::glMultiDrawElementsIndirect (glw::GLenum param0, glw::GLenum param1, const void* param2, glw::GLsizei param3, glw::GLsizei param4)
3836{
3837	if (m_enableLog)
3838		m_log << TestLog::Message << "glMultiDrawElementsIndirect(" << toHex(param0) << ", " << toHex(param1) << ", " << toHex(param2) << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
3839	m_gl.multiDrawElementsIndirect(param0, param1, param2, param3, param4);
3840}
3841
3842void CallLogWrapper::glGetProgramInterfaceiv (glw::GLuint param0, glw::GLenum param1, glw::GLenum param2, glw::GLint* param3)
3843{
3844	if (m_enableLog)
3845		m_log << TestLog::Message << "glGetProgramInterfaceiv(" << param0 << ", " << toHex(param1) << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
3846	m_gl.getProgramInterfaceiv(param0, param1, param2, param3);
3847}
3848
3849glw::GLuint CallLogWrapper::glGetProgramResourceIndex (glw::GLuint param0, glw::GLenum param1, const glw::GLchar* param2)
3850{
3851	if (m_enableLog)
3852		m_log << TestLog::Message << "glGetProgramResourceIndex(" << param0 << ", " << getProgramInterfaceStr(param1) << ", " << getStringStr(param2) << ");" << TestLog::EndMessage;
3853	glw::GLuint returnValue = m_gl.getProgramResourceIndex(param0, param1, param2);
3854	if (m_enableLog)
3855		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
3856	return returnValue;
3857}
3858
3859void CallLogWrapper::glGetProgramResourceName (glw::GLuint param0, glw::GLenum param1, glw::GLuint param2, glw::GLsizei param3, glw::GLsizei* param4, glw::GLchar* param5)
3860{
3861	if (m_enableLog)
3862		m_log << TestLog::Message << "glGetProgramResourceName(" << param0 << ", " << toHex(param1) << ", " << param2 << ", " << param3 << ", " << toHex(param4) << ", " << toHex(param5) << ");" << TestLog::EndMessage;
3863	m_gl.getProgramResourceName(param0, param1, param2, param3, param4, param5);
3864}
3865
3866void CallLogWrapper::glGetProgramResourceiv (glw::GLuint param0, glw::GLenum param1, glw::GLuint param2, glw::GLsizei param3, const glw::GLenum* param4, glw::GLsizei param5, glw::GLsizei* param6, glw::GLint* param7)
3867{
3868	if (m_enableLog)
3869		m_log << TestLog::Message << "glGetProgramResourceiv(" << param0 << ", " << getProgramInterfaceStr(param1) << ", " << param2 << ", " << param3 << ", " << toHex(param4) << ", " << param5 << ", " << toHex(param6) << ", " << toHex(param7) << ");" << TestLog::EndMessage;
3870	m_gl.getProgramResourceiv(param0, param1, param2, param3, param4, param5, param6, param7);
3871}
3872
3873glw::GLint CallLogWrapper::glGetProgramResourceLocation (glw::GLuint param0, glw::GLenum param1, const glw::GLchar* param2)
3874{
3875	if (m_enableLog)
3876		m_log << TestLog::Message << "glGetProgramResourceLocation(" << param0 << ", " << toHex(param1) << ", " << getStringStr(param2) << ");" << TestLog::EndMessage;
3877	glw::GLint returnValue = m_gl.getProgramResourceLocation(param0, param1, param2);
3878	if (m_enableLog)
3879		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
3880	return returnValue;
3881}
3882
3883glw::GLint CallLogWrapper::glGetProgramResourceLocationIndex (glw::GLuint param0, glw::GLenum param1, const glw::GLchar* param2)
3884{
3885	if (m_enableLog)
3886		m_log << TestLog::Message << "glGetProgramResourceLocationIndex(" << param0 << ", " << toHex(param1) << ", " << getStringStr(param2) << ");" << TestLog::EndMessage;
3887	glw::GLint returnValue = m_gl.getProgramResourceLocationIndex(param0, param1, param2);
3888	if (m_enableLog)
3889		m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
3890	return returnValue;
3891}
3892
3893void CallLogWrapper::glShaderStorageBlockBinding (glw::GLuint param0, glw::GLuint param1, glw::GLuint param2)
3894{
3895	if (m_enableLog)
3896		m_log << TestLog::Message << "glShaderStorageBlockBinding(" << param0 << ", " << param1 << ", " << param2 << ");" << TestLog::EndMessage;
3897	m_gl.shaderStorageBlockBinding(param0, param1, param2);
3898}
3899
3900void CallLogWrapper::glTexBufferRange (glw::GLenum param0, glw::GLenum param1, glw::GLuint param2, glw::GLintptr param3, glw::GLsizeiptr param4)
3901{
3902	if (m_enableLog)
3903		m_log << TestLog::Message << "glTexBufferRange(" << getBufferTargetStr(param0) << ", " << getPixelFormatStr(param1) << ", " << param2 << ", " << param3 << ", " << param4 << ");" << TestLog::EndMessage;
3904	m_gl.texBufferRange(param0, param1, param2, param3, param4);
3905}
3906
3907void CallLogWrapper::glTexStorage2DMultisample (glw::GLenum param0, glw::GLsizei param1, glw::GLenum param2, glw::GLsizei param3, glw::GLsizei param4, glw::GLboolean param5)
3908{
3909	if (m_enableLog)
3910		m_log << TestLog::Message << "glTexStorage2DMultisample(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getPixelFormatStr(param2) << ", " << param3 << ", " << param4 << ", " << getBooleanStr(param5) << ");" << TestLog::EndMessage;
3911	m_gl.texStorage2DMultisample(param0, param1, param2, param3, param4, param5);
3912}
3913
3914void CallLogWrapper::glTexStorage3DMultisample (glw::GLenum param0, glw::GLsizei param1, glw::GLenum param2, glw::GLsizei param3, glw::GLsizei param4, glw::GLsizei param5, glw::GLboolean param6)
3915{
3916	if (m_enableLog)
3917		m_log << TestLog::Message << "glTexStorage3DMultisample(" << getTextureTargetStr(param0) << ", " << param1 << ", " << getPixelFormatStr(param2) << ", " << param3 << ", " << param4 << ", " << param5 << ", " << getBooleanStr(param6) << ");" << TestLog::EndMessage;
3918	m_gl.texStorage3DMultisample(param0, param1, param2, param3, param4, param5, param6);
3919}
3920
3921void CallLogWrapper::glTextureView (glw::GLuint param0, glw::GLenum param1, glw::GLuint param2, glw::GLenum param3, glw::GLuint param4, glw::GLuint param5, glw::GLuint param6, glw::GLuint param7)
3922{
3923	if (m_enableLog)
3924		m_log << TestLog::Message << "glTextureView(" << param0 << ", " << toHex(param1) << ", " << param2 << ", " << toHex(param3) << ", " << param4 << ", " << param5 << ", " << param6 << ", " << param7 << ");" << TestLog::EndMessage;
3925	m_gl.textureView(param0, param1, param2, param3, param4, param5, param6, param7);
3926}
3927
3928void CallLogWrapper::glBindVertexBuffer (glw::GLuint param0, glw::GLuint param1, glw::GLintptr param2, glw::GLsizei param3)
3929{
3930	if (m_enableLog)
3931		m_log << TestLog::Message << "glBindVertexBuffer(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ");" << TestLog::EndMessage;
3932	m_gl.bindVertexBuffer(param0, param1, param2, param3);
3933}
3934
3935void CallLogWrapper::glVertexAttribFormat (glw::GLuint param0, glw::GLint param1, glw::GLenum param2, glw::GLboolean param3, glw::GLuint param4)
3936{
3937	if (m_enableLog)
3938		m_log << TestLog::Message << "glVertexAttribFormat(" << param0 << ", " << param1 << ", " << getTypeStr(param2) << ", " << getBooleanStr(param3) << ", " << param4 << ");" << TestLog::EndMessage;
3939	m_gl.vertexAttribFormat(param0, param1, param2, param3, param4);
3940}
3941
3942void CallLogWrapper::glVertexAttribIFormat (glw::GLuint param0, glw::GLint param1, glw::GLenum param2, glw::GLuint param3)
3943{
3944	if (m_enableLog)
3945		m_log << TestLog::Message << "glVertexAttribIFormat(" << param0 << ", " << param1 << ", " << getTypeStr(param2) << ", " << param3 << ");" << TestLog::EndMessage;
3946	m_gl.vertexAttribIFormat(param0, param1, param2, param3);
3947}
3948
3949void CallLogWrapper::glVertexAttribLFormat (glw::GLuint param0, glw::GLint param1, glw::GLenum param2, glw::GLuint param3)
3950{
3951	if (m_enableLog)
3952		m_log << TestLog::Message << "glVertexAttribLFormat(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << param3 << ");" << TestLog::EndMessage;
3953	m_gl.vertexAttribLFormat(param0, param1, param2, param3);
3954}
3955
3956void CallLogWrapper::glVertexAttribBinding (glw::GLuint param0, glw::GLuint param1)
3957{
3958	if (m_enableLog)
3959		m_log << TestLog::Message << "glVertexAttribBinding(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
3960	m_gl.vertexAttribBinding(param0, param1);
3961}
3962
3963void CallLogWrapper::glVertexBindingDivisor (glw::GLuint param0, glw::GLuint param1)
3964{
3965	if (m_enableLog)
3966		m_log << TestLog::Message << "glVertexBindingDivisor(" << param0 << ", " << param1 << ");" << TestLog::EndMessage;
3967	m_gl.vertexBindingDivisor(param0, param1);
3968}
3969
3970void CallLogWrapper::glBufferStorage (glw::GLenum param0, glw::GLsizeiptr param1, const void* param2, glw::GLbitfield param3)
3971{
3972	if (m_enableLog)
3973		m_log << TestLog::Message << "glBufferStorage(" << toHex(param0) << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ");" << TestLog::EndMessage;
3974	m_gl.bufferStorage(param0, param1, param2, param3);
3975}
3976
3977void CallLogWrapper::glClearTexImage (glw::GLuint param0, glw::GLint param1, glw::GLenum param2, glw::GLenum param3, const void* param4)
3978{
3979	if (m_enableLog)
3980		m_log << TestLog::Message << "glClearTexImage(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
3981	m_gl.clearTexImage(param0, param1, param2, param3, param4);
3982}
3983
3984void CallLogWrapper::glClearTexSubImage (glw::GLuint param0, glw::GLint param1, glw::GLint param2, glw::GLint param3, glw::GLint param4, glw::GLsizei param5, glw::GLsizei param6, glw::GLsizei param7, glw::GLenum param8, glw::GLenum param9, const void* param10)
3985{
3986	if (m_enableLog)
3987		m_log << TestLog::Message << "glClearTexSubImage(" << param0 << ", " << param1 << ", " << param2 << ", " << param3 << ", " << param4 << ", " << param5 << ", " << param6 << ", " << param7 << ", " << toHex(param8) << ", " << toHex(param9) << ", " << toHex(param10) << ");" << TestLog::EndMessage;
3988	m_gl.clearTexSubImage(param0, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
3989}
3990
3991void CallLogWrapper::glBindBuffersBase (glw::GLenum param0, glw::GLuint param1, glw::GLsizei param2, const glw::GLuint* param3)
3992{
3993	if (m_enableLog)
3994		m_log << TestLog::Message << "glBindBuffersBase(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ");" << TestLog::EndMessage;
3995	m_gl.bindBuffersBase(param0, param1, param2, param3);
3996}
3997
3998void CallLogWrapper::glBindBuffersRange (glw::GLenum param0, glw::GLuint param1, glw::GLsizei param2, const glw::GLuint* param3, const glw::GLintptr* param4, const glw::GLsizeiptr* param5)
3999{
4000	if (m_enableLog)
4001		m_log << TestLog::Message << "glBindBuffersRange(" << toHex(param0) << ", " << param1 << ", " << param2 << ", " << toHex(param3) << ", " << toHex(param4) << ", " << toHex(param5) << ");" << TestLog::EndMessage;
4002	m_gl.bindBuffersRange(param0, param1, param2, param3, param4, param5);
4003}
4004
4005void CallLogWrapper::glBindTextures (glw::GLuint param0, glw::GLsizei param1, const glw::GLuint* param2)
4006{
4007	if (m_enableLog)
4008		m_log << TestLog::Message << "glBindTextures(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
4009	m_gl.bindTextures(param0, param1, param2);
4010}
4011
4012void CallLogWrapper::glBindSamplers (glw::GLuint param0, glw::GLsizei param1, const glw::GLuint* param2)
4013{
4014	if (m_enableLog)
4015		m_log << TestLog::Message << "glBindSamplers(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
4016	m_gl.bindSamplers(param0, param1, param2);
4017}
4018
4019void CallLogWrapper::glBindImageTextures (glw::GLuint param0, glw::GLsizei param1, const glw::GLuint* param2)
4020{
4021	if (m_enableLog)
4022		m_log << TestLog::Message << "glBindImageTextures(" << param0 << ", " << param1 << ", " << toHex(param2) << ");" << TestLog::EndMessage;
4023	m_gl.bindImageTextures(param0, param1, param2);
4024}
4025
4026void CallLogWrapper::glBindVertexBuffers (glw::GLuint param0, glw::GLsizei param1, const glw::GLuint* param2, const glw::GLintptr* param3, const glw::GLsizei* param4)
4027{
4028	if (m_enableLog)
4029		m_log << TestLog::Message << "glBindVertexBuffers(" << param0 << ", " << param1 << ", " << toHex(param2) << ", " << toHex(param3) << ", " << toHex(param4) << ");" << TestLog::EndMessage;
4030	m_gl.bindVertexBuffers(param0, param1, param2, param3, param4);
4031}
4032