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

void glBlendColor_dispatchLoggingWrapper(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
	DISPATCH_DEBUG_LOG("glBlendColor(red:%f, green:%f, blue:%f, alpha:%f)", red, green, blue, alpha);
	GLDispatch::glBlendColor_underlying(red, green, blue, alpha);
}

void glStencilFuncSeparate_dispatchLoggingWrapper(GLenum face, GLenum func, GLint ref, GLuint mask) {
	DISPATCH_DEBUG_LOG("glStencilFuncSeparate(face:0x%X, func:0x%X, ref:%d, mask:%d)", face, func, ref, mask);
	GLDispatch::glStencilFuncSeparate_underlying(face, func, ref, mask);
}

void glStencilMaskSeparate_dispatchLoggingWrapper(GLenum face, GLuint mask) {
	DISPATCH_DEBUG_LOG("glStencilMaskSeparate(face:0x%X, mask:%d)", face, mask);
	GLDispatch::glStencilMaskSeparate_underlying(face, mask);
}

void glStencilOpSeparate_dispatchLoggingWrapper(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) {
	DISPATCH_DEBUG_LOG("glStencilOpSeparate(face:0x%X, fail:0x%X, zfail:0x%X, zpass:0x%X)", face, fail, zfail, zpass);
	GLDispatch::glStencilOpSeparate_underlying(face, fail, zfail, zpass);
}

GLboolean glIsProgram_dispatchLoggingWrapper(GLuint program) {
	DISPATCH_DEBUG_LOG("glIsProgram(program:%d)", program);
	return GLDispatch::glIsProgram_underlying(program);
}

GLboolean glIsShader_dispatchLoggingWrapper(GLuint shader) {
	DISPATCH_DEBUG_LOG("glIsShader(shader:%d)", shader);
	return GLDispatch::glIsShader_underlying(shader);
}

void glVertexAttrib1f_dispatchLoggingWrapper(GLuint indx, GLfloat x) {
	DISPATCH_DEBUG_LOG("glVertexAttrib1f(indx:%d, x:%f)", indx, x);
	GLDispatch::glVertexAttrib1f_underlying(indx, x);
}

void glVertexAttrib1fv_dispatchLoggingWrapper(GLuint indx, const GLfloat* values) {
	DISPATCH_DEBUG_LOG("glVertexAttrib1fv(indx:%d, values:%p)", indx, values);
	GLDispatch::glVertexAttrib1fv_underlying(indx, values);
}

void glVertexAttrib2f_dispatchLoggingWrapper(GLuint indx, GLfloat x, GLfloat y) {
	DISPATCH_DEBUG_LOG("glVertexAttrib2f(indx:%d, x:%f, y:%f)", indx, x, y);
	GLDispatch::glVertexAttrib2f_underlying(indx, x, y);
}

void glVertexAttrib2fv_dispatchLoggingWrapper(GLuint indx, const GLfloat* values) {
	DISPATCH_DEBUG_LOG("glVertexAttrib2fv(indx:%d, values:%p)", indx, values);
	GLDispatch::glVertexAttrib2fv_underlying(indx, values);
}

void glVertexAttrib3f_dispatchLoggingWrapper(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
	DISPATCH_DEBUG_LOG("glVertexAttrib3f(indx:%d, x:%f, y:%f, z:%f)", indx, x, y, z);
	GLDispatch::glVertexAttrib3f_underlying(indx, x, y, z);
}

void glVertexAttrib3fv_dispatchLoggingWrapper(GLuint indx, const GLfloat* values) {
	DISPATCH_DEBUG_LOG("glVertexAttrib3fv(indx:%d, values:%p)", indx, values);
	GLDispatch::glVertexAttrib3fv_underlying(indx, values);
}

void glVertexAttrib4f_dispatchLoggingWrapper(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
	DISPATCH_DEBUG_LOG("glVertexAttrib4f(indx:%d, x:%f, y:%f, z:%f, w:%f)", indx, x, y, z, w);
	GLDispatch::glVertexAttrib4f_underlying(indx, x, y, z, w);
}

void glVertexAttrib4fv_dispatchLoggingWrapper(GLuint indx, const GLfloat* values) {
	DISPATCH_DEBUG_LOG("glVertexAttrib4fv(indx:%d, values:%p)", indx, values);
	GLDispatch::glVertexAttrib4fv_underlying(indx, values);
}

