host/gl/OpenGLESDispatch/gles1_extensions_dispatch_logging_wrappers.impl

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

void glCurrentPaletteMatrixARB_dispatchLoggingWrapper(GLint index) {
	DISPATCH_DEBUG_LOG("glCurrentPaletteMatrixARB(index:%d)", index);
	GLDispatch::glCurrentPaletteMatrixARB_underlying(index);
}

void glMatrixIndexuivARB_dispatchLoggingWrapper(GLint size, GLuint * indices) {
	DISPATCH_DEBUG_LOG("glMatrixIndexuivARB(size:%d, indices:%p)", size, indices);
	GLDispatch::glMatrixIndexuivARB_underlying(size, indices);
}

void glMatrixIndexPointerARB_dispatchLoggingWrapper(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) {
	DISPATCH_DEBUG_LOG("glMatrixIndexPointerARB(size:%d, type:0x%X, stride:%d, pointer:%p)", size, type, stride, pointer);
	GLDispatch::glMatrixIndexPointerARB_underlying(size, type, stride, pointer);
}

void glWeightPointerARB_dispatchLoggingWrapper(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) {
	DISPATCH_DEBUG_LOG("glWeightPointerARB(size:%d, type:0x%X, stride:%d, pointer:%p)", size, type, stride, pointer);
	GLDispatch::glWeightPointerARB_underlying(size, type, stride, pointer);
}

void glTexGenf_dispatchLoggingWrapper(GLenum coord, GLenum pname, GLfloat param) {
	DISPATCH_DEBUG_LOG("glTexGenf(coord:0x%X, pname:0x%X, param:%f)", coord, pname, param);
	GLDispatch::glTexGenf_underlying(coord, pname, param);
}

void glTexGeni_dispatchLoggingWrapper(GLenum coord, GLenum pname, GLint param) {
	DISPATCH_DEBUG_LOG("glTexGeni(coord:0x%X, pname:0x%X, param:%d)", coord, pname, param);
	GLDispatch::glTexGeni_underlying(coord, pname, param);
}

void glTexGenfv_dispatchLoggingWrapper(GLenum coord, GLenum pname, const GLfloat * params) {
	DISPATCH_DEBUG_LOG("glTexGenfv(coord:0x%X, pname:0x%X, params:%p)", coord, pname, params);
	GLDispatch::glTexGenfv_underlying(coord, pname, params);
}

void glTexGeniv_dispatchLoggingWrapper(GLenum coord, GLenum pname, const GLint * params) {
	DISPATCH_DEBUG_LOG("glTexGeniv(coord:0x%X, pname:0x%X, params:%p)", coord, pname, params);
	GLDispatch::glTexGeniv_underlying(coord, pname, params);
}

void glGetTexGenfv_dispatchLoggingWrapper(GLenum coord, GLenum pname, GLfloat * params) {
	DISPATCH_DEBUG_LOG("glGetTexGenfv(coord:0x%X, pname:0x%X, params:%p)", coord, pname, params);
	GLDispatch::glGetTexGenfv_underlying(coord, pname, params);
}

void glGetTexGeniv_dispatchLoggingWrapper(GLenum coord, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetTexGeniv(coord:0x%X, pname:0x%X, params:%p)", coord, pname, params);
	GLDispatch::glGetTexGeniv_underlying(coord, pname, params);
}

void glColorPointerWithDataSize_dispatchLoggingWrapper(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer, GLsizei dataSize) {
	DISPATCH_DEBUG_LOG("glColorPointerWithDataSize(size:%d, type:0x%X, stride:%d, pointer:%p, dataSize:%d)", size, type, stride, pointer, dataSize);
	GLDispatch::glColorPointerWithDataSize_underlying(size, type, stride, pointer, dataSize);
}

void glNormalPointerWithDataSize_dispatchLoggingWrapper(GLenum type, GLsizei stride, const GLvoid * pointer, GLsizei dataSize) {
	DISPATCH_DEBUG_LOG("glNormalPointerWithDataSize(type:0x%X, stride:%d, pointer:%p, dataSize:%d)", type, stride, pointer, dataSize);
	GLDispatch::glNormalPointerWithDataSize_underlying(type, stride, pointer, dataSize);
}

void glTexCoordPointerWithDataSize_dispatchLoggingWrapper(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer, GLsizei dataSize) {
	DISPATCH_DEBUG_LOG("glTexCoordPointerWithDataSize(size:%d, type:0x%X, stride:%d, pointer:%p, dataSize:%d)", size, type, stride, pointer, dataSize);
	GLDispatch::glTexCoordPointerWithDataSize_underlying(size, type, stride, pointer, dataSize);
}

