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

GLboolean glIsRenderbufferEXT_dispatchLoggingWrapper(GLuint renderbuffer) {
	DISPATCH_DEBUG_LOG("glIsRenderbufferEXT(renderbuffer:%d)", renderbuffer);
	return GLDispatch::glIsRenderbufferEXT_underlying(renderbuffer);
}

void glBindRenderbufferEXT_dispatchLoggingWrapper(GLenum target, GLuint renderbuffer) {
	DISPATCH_DEBUG_LOG("glBindRenderbufferEXT(target:0x%X, renderbuffer:%d)", target, renderbuffer);
	GLDispatch::glBindRenderbufferEXT_underlying(target, renderbuffer);
}

void glDeleteRenderbuffersEXT_dispatchLoggingWrapper(GLsizei n, const GLuint * renderbuffers) {
	DISPATCH_DEBUG_LOG("glDeleteRenderbuffersEXT(n:%d, renderbuffers:%p)", n, renderbuffers);
	GLDispatch::glDeleteRenderbuffersEXT_underlying(n, renderbuffers);
}

void glGenRenderbuffersEXT_dispatchLoggingWrapper(GLsizei n, GLuint * renderbuffers) {
	DISPATCH_DEBUG_LOG("glGenRenderbuffersEXT(n:%d, renderbuffers:%p)", n, renderbuffers);
	GLDispatch::glGenRenderbuffersEXT_underlying(n, renderbuffers);
}

void glRenderbufferStorageEXT_dispatchLoggingWrapper(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
	DISPATCH_DEBUG_LOG("glRenderbufferStorageEXT(target:0x%X, internalformat:0x%X, width:%d, height:%d)", target, internalformat, width, height);
	GLDispatch::glRenderbufferStorageEXT_underlying(target, internalformat, width, height);
}

