host/gl/OpenGLESDispatch/gles_common_dispatch_logging_wrappers.impl

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

void glActiveTexture_dispatchLoggingWrapper(GLenum texture) {
	DISPATCH_DEBUG_LOG("glActiveTexture(texture:0x%X)", texture);
	GLDispatch::glActiveTexture_underlying(texture);
}

void glBindBuffer_dispatchLoggingWrapper(GLenum target, GLuint buffer) {
	DISPATCH_DEBUG_LOG("glBindBuffer(target:0x%X, buffer:%d)", target, buffer);
	GLDispatch::glBindBuffer_underlying(target, buffer);
}

void glBindTexture_dispatchLoggingWrapper(GLenum target, GLuint texture) {
	DISPATCH_DEBUG_LOG("glBindTexture(target:0x%X, texture:%d)", target, texture);
	GLDispatch::glBindTexture_underlying(target, texture);
}

void glBlendFunc_dispatchLoggingWrapper(GLenum sfactor, GLenum dfactor) {
	DISPATCH_DEBUG_LOG("glBlendFunc(sfactor:0x%X, dfactor:0x%X)", sfactor, dfactor);
	GLDispatch::glBlendFunc_underlying(sfactor, dfactor);
}

void glBlendEquation_dispatchLoggingWrapper(GLenum mode) {
	DISPATCH_DEBUG_LOG("glBlendEquation(mode:0x%X)", mode);
	GLDispatch::glBlendEquation_underlying(mode);
}

void glBlendEquationSeparate_dispatchLoggingWrapper(GLenum modeRGB, GLenum modeAlpha) {
	DISPATCH_DEBUG_LOG("glBlendEquationSeparate(modeRGB:0x%X, modeAlpha:0x%X)", modeRGB, modeAlpha);
	GLDispatch::glBlendEquationSeparate_underlying(modeRGB, modeAlpha);
}