void glVertexAttribPointer_dispatchLoggingWrapper(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr) {
	DISPATCH_DEBUG_LOG("glVertexAttribPointer(indx:%d, size:%d, type:0x%X, normalized:%d, stride:%d, ptr:%p)", indx, size, type, normalized, stride, ptr);
	GLDispatch::glVertexAttribPointer_underlying(indx, size, type, normalized, stride, ptr);
}

void glDisableVertexAttribArray_dispatchLoggingWrapper(GLuint index) {
	DISPATCH_DEBUG_LOG("glDisableVertexAttribArray(index:%d)", index);
	GLDispatch::glDisableVertexAttribArray_underlying(index);
}

void glEnableVertexAttribArray_dispatchLoggingWrapper(GLuint index) {
	DISPATCH_DEBUG_LOG("glEnableVertexAttribArray(index:%d)", index);
	GLDispatch::glEnableVertexAttribArray_underlying(index);
}

void glGetVertexAttribfv_dispatchLoggingWrapper(GLuint index, GLenum pname, GLfloat* params) {
	DISPATCH_DEBUG_LOG("glGetVertexAttribfv(index:%d, pname:0x%X, params:%p)", index, pname, params);
	GLDispatch::glGetVertexAttribfv_underlying(index, pname, params);
}

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

void glGetVertexAttribPointerv_dispatchLoggingWrapper(GLuint index, GLenum pname, GLvoid** pointer) {
	DISPATCH_DEBUG_LOG("glGetVertexAttribPointerv(index:%d, pname:0x%X, pointer:%p)", index, pname, pointer);
	GLDispatch::glGetVertexAttribPointerv_underlying(index, pname, pointer);
}

void glUniform1f_dispatchLoggingWrapper(GLint location, GLfloat x) {
	DISPATCH_DEBUG_LOG("glUniform1f(location:%d, x:%f)", location, x);
	GLDispatch::glUniform1f_underlying(location, x);
}

void glUniform1fv_dispatchLoggingWrapper(GLint location, GLsizei count, const GLfloat* v) {
	DISPATCH_DEBUG_LOG("glUniform1fv(location:%d, count:%d, v:%p)", location, count, v);
	GLDispatch::glUniform1fv_underlying(location, count, v);
}

void glUniform1i_dispatchLoggingWrapper(GLint location, GLint x) {
	DISPATCH_DEBUG_LOG("glUniform1i(location:%d, x:%d)", location, x);
	GLDispatch::glUniform1i_underlying(location, x);
}

void glUniform1iv_dispatchLoggingWrapper(GLint location, GLsizei count, const GLint* v) {
	DISPATCH_DEBUG_LOG("glUniform1iv(location:%d, count:%d, v:%p)", location, count, v);
	GLDispatch::glUniform1iv_underlying(location, count, v);
}

void glUniform2f_dispatchLoggingWrapper(GLint location, GLfloat x, GLfloat y) {
	DISPATCH_DEBUG_LOG("glUniform2f(location:%d, x:%f, y:%f)", location, x, y);
	GLDispatch::glUniform2f_underlying(location, x, y);
}

void glUniform2fv_dispatchLoggingWrapper(GLint location, GLsizei count, const GLfloat* v) {
	DISPATCH_DEBUG_LOG("glUniform2fv(location:%d, count:%d, v:%p)", location, count, v);
	GLDispatch::glUniform2fv_underlying(location, count, v);
}

void glUniform2i_dispatchLoggingWrapper(GLint location, GLint x, GLint y) {
	DISPATCH_DEBUG_LOG("glUniform2i(location:%d, x:%d, y:%d)", location, x, y);
	GLDispatch::glUniform2i_underlying(location, x, y);
}

void glUniform2iv_dispatchLoggingWrapper(GLint location, GLsizei count, const GLint* v) {
	DISPATCH_DEBUG_LOG("glUniform2iv(location:%d, count:%d, v:%p)", location, count, v);
	GLDispatch::glUniform2iv_underlying(location, count, v);
}

void glUniform3f_dispatchLoggingWrapper(GLint location, GLfloat x, GLfloat y, GLfloat z) {
	DISPATCH_DEBUG_LOG("glUniform3f(location:%d, x:%f, y:%f, z:%f)", location, x, y, z);
	GLDispatch::glUniform3f_underlying(location, x, y, z);
}

void glUniform3fv_dispatchLoggingWrapper(GLint location, GLsizei count, const GLfloat* v) {
	DISPATCH_DEBUG_LOG("glUniform3fv(location:%d, count:%d, v:%p)", location, count, v);
	GLDispatch::glUniform3fv_underlying(location, count, v);
}

