// Auto-generated with: android/scripts/gen-entries.py --mode=dispatch_logging_wrappers stream-servers/gl/OpenGLESDispatch/gles3_only.entries --output=stream-servers/gl/OpenGLESDispatch/gles3_only_dispatch_logging_wrappers.impl
// DO NOT EDIT THIS FILE

GLconstubyteptr glGetStringi_dispatchLoggingWrapper(GLenum name, GLint index) {
	DISPATCH_DEBUG_LOG("glGetStringi(name:0x%X, index:%d)", name, index);
	return GLDispatch::glGetStringi_underlying(name, index);
}

void glGenVertexArrays_dispatchLoggingWrapper(GLsizei n, GLuint* arrays) {
	DISPATCH_DEBUG_LOG("glGenVertexArrays(n:%d, arrays:%p)", n, arrays);
	GLDispatch::glGenVertexArrays_underlying(n, arrays);
}

void glBindVertexArray_dispatchLoggingWrapper(GLuint array) {
	DISPATCH_DEBUG_LOG("glBindVertexArray(array:%d)", array);
	GLDispatch::glBindVertexArray_underlying(array);
}

void glDeleteVertexArrays_dispatchLoggingWrapper(GLsizei n, const GLuint * arrays) {
	DISPATCH_DEBUG_LOG("glDeleteVertexArrays(n:%d, arrays:%p)", n, arrays);
	GLDispatch::glDeleteVertexArrays_underlying(n, arrays);
}

GLboolean glIsVertexArray_dispatchLoggingWrapper(GLuint array) {
	DISPATCH_DEBUG_LOG("glIsVertexArray(array:%d)", array);
	return GLDispatch::glIsVertexArray_underlying(array);
}

void * glMapBufferRange_dispatchLoggingWrapper(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
	DISPATCH_DEBUG_LOG("glMapBufferRange(target:0x%X, offset:%ld, length:%ld, access:%d)", target, offset, length, access);
	return GLDispatch::glMapBufferRange_underlying(target, offset, length, access);
}

GLboolean glUnmapBuffer_dispatchLoggingWrapper(GLenum target) {
	DISPATCH_DEBUG_LOG("glUnmapBuffer(target:0x%X)", target);
	return GLDispatch::glUnmapBuffer_underlying(target);
}

void glFlushMappedBufferRange_dispatchLoggingWrapper(GLenum target, GLintptr offset, GLsizeiptr length) {
	DISPATCH_DEBUG_LOG("glFlushMappedBufferRange(target:0x%X, offset:%ld, length:%ld)", target, offset, length);
	GLDispatch::glFlushMappedBufferRange_underlying(target, offset, length);
}