void glBlendFuncSeparate_dispatchLoggingWrapper(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
	DISPATCH_DEBUG_LOG("glBlendFuncSeparate(srcRGB:0x%X, dstRGB:0x%X, srcAlpha:0x%X, dstAlpha:0x%X)", srcRGB, dstRGB, srcAlpha, dstAlpha);
	GLDispatch::glBlendFuncSeparate_underlying(srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void glBufferData_dispatchLoggingWrapper(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) {
	DISPATCH_DEBUG_LOG("glBufferData(target:0x%X, size:%ld, data:%p, usage:0x%X)", target, size, data, usage);
	GLDispatch::glBufferData_underlying(target, size, data, usage);
}

void glBufferSubData_dispatchLoggingWrapper(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) {
	DISPATCH_DEBUG_LOG("glBufferSubData(target:0x%X, offset:%ld, size:%ld, data:%p)", target, offset, size, data);
	GLDispatch::glBufferSubData_underlying(target, offset, size, data);
}

void glClear_dispatchLoggingWrapper(GLbitfield mask) {
	DISPATCH_DEBUG_LOG("glClear(mask:%d)", mask);
	GLDispatch::glClear_underlying(mask);
}

void glClearColor_dispatchLoggingWrapper(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
	DISPATCH_DEBUG_LOG("glClearColor(red:%f, green:%f, blue:%f, alpha:%f)", red, green, blue, alpha);
	GLDispatch::glClearColor_underlying(red, green, blue, alpha);
}

void glClearDepth_dispatchLoggingWrapper(GLclampd depth) {
	DISPATCH_DEBUG_LOG("glClearDepth(depth:%f)", depth);
	GLDispatch::glClearDepth_underlying(depth);
}

void glClearDepthf_dispatchLoggingWrapper(GLclampf depth) {
	DISPATCH_DEBUG_LOG("glClearDepthf(depth:%f)", depth);
	GLDispatch::glClearDepthf_underlying(depth);
}

void glClearStencil_dispatchLoggingWrapper(GLint s) {
	DISPATCH_DEBUG_LOG("glClearStencil(s:%d)", s);
	GLDispatch::glClearStencil_underlying(s);
}

void glColorMask_dispatchLoggingWrapper(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
	DISPATCH_DEBUG_LOG("glColorMask(red:%d, green:%d, blue:%d, alpha:%d)", red, green, blue, alpha);
	GLDispatch::glColorMask_underlying(red, green, blue, alpha);
}

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

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

void glCopyTexImage2D_dispatchLoggingWrapper(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
	DISPATCH_DEBUG_LOG("glCopyTexImage2D(target:0x%X, level:%d, internalFormat:0x%X, x:%d, y:%d, width:%d, height:%d, border:%d)", target, level, internalFormat, x, y, width, height, border);
	GLDispatch::glCopyTexImage2D_underlying(target, level, internalFormat, x, y, width, height, border);
}

void glCopyTexSubImage2D_dispatchLoggingWrapper(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
	DISPATCH_DEBUG_LOG("glCopyTexSubImage2D(target:0x%X, level:%d, xoffset:%d, yoffset:%d, x:%d, y:%d, width:%d, height:%d)", target, level, xoffset, yoffset, x, y, width, height);
	GLDispatch::glCopyTexSubImage2D_underlying(target, level, xoffset, yoffset, x, y, width, height);
}

void glCullFace_dispatchLoggingWrapper(GLenum mode) {
	DISPATCH_DEBUG_LOG("glCullFace(mode:0x%X)", mode);
	GLDispatch::glCullFace_underlying(mode);
}

void glDeleteBuffers_dispatchLoggingWrapper(GLsizei n, const GLuint * buffers) {
	DISPATCH_DEBUG_LOG("glDeleteBuffers(n:%d, buffers:%p)", n, buffers);
	GLDispatch::glDeleteBuffers_underlying(n, buffers);
}

void glDeleteTextures_dispatchLoggingWrapper(GLsizei n, const GLuint * textures) {
	DISPATCH_DEBUG_LOG("glDeleteTextures(n:%d, textures:%p)", n, textures);
	GLDispatch::glDeleteTextures_underlying(n, textures);
}

void glDepthFunc_dispatchLoggingWrapper(GLenum func) {
	DISPATCH_DEBUG_LOG("glDepthFunc(func:0x%X)", func);
	GLDispatch::glDepthFunc_underlying(func);
}

void glDepthMask_dispatchLoggingWrapper(GLboolean flag) {
	DISPATCH_DEBUG_LOG("glDepthMask(flag:%d)", flag);
	GLDispatch::glDepthMask_underlying(flag);
}

void glDepthRange_dispatchLoggingWrapper(GLclampd zNear, GLclampd zFar) {
	DISPATCH_DEBUG_LOG("glDepthRange(zNear:%f, zFar:%f)", zNear, zFar);
	GLDispatch::glDepthRange_underlying(zNear, zFar);
}

void glDepthRangef_dispatchLoggingWrapper(GLclampf zNear, GLclampf zFar) {
	DISPATCH_DEBUG_LOG("glDepthRangef(zNear:%f, zFar:%f)", zNear, zFar);
	GLDispatch::glDepthRangef_underlying(zNear, zFar);
}

void glDisable_dispatchLoggingWrapper(GLenum cap) {
	DISPATCH_DEBUG_LOG("glDisable(cap:0x%X)", cap);
	GLDispatch::glDisable_underlying(cap);
}

void glDrawArrays_dispatchLoggingWrapper(GLenum mode, GLint first, GLsizei count) {
	DISPATCH_DEBUG_LOG("glDrawArrays(mode:0x%X, first:%d, count:%d)", mode, first, count);
	GLDispatch::glDrawArrays_underlying(mode, first, count);
}

void glDrawElements_dispatchLoggingWrapper(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices) {
	DISPATCH_DEBUG_LOG("glDrawElements(mode:0x%X, count:%d, type:0x%X, indices:%p)", mode, count, type, indices);
	GLDispatch::glDrawElements_underlying(mode, count, type, indices);
}

void glEnable_dispatchLoggingWrapper(GLenum cap) {
	DISPATCH_DEBUG_LOG("glEnable(cap:0x%X)", cap);
	GLDispatch::glEnable_underlying(cap);
}

void glFinish_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glFinish()");
	GLDispatch::glFinish_underlying();
}

void glFlush_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glFlush()");
	GLDispatch::glFlush_underlying();
}

void glFrontFace_dispatchLoggingWrapper(GLenum mode) {
	DISPATCH_DEBUG_LOG("glFrontFace(mode:0x%X)", mode);
	GLDispatch::glFrontFace_underlying(mode);
}

void glGenBuffers_dispatchLoggingWrapper(GLsizei n, GLuint * buffers) {
	DISPATCH_DEBUG_LOG("glGenBuffers(n:%d, buffers:%p)", n, buffers);
	GLDispatch::glGenBuffers_underlying(n, buffers);
}

void glGenTextures_dispatchLoggingWrapper(GLsizei n, GLuint * textures) {
	DISPATCH_DEBUG_LOG("glGenTextures(n:%d, textures:%p)", n, textures);
	GLDispatch::glGenTextures_underlying(n, textures);
}

void glGetBooleanv_dispatchLoggingWrapper(GLenum pname, GLboolean * params) {
	DISPATCH_DEBUG_LOG("glGetBooleanv(pname:0x%X, params:%p)", pname, params);
	GLDispatch::glGetBooleanv_underlying(pname, params);
}

void glGetBufferParameteriv_dispatchLoggingWrapper(GLenum buffer, GLenum parameter, GLint * value) {
	DISPATCH_DEBUG_LOG("glGetBufferParameteriv(buffer:0x%X, parameter:0x%X, value:%p)", buffer, parameter, value);
	GLDispatch::glGetBufferParameteriv_underlying(buffer, parameter, value);
}