void glUniform3i_dispatchLoggingWrapper(GLint location, GLint x, GLint y, GLint z) {
	DISPATCH_DEBUG_LOG("glUniform3i(location:%d, x:%d, y:%d, z:%d)", location, x, y, z);
	GLDispatch::glUniform3i_underlying(location, x, y, z);
}

void glUniform3iv_dispatchLoggingWrapper(GLint location, GLsizei count, const GLint* v) {
	DISPATCH_DEBUG_LOG("glUniform3iv(location:%d, count:%d, v:%p)", location, count, v);
	GLDispatch::glUniform3iv_underlying(location, count, v);
}

void glUniform4f_dispatchLoggingWrapper(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
	DISPATCH_DEBUG_LOG("glUniform4f(location:%d, x:%f, y:%f, z:%f, w:%f)", location, x, y, z, w);
	GLDispatch::glUniform4f_underlying(location, x, y, z, w);
}

void glUniform4fv_dispatchLoggingWrapper(GLint location, GLsizei count, const GLfloat* v) {
	DISPATCH_DEBUG_LOG("glUniform4fv(location:%d, count:%d, v:%p)", location, count, v);
	GLDispatch::glUniform4fv_underlying(location, count, v);
}

void glUniform4i_dispatchLoggingWrapper(GLint location, GLint x, GLint y, GLint z, GLint w) {
	DISPATCH_DEBUG_LOG("glUniform4i(location:%d, x:%d, y:%d, z:%d, w:%d)", location, x, y, z, w);
	GLDispatch::glUniform4i_underlying(location, x, y, z, w);
}

void glUniform4iv_dispatchLoggingWrapper(GLint location, GLsizei count, const GLint* v) {
	DISPATCH_DEBUG_LOG("glUniform4iv(location:%d, count:%d, v:%p)", location, count, v);
	GLDispatch::glUniform4iv_underlying(location, count, v);
}

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

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

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

void glAttachShader_dispatchLoggingWrapper(GLuint program, GLuint shader) {
	DISPATCH_DEBUG_LOG("glAttachShader(program:%d, shader:%d)", program, shader);
	GLDispatch::glAttachShader_underlying(program, shader);
}

void glBindAttribLocation_dispatchLoggingWrapper(GLuint program, GLuint index, const GLchar* name) {
	DISPATCH_DEBUG_LOG("glBindAttribLocation(program:%d, index:%d, name:%p)", program, index, name);
	GLDispatch::glBindAttribLocation_underlying(program, index, name);
}

void glCompileShader_dispatchLoggingWrapper(GLuint shader) {
	DISPATCH_DEBUG_LOG("glCompileShader(shader:%d)", shader);
	GLDispatch::glCompileShader_underlying(shader);
}

GLuint glCreateProgram_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glCreateProgram()");
	return GLDispatch::glCreateProgram_underlying();
}

GLuint glCreateShader_dispatchLoggingWrapper(GLenum type) {
	DISPATCH_DEBUG_LOG("glCreateShader(type:0x%X)", type);
	return GLDispatch::glCreateShader_underlying(type);
}

void glDeleteProgram_dispatchLoggingWrapper(GLuint program) {
	DISPATCH_DEBUG_LOG("glDeleteProgram(program:%d)", program);
	GLDispatch::glDeleteProgram_underlying(program);
}

void glDeleteShader_dispatchLoggingWrapper(GLuint shader) {
	DISPATCH_DEBUG_LOG("glDeleteShader(shader:%d)", shader);
	GLDispatch::glDeleteShader_underlying(shader);
}

void glDetachShader_dispatchLoggingWrapper(GLuint program, GLuint shader) {
	DISPATCH_DEBUG_LOG("glDetachShader(program:%d, shader:%d)", program, shader);
	GLDispatch::glDetachShader_underlying(program, shader);
}

void glLinkProgram_dispatchLoggingWrapper(GLuint program) {
	DISPATCH_DEBUG_LOG("glLinkProgram(program:%d)", program);
	GLDispatch::glLinkProgram_underlying(program);
}

void glUseProgram_dispatchLoggingWrapper(GLuint program) {
	DISPATCH_DEBUG_LOG("glUseProgram(program:%d)", program);
	GLDispatch::glUseProgram_underlying(program);
}

void glValidateProgram_dispatchLoggingWrapper(GLuint program) {
	DISPATCH_DEBUG_LOG("glValidateProgram(program:%d)", program);
	GLDispatch::glValidateProgram_underlying(program);
}