void glVertexPointerWithDataSize_dispatchLoggingWrapper(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer, GLsizei dataSize) {
	DISPATCH_DEBUG_LOG("glVertexPointerWithDataSize(size:%d, type:0x%X, stride:%d, pointer:%p, dataSize:%d)", size, type, stride, pointer, dataSize);
	GLDispatch::glVertexPointerWithDataSize_underlying(size, type, stride, pointer, dataSize);
}

void glPointSizePointerOES_dispatchLoggingWrapper(GLenum type, GLsizei stride, const GLvoid * pointer) {
	DISPATCH_DEBUG_LOG("glPointSizePointerOES(type:0x%X, stride:%d, pointer:%p)", type, stride, pointer);
	GLDispatch::glPointSizePointerOES_underlying(type, stride, pointer);
}

void glBlendEquationSeparateOES_dispatchLoggingWrapper(GLenum modeRGB, GLenum modeAlpha) {
	DISPATCH_DEBUG_LOG("glBlendEquationSeparateOES(modeRGB:0x%X, modeAlpha:0x%X)", modeRGB, modeAlpha);
	GLDispatch::glBlendEquationSeparateOES_underlying(modeRGB, modeAlpha);
}

void glBlendFuncSeparateOES_dispatchLoggingWrapper(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
	DISPATCH_DEBUG_LOG("glBlendFuncSeparateOES(srcRGB:0x%X, dstRGB:0x%X, srcAlpha:0x%X, dstAlpha:0x%X)", srcRGB, dstRGB, srcAlpha, dstAlpha);
	GLDispatch::glBlendFuncSeparateOES_underlying(srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void glBlendEquationOES_dispatchLoggingWrapper(GLenum mode) {
	DISPATCH_DEBUG_LOG("glBlendEquationOES(mode:0x%X)", mode);
	GLDispatch::glBlendEquationOES_underlying(mode);
}

void glDrawTexsOES_dispatchLoggingWrapper(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) {
	DISPATCH_DEBUG_LOG("glDrawTexsOES(x:%d, y:%d, z:%d, width:%d, height:%d)", x, y, z, width, height);
	GLDispatch::glDrawTexsOES_underlying(x, y, z, width, height);
}

void glDrawTexiOES_dispatchLoggingWrapper(GLint x, GLint y, GLint z, GLint width, GLint height) {
	DISPATCH_DEBUG_LOG("glDrawTexiOES(x:%d, y:%d, z:%d, width:%d, height:%d)", x, y, z, width, height);
	GLDispatch::glDrawTexiOES_underlying(x, y, z, width, height);
}

void glDrawTexxOES_dispatchLoggingWrapper(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) {
	DISPATCH_DEBUG_LOG("glDrawTexxOES(x:%d, y:%d, z:%d, width:%d, height:%d)", x, y, z, width, height);
	GLDispatch::glDrawTexxOES_underlying(x, y, z, width, height);
}

void glDrawTexsvOES_dispatchLoggingWrapper(const GLshort * coords) {
	DISPATCH_DEBUG_LOG("glDrawTexsvOES(coords:%p)", coords);
	GLDispatch::glDrawTexsvOES_underlying(coords);
}

void glDrawTexivOES_dispatchLoggingWrapper(const GLint * coords) {
	DISPATCH_DEBUG_LOG("glDrawTexivOES(coords:%p)", coords);
	GLDispatch::glDrawTexivOES_underlying(coords);
}

void glDrawTexxvOES_dispatchLoggingWrapper(const GLfixed * coords) {
	DISPATCH_DEBUG_LOG("glDrawTexxvOES(coords:%p)", coords);
	GLDispatch::glDrawTexxvOES_underlying(coords);
}

void glDrawTexfOES_dispatchLoggingWrapper(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) {
	DISPATCH_DEBUG_LOG("glDrawTexfOES(x:%f, y:%f, z:%f, width:%f, height:%f)", x, y, z, width, height);
	GLDispatch::glDrawTexfOES_underlying(x, y, z, width, height);
}

void glDrawTexfvOES_dispatchLoggingWrapper(const GLfloat * coords) {
	DISPATCH_DEBUG_LOG("glDrawTexfvOES(coords:%p)", coords);
	GLDispatch::glDrawTexfvOES_underlying(coords);
}

GLboolean glIsRenderbufferOES_dispatchLoggingWrapper(GLuint renderbuffer) {
	DISPATCH_DEBUG_LOG("glIsRenderbufferOES(renderbuffer:%d)", renderbuffer);
	return GLDispatch::glIsRenderbufferOES_underlying(renderbuffer);
}

void glBindRenderbufferOES_dispatchLoggingWrapper(GLenum target, GLuint renderbuffer) {
	DISPATCH_DEBUG_LOG("glBindRenderbufferOES(target:0x%X, renderbuffer:%d)", target, renderbuffer);
	GLDispatch::glBindRenderbufferOES_underlying(target, renderbuffer);
}

void glDeleteRenderbuffersOES_dispatchLoggingWrapper(GLsizei n, const GLuint* renderbuffers) {
	DISPATCH_DEBUG_LOG("glDeleteRenderbuffersOES(n:%d, renderbuffers:%p)", n, renderbuffers);
	GLDispatch::glDeleteRenderbuffersOES_underlying(n, renderbuffers);
}

void glGenRenderbuffersOES_dispatchLoggingWrapper(GLsizei n, GLuint* renderbuffers) {
	DISPATCH_DEBUG_LOG("glGenRenderbuffersOES(n:%d, renderbuffers:%p)", n, renderbuffers);
	GLDispatch::glGenRenderbuffersOES_underlying(n, renderbuffers);
}

void glRenderbufferStorageOES_dispatchLoggingWrapper(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
	DISPATCH_DEBUG_LOG("glRenderbufferStorageOES(target:0x%X, internalformat:0x%X, width:%d, height:%d)", target, internalformat, width, height);
	GLDispatch::glRenderbufferStorageOES_underlying(target, internalformat, width, height);
}

void glGetRenderbufferParameterivOES_dispatchLoggingWrapper(GLenum target, GLenum pname, GLint* params) {
	DISPATCH_DEBUG_LOG("glGetRenderbufferParameterivOES(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glGetRenderbufferParameterivOES_underlying(target, pname, params);
}

GLboolean glIsFramebufferOES_dispatchLoggingWrapper(GLuint framebuffer) {
	DISPATCH_DEBUG_LOG("glIsFramebufferOES(framebuffer:%d)", framebuffer);
	return GLDispatch::glIsFramebufferOES_underlying(framebuffer);
}

void glBindFramebufferOES_dispatchLoggingWrapper(GLenum target, GLuint framebuffer) {
	DISPATCH_DEBUG_LOG("glBindFramebufferOES(target:0x%X, framebuffer:%d)", target, framebuffer);
	GLDispatch::glBindFramebufferOES_underlying(target, framebuffer);
}

void glDeleteFramebuffersOES_dispatchLoggingWrapper(GLsizei n, const GLuint* framebuffers) {
	DISPATCH_DEBUG_LOG("glDeleteFramebuffersOES(n:%d, framebuffers:%p)", n, framebuffers);
	GLDispatch::glDeleteFramebuffersOES_underlying(n, framebuffers);
}

void glGenFramebuffersOES_dispatchLoggingWrapper(GLsizei n, GLuint* framebuffers) {
	DISPATCH_DEBUG_LOG("glGenFramebuffersOES(n:%d, framebuffers:%p)", n, framebuffers);
	GLDispatch::glGenFramebuffersOES_underlying(n, framebuffers);
}

GLenum glCheckFramebufferStatusOES_dispatchLoggingWrapper(GLenum target) {
	DISPATCH_DEBUG_LOG("glCheckFramebufferStatusOES(target:0x%X)", target);
	return GLDispatch::glCheckFramebufferStatusOES_underlying(target);
}

void glFramebufferRenderbufferOES_dispatchLoggingWrapper(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
	DISPATCH_DEBUG_LOG("glFramebufferRenderbufferOES(target:0x%X, attachment:0x%X, renderbuffertarget:0x%X, renderbuffer:%d)", target, attachment, renderbuffertarget, renderbuffer);
	GLDispatch::glFramebufferRenderbufferOES_underlying(target, attachment, renderbuffertarget, renderbuffer);
}

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

void glGetFramebufferAttachmentParameterivOES_dispatchLoggingWrapper(GLenum target, GLenum attachment, GLenum pname, GLint* params) {
	DISPATCH_DEBUG_LOG("glGetFramebufferAttachmentParameterivOES(target:0x%X, attachment:0x%X, pname:0x%X, params:%p)", target, attachment, pname, params);
	GLDispatch::glGetFramebufferAttachmentParameterivOES_underlying(target, attachment, pname, params);
}

void glGenerateMipmapOES_dispatchLoggingWrapper(GLenum target) {
	DISPATCH_DEBUG_LOG("glGenerateMipmapOES(target:0x%X)", target);
	GLDispatch::glGenerateMipmapOES_underlying(target);
}

void glCurrentPaletteMatrixOES_dispatchLoggingWrapper(GLuint matrixpaletteindex) {
	DISPATCH_DEBUG_LOG("glCurrentPaletteMatrixOES(matrixpaletteindex:%d)", matrixpaletteindex);
	GLDispatch::glCurrentPaletteMatrixOES_underlying(matrixpaletteindex);
}

void glLoadPaletteFromModelViewMatrixOES_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glLoadPaletteFromModelViewMatrixOES()");
	GLDispatch::glLoadPaletteFromModelViewMatrixOES_underlying();
}

void glMatrixIndexPointerOES_dispatchLoggingWrapper(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {
	DISPATCH_DEBUG_LOG("glMatrixIndexPointerOES(size:%d, type:0x%X, stride:%d, pointer:%p)", size, type, stride, pointer);
	GLDispatch::glMatrixIndexPointerOES_underlying(size, type, stride, pointer);
}

void glWeightPointerOES_dispatchLoggingWrapper(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {
	DISPATCH_DEBUG_LOG("glWeightPointerOES(size:%d, type:0x%X, stride:%d, pointer:%p)", size, type, stride, pointer);
	GLDispatch::glWeightPointerOES_underlying(size, type, stride, pointer);
}

void glTexGenfOES_dispatchLoggingWrapper(GLenum coord, GLenum pname, GLfloat param) {
	DISPATCH_DEBUG_LOG("glTexGenfOES(coord:0x%X, pname:0x%X, param:%f)", coord, pname, param);
	GLDispatch::glTexGenfOES_underlying(coord, pname, param);
}

void glTexGenfvOES_dispatchLoggingWrapper(GLenum coord, GLenum pname, const GLfloat * params) {
	DISPATCH_DEBUG_LOG("glTexGenfvOES(coord:0x%X, pname:0x%X, params:%p)", coord, pname, params);
	GLDispatch::glTexGenfvOES_underlying(coord, pname, params);
}

void glTexGeniOES_dispatchLoggingWrapper(GLenum coord, GLenum pname, GLint param) {
	DISPATCH_DEBUG_LOG("glTexGeniOES(coord:0x%X, pname:0x%X, param:%d)", coord, pname, param);
	GLDispatch::glTexGeniOES_underlying(coord, pname, param);
}

void glTexGenivOES_dispatchLoggingWrapper(GLenum coord, GLenum pname, const GLint * params) {
	DISPATCH_DEBUG_LOG("glTexGenivOES(coord:0x%X, pname:0x%X, params:%p)", coord, pname, params);
	GLDispatch::glTexGenivOES_underlying(coord, pname, params);
}

void glTexGenxOES_dispatchLoggingWrapper(GLenum coord, GLenum pname, GLfixed param) {
	DISPATCH_DEBUG_LOG("glTexGenxOES(coord:0x%X, pname:0x%X, param:%d)", coord, pname, param);
	GLDispatch::glTexGenxOES_underlying(coord, pname, param);
}

void glTexGenxvOES_dispatchLoggingWrapper(GLenum coord, GLenum pname, const GLfixed * params) {
	DISPATCH_DEBUG_LOG("glTexGenxvOES(coord:0x%X, pname:0x%X, params:%p)", coord, pname, params);
	GLDispatch::glTexGenxvOES_underlying(coord, pname, params);
}

void glGetTexGenfvOES_dispatchLoggingWrapper(GLenum coord, GLenum pname, GLfloat * params) {
	DISPATCH_DEBUG_LOG("glGetTexGenfvOES(coord:0x%X, pname:0x%X, params:%p)", coord, pname, params);
	GLDispatch::glGetTexGenfvOES_underlying(coord, pname, params);
}

void glGetTexGenivOES_dispatchLoggingWrapper(GLenum coord, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetTexGenivOES(coord:0x%X, pname:0x%X, params:%p)", coord, pname, params);
	GLDispatch::glGetTexGenivOES_underlying(coord, pname, params);
}

void glGetTexGenxvOES_dispatchLoggingWrapper(GLenum coord, GLenum pname, GLfixed * params) {
	DISPATCH_DEBUG_LOG("glGetTexGenxvOES(coord:0x%X, pname:0x%X, params:%p)", coord, pname, params);
	GLDispatch::glGetTexGenxvOES_underlying(coord, pname, params);
}