void glGetRenderbufferParameterivEXT_dispatchLoggingWrapper(GLenum target, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetRenderbufferParameterivEXT(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glGetRenderbufferParameterivEXT_underlying(target, pname, params);
}

GLboolean glIsFramebufferEXT_dispatchLoggingWrapper(GLuint framebuffer) {
	DISPATCH_DEBUG_LOG("glIsFramebufferEXT(framebuffer:%d)", framebuffer);
	return GLDispatch::glIsFramebufferEXT_underlying(framebuffer);
}

void glBindFramebufferEXT_dispatchLoggingWrapper(GLenum target, GLuint framebuffer) {
	DISPATCH_DEBUG_LOG("glBindFramebufferEXT(target:0x%X, framebuffer:%d)", target, framebuffer);
	GLDispatch::glBindFramebufferEXT_underlying(target, framebuffer);
}

void glDeleteFramebuffersEXT_dispatchLoggingWrapper(GLsizei n, const GLuint * framebuffers) {
	DISPATCH_DEBUG_LOG("glDeleteFramebuffersEXT(n:%d, framebuffers:%p)", n, framebuffers);
	GLDispatch::glDeleteFramebuffersEXT_underlying(n, framebuffers);
}

void glGenFramebuffersEXT_dispatchLoggingWrapper(GLsizei n, GLuint * framebuffers) {
	DISPATCH_DEBUG_LOG("glGenFramebuffersEXT(n:%d, framebuffers:%p)", n, framebuffers);
	GLDispatch::glGenFramebuffersEXT_underlying(n, framebuffers);
}

GLenum glCheckFramebufferStatusEXT_dispatchLoggingWrapper(GLenum target) {
	DISPATCH_DEBUG_LOG("glCheckFramebufferStatusEXT(target:0x%X)", target);
	return GLDispatch::glCheckFramebufferStatusEXT_underlying(target);
}

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

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

void glFramebufferTexture3DEXT_dispatchLoggingWrapper(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {
	DISPATCH_DEBUG_LOG("glFramebufferTexture3DEXT(target:0x%X, attachment:0x%X, textarget:0x%X, texture:%d, level:%d, zoffset:%d)", target, attachment, textarget, texture, level, zoffset);
	GLDispatch::glFramebufferTexture3DEXT_underlying(target, attachment, textarget, texture, level, zoffset);
}

void glFramebufferRenderbufferEXT_dispatchLoggingWrapper(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
	DISPATCH_DEBUG_LOG("glFramebufferRenderbufferEXT(target:0x%X, attachment:0x%X, renderbuffertarget:0x%X, renderbuffer:%d)", target, attachment, renderbuffertarget, renderbuffer);
	GLDispatch::glFramebufferRenderbufferEXT_underlying(target, attachment, renderbuffertarget, renderbuffer);
}

void glGetFramebufferAttachmentParameterivEXT_dispatchLoggingWrapper(GLenum target, GLenum attachment, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetFramebufferAttachmentParameterivEXT(target:0x%X, attachment:0x%X, pname:0x%X, params:%p)", target, attachment, pname, params);
	GLDispatch::glGetFramebufferAttachmentParameterivEXT_underlying(target, attachment, pname, params);
}

void glGenerateMipmapEXT_dispatchLoggingWrapper(GLenum target) {
	DISPATCH_DEBUG_LOG("glGenerateMipmapEXT(target:0x%X)", target);
	GLDispatch::glGenerateMipmapEXT_underlying(target);
}

GLenum glGetGraphicsResetStatusEXT_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glGetGraphicsResetStatusEXT()");
	return GLDispatch::glGetGraphicsResetStatusEXT_underlying();
}

void glReadnPixelsEXT_dispatchLoggingWrapper(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data) {
	DISPATCH_DEBUG_LOG("glReadnPixelsEXT(x:%d, y:%d, width:%d, height:%d, format:0x%X, type:0x%X, bufSize:%d, data:%p)", x, y, width, height, format, type, bufSize, data);
	GLDispatch::glReadnPixelsEXT_underlying(x, y, width, height, format, type, bufSize, data);
}

void glGetnUniformfvEXT_dispatchLoggingWrapper(GLuint program, GLint location, GLsizei bufSize, float * params) {
	DISPATCH_DEBUG_LOG("glGetnUniformfvEXT(program:%d, location:%d, bufSize:%d, params:%p)", program, location, bufSize, params);
	GLDispatch::glGetnUniformfvEXT_underlying(program, location, bufSize, params);
}

void glGetnUniformivEXT_dispatchLoggingWrapper(GLuint program, GLint location, GLsizei bufSize, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetnUniformivEXT(program:%d, location:%d, bufSize:%d, params:%p)", program, location, bufSize, params);
	GLDispatch::glGetnUniformivEXT_underlying(program, location, bufSize, params);
}

void glEGLImageTargetTexture2DOES_dispatchLoggingWrapper(GLenum target, GLeglImageOES image) {
	DISPATCH_DEBUG_LOG("glEGLImageTargetTexture2DOES(target:0x%X, image:%p)", target, image);
	GLDispatch::glEGLImageTargetTexture2DOES_underlying(target, image);
}

void glEGLImageTargetRenderbufferStorageOES_dispatchLoggingWrapper(GLenum target, GLeglImageOES image) {
	DISPATCH_DEBUG_LOG("glEGLImageTargetRenderbufferStorageOES(target:0x%X, image:%p)", target, image);
	GLDispatch::glEGLImageTargetRenderbufferStorageOES_underlying(target, image);
}

void glDrawArraysNullAEMU_dispatchLoggingWrapper(GLenum mode, GLint first, GLsizei count) {
	DISPATCH_DEBUG_LOG("glDrawArraysNullAEMU(mode:0x%X, first:%d, count:%d)", mode, first, count);
	GLDispatch::glDrawArraysNullAEMU_underlying(mode, first, count);
}

void glDrawElementsNullAEMU_dispatchLoggingWrapper(GLenum mode, GLsizei count, GLenum type, const void * indices) {
	DISPATCH_DEBUG_LOG("glDrawElementsNullAEMU(mode:0x%X, count:%d, type:0x%X, indices:%p)", mode, count, type, indices);
	GLDispatch::glDrawElementsNullAEMU_underlying(mode, count, type, indices);
}

void glGetUnsignedBytevEXT_dispatchLoggingWrapper(GLenum pname, GLubyte* data) {
	DISPATCH_DEBUG_LOG("glGetUnsignedBytevEXT(pname:0x%X, data:%p)", pname, data);
	GLDispatch::glGetUnsignedBytevEXT_underlying(pname, data);
}

void glGetUnsignedBytei_vEXT_dispatchLoggingWrapper(GLenum target, GLuint index, GLubyte* data) {
	DISPATCH_DEBUG_LOG("glGetUnsignedBytei_vEXT(target:0x%X, index:%d, data:%p)", target, index, data);
	GLDispatch::glGetUnsignedBytei_vEXT_underlying(target, index, data);
}

void glImportMemoryFdEXT_dispatchLoggingWrapper(GLuint memory, GLuint64 size, GLenum handleType, GLint fd) {
	DISPATCH_DEBUG_LOG("glImportMemoryFdEXT(memory:%d, size:%lu, handleType:0x%X, fd:%d)", memory, size, handleType, fd);
	GLDispatch::glImportMemoryFdEXT_underlying(memory, size, handleType, fd);
}

void glImportMemoryWin32HandleEXT_dispatchLoggingWrapper(GLuint memory, GLuint64 size, GLenum handleType, void* handle) {
	DISPATCH_DEBUG_LOG("glImportMemoryWin32HandleEXT(memory:%d, size:%lu, handleType:0x%X, handle:%p)", memory, size, handleType, handle);
	GLDispatch::glImportMemoryWin32HandleEXT_underlying(memory, size, handleType, handle);
}

void glDeleteMemoryObjectsEXT_dispatchLoggingWrapper(GLsizei n, const GLuint * memoryObjects) {
	DISPATCH_DEBUG_LOG("glDeleteMemoryObjectsEXT(n:%d, memoryObjects:%p)", n, memoryObjects);
	GLDispatch::glDeleteMemoryObjectsEXT_underlying(n, memoryObjects);
}

GLboolean glIsMemoryObjectEXT_dispatchLoggingWrapper(GLuint memoryObject) {
	DISPATCH_DEBUG_LOG("glIsMemoryObjectEXT(memoryObject:%d)", memoryObject);
	return GLDispatch::glIsMemoryObjectEXT_underlying(memoryObject);
}

void glCreateMemoryObjectsEXT_dispatchLoggingWrapper(GLsizei n, GLuint * memoryObjects) {
	DISPATCH_DEBUG_LOG("glCreateMemoryObjectsEXT(n:%d, memoryObjects:%p)", n, memoryObjects);
	GLDispatch::glCreateMemoryObjectsEXT_underlying(n, memoryObjects);
}

void glMemoryObjectParameterivEXT_dispatchLoggingWrapper(GLuint memoryObject, GLenum pname, const GLint * params) {
	DISPATCH_DEBUG_LOG("glMemoryObjectParameterivEXT(memoryObject:%d, pname:0x%X, params:%p)", memoryObject, pname, params);
	GLDispatch::glMemoryObjectParameterivEXT_underlying(memoryObject, pname, params);
}

void glGetMemoryObjectParameterivEXT_dispatchLoggingWrapper(GLuint memoryObject, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetMemoryObjectParameterivEXT(memoryObject:%d, pname:0x%X, params:%p)", memoryObject, pname, params);
	GLDispatch::glGetMemoryObjectParameterivEXT_underlying(memoryObject, pname, params);
}

void glTexStorageMem2DEXT_dispatchLoggingWrapper(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset) {
	DISPATCH_DEBUG_LOG("glTexStorageMem2DEXT(target:0x%X, levels:%d, internalFormat:0x%X, width:%d, height:%d, memory:%d, offset:%lu)", target, levels, internalFormat, width, height, memory, offset);
	GLDispatch::glTexStorageMem2DEXT_underlying(target, levels, internalFormat, width, height, memory, offset);
}

void glTexStorageMem2DMultisampleEXT_dispatchLoggingWrapper(GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset) {
	DISPATCH_DEBUG_LOG("glTexStorageMem2DMultisampleEXT(target:0x%X, samples:%d, internalFormat:0x%X, width:%d, height:%d, fixedSampleLocations:%d, memory:%d, offset:%lu)", target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset);
	GLDispatch::glTexStorageMem2DMultisampleEXT_underlying(target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset);
}

void glTexStorageMem3DEXT_dispatchLoggingWrapper(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset) {
	DISPATCH_DEBUG_LOG("glTexStorageMem3DEXT(target:0x%X, levels:%d, internalFormat:0x%X, width:%d, height:%d, depth:%d, memory:%d, offset:%lu)", target, levels, internalFormat, width, height, depth, memory, offset);
	GLDispatch::glTexStorageMem3DEXT_underlying(target, levels, internalFormat, width, height, depth, memory, offset);
}

void glTexStorageMem3DMultisampleEXT_dispatchLoggingWrapper(GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset) {
	DISPATCH_DEBUG_LOG("glTexStorageMem3DMultisampleEXT(target:0x%X, samples:%d, internalFormat:0x%X, width:%d, height:%d, depth:%d, fixedSampleLocations:%d, memory:%d, offset:%lu)", target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset);
	GLDispatch::glTexStorageMem3DMultisampleEXT_underlying(target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset);
}

void glBufferStorageMemEXT_dispatchLoggingWrapper(GLenum target, GLsizeiptr size, GLuint memory, GLuint64 offset) {
	DISPATCH_DEBUG_LOG("glBufferStorageMemEXT(target:0x%X, size:%ld, memory:%d, offset:%lu)", target, size, memory, offset);
	GLDispatch::glBufferStorageMemEXT_underlying(target, size, memory, offset);
}

void glTexParameteriHOST_dispatchLoggingWrapper(GLenum target, GLenum pname, GLint param) {
	DISPATCH_DEBUG_LOG("glTexParameteriHOST(target:0x%X, pname:0x%X, param:%d)", target, pname, param);
	GLDispatch::glTexParameteriHOST_underlying(target, pname, param);
}

void glImportSemaphoreFdEXT_dispatchLoggingWrapper(GLuint semaphore, GLenum handleType, GLint fd) {
	DISPATCH_DEBUG_LOG("glImportSemaphoreFdEXT(semaphore:%d, handleType:0x%X, fd:%d)", semaphore, handleType, fd);
	GLDispatch::glImportSemaphoreFdEXT_underlying(semaphore, handleType, fd);
}

void glImportSemaphoreWin32HandleEXT_dispatchLoggingWrapper(GLuint semaphore, GLenum handleType, void* handle) {
	DISPATCH_DEBUG_LOG("glImportSemaphoreWin32HandleEXT(semaphore:%d, handleType:0x%X, handle:%p)", semaphore, handleType, handle);
	GLDispatch::glImportSemaphoreWin32HandleEXT_underlying(semaphore, handleType, handle);
}

void glGenSemaphoresEXT_dispatchLoggingWrapper(GLsizei n, GLuint * semaphores) {
	DISPATCH_DEBUG_LOG("glGenSemaphoresEXT(n:%d, semaphores:%p)", n, semaphores);
	GLDispatch::glGenSemaphoresEXT_underlying(n, semaphores);
}

void glDeleteSemaphoresEXT_dispatchLoggingWrapper(GLsizei n, const GLuint * semaphores) {
	DISPATCH_DEBUG_LOG("glDeleteSemaphoresEXT(n:%d, semaphores:%p)", n, semaphores);
	GLDispatch::glDeleteSemaphoresEXT_underlying(n, semaphores);
}

GLboolean glIsSemaphoreEXT_dispatchLoggingWrapper(GLuint semaphore) {
	DISPATCH_DEBUG_LOG("glIsSemaphoreEXT(semaphore:%d)", semaphore);
	return GLDispatch::glIsSemaphoreEXT_underlying(semaphore);
}

void glSemaphoreParameterui64vEXT_dispatchLoggingWrapper(GLuint semaphore, GLenum pname, const GLuint64 * params) {
	DISPATCH_DEBUG_LOG("glSemaphoreParameterui64vEXT(semaphore:%d, pname:0x%X, params:%p)", semaphore, pname, params);
	GLDispatch::glSemaphoreParameterui64vEXT_underlying(semaphore, pname, params);
}

void glGetSemaphoreParameterui64vEXT_dispatchLoggingWrapper(GLuint semaphore, GLenum pname, GLuint64 * params) {
	DISPATCH_DEBUG_LOG("glGetSemaphoreParameterui64vEXT(semaphore:%d, pname:0x%X, params:%p)", semaphore, pname, params);
	GLDispatch::glGetSemaphoreParameterui64vEXT_underlying(semaphore, pname, params);
}

void glWaitSemaphoreEXT_dispatchLoggingWrapper(GLuint semaphore, GLuint numBufferBarriers, const GLuint * buffers, GLuint numTextureBarriers, const GLuint * textures, const GLenum * srcLayouts) {
	DISPATCH_DEBUG_LOG("glWaitSemaphoreEXT(semaphore:%d, numBufferBarriers:%d, buffers:%p, numTextureBarriers:%d, textures:%p, srcLayouts:%p)", semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
	GLDispatch::glWaitSemaphoreEXT_underlying(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
}

void glSignalSemaphoreEXT_dispatchLoggingWrapper(GLuint semaphore, GLuint numBufferBarriers, const GLuint * buffers, GLuint numTextureBarriers, const GLuint * textures, const GLenum * dstLayouts) {
	DISPATCH_DEBUG_LOG("glSignalSemaphoreEXT(semaphore:%d, numBufferBarriers:%d, buffers:%p, numTextureBarriers:%d, textures:%p, dstLayouts:%p)", semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
	GLDispatch::glSignalSemaphoreEXT_underlying(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
}

GLuint glGetGlobalTexName_dispatchLoggingWrapper(GLuint localTexName) {
	DISPATCH_DEBUG_LOG("glGetGlobalTexName(localTexName:%d)", localTexName);
	return GLDispatch::glGetGlobalTexName_underlying(localTexName);
}