void glGetActiveAttrib_dispatchLoggingWrapper(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) {
	DISPATCH_DEBUG_LOG("glGetActiveAttrib(program:%d, index:%d, bufsize:%d, length:%p, size:%p, type:%p, name:%p)", program, index, bufsize, length, size, type, name);
	GLDispatch::glGetActiveAttrib_underlying(program, index, bufsize, length, size, type, name);
}

void glGetActiveUniform_dispatchLoggingWrapper(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) {
	DISPATCH_DEBUG_LOG("glGetActiveUniform(program:%d, index:%d, bufsize:%d, length:%p, size:%p, type:%p, name:%p)", program, index, bufsize, length, size, type, name);
	GLDispatch::glGetActiveUniform_underlying(program, index, bufsize, length, size, type, name);
}

void glGetAttachedShaders_dispatchLoggingWrapper(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) {
	DISPATCH_DEBUG_LOG("glGetAttachedShaders(program:%d, maxcount:%d, count:%p, shaders:%p)", program, maxcount, count, shaders);
	GLDispatch::glGetAttachedShaders_underlying(program, maxcount, count, shaders);
}

int glGetAttribLocation_dispatchLoggingWrapper(GLuint program, const GLchar* name) {
	DISPATCH_DEBUG_LOG("glGetAttribLocation(program:%d, name:%p)", program, name);
	return GLDispatch::glGetAttribLocation_underlying(program, name);
}

void glGetProgramiv_dispatchLoggingWrapper(GLuint program, GLenum pname, GLint* params) {
	DISPATCH_DEBUG_LOG("glGetProgramiv(program:%d, pname:0x%X, params:%p)", program, pname, params);
	GLDispatch::glGetProgramiv_underlying(program, pname, params);
}

void glGetProgramInfoLog_dispatchLoggingWrapper(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog) {
	DISPATCH_DEBUG_LOG("glGetProgramInfoLog(program:%d, bufsize:%d, length:%p, infolog:%p)", program, bufsize, length, infolog);
	GLDispatch::glGetProgramInfoLog_underlying(program, bufsize, length, infolog);
}

void glGetShaderiv_dispatchLoggingWrapper(GLuint shader, GLenum pname, GLint* params) {
	DISPATCH_DEBUG_LOG("glGetShaderiv(shader:%d, pname:0x%X, params:%p)", shader, pname, params);
	GLDispatch::glGetShaderiv_underlying(shader, pname, params);
}

void glGetShaderInfoLog_dispatchLoggingWrapper(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog) {
	DISPATCH_DEBUG_LOG("glGetShaderInfoLog(shader:%d, bufsize:%d, length:%p, infolog:%p)", shader, bufsize, length, infolog);
	GLDispatch::glGetShaderInfoLog_underlying(shader, bufsize, length, infolog);
}

void glGetShaderSource_dispatchLoggingWrapper(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source) {
	DISPATCH_DEBUG_LOG("glGetShaderSource(shader:%d, bufsize:%d, length:%p, source:%p)", shader, bufsize, length, source);
	GLDispatch::glGetShaderSource_underlying(shader, bufsize, length, source);
}

void glGetUniformfv_dispatchLoggingWrapper(GLuint program, GLint location, GLfloat* params) {
	DISPATCH_DEBUG_LOG("glGetUniformfv(program:%d, location:%d, params:%p)", program, location, params);
	GLDispatch::glGetUniformfv_underlying(program, location, params);
}

void glGetUniformiv_dispatchLoggingWrapper(GLuint program, GLint location, GLint* params) {
	DISPATCH_DEBUG_LOG("glGetUniformiv(program:%d, location:%d, params:%p)", program, location, params);
	GLDispatch::glGetUniformiv_underlying(program, location, params);
}

int glGetUniformLocation_dispatchLoggingWrapper(GLuint program, const GLchar* name) {
	DISPATCH_DEBUG_LOG("glGetUniformLocation(program:%d, name:%p)", program, name);
	return GLDispatch::glGetUniformLocation_underlying(program, name);
}

void glShaderSource_dispatchLoggingWrapper(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length) {
	DISPATCH_DEBUG_LOG("glShaderSource(shader:%d, count:%d, string:%p, length:%p)", shader, count, string, length);
	GLDispatch::glShaderSource_underlying(shader, count, string, length);
}

void glBindFramebuffer_dispatchLoggingWrapper(GLenum target, GLuint framebuffer) {
	DISPATCH_DEBUG_LOG("glBindFramebuffer(target:0x%X, framebuffer:%d)", target, framebuffer);
	GLDispatch::glBindFramebuffer_underlying(target, framebuffer);
}