void glBindBufferRange_dispatchLoggingWrapper(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {
	DISPATCH_DEBUG_LOG("glBindBufferRange(target:0x%X, index:%d, buffer:%d, offset:%ld, size:%ld)", target, index, buffer, offset, size);
	GLDispatch::glBindBufferRange_underlying(target, index, buffer, offset, size);
}

void glBindBufferBase_dispatchLoggingWrapper(GLenum target, GLuint index, GLuint buffer) {
	DISPATCH_DEBUG_LOG("glBindBufferBase(target:0x%X, index:%d, buffer:%d)", target, index, buffer);
	GLDispatch::glBindBufferBase_underlying(target, index, buffer);
}

void glCopyBufferSubData_dispatchLoggingWrapper(GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size) {
	DISPATCH_DEBUG_LOG("glCopyBufferSubData(readtarget:0x%X, writetarget:0x%X, readoffset:%ld, writeoffset:%ld, size:%ld)", readtarget, writetarget, readoffset, writeoffset, size);
	GLDispatch::glCopyBufferSubData_underlying(readtarget, writetarget, readoffset, writeoffset, size);
}

void glClearBufferiv_dispatchLoggingWrapper(GLenum buffer, GLint drawBuffer, const GLint * value) {
	DISPATCH_DEBUG_LOG("glClearBufferiv(buffer:0x%X, drawBuffer:%d, value:%p)", buffer, drawBuffer, value);
	GLDispatch::glClearBufferiv_underlying(buffer, drawBuffer, value);
}

void glClearBufferuiv_dispatchLoggingWrapper(GLenum buffer, GLint drawBuffer, const GLuint * value) {
	DISPATCH_DEBUG_LOG("glClearBufferuiv(buffer:0x%X, drawBuffer:%d, value:%p)", buffer, drawBuffer, value);
	GLDispatch::glClearBufferuiv_underlying(buffer, drawBuffer, value);
}

void glClearBufferfv_dispatchLoggingWrapper(GLenum buffer, GLint drawBuffer, const GLfloat * value) {
	DISPATCH_DEBUG_LOG("glClearBufferfv(buffer:0x%X, drawBuffer:%d, value:%p)", buffer, drawBuffer, value);
	GLDispatch::glClearBufferfv_underlying(buffer, drawBuffer, value);
}

void glClearBufferfi_dispatchLoggingWrapper(GLenum buffer, GLint drawBuffer, GLfloat depth, GLint stencil) {
	DISPATCH_DEBUG_LOG("glClearBufferfi(buffer:0x%X, drawBuffer:%d, depth:%f, stencil:%d)", buffer, drawBuffer, depth, stencil);
	GLDispatch::glClearBufferfi_underlying(buffer, drawBuffer, depth, stencil);
}

void glGetBufferParameteri64v_dispatchLoggingWrapper(GLenum target, GLenum value, GLint64 * data) {
	DISPATCH_DEBUG_LOG("glGetBufferParameteri64v(target:0x%X, value:0x%X, data:%p)", target, value, data);
	GLDispatch::glGetBufferParameteri64v_underlying(target, value, data);
}

void glGetBufferPointerv_dispatchLoggingWrapper(GLenum target, GLenum pname, GLvoid ** params) {
	DISPATCH_DEBUG_LOG("glGetBufferPointerv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glGetBufferPointerv_underlying(target, pname, params);
}

void glUniformBlockBinding_dispatchLoggingWrapper(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) {
	DISPATCH_DEBUG_LOG("glUniformBlockBinding(program:%d, uniformBlockIndex:%d, uniformBlockBinding:%d)", program, uniformBlockIndex, uniformBlockBinding);
	GLDispatch::glUniformBlockBinding_underlying(program, uniformBlockIndex, uniformBlockBinding);
}

GLuint glGetUniformBlockIndex_dispatchLoggingWrapper(GLuint program, const GLchar * uniformBlockName) {
	DISPATCH_DEBUG_LOG("glGetUniformBlockIndex(program:%d, uniformBlockName:%p)", program, uniformBlockName);
	return GLDispatch::glGetUniformBlockIndex_underlying(program, uniformBlockName);
}

void glGetUniformIndices_dispatchLoggingWrapper(GLuint program, GLsizei uniformCount, const GLchar ** uniformNames, GLuint * uniformIndices) {
	DISPATCH_DEBUG_LOG("glGetUniformIndices(program:%d, uniformCount:%d, uniformNames:%p, uniformIndices:%p)", program, uniformCount, uniformNames, uniformIndices);
	GLDispatch::glGetUniformIndices_underlying(program, uniformCount, uniformNames, uniformIndices);
}

void glGetActiveUniformBlockiv_dispatchLoggingWrapper(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetActiveUniformBlockiv(program:%d, uniformBlockIndex:%d, pname:0x%X, params:%p)", program, uniformBlockIndex, pname, params);
	GLDispatch::glGetActiveUniformBlockiv_underlying(program, uniformBlockIndex, pname, params);
}

void glGetActiveUniformBlockName_dispatchLoggingWrapper(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName) {
	DISPATCH_DEBUG_LOG("glGetActiveUniformBlockName(program:%d, uniformBlockIndex:%d, bufSize:%d, length:%p, uniformBlockName:%p)", program, uniformBlockIndex, bufSize, length, uniformBlockName);
	GLDispatch::glGetActiveUniformBlockName_underlying(program, uniformBlockIndex, bufSize, length, uniformBlockName);
}

void glUniform1ui_dispatchLoggingWrapper(GLint location, GLuint v0) {
	DISPATCH_DEBUG_LOG("glUniform1ui(location:%d, v0:%d)", location, v0);
	GLDispatch::glUniform1ui_underlying(location, v0);
}

void glUniform2ui_dispatchLoggingWrapper(GLint location, GLuint v0, GLuint v1) {
	DISPATCH_DEBUG_LOG("glUniform2ui(location:%d, v0:%d, v1:%d)", location, v0, v1);
	GLDispatch::glUniform2ui_underlying(location, v0, v1);
}

void glUniform3ui_dispatchLoggingWrapper(GLint location, GLuint v0, GLuint v1, GLuint v2) {
	DISPATCH_DEBUG_LOG("glUniform3ui(location:%d, v0:%d, v1:%d, v2:%d)", location, v0, v1, v2);
	GLDispatch::glUniform3ui_underlying(location, v0, v1, v2);
}

void glUniform4ui_dispatchLoggingWrapper(GLint location, GLint v0, GLuint v1, GLuint v2, GLuint v3) {
	DISPATCH_DEBUG_LOG("glUniform4ui(location:%d, v0:%d, v1:%d, v2:%d, v3:%d)", location, v0, v1, v2, v3);
	GLDispatch::glUniform4ui_underlying(location, v0, v1, v2, v3);
}

void glUniform1uiv_dispatchLoggingWrapper(GLint location, GLsizei count, const GLuint * value) {
	DISPATCH_DEBUG_LOG("glUniform1uiv(location:%d, count:%d, value:%p)", location, count, value);
	GLDispatch::glUniform1uiv_underlying(location, count, value);
}

void glUniform2uiv_dispatchLoggingWrapper(GLint location, GLsizei count, const GLuint * value) {
	DISPATCH_DEBUG_LOG("glUniform2uiv(location:%d, count:%d, value:%p)", location, count, value);
	GLDispatch::glUniform2uiv_underlying(location, count, value);
}

void glUniform3uiv_dispatchLoggingWrapper(GLint location, GLsizei count, const GLuint * value) {
	DISPATCH_DEBUG_LOG("glUniform3uiv(location:%d, count:%d, value:%p)", location, count, value);
	GLDispatch::glUniform3uiv_underlying(location, count, value);
}

void glUniform4uiv_dispatchLoggingWrapper(GLint location, GLsizei count, const GLuint * value) {
	DISPATCH_DEBUG_LOG("glUniform4uiv(location:%d, count:%d, value:%p)", location, count, value);
	GLDispatch::glUniform4uiv_underlying(location, count, value);
}

void glUniformMatrix2x3fv_dispatchLoggingWrapper(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
	DISPATCH_DEBUG_LOG("glUniformMatrix2x3fv(location:%d, count:%d, transpose:%d, value:%p)", location, count, transpose, value);
	GLDispatch::glUniformMatrix2x3fv_underlying(location, count, transpose, value);
}

void glUniformMatrix3x2fv_dispatchLoggingWrapper(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
	DISPATCH_DEBUG_LOG("glUniformMatrix3x2fv(location:%d, count:%d, transpose:%d, value:%p)", location, count, transpose, value);
	GLDispatch::glUniformMatrix3x2fv_underlying(location, count, transpose, value);
}

void glUniformMatrix2x4fv_dispatchLoggingWrapper(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
	DISPATCH_DEBUG_LOG("glUniformMatrix2x4fv(location:%d, count:%d, transpose:%d, value:%p)", location, count, transpose, value);
	GLDispatch::glUniformMatrix2x4fv_underlying(location, count, transpose, value);
}

void glUniformMatrix4x2fv_dispatchLoggingWrapper(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
	DISPATCH_DEBUG_LOG("glUniformMatrix4x2fv(location:%d, count:%d, transpose:%d, value:%p)", location, count, transpose, value);
	GLDispatch::glUniformMatrix4x2fv_underlying(location, count, transpose, value);
}

void glUniformMatrix3x4fv_dispatchLoggingWrapper(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
	DISPATCH_DEBUG_LOG("glUniformMatrix3x4fv(location:%d, count:%d, transpose:%d, value:%p)", location, count, transpose, value);
	GLDispatch::glUniformMatrix3x4fv_underlying(location, count, transpose, value);
}

void glUniformMatrix4x3fv_dispatchLoggingWrapper(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
	DISPATCH_DEBUG_LOG("glUniformMatrix4x3fv(location:%d, count:%d, transpose:%d, value:%p)", location, count, transpose, value);
	GLDispatch::glUniformMatrix4x3fv_underlying(location, count, transpose, value);
}

void glGetUniformuiv_dispatchLoggingWrapper(GLuint program, GLint location, GLuint * params) {
	DISPATCH_DEBUG_LOG("glGetUniformuiv(program:%d, location:%d, params:%p)", program, location, params);
	GLDispatch::glGetUniformuiv_underlying(program, location, params);
}

void glGetActiveUniformsiv_dispatchLoggingWrapper(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetActiveUniformsiv(program:%d, uniformCount:%d, uniformIndices:%p, pname:0x%X, params:%p)", program, uniformCount, uniformIndices, pname, params);
	GLDispatch::glGetActiveUniformsiv_underlying(program, uniformCount, uniformIndices, pname, params);
}

void glVertexAttribI4i_dispatchLoggingWrapper(GLuint index, GLint v0, GLint v1, GLint v2, GLint v3) {
	DISPATCH_DEBUG_LOG("glVertexAttribI4i(index:%d, v0:%d, v1:%d, v2:%d, v3:%d)", index, v0, v1, v2, v3);
	GLDispatch::glVertexAttribI4i_underlying(index, v0, v1, v2, v3);
}

void glVertexAttribI4ui_dispatchLoggingWrapper(GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
	DISPATCH_DEBUG_LOG("glVertexAttribI4ui(index:%d, v0:%d, v1:%d, v2:%d, v3:%d)", index, v0, v1, v2, v3);
	GLDispatch::glVertexAttribI4ui_underlying(index, v0, v1, v2, v3);
}

void glVertexAttribI4iv_dispatchLoggingWrapper(GLuint index, const GLint * v) {
	DISPATCH_DEBUG_LOG("glVertexAttribI4iv(index:%d, v:%p)", index, v);
	GLDispatch::glVertexAttribI4iv_underlying(index, v);
}

void glVertexAttribI4uiv_dispatchLoggingWrapper(GLuint index, const GLuint * v) {
	DISPATCH_DEBUG_LOG("glVertexAttribI4uiv(index:%d, v:%p)", index, v);
	GLDispatch::glVertexAttribI4uiv_underlying(index, v);
}

void glVertexAttribIPointer_dispatchLoggingWrapper(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {
	DISPATCH_DEBUG_LOG("glVertexAttribIPointer(index:%d, size:%d, type:0x%X, stride:%d, pointer:%p)", index, size, type, stride, pointer);
	GLDispatch::glVertexAttribIPointer_underlying(index, size, type, stride, pointer);
}

void glGetVertexAttribIiv_dispatchLoggingWrapper(GLuint index, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetVertexAttribIiv(index:%d, pname:0x%X, params:%p)", index, pname, params);
	GLDispatch::glGetVertexAttribIiv_underlying(index, pname, params);
}

void glGetVertexAttribIuiv_dispatchLoggingWrapper(GLuint index, GLenum pname, GLuint * params) {
	DISPATCH_DEBUG_LOG("glGetVertexAttribIuiv(index:%d, pname:0x%X, params:%p)", index, pname, params);
	GLDispatch::glGetVertexAttribIuiv_underlying(index, pname, params);
}

void glVertexAttribDivisor_dispatchLoggingWrapper(GLuint index, GLuint divisor) {
	DISPATCH_DEBUG_LOG("glVertexAttribDivisor(index:%d, divisor:%d)", index, divisor);
	GLDispatch::glVertexAttribDivisor_underlying(index, divisor);
}

void glDrawArraysInstanced_dispatchLoggingWrapper(GLenum mode, GLint first, GLsizei count, GLsizei primcount) {
	DISPATCH_DEBUG_LOG("glDrawArraysInstanced(mode:0x%X, first:%d, count:%d, primcount:%d)", mode, first, count, primcount);
	GLDispatch::glDrawArraysInstanced_underlying(mode, first, count, primcount);
}

void glDrawElementsInstanced_dispatchLoggingWrapper(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount) {
	DISPATCH_DEBUG_LOG("glDrawElementsInstanced(mode:0x%X, count:%d, type:0x%X, indices:%p, primcount:%d)", mode, count, type, indices, primcount);
	GLDispatch::glDrawElementsInstanced_underlying(mode, count, type, indices, primcount);
}

void glDrawRangeElements_dispatchLoggingWrapper(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices) {
	DISPATCH_DEBUG_LOG("glDrawRangeElements(mode:0x%X, start:%d, end:%d, count:%d, type:0x%X, indices:%p)", mode, start, end, count, type, indices);
	GLDispatch::glDrawRangeElements_underlying(mode, start, end, count, type, indices);
}

GLsync glFenceSync_dispatchLoggingWrapper(GLenum condition, GLbitfield flags) {
	DISPATCH_DEBUG_LOG("glFenceSync(condition:0x%X, flags:%d)", condition, flags);
	return GLDispatch::glFenceSync_underlying(condition, flags);
}

GLenum glClientWaitSync_dispatchLoggingWrapper(GLsync wait_on, GLbitfield flags, GLuint64 timeout) {
	DISPATCH_DEBUG_LOG("glClientWaitSync(wait_on:%p, flags:%d, timeout:%lu)", wait_on, flags, timeout);
	return GLDispatch::glClientWaitSync_underlying(wait_on, flags, timeout);
}

void glWaitSync_dispatchLoggingWrapper(GLsync wait_on, GLbitfield flags, GLuint64 timeout) {
	DISPATCH_DEBUG_LOG("glWaitSync(wait_on:%p, flags:%d, timeout:%lu)", wait_on, flags, timeout);
	GLDispatch::glWaitSync_underlying(wait_on, flags, timeout);
}

void glDeleteSync_dispatchLoggingWrapper(GLsync to_delete) {
	DISPATCH_DEBUG_LOG("glDeleteSync(to_delete:%p)", to_delete);
	GLDispatch::glDeleteSync_underlying(to_delete);
}

GLboolean glIsSync_dispatchLoggingWrapper(GLsync sync) {
	DISPATCH_DEBUG_LOG("glIsSync(sync:%p)", sync);
	return GLDispatch::glIsSync_underlying(sync);
}

void glGetSynciv_dispatchLoggingWrapper(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values) {
	DISPATCH_DEBUG_LOG("glGetSynciv(sync:%p, pname:0x%X, bufSize:%d, length:%p, values:%p)", sync, pname, bufSize, length, values);
	GLDispatch::glGetSynciv_underlying(sync, pname, bufSize, length, values);
}

void glDrawBuffers_dispatchLoggingWrapper(GLsizei n, const GLenum * bufs) {
	DISPATCH_DEBUG_LOG("glDrawBuffers(n:%d, bufs:%p)", n, bufs);
	GLDispatch::glDrawBuffers_underlying(n, bufs);
}

void glReadBuffer_dispatchLoggingWrapper(GLenum src) {
	DISPATCH_DEBUG_LOG("glReadBuffer(src:0x%X)", src);
	GLDispatch::glReadBuffer_underlying(src);
}

void glBlitFramebuffer_dispatchLoggingWrapper(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
	DISPATCH_DEBUG_LOG("glBlitFramebuffer(srcX0:%d, srcY0:%d, srcX1:%d, srcY1:%d, dstX0:%d, dstY0:%d, dstX1:%d, dstY1:%d, mask:%d, filter:0x%X)", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
	GLDispatch::glBlitFramebuffer_underlying(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}

void glInvalidateFramebuffer_dispatchLoggingWrapper(GLenum target, GLsizei numAttachments, const GLenum * attachments) {
	DISPATCH_DEBUG_LOG("glInvalidateFramebuffer(target:0x%X, numAttachments:%d, attachments:%p)", target, numAttachments, attachments);
	GLDispatch::glInvalidateFramebuffer_underlying(target, numAttachments, attachments);
}

void glInvalidateSubFramebuffer_dispatchLoggingWrapper(GLenum target, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height) {
	DISPATCH_DEBUG_LOG("glInvalidateSubFramebuffer(target:0x%X, numAttachments:%d, attachments:%p, x:%d, y:%d, width:%d, height:%d)", target, numAttachments, attachments, x, y, width, height);
	GLDispatch::glInvalidateSubFramebuffer_underlying(target, numAttachments, attachments, x, y, width, height);
}

void glFramebufferTextureLayer_dispatchLoggingWrapper(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {
	DISPATCH_DEBUG_LOG("glFramebufferTextureLayer(target:0x%X, attachment:0x%X, texture:%d, level:%d, layer:%d)", target, attachment, texture, level, layer);
	GLDispatch::glFramebufferTextureLayer_underlying(target, attachment, texture, level, layer);
}

void glGetInternalformativ_dispatchLoggingWrapper(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetInternalformativ(target:0x%X, internalformat:0x%X, pname:0x%X, bufSize:%d, params:%p)", target, internalformat, pname, bufSize, params);
	GLDispatch::glGetInternalformativ_underlying(target, internalformat, pname, bufSize, params);
}

void glTexStorage2D_dispatchLoggingWrapper(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) {
	DISPATCH_DEBUG_LOG("glTexStorage2D(target:0x%X, levels:%d, internalformat:0x%X, width:%d, height:%d)", target, levels, internalformat, width, height);
	GLDispatch::glTexStorage2D_underlying(target, levels, internalformat, width, height);
}

void glBeginTransformFeedback_dispatchLoggingWrapper(GLenum primitiveMode) {
	DISPATCH_DEBUG_LOG("glBeginTransformFeedback(primitiveMode:0x%X)", primitiveMode);
	GLDispatch::glBeginTransformFeedback_underlying(primitiveMode);
}

void glEndTransformFeedback_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glEndTransformFeedback()");
	GLDispatch::glEndTransformFeedback_underlying();
}

void glGenTransformFeedbacks_dispatchLoggingWrapper(GLsizei n, GLuint * ids) {
	DISPATCH_DEBUG_LOG("glGenTransformFeedbacks(n:%d, ids:%p)", n, ids);
	GLDispatch::glGenTransformFeedbacks_underlying(n, ids);
}

void glDeleteTransformFeedbacks_dispatchLoggingWrapper(GLsizei n, const GLuint * ids) {
	DISPATCH_DEBUG_LOG("glDeleteTransformFeedbacks(n:%d, ids:%p)", n, ids);
	GLDispatch::glDeleteTransformFeedbacks_underlying(n, ids);
}

void glBindTransformFeedback_dispatchLoggingWrapper(GLenum target, GLuint id) {
	DISPATCH_DEBUG_LOG("glBindTransformFeedback(target:0x%X, id:%d)", target, id);
	GLDispatch::glBindTransformFeedback_underlying(target, id);
}

void glPauseTransformFeedback_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glPauseTransformFeedback()");
	GLDispatch::glPauseTransformFeedback_underlying();
}

void glResumeTransformFeedback_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glResumeTransformFeedback()");
	GLDispatch::glResumeTransformFeedback_underlying();
}

GLboolean glIsTransformFeedback_dispatchLoggingWrapper(GLuint id) {
	DISPATCH_DEBUG_LOG("glIsTransformFeedback(id:%d)", id);
	return GLDispatch::glIsTransformFeedback_underlying(id);
}

void glTransformFeedbackVaryings_dispatchLoggingWrapper(GLuint program, GLsizei count, const char ** varyings, GLenum bufferMode) {
	DISPATCH_DEBUG_LOG("glTransformFeedbackVaryings(program:%d, count:%d, varyings:%p, bufferMode:0x%X)", program, count, varyings, bufferMode);
	GLDispatch::glTransformFeedbackVaryings_underlying(program, count, varyings, bufferMode);
}

void glGetTransformFeedbackVarying_dispatchLoggingWrapper(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, char * name) {
	DISPATCH_DEBUG_LOG("glGetTransformFeedbackVarying(program:%d, index:%d, bufSize:%d, length:%p, size:%p, type:%p, name:%p)", program, index, bufSize, length, size, type, name);
	GLDispatch::glGetTransformFeedbackVarying_underlying(program, index, bufSize, length, size, type, name);
}

void glGenSamplers_dispatchLoggingWrapper(GLsizei n, GLuint * samplers) {
	DISPATCH_DEBUG_LOG("glGenSamplers(n:%d, samplers:%p)", n, samplers);
	GLDispatch::glGenSamplers_underlying(n, samplers);
}

void glDeleteSamplers_dispatchLoggingWrapper(GLsizei n, const GLuint * samplers) {
	DISPATCH_DEBUG_LOG("glDeleteSamplers(n:%d, samplers:%p)", n, samplers);
	GLDispatch::glDeleteSamplers_underlying(n, samplers);
}

void glBindSampler_dispatchLoggingWrapper(GLuint unit, GLuint sampler) {
	DISPATCH_DEBUG_LOG("glBindSampler(unit:%d, sampler:%d)", unit, sampler);
	GLDispatch::glBindSampler_underlying(unit, sampler);
}

void glSamplerParameterf_dispatchLoggingWrapper(GLuint sampler, GLenum pname, GLfloat param) {
	DISPATCH_DEBUG_LOG("glSamplerParameterf(sampler:%d, pname:0x%X, param:%f)", sampler, pname, param);
	GLDispatch::glSamplerParameterf_underlying(sampler, pname, param);
}

void glSamplerParameteri_dispatchLoggingWrapper(GLuint sampler, GLenum pname, GLint param) {
	DISPATCH_DEBUG_LOG("glSamplerParameteri(sampler:%d, pname:0x%X, param:%d)", sampler, pname, param);
	GLDispatch::glSamplerParameteri_underlying(sampler, pname, param);
}

void glSamplerParameterfv_dispatchLoggingWrapper(GLuint sampler, GLenum pname, const GLfloat * params) {
	DISPATCH_DEBUG_LOG("glSamplerParameterfv(sampler:%d, pname:0x%X, params:%p)", sampler, pname, params);
	GLDispatch::glSamplerParameterfv_underlying(sampler, pname, params);
}

void glSamplerParameteriv_dispatchLoggingWrapper(GLuint sampler, GLenum pname, const GLint * params) {
	DISPATCH_DEBUG_LOG("glSamplerParameteriv(sampler:%d, pname:0x%X, params:%p)", sampler, pname, params);
	GLDispatch::glSamplerParameteriv_underlying(sampler, pname, params);
}

void glGetSamplerParameterfv_dispatchLoggingWrapper(GLuint sampler, GLenum pname, GLfloat * params) {
	DISPATCH_DEBUG_LOG("glGetSamplerParameterfv(sampler:%d, pname:0x%X, params:%p)", sampler, pname, params);
	GLDispatch::glGetSamplerParameterfv_underlying(sampler, pname, params);
}

void glGetSamplerParameteriv_dispatchLoggingWrapper(GLuint sampler, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetSamplerParameteriv(sampler:%d, pname:0x%X, params:%p)", sampler, pname, params);
	GLDispatch::glGetSamplerParameteriv_underlying(sampler, pname, params);
}

GLboolean glIsSampler_dispatchLoggingWrapper(GLuint sampler) {
	DISPATCH_DEBUG_LOG("glIsSampler(sampler:%d)", sampler);
	return GLDispatch::glIsSampler_underlying(sampler);
}

void glGenQueries_dispatchLoggingWrapper(GLsizei n, GLuint * queries) {
	DISPATCH_DEBUG_LOG("glGenQueries(n:%d, queries:%p)", n, queries);
	GLDispatch::glGenQueries_underlying(n, queries);
}

void glDeleteQueries_dispatchLoggingWrapper(GLsizei n, const GLuint * queries) {
	DISPATCH_DEBUG_LOG("glDeleteQueries(n:%d, queries:%p)", n, queries);
	GLDispatch::glDeleteQueries_underlying(n, queries);
}

void glBeginQuery_dispatchLoggingWrapper(GLenum target, GLuint query) {
	DISPATCH_DEBUG_LOG("glBeginQuery(target:0x%X, query:%d)", target, query);
	GLDispatch::glBeginQuery_underlying(target, query);
}

void glEndQuery_dispatchLoggingWrapper(GLenum target) {
	DISPATCH_DEBUG_LOG("glEndQuery(target:0x%X)", target);
	GLDispatch::glEndQuery_underlying(target);
}

void glGetQueryiv_dispatchLoggingWrapper(GLenum target, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetQueryiv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glGetQueryiv_underlying(target, pname, params);
}

void glGetQueryObjectuiv_dispatchLoggingWrapper(GLuint query, GLenum pname, GLuint * params) {
	DISPATCH_DEBUG_LOG("glGetQueryObjectuiv(query:%d, pname:0x%X, params:%p)", query, pname, params);
	GLDispatch::glGetQueryObjectuiv_underlying(query, pname, params);
}

GLboolean glIsQuery_dispatchLoggingWrapper(GLuint query) {
	DISPATCH_DEBUG_LOG("glIsQuery(query:%d)", query);
	return GLDispatch::glIsQuery_underlying(query);
}

void glProgramParameteri_dispatchLoggingWrapper(GLuint program, GLenum pname, GLint value) {
	DISPATCH_DEBUG_LOG("glProgramParameteri(program:%d, pname:0x%X, value:%d)", program, pname, value);
	GLDispatch::glProgramParameteri_underlying(program, pname, value);
}

void glProgramBinary_dispatchLoggingWrapper(GLuint program, GLenum binaryFormat, const void * binary, GLsizei length) {
	DISPATCH_DEBUG_LOG("glProgramBinary(program:%d, binaryFormat:0x%X, binary:%p, length:%d)", program, binaryFormat, binary, length);
	GLDispatch::glProgramBinary_underlying(program, binaryFormat, binary, length);
}

void glGetProgramBinary_dispatchLoggingWrapper(GLuint program, GLsizei bufsize, GLsizei * length, GLenum * binaryFormat, void * binary) {
	DISPATCH_DEBUG_LOG("glGetProgramBinary(program:%d, bufsize:%d, length:%p, binaryFormat:%p, binary:%p)", program, bufsize, length, binaryFormat, binary);
	GLDispatch::glGetProgramBinary_underlying(program, bufsize, length, binaryFormat, binary);
}

GLint glGetFragDataLocation_dispatchLoggingWrapper(GLuint program, const char * name) {
	DISPATCH_DEBUG_LOG("glGetFragDataLocation(program:%d, name:%p)", program, name);
	return GLDispatch::glGetFragDataLocation_underlying(program, name);
}

void glGetInteger64v_dispatchLoggingWrapper(GLenum pname, GLint64 * data) {
	DISPATCH_DEBUG_LOG("glGetInteger64v(pname:0x%X, data:%p)", pname, data);
	GLDispatch::glGetInteger64v_underlying(pname, data);
}

void glGetIntegeri_v_dispatchLoggingWrapper(GLenum target, GLuint index, GLint * data) {
	DISPATCH_DEBUG_LOG("glGetIntegeri_v(target:0x%X, index:%d, data:%p)", target, index, data);
	GLDispatch::glGetIntegeri_v_underlying(target, index, data);
}

void glGetInteger64i_v_dispatchLoggingWrapper(GLenum target, GLuint index, GLint64 * data) {
	DISPATCH_DEBUG_LOG("glGetInteger64i_v(target:0x%X, index:%d, data:%p)", target, index, data);
	GLDispatch::glGetInteger64i_v_underlying(target, index, data);
}

void glTexImage3D_dispatchLoggingWrapper(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * data) {
	DISPATCH_DEBUG_LOG("glTexImage3D(target:0x%X, level:%d, internalFormat:%d, width:%d, height:%d, depth:%d, border:%d, format:0x%X, type:0x%X, data:%p)", target, level, internalFormat, width, height, depth, border, format, type, data);
	GLDispatch::glTexImage3D_underlying(target, level, internalFormat, width, height, depth, border, format, type, data);
}

void glTexStorage3D_dispatchLoggingWrapper(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) {
	DISPATCH_DEBUG_LOG("glTexStorage3D(target:0x%X, levels:%d, internalformat:0x%X, width:%d, height:%d, depth:%d)", target, levels, internalformat, width, height, depth);
	GLDispatch::glTexStorage3D_underlying(target, levels, internalformat, width, height, depth);
}

void glTexSubImage3D_dispatchLoggingWrapper(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * data) {
	DISPATCH_DEBUG_LOG("glTexSubImage3D(target:0x%X, level:%d, xoffset:%d, yoffset:%d, zoffset:%d, width:%d, height:%d, depth:%d, format:0x%X, type:0x%X, data:%p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
	GLDispatch::glTexSubImage3D_underlying(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
}

void glCompressedTexImage3D_dispatchLoggingWrapper(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data) {
	DISPATCH_DEBUG_LOG("glCompressedTexImage3D(target:0x%X, level:%d, internalformat:0x%X, width:%d, height:%d, depth:%d, border:%d, imageSize:%d, data:%p)", target, level, internalformat, width, height, depth, border, imageSize, data);
	GLDispatch::glCompressedTexImage3D_underlying(target, level, internalformat, width, height, depth, border, imageSize, data);
}

void glCompressedTexSubImage3D_dispatchLoggingWrapper(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data) {
	DISPATCH_DEBUG_LOG("glCompressedTexSubImage3D(target:0x%X, level:%d, xoffset:%d, yoffset:%d, zoffset:%d, width:%d, height:%d, depth:%d, format:0x%X, imageSize:%d, data:%p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
	GLDispatch::glCompressedTexSubImage3D_underlying(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}

void glCopyTexSubImage3D_dispatchLoggingWrapper(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
	DISPATCH_DEBUG_LOG("glCopyTexSubImage3D(target:0x%X, level:%d, xoffset:%d, yoffset:%d, zoffset:%d, x:%d, y:%d, width:%d, height:%d)", target, level, xoffset, yoffset, zoffset, x, y, width, height);
	GLDispatch::glCopyTexSubImage3D_underlying(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}