GLenum glGetError_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glGetError()");
	return GLDispatch::glGetError_underlying();
}

void glGetFloatv_dispatchLoggingWrapper(GLenum pname, GLfloat * params) {
	DISPATCH_DEBUG_LOG("glGetFloatv(pname:0x%X, params:%p)", pname, params);
	GLDispatch::glGetFloatv_underlying(pname, params);
}

void glGetIntegerv_dispatchLoggingWrapper(GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetIntegerv(pname:0x%X, params:%p)", pname, params);
	GLDispatch::glGetIntegerv_underlying(pname, params);
}

GLconstubyteptr glGetString_dispatchLoggingWrapper(GLenum name) {
	DISPATCH_DEBUG_LOG("glGetString(name:0x%X)", name);
	return GLDispatch::glGetString_underlying(name);
}

void glTexParameterf_dispatchLoggingWrapper(GLenum target, GLenum pname, GLfloat param) {
	DISPATCH_DEBUG_LOG("glTexParameterf(target:0x%X, pname:0x%X, param:%f)", target, pname, param);
	GLDispatch::glTexParameterf_underlying(target, pname, param);
}

void glTexParameterfv_dispatchLoggingWrapper(GLenum target, GLenum pname, const GLfloat * params) {
	DISPATCH_DEBUG_LOG("glTexParameterfv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glTexParameterfv_underlying(target, pname, params);
}

void glGetTexImage_dispatchLoggingWrapper(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels) {
	DISPATCH_DEBUG_LOG("glGetTexImage(target:0x%X, level:%d, format:0x%X, type:0x%X, pixels:%p)", target, level, format, type, pixels);
	GLDispatch::glGetTexImage_underlying(target, level, format, type, pixels);
}

void glGetTexParameterfv_dispatchLoggingWrapper(GLenum target, GLenum pname, GLfloat * params) {
	DISPATCH_DEBUG_LOG("glGetTexParameterfv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glGetTexParameterfv_underlying(target, pname, params);
}

void glGetTexParameteriv_dispatchLoggingWrapper(GLenum target, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetTexParameteriv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glGetTexParameteriv_underlying(target, pname, params);
}

void glGetTexLevelParameteriv_dispatchLoggingWrapper(GLenum target, GLint level, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetTexLevelParameteriv(target:0x%X, level:%d, pname:0x%X, params:%p)", target, level, pname, params);
	GLDispatch::glGetTexLevelParameteriv_underlying(target, level, pname, params);
}

void glGetTexLevelParameterfv_dispatchLoggingWrapper(GLenum target, GLint level, GLenum pname, GLfloat * params) {
	DISPATCH_DEBUG_LOG("glGetTexLevelParameterfv(target:0x%X, level:%d, pname:0x%X, params:%p)", target, level, pname, params);
	GLDispatch::glGetTexLevelParameterfv_underlying(target, level, pname, params);
}

void glHint_dispatchLoggingWrapper(GLenum target, GLenum mode) {
	DISPATCH_DEBUG_LOG("glHint(target:0x%X, mode:0x%X)", target, mode);
	GLDispatch::glHint_underlying(target, mode);
}

GLboolean glIsBuffer_dispatchLoggingWrapper(GLuint buffer) {
	DISPATCH_DEBUG_LOG("glIsBuffer(buffer:%d)", buffer);
	return GLDispatch::glIsBuffer_underlying(buffer);
}

GLboolean glIsEnabled_dispatchLoggingWrapper(GLenum cap) {
	DISPATCH_DEBUG_LOG("glIsEnabled(cap:0x%X)", cap);
	return GLDispatch::glIsEnabled_underlying(cap);
}

GLboolean glIsTexture_dispatchLoggingWrapper(GLuint texture) {
	DISPATCH_DEBUG_LOG("glIsTexture(texture:%d)", texture);
	return GLDispatch::glIsTexture_underlying(texture);
}

void glLineWidth_dispatchLoggingWrapper(GLfloat width) {
	DISPATCH_DEBUG_LOG("glLineWidth(width:%f)", width);
	GLDispatch::glLineWidth_underlying(width);
}

void glPolygonOffset_dispatchLoggingWrapper(GLfloat factor, GLfloat units) {
	DISPATCH_DEBUG_LOG("glPolygonOffset(factor:%f, units:%f)", factor, units);
	GLDispatch::glPolygonOffset_underlying(factor, units);
}

void glPixelStorei_dispatchLoggingWrapper(GLenum pname, GLint param) {
	DISPATCH_DEBUG_LOG("glPixelStorei(pname:0x%X, param:%d)", pname, param);
	GLDispatch::glPixelStorei_underlying(pname, param);
}

void glReadPixels_dispatchLoggingWrapper(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels) {
	DISPATCH_DEBUG_LOG("glReadPixels(x:%d, y:%d, width:%d, height:%d, format:0x%X, type:0x%X, pixels:%p)", x, y, width, height, format, type, pixels);
	GLDispatch::glReadPixels_underlying(x, y, width, height, format, type, pixels);
}

void glRenderbufferStorageMultisample_dispatchLoggingWrapper(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {
	DISPATCH_DEBUG_LOG("glRenderbufferStorageMultisample(target:0x%X, samples:%d, internalformat:0x%X, width:%d, height:%d)", target, samples, internalformat, width, height);
	GLDispatch::glRenderbufferStorageMultisample_underlying(target, samples, internalformat, width, height);
}

void glSampleCoverage_dispatchLoggingWrapper(GLclampf value, GLboolean invert) {
	DISPATCH_DEBUG_LOG("glSampleCoverage(value:%f, invert:%d)", value, invert);
	GLDispatch::glSampleCoverage_underlying(value, invert);
}

void glScissor_dispatchLoggingWrapper(GLint x, GLint y, GLsizei width, GLsizei height) {
	DISPATCH_DEBUG_LOG("glScissor(x:%d, y:%d, width:%d, height:%d)", x, y, width, height);
	GLDispatch::glScissor_underlying(x, y, width, height);
}

void glStencilFunc_dispatchLoggingWrapper(GLenum func, GLint ref, GLuint mask) {
	DISPATCH_DEBUG_LOG("glStencilFunc(func:0x%X, ref:%d, mask:%d)", func, ref, mask);
	GLDispatch::glStencilFunc_underlying(func, ref, mask);
}

void glStencilMask_dispatchLoggingWrapper(GLuint mask) {
	DISPATCH_DEBUG_LOG("glStencilMask(mask:%d)", mask);
	GLDispatch::glStencilMask_underlying(mask);
}

void glStencilOp_dispatchLoggingWrapper(GLenum fail, GLenum zfail, GLenum zpass) {
	DISPATCH_DEBUG_LOG("glStencilOp(fail:0x%X, zfail:0x%X, zpass:0x%X)", fail, zfail, zpass);
	GLDispatch::glStencilOp_underlying(fail, zfail, zpass);
}

void glTexImage2D_dispatchLoggingWrapper(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {
	DISPATCH_DEBUG_LOG("glTexImage2D(target:0x%X, level:%d, internalformat:%d, width:%d, height:%d, border:%d, format:0x%X, type:0x%X, pixels:%p)", target, level, internalformat, width, height, border, format, type, pixels);
	GLDispatch::glTexImage2D_underlying(target, level, internalformat, width, height, border, format, type, pixels);
}

void glTexParameteri_dispatchLoggingWrapper(GLenum target, GLenum pname, GLint param) {
	DISPATCH_DEBUG_LOG("glTexParameteri(target:0x%X, pname:0x%X, param:%d)", target, pname, param);
	GLDispatch::glTexParameteri_underlying(target, pname, param);
}

void glTexParameteriv_dispatchLoggingWrapper(GLenum target, GLenum pname, const GLint * params) {
	DISPATCH_DEBUG_LOG("glTexParameteriv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glTexParameteriv_underlying(target, pname, params);
}

void glTexSubImage2D_dispatchLoggingWrapper(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) {
	DISPATCH_DEBUG_LOG("glTexSubImage2D(target:0x%X, level:%d, xoffset:%d, yoffset:%d, width:%d, height:%d, format:0x%X, type:0x%X, pixels:%p)", target, level, xoffset, yoffset, width, height, format, type, pixels);
	GLDispatch::glTexSubImage2D_underlying(target, level, xoffset, yoffset, width, height, format, type, pixels);
}

void glViewport_dispatchLoggingWrapper(GLint x, GLint y, GLsizei width, GLsizei height) {
	DISPATCH_DEBUG_LOG("glViewport(x:%d, y:%d, width:%d, height:%d)", x, y, width, height);
	GLDispatch::glViewport_underlying(x, y, width, height);
}

void glPushAttrib_dispatchLoggingWrapper(GLbitfield mask) {
	DISPATCH_DEBUG_LOG("glPushAttrib(mask:%d)", mask);
	GLDispatch::glPushAttrib_underlying(mask);
}

void glPushClientAttrib_dispatchLoggingWrapper(GLbitfield mask) {
	DISPATCH_DEBUG_LOG("glPushClientAttrib(mask:%d)", mask);
	GLDispatch::glPushClientAttrib_underlying(mask);
}

void glPopAttrib_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glPopAttrib()");
	GLDispatch::glPopAttrib_underlying();
}

void glPopClientAttrib_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glPopClientAttrib()");
	GLDispatch::glPopClientAttrib_underlying();
}