void glGenFramebuffers_dispatchLoggingWrapper(GLsizei n, GLuint* framebuffers) {
	DISPATCH_DEBUG_LOG("glGenFramebuffers(n:%d, framebuffers:%p)", n, framebuffers);
	GLDispatch::glGenFramebuffers_underlying(n, framebuffers);
}

void glFramebufferTexture2D_dispatchLoggingWrapper(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
	DISPATCH_DEBUG_LOG("glFramebufferTexture2D(target:0x%X, attachment:0x%X, textarget:0x%X, texture:%d, level:%d)", target, attachment, textarget, texture, level);
	GLDispatch::glFramebufferTexture2D_underlying(target, attachment, textarget, texture, level);
}

GLenum glCheckFramebufferStatus_dispatchLoggingWrapper(GLenum target) {
	DISPATCH_DEBUG_LOG("glCheckFramebufferStatus(target:0x%X)", target);
	return GLDispatch::glCheckFramebufferStatus_underlying(target);
}

GLboolean glIsFramebuffer_dispatchLoggingWrapper(GLuint framebuffer) {
	DISPATCH_DEBUG_LOG("glIsFramebuffer(framebuffer:%d)", framebuffer);
	return GLDispatch::glIsFramebuffer_underlying(framebuffer);
}

void glDeleteFramebuffers_dispatchLoggingWrapper(GLsizei n, const GLuint* framebuffers) {
	DISPATCH_DEBUG_LOG("glDeleteFramebuffers(n:%d, framebuffers:%p)", n, framebuffers);
	GLDispatch::glDeleteFramebuffers_underlying(n, framebuffers);
}

GLboolean glIsRenderbuffer_dispatchLoggingWrapper(GLuint renderbuffer) {
	DISPATCH_DEBUG_LOG("glIsRenderbuffer(renderbuffer:%d)", renderbuffer);
	return GLDispatch::glIsRenderbuffer_underlying(renderbuffer);
}

void glBindRenderbuffer_dispatchLoggingWrapper(GLenum target, GLuint renderbuffer) {
	DISPATCH_DEBUG_LOG("glBindRenderbuffer(target:0x%X, renderbuffer:%d)", target, renderbuffer);
	GLDispatch::glBindRenderbuffer_underlying(target, renderbuffer);
}

void glDeleteRenderbuffers_dispatchLoggingWrapper(GLsizei n, const GLuint * renderbuffers) {
	DISPATCH_DEBUG_LOG("glDeleteRenderbuffers(n:%d, renderbuffers:%p)", n, renderbuffers);
	GLDispatch::glDeleteRenderbuffers_underlying(n, renderbuffers);
}

void glGenRenderbuffers_dispatchLoggingWrapper(GLsizei n, GLuint * renderbuffers) {
	DISPATCH_DEBUG_LOG("glGenRenderbuffers(n:%d, renderbuffers:%p)", n, renderbuffers);
	GLDispatch::glGenRenderbuffers_underlying(n, renderbuffers);
}

void glRenderbufferStorage_dispatchLoggingWrapper(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
	DISPATCH_DEBUG_LOG("glRenderbufferStorage(target:0x%X, internalformat:0x%X, width:%d, height:%d)", target, internalformat, width, height);
	GLDispatch::glRenderbufferStorage_underlying(target, internalformat, width, height);
}

void glGetRenderbufferParameteriv_dispatchLoggingWrapper(GLenum target, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetRenderbufferParameteriv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glGetRenderbufferParameteriv_underlying(target, pname, params);
}

void glFramebufferRenderbuffer_dispatchLoggingWrapper(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
	DISPATCH_DEBUG_LOG("glFramebufferRenderbuffer(target:0x%X, attachment:0x%X, renderbuffertarget:0x%X, renderbuffer:%d)", target, attachment, renderbuffertarget, renderbuffer);
	GLDispatch::glFramebufferRenderbuffer_underlying(target, attachment, renderbuffertarget, renderbuffer);
}

void glGetFramebufferAttachmentParameteriv_dispatchLoggingWrapper(GLenum target, GLenum attachment, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetFramebufferAttachmentParameteriv(target:0x%X, attachment:0x%X, pname:0x%X, params:%p)", target, attachment, pname, params);
	GLDispatch::glGetFramebufferAttachmentParameteriv_underlying(target, attachment, pname, params);
}

void glGenerateMipmap_dispatchLoggingWrapper(GLenum target) {
	DISPATCH_DEBUG_LOG("glGenerateMipmap(target:0x%X)", target);
	GLDispatch::glGenerateMipmap_underlying(target);
}