framework/opengl/wrapper/glwImpl.inl

/* WARNING: This is auto-generated file. Do not modify, since changes will
 * be lost! Modify the generating script instead.
 */

GLsync glwCreateSyncFromCLeventARB (struct _cl_context* context, struct _cl_event* event, GLbitfield flags)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLsync)0;
	return gl->createSyncFromCLeventARB(context, event, flags);
}

void glwBlendBarrierKHR ()
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->blendBarrierKHR();
}

void glwCullFace (GLenum mode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->cullFace(mode);
}

void glwFrontFace (GLenum mode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->frontFace(mode);
}

void glwHint (GLenum target, GLenum mode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->hint(target, mode);
}

void glwLineWidth (GLfloat width)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->lineWidth(width);
}

void glwPointSize (GLfloat size)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->pointSize(size);
}

void glwPolygonMode (GLenum face, GLenum mode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->polygonMode(face, mode);
}

void glwScissor (GLint x, GLint y, GLsizei width, GLsizei height)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->scissor(x, y, width, height);
}

void glwTexParameterf (GLenum target, GLenum pname, GLfloat param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texParameterf(target, pname, param);
}

void glwTexParameterfv (GLenum target, GLenum pname, const GLfloat* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texParameterfv(target, pname, params);
}

void glwTexParameteri (GLenum target, GLenum pname, GLint param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texParameteri(target, pname, param);
}

void glwTexParameteriv (GLenum target, GLenum pname, const GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texParameteriv(target, pname, params);
}

void glwTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texImage1D(target, level, internalformat, width, border, format, type, pixels);
}

void glwTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texImage2D(target, level, internalformat, width, height, border, format, type, pixels);
}

void glwDrawBuffer (GLenum mode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawBuffer(mode);
}

void glwClear (GLbitfield mask)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clear(mask);
}

void glwClearColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clearColor(red, green, blue, alpha);
}

void glwClearStencil (GLint s)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clearStencil(s);
}

void glwClearDepth (GLdouble depth)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clearDepth(depth);
}

void glwStencilMask (GLuint mask)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->stencilMask(mask);
}

void glwColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->colorMask(red, green, blue, alpha);
}

void glwDepthMask (GLboolean flag)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->depthMask(flag);
}

void glwDisable (GLenum cap)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->disable(cap);
}

void glwEnable (GLenum cap)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->enable(cap);
}

void glwFinish ()
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->finish();
}

void glwFlush ()
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->flush();
}

void glwBlendFunc (GLenum sfactor, GLenum dfactor)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->blendFunc(sfactor, dfactor);
}

void glwLogicOp (GLenum opcode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->logicOp(opcode);
}

void glwStencilFunc (GLenum func, GLint ref, GLuint mask)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->stencilFunc(func, ref, mask);
}

void glwStencilOp (GLenum fail, GLenum zfail, GLenum zpass)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->stencilOp(fail, zfail, zpass);
}

void glwDepthFunc (GLenum func)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->depthFunc(func);
}

void glwPixelStoref (GLenum pname, GLfloat param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->pixelStoref(pname, param);
}

void glwPixelStorei (GLenum pname, GLint param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->pixelStorei(pname, param);
}

void glwReadBuffer (GLenum mode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->readBuffer(mode);
}

void glwReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->readPixels(x, y, width, height, format, type, pixels);
}

void glwGetBooleanv (GLenum pname, GLboolean* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getBooleanv(pname, params);
}

void glwGetDoublev (GLenum pname, GLdouble* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getDoublev(pname, params);
}

GLenum glwGetError ()
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return GL_INVALID_OPERATION;
	return gl->getError();
}

void glwGetFloatv (GLenum pname, GLfloat* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getFloatv(pname, params);
}

void glwGetIntegerv (GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getIntegerv(pname, params);
}

const GLubyte* glwGetString (GLenum name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (const GLubyte*)0;
	return gl->getString(name);
}

void glwGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getTexImage(target, level, format, type, pixels);
}

void glwGetTexParameterfv (GLenum target, GLenum pname, GLfloat* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getTexParameterfv(target, pname, params);
}

void glwGetTexParameteriv (GLenum target, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getTexParameteriv(target, pname, params);
}

void glwGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getTexLevelParameterfv(target, level, pname, params);
}

void glwGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getTexLevelParameteriv(target, level, pname, params);
}

GLboolean glwIsEnabled (GLenum cap)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isEnabled(cap);
}

void glwDepthRange (GLdouble near, GLdouble far)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->depthRange(near, far);
}

void glwViewport (GLint x, GLint y, GLsizei width, GLsizei height)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->viewport(x, y, width, height);
}

void glwDrawArrays (GLenum mode, GLint first, GLsizei count)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawArrays(mode, first, count);
}

void glwDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawElements(mode, count, type, indices);
}

void glwGetPointerv (GLenum pname, GLvoid** params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getPointerv(pname, params);
}

void glwPolygonOffset (GLfloat factor, GLfloat units)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->polygonOffset(factor, units);
}

void glwCopyTexImage1D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->copyTexImage1D(target, level, internalformat, x, y, width, border);
}

void glwCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->copyTexImage2D(target, level, internalformat, x, y, width, height, border);
}

void glwCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->copyTexSubImage1D(target, level, xoffset, x, y, width);
}

void glwCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}

void glwTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid* pixels)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texSubImage1D(target, level, xoffset, width, format, type, pixels);
}

void glwTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
}

void glwBindTexture (GLenum target, GLuint texture)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindTexture(target, texture);
}

void glwDeleteTextures (GLsizei n, const GLuint* textures)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->deleteTextures(n, textures);
}

void glwGenTextures (GLsizei n, GLuint* textures)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->genTextures(n, textures);
}

GLboolean glwIsTexture (GLuint texture)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isTexture(texture);
}

void glwBlendColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->blendColor(red, green, blue, alpha);
}

void glwBlendEquation (GLenum mode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->blendEquation(mode);
}

void glwDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawRangeElements(mode, start, end, count, type, indices);
}

void glwTexImage3D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
}

void glwTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}

void glwCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

void glwActiveTexture (GLenum texture)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->activeTexture(texture);
}

void glwSampleCoverage (GLfloat value, GLboolean invert)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->sampleCoverage(value, invert);
}

void glwCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->compressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}

void glwCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->compressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}

void glwCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->compressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}

void glwCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}

void glwCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}

void glwCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->compressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}

void glwGetCompressedTexImage (GLenum target, GLint level, GLvoid* img)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getCompressedTexImage(target, level, img);
}

void glwBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->blendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}

void glwMultiDrawArrays (GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->multiDrawArrays(mode, first, count, drawcount);
}

void glwMultiDrawElements (GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei drawcount)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->multiDrawElements(mode, count, type, indices, drawcount);
}

void glwPointParameterf (GLenum pname, GLfloat param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->pointParameterf(pname, param);
}

void glwPointParameterfv (GLenum pname, const GLfloat* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->pointParameterfv(pname, params);
}

void glwPointParameteri (GLenum pname, GLint param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->pointParameteri(pname, param);
}

void glwPointParameteriv (GLenum pname, const GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->pointParameteriv(pname, params);
}

void glwGenQueries (GLsizei n, GLuint* ids)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->genQueries(n, ids);
}

void glwDeleteQueries (GLsizei n, const GLuint* ids)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->deleteQueries(n, ids);
}

GLboolean glwIsQuery (GLuint id)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isQuery(id);
}

void glwBeginQuery (GLenum target, GLuint id)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->beginQuery(target, id);
}

void glwEndQuery (GLenum target)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->endQuery(target);
}

void glwGetQueryiv (GLenum target, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getQueryiv(target, pname, params);
}

void glwGetQueryObjectiv (GLuint id, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getQueryObjectiv(id, pname, params);
}

void glwGetQueryObjectuiv (GLuint id, GLenum pname, GLuint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getQueryObjectuiv(id, pname, params);
}

void glwBindBuffer (GLenum target, GLuint buffer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindBuffer(target, buffer);
}

void glwDeleteBuffers (GLsizei n, const GLuint* buffers)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->deleteBuffers(n, buffers);
}

void glwGenBuffers (GLsizei n, GLuint* buffers)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->genBuffers(n, buffers);
}

GLboolean glwIsBuffer (GLuint buffer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isBuffer(buffer);
}

void glwBufferData (GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bufferData(target, size, data, usage);
}

void glwBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bufferSubData(target, offset, size, data);
}

void glwGetBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getBufferSubData(target, offset, size, data);
}

GLvoid* glwMapBuffer (GLenum target, GLenum access)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLvoid*)0;
	return gl->mapBuffer(target, access);
}

GLboolean glwUnmapBuffer (GLenum target)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->unmapBuffer(target);
}

void glwGetBufferParameteriv (GLenum target, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getBufferParameteriv(target, pname, params);
}

void glwGetBufferPointerv (GLenum target, GLenum pname, GLvoid** params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getBufferPointerv(target, pname, params);
}

void glwBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->blendEquationSeparate(modeRGB, modeAlpha);
}

void glwDrawBuffers (GLsizei n, const GLenum* bufs)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawBuffers(n, bufs);
}

void glwStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->stencilOpSeparate(face, sfail, dpfail, dppass);
}

void glwStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->stencilFuncSeparate(face, func, ref, mask);
}

void glwStencilMaskSeparate (GLenum face, GLuint mask)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->stencilMaskSeparate(face, mask);
}

void glwAttachShader (GLuint program, GLuint shader)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->attachShader(program, shader);
}

void glwBindAttribLocation (GLuint program, GLuint index, const GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindAttribLocation(program, index, name);
}

void glwCompileShader (GLuint shader)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->compileShader(shader);
}

GLuint glwCreateProgram ()
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLuint)0;
	return gl->createProgram();
}

GLuint glwCreateShader (GLenum type)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLuint)0;
	return gl->createShader(type);
}

void glwDeleteProgram (GLuint program)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->deleteProgram(program);
}

void glwDeleteShader (GLuint shader)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->deleteShader(shader);
}

void glwDetachShader (GLuint program, GLuint shader)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->detachShader(program, shader);
}

void glwDisableVertexAttribArray (GLuint index)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->disableVertexAttribArray(index);
}

void glwEnableVertexAttribArray (GLuint index)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->enableVertexAttribArray(index);
}

void glwGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getActiveAttrib(program, index, bufSize, length, size, type, name);
}

void glwGetActiveUniform (GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getActiveUniform(program, index, bufSize, length, size, type, name);
}

void glwGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getAttachedShaders(program, maxCount, count, obj);
}

GLint glwGetAttribLocation (GLuint program, const GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLint)0;
	return gl->getAttribLocation(program, name);
}

void glwGetProgramiv (GLuint program, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getProgramiv(program, pname, params);
}

void glwGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getProgramInfoLog(program, bufSize, length, infoLog);
}

void glwGetShaderiv (GLuint shader, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getShaderiv(shader, pname, params);
}

void glwGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getShaderInfoLog(shader, bufSize, length, infoLog);
}

void glwGetShaderSource (GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getShaderSource(shader, bufSize, length, source);
}

GLint glwGetUniformLocation (GLuint program, const GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLint)0;
	return gl->getUniformLocation(program, name);
}

void glwGetUniformfv (GLuint program, GLint location, GLfloat* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getUniformfv(program, location, params);
}

void glwGetUniformiv (GLuint program, GLint location, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getUniformiv(program, location, params);
}

void glwGetVertexAttribdv (GLuint index, GLenum pname, GLdouble* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getVertexAttribdv(index, pname, params);
}

void glwGetVertexAttribfv (GLuint index, GLenum pname, GLfloat* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getVertexAttribfv(index, pname, params);
}

void glwGetVertexAttribiv (GLuint index, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getVertexAttribiv(index, pname, params);
}

void glwGetVertexAttribPointerv (GLuint index, GLenum pname, GLvoid** pointer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getVertexAttribPointerv(index, pname, pointer);
}

GLboolean glwIsProgram (GLuint program)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isProgram(program);
}

GLboolean glwIsShader (GLuint shader)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isShader(shader);
}

void glwLinkProgram (GLuint program)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->linkProgram(program);
}

void glwShaderSource (GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->shaderSource(shader, count, string, length);
}

void glwUseProgram (GLuint program)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->useProgram(program);
}

void glwUniform1f (GLint location, GLfloat v0)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform1f(location, v0);
}

void glwUniform2f (GLint location, GLfloat v0, GLfloat v1)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform2f(location, v0, v1);
}

void glwUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform3f(location, v0, v1, v2);
}

void glwUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform4f(location, v0, v1, v2, v3);
}

void glwUniform1i (GLint location, GLint v0)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform1i(location, v0);
}

void glwUniform2i (GLint location, GLint v0, GLint v1)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform2i(location, v0, v1);
}

void glwUniform3i (GLint location, GLint v0, GLint v1, GLint v2)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform3i(location, v0, v1, v2);
}

void glwUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform4i(location, v0, v1, v2, v3);
}

void glwUniform1fv (GLint location, GLsizei count, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform1fv(location, count, value);
}

void glwUniform2fv (GLint location, GLsizei count, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform2fv(location, count, value);
}

void glwUniform3fv (GLint location, GLsizei count, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform3fv(location, count, value);
}

void glwUniform4fv (GLint location, GLsizei count, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform4fv(location, count, value);
}

void glwUniform1iv (GLint location, GLsizei count, const GLint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform1iv(location, count, value);
}

void glwUniform2iv (GLint location, GLsizei count, const GLint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform2iv(location, count, value);
}

void glwUniform3iv (GLint location, GLsizei count, const GLint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform3iv(location, count, value);
}

void glwUniform4iv (GLint location, GLsizei count, const GLint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform4iv(location, count, value);
}

void glwUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix2fv(location, count, transpose, value);
}

void glwUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix3fv(location, count, transpose, value);
}

void glwUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix4fv(location, count, transpose, value);
}

void glwValidateProgram (GLuint program)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->validateProgram(program);
}

void glwVertexAttrib1d (GLuint index, GLdouble x)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib1d(index, x);
}

void glwVertexAttrib1dv (GLuint index, const GLdouble* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib1dv(index, v);
}

void glwVertexAttrib1f (GLuint index, GLfloat x)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib1f(index, x);
}

void glwVertexAttrib1fv (GLuint index, const GLfloat* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib1fv(index, v);
}

void glwVertexAttrib1s (GLuint index, GLshort x)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib1s(index, x);
}

void glwVertexAttrib1sv (GLuint index, const GLshort* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib1sv(index, v);
}

void glwVertexAttrib2d (GLuint index, GLdouble x, GLdouble y)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib2d(index, x, y);
}

void glwVertexAttrib2dv (GLuint index, const GLdouble* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib2dv(index, v);
}

void glwVertexAttrib2f (GLuint index, GLfloat x, GLfloat y)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib2f(index, x, y);
}

void glwVertexAttrib2fv (GLuint index, const GLfloat* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib2fv(index, v);
}

void glwVertexAttrib2s (GLuint index, GLshort x, GLshort y)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib2s(index, x, y);
}

void glwVertexAttrib2sv (GLuint index, const GLshort* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib2sv(index, v);
}

void glwVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib3d(index, x, y, z);
}

void glwVertexAttrib3dv (GLuint index, const GLdouble* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib3dv(index, v);
}

void glwVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib3f(index, x, y, z);
}

void glwVertexAttrib3fv (GLuint index, const GLfloat* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib3fv(index, v);
}

void glwVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib3s(index, x, y, z);
}

void glwVertexAttrib3sv (GLuint index, const GLshort* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib3sv(index, v);
}

void glwVertexAttrib4Nbv (GLuint index, const GLbyte* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4Nbv(index, v);
}

void glwVertexAttrib4Niv (GLuint index, const GLint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4Niv(index, v);
}

void glwVertexAttrib4Nsv (GLuint index, const GLshort* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4Nsv(index, v);
}

void glwVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4Nub(index, x, y, z, w);
}

void glwVertexAttrib4Nubv (GLuint index, const GLubyte* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4Nubv(index, v);
}

void glwVertexAttrib4Nuiv (GLuint index, const GLuint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4Nuiv(index, v);
}

void glwVertexAttrib4Nusv (GLuint index, const GLushort* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4Nusv(index, v);
}

void glwVertexAttrib4bv (GLuint index, const GLbyte* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4bv(index, v);
}

void glwVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4d(index, x, y, z, w);
}

void glwVertexAttrib4dv (GLuint index, const GLdouble* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4dv(index, v);
}

void glwVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4f(index, x, y, z, w);
}

void glwVertexAttrib4fv (GLuint index, const GLfloat* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4fv(index, v);
}

void glwVertexAttrib4iv (GLuint index, const GLint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4iv(index, v);
}

void glwVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4s(index, x, y, z, w);
}

void glwVertexAttrib4sv (GLuint index, const GLshort* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4sv(index, v);
}

void glwVertexAttrib4ubv (GLuint index, const GLubyte* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4ubv(index, v);
}

void glwVertexAttrib4uiv (GLuint index, const GLuint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4uiv(index, v);
}

void glwVertexAttrib4usv (GLuint index, const GLushort* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttrib4usv(index, v);
}

void glwVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribPointer(index, size, type, normalized, stride, pointer);
}

void glwUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix2x3fv(location, count, transpose, value);
}

void glwUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix3x2fv(location, count, transpose, value);
}

void glwUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix2x4fv(location, count, transpose, value);
}

void glwUniformMatrix4x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix4x2fv(location, count, transpose, value);
}

void glwUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix3x4fv(location, count, transpose, value);
}

void glwUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix4x3fv(location, count, transpose, value);
}

void glwColorMaski (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->colorMaski(index, r, g, b, a);
}

void glwGetBooleani_v (GLenum target, GLuint index, GLboolean* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getBooleani_v(target, index, data);
}

void glwGetIntegeri_v (GLenum target, GLuint index, GLint* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getIntegeri_v(target, index, data);
}

void glwEnablei (GLenum target, GLuint index)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->enablei(target, index);
}

void glwDisablei (GLenum target, GLuint index)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->disablei(target, index);
}

GLboolean glwIsEnabledi (GLenum target, GLuint index)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isEnabledi(target, index);
}

void glwBeginTransformFeedback (GLenum primitiveMode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->beginTransformFeedback(primitiveMode);
}

void glwEndTransformFeedback ()
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->endTransformFeedback();
}

void glwBindBufferRange (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindBufferRange(target, index, buffer, offset, size);
}

void glwBindBufferBase (GLenum target, GLuint index, GLuint buffer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindBufferBase(target, index, buffer);
}

void glwTransformFeedbackVaryings (GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->transformFeedbackVaryings(program, count, varyings, bufferMode);
}

void glwGetTransformFeedbackVarying (GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
}

void glwClampColor (GLenum target, GLenum clamp)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clampColor(target, clamp);
}

void glwBeginConditionalRender (GLuint id, GLenum mode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->beginConditionalRender(id, mode);
}

void glwEndConditionalRender ()
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->endConditionalRender();
}

void glwVertexAttribIPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribIPointer(index, size, type, stride, pointer);
}

void glwGetVertexAttribIiv (GLuint index, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getVertexAttribIiv(index, pname, params);
}

void glwGetVertexAttribIuiv (GLuint index, GLenum pname, GLuint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getVertexAttribIuiv(index, pname, params);
}

void glwVertexAttribI1i (GLuint index, GLint x)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI1i(index, x);
}

void glwVertexAttribI2i (GLuint index, GLint x, GLint y)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI2i(index, x, y);
}

void glwVertexAttribI3i (GLuint index, GLint x, GLint y, GLint z)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI3i(index, x, y, z);
}

void glwVertexAttribI4i (GLuint index, GLint x, GLint y, GLint z, GLint w)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI4i(index, x, y, z, w);
}

void glwVertexAttribI1ui (GLuint index, GLuint x)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI1ui(index, x);
}

void glwVertexAttribI2ui (GLuint index, GLuint x, GLuint y)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI2ui(index, x, y);
}

void glwVertexAttribI3ui (GLuint index, GLuint x, GLuint y, GLuint z)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI3ui(index, x, y, z);
}

void glwVertexAttribI4ui (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI4ui(index, x, y, z, w);
}

void glwVertexAttribI1iv (GLuint index, const GLint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI1iv(index, v);
}

void glwVertexAttribI2iv (GLuint index, const GLint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI2iv(index, v);
}

void glwVertexAttribI3iv (GLuint index, const GLint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI3iv(index, v);
}

void glwVertexAttribI4iv (GLuint index, const GLint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI4iv(index, v);
}

void glwVertexAttribI1uiv (GLuint index, const GLuint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI1uiv(index, v);
}

void glwVertexAttribI2uiv (GLuint index, const GLuint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI2uiv(index, v);
}

void glwVertexAttribI3uiv (GLuint index, const GLuint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI3uiv(index, v);
}

void glwVertexAttribI4uiv (GLuint index, const GLuint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI4uiv(index, v);
}

void glwVertexAttribI4bv (GLuint index, const GLbyte* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI4bv(index, v);
}

void glwVertexAttribI4sv (GLuint index, const GLshort* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI4sv(index, v);
}

void glwVertexAttribI4ubv (GLuint index, const GLubyte* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI4ubv(index, v);
}

void glwVertexAttribI4usv (GLuint index, const GLushort* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribI4usv(index, v);
}

void glwGetUniformuiv (GLuint program, GLint location, GLuint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getUniformuiv(program, location, params);
}

void glwBindFragDataLocation (GLuint program, GLuint color, const GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindFragDataLocation(program, color, name);
}

GLint glwGetFragDataLocation (GLuint program, const GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLint)0;
	return gl->getFragDataLocation(program, name);
}

void glwUniform1ui (GLint location, GLuint v0)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform1ui(location, v0);
}

void glwUniform2ui (GLint location, GLuint v0, GLuint v1)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform2ui(location, v0, v1);
}

void glwUniform3ui (GLint location, GLuint v0, GLuint v1, GLuint v2)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform3ui(location, v0, v1, v2);
}

void glwUniform4ui (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform4ui(location, v0, v1, v2, v3);
}

void glwUniform1uiv (GLint location, GLsizei count, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform1uiv(location, count, value);
}

void glwUniform2uiv (GLint location, GLsizei count, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform2uiv(location, count, value);
}

void glwUniform3uiv (GLint location, GLsizei count, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform3uiv(location, count, value);
}

void glwUniform4uiv (GLint location, GLsizei count, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform4uiv(location, count, value);
}

void glwTexParameterIiv (GLenum target, GLenum pname, const GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texParameterIiv(target, pname, params);
}

void glwTexParameterIuiv (GLenum target, GLenum pname, const GLuint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texParameterIuiv(target, pname, params);
}

void glwGetTexParameterIiv (GLenum target, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getTexParameterIiv(target, pname, params);
}

void glwGetTexParameterIuiv (GLenum target, GLenum pname, GLuint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getTexParameterIuiv(target, pname, params);
}

void glwClearBufferiv (GLenum buffer, GLint drawbuffer, const GLint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clearBufferiv(buffer, drawbuffer, value);
}

void glwClearBufferuiv (GLenum buffer, GLint drawbuffer, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clearBufferuiv(buffer, drawbuffer, value);
}

void glwClearBufferfv (GLenum buffer, GLint drawbuffer, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clearBufferfv(buffer, drawbuffer, value);
}

void glwClearBufferfi (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clearBufferfi(buffer, drawbuffer, depth, stencil);
}

const GLubyte* glwGetStringi (GLenum name, GLuint index)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (const GLubyte*)0;
	return gl->getStringi(name, index);
}

GLboolean glwIsRenderbuffer (GLuint renderbuffer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isRenderbuffer(renderbuffer);
}

void glwBindRenderbuffer (GLenum target, GLuint renderbuffer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindRenderbuffer(target, renderbuffer);
}

void glwDeleteRenderbuffers (GLsizei n, const GLuint* renderbuffers)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->deleteRenderbuffers(n, renderbuffers);
}

void glwGenRenderbuffers (GLsizei n, GLuint* renderbuffers)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->genRenderbuffers(n, renderbuffers);
}

void glwRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->renderbufferStorage(target, internalformat, width, height);
}

void glwGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getRenderbufferParameteriv(target, pname, params);
}

GLboolean glwIsFramebuffer (GLuint framebuffer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isFramebuffer(framebuffer);
}

void glwBindFramebuffer (GLenum target, GLuint framebuffer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindFramebuffer(target, framebuffer);
}

void glwDeleteFramebuffers (GLsizei n, const GLuint* framebuffers)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->deleteFramebuffers(n, framebuffers);
}

void glwGenFramebuffers (GLsizei n, GLuint* framebuffers)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->genFramebuffers(n, framebuffers);
}

GLenum glwCheckFramebufferStatus (GLenum target)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLenum)0;
	return gl->checkFramebufferStatus(target);
}

void glwFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->framebufferTexture1D(target, attachment, textarget, texture, level);
}

void glwFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->framebufferTexture2D(target, attachment, textarget, texture, level);
}

void glwFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->framebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}

void glwFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}

void glwGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
}

void glwGenerateMipmap (GLenum target)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->generateMipmap(target);
}

void glwBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}

void glwRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->renderbufferStorageMultisample(target, samples, internalformat, width, height);
}

void glwFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->framebufferTextureLayer(target, attachment, texture, level, layer);
}

GLvoid* glwMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLvoid*)0;
	return gl->mapBufferRange(target, offset, length, access);
}

void glwFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->flushMappedBufferRange(target, offset, length);
}

void glwBindVertexArray (GLuint array)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindVertexArray(array);
}

void glwDeleteVertexArrays (GLsizei n, const GLuint* arrays)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->deleteVertexArrays(n, arrays);
}

void glwGenVertexArrays (GLsizei n, GLuint* arrays)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->genVertexArrays(n, arrays);
}

GLboolean glwIsVertexArray (GLuint array)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isVertexArray(array);
}

void glwTexBuffer (GLenum target, GLenum internalformat, GLuint buffer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texBuffer(target, internalformat, buffer);
}

void glwPrimitiveRestartIndex (GLuint index)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->primitiveRestartIndex(index);
}

void glwCopyBufferSubData (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
}

void glwDrawArraysInstanced (GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawArraysInstanced(mode, first, count, instancecount);
}

void glwDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instancecount)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawElementsInstanced(mode, count, type, indices, instancecount);
}

void glwGetUniformIndices (GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getUniformIndices(program, uniformCount, uniformNames, uniformIndices);
}

void glwGetActiveUniformsiv (GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
}

void glwGetActiveUniformName (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
}

GLuint glwGetUniformBlockIndex (GLuint program, const GLchar* uniformBlockName)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLuint)0;
	return gl->getUniformBlockIndex(program, uniformBlockName);
}

void glwGetActiveUniformBlockiv (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
}

void glwGetActiveUniformBlockName (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
}

void glwUniformBlockBinding (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}

void glwGetInteger64i_v (GLenum target, GLuint index, GLint64* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getInteger64i_v(target, index, data);
}

void glwGetBufferParameteri64v (GLenum target, GLenum pname, GLint64* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getBufferParameteri64v(target, pname, params);
}

void glwFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->framebufferTexture(target, attachment, texture, level);
}

void glwDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLint basevertex)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawElementsBaseVertex(mode, count, type, indices, basevertex);
}

void glwDrawRangeElementsBaseVertex (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices, GLint basevertex)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
}

void glwDrawElementsInstancedBaseVertex (GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instancecount, GLint basevertex)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
}

void glwMultiDrawElementsBaseVertex (GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei drawcount, const GLint* basevertex)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->multiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
}

void glwProvokingVertex (GLenum mode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->provokingVertex(mode);
}

GLsync glwFenceSync (GLenum condition, GLbitfield flags)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLsync)0;
	return gl->fenceSync(condition, flags);
}

GLboolean glwIsSync (GLsync sync)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isSync(sync);
}

void glwDeleteSync (GLsync sync)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->deleteSync(sync);
}

GLenum glwClientWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLenum)0;
	return gl->clientWaitSync(sync, flags, timeout);
}

void glwWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->waitSync(sync, flags, timeout);
}

void glwGetInteger64v (GLenum pname, GLint64* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getInteger64v(pname, params);
}

void glwGetSynciv (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getSynciv(sync, pname, bufSize, length, values);
}

void glwTexImage2DMultisample (GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
}

void glwTexImage3DMultisample (GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
}

void glwGetMultisamplefv (GLenum pname, GLuint index, GLfloat* val)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getMultisamplefv(pname, index, val);
}

void glwSampleMaski (GLuint index, GLbitfield mask)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->sampleMaski(index, mask);
}

void glwVertexAttribDivisor (GLuint index, GLuint divisor)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribDivisor(index, divisor);
}

void glwBindFragDataLocationIndexed (GLuint program, GLuint colorNumber, GLuint index, const GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindFragDataLocationIndexed(program, colorNumber, index, name);
}

GLint glwGetFragDataIndex (GLuint program, const GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLint)0;
	return gl->getFragDataIndex(program, name);
}

void glwGenSamplers (GLsizei count, GLuint* samplers)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->genSamplers(count, samplers);
}

void glwDeleteSamplers (GLsizei count, const GLuint* samplers)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->deleteSamplers(count, samplers);
}

GLboolean glwIsSampler (GLuint sampler)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isSampler(sampler);
}

void glwBindSampler (GLuint unit, GLuint sampler)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindSampler(unit, sampler);
}

void glwSamplerParameteri (GLuint sampler, GLenum pname, GLint param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->samplerParameteri(sampler, pname, param);
}

void glwSamplerParameteriv (GLuint sampler, GLenum pname, const GLint* param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->samplerParameteriv(sampler, pname, param);
}

void glwSamplerParameterf (GLuint sampler, GLenum pname, GLfloat param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->samplerParameterf(sampler, pname, param);
}

void glwSamplerParameterfv (GLuint sampler, GLenum pname, const GLfloat* param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->samplerParameterfv(sampler, pname, param);
}

void glwSamplerParameterIiv (GLuint sampler, GLenum pname, const GLint* param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->samplerParameterIiv(sampler, pname, param);
}

void glwSamplerParameterIuiv (GLuint sampler, GLenum pname, const GLuint* param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->samplerParameterIuiv(sampler, pname, param);
}

void glwGetSamplerParameteriv (GLuint sampler, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getSamplerParameteriv(sampler, pname, params);
}

void glwGetSamplerParameterIiv (GLuint sampler, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getSamplerParameterIiv(sampler, pname, params);
}

void glwGetSamplerParameterfv (GLuint sampler, GLenum pname, GLfloat* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getSamplerParameterfv(sampler, pname, params);
}

void glwGetSamplerParameterIuiv (GLuint sampler, GLenum pname, GLuint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getSamplerParameterIuiv(sampler, pname, params);
}

void glwQueryCounter (GLuint id, GLenum target)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->queryCounter(id, target);
}

void glwGetQueryObjecti64v (GLuint id, GLenum pname, GLint64* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getQueryObjecti64v(id, pname, params);
}

void glwGetQueryObjectui64v (GLuint id, GLenum pname, GLuint64* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getQueryObjectui64v(id, pname, params);
}

void glwVertexAttribP1ui (GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribP1ui(index, type, normalized, value);
}

void glwVertexAttribP1uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribP1uiv(index, type, normalized, value);
}

void glwVertexAttribP2ui (GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribP2ui(index, type, normalized, value);
}

void glwVertexAttribP2uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribP2uiv(index, type, normalized, value);
}

void glwVertexAttribP3ui (GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribP3ui(index, type, normalized, value);
}

void glwVertexAttribP3uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribP3uiv(index, type, normalized, value);
}

void glwVertexAttribP4ui (GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribP4ui(index, type, normalized, value);
}

void glwVertexAttribP4uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribP4uiv(index, type, normalized, value);
}

void glwBlendEquationi (GLuint buf, GLenum mode)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->blendEquationi(buf, mode);
}

void glwBlendEquationSeparatei (GLuint buf, GLenum modeRGB, GLenum modeAlpha)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->blendEquationSeparatei(buf, modeRGB, modeAlpha);
}

void glwBlendFunci (GLuint buf, GLenum src, GLenum dst)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->blendFunci(buf, src, dst);
}

void glwBlendFuncSeparatei (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void glwDrawArraysIndirect (GLenum mode, const GLvoid* indirect)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawArraysIndirect(mode, indirect);
}

void glwDrawElementsIndirect (GLenum mode, GLenum type, const GLvoid* indirect)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawElementsIndirect(mode, type, indirect);
}

void glwUniform1d (GLint location, GLdouble x)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform1d(location, x);
}

void glwUniform2d (GLint location, GLdouble x, GLdouble y)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform2d(location, x, y);
}

void glwUniform3d (GLint location, GLdouble x, GLdouble y, GLdouble z)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform3d(location, x, y, z);
}

void glwUniform4d (GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform4d(location, x, y, z, w);
}

void glwUniform1dv (GLint location, GLsizei count, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform1dv(location, count, value);
}

void glwUniform2dv (GLint location, GLsizei count, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform2dv(location, count, value);
}

void glwUniform3dv (GLint location, GLsizei count, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform3dv(location, count, value);
}

void glwUniform4dv (GLint location, GLsizei count, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniform4dv(location, count, value);
}

void glwUniformMatrix2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix2dv(location, count, transpose, value);
}

void glwUniformMatrix3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix3dv(location, count, transpose, value);
}

void glwUniformMatrix4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix4dv(location, count, transpose, value);
}

void glwUniformMatrix2x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix2x3dv(location, count, transpose, value);
}

void glwUniformMatrix2x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix2x4dv(location, count, transpose, value);
}

void glwUniformMatrix3x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix3x2dv(location, count, transpose, value);
}

void glwUniformMatrix3x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix3x4dv(location, count, transpose, value);
}

void glwUniformMatrix4x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix4x2dv(location, count, transpose, value);
}

void glwUniformMatrix4x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformMatrix4x3dv(location, count, transpose, value);
}

void glwGetUniformdv (GLuint program, GLint location, GLdouble* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getUniformdv(program, location, params);
}

void glwMinSampleShading (GLfloat value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->minSampleShading(value);
}

GLint glwGetSubroutineUniformLocation (GLuint program, GLenum shadertype, const GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLint)0;
	return gl->getSubroutineUniformLocation(program, shadertype, name);
}

GLuint glwGetSubroutineIndex (GLuint program, GLenum shadertype, const GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLuint)0;
	return gl->getSubroutineIndex(program, shadertype, name);
}

void glwGetActiveSubroutineUniformiv (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getActiveSubroutineUniformiv(program, shadertype, index, pname, values);
}

void glwGetActiveSubroutineUniformName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
}

void glwGetActiveSubroutineName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getActiveSubroutineName(program, shadertype, index, bufsize, length, name);
}

void glwUniformSubroutinesuiv (GLenum shadertype, GLsizei count, const GLuint* indices)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->uniformSubroutinesuiv(shadertype, count, indices);
}

void glwGetUniformSubroutineuiv (GLenum shadertype, GLint location, GLuint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getUniformSubroutineuiv(shadertype, location, params);
}

void glwGetProgramStageiv (GLuint program, GLenum shadertype, GLenum pname, GLint* values)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getProgramStageiv(program, shadertype, pname, values);
}

void glwPatchParameteri (GLenum pname, GLint value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->patchParameteri(pname, value);
}

void glwPatchParameterfv (GLenum pname, const GLfloat* values)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->patchParameterfv(pname, values);
}

void glwBindTransformFeedback (GLenum target, GLuint id)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindTransformFeedback(target, id);
}

void glwDeleteTransformFeedbacks (GLsizei n, const GLuint* ids)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->deleteTransformFeedbacks(n, ids);
}

void glwGenTransformFeedbacks (GLsizei n, GLuint* ids)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->genTransformFeedbacks(n, ids);
}

GLboolean glwIsTransformFeedback (GLuint id)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isTransformFeedback(id);
}

void glwPauseTransformFeedback ()
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->pauseTransformFeedback();
}

void glwResumeTransformFeedback ()
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->resumeTransformFeedback();
}

void glwDrawTransformFeedback (GLenum mode, GLuint id)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawTransformFeedback(mode, id);
}

void glwDrawTransformFeedbackStream (GLenum mode, GLuint id, GLuint stream)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawTransformFeedbackStream(mode, id, stream);
}

void glwBeginQueryIndexed (GLenum target, GLuint index, GLuint id)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->beginQueryIndexed(target, index, id);
}

void glwEndQueryIndexed (GLenum target, GLuint index)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->endQueryIndexed(target, index);
}

void glwGetQueryIndexediv (GLenum target, GLuint index, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getQueryIndexediv(target, index, pname, params);
}

void glwReleaseShaderCompiler ()
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->releaseShaderCompiler();
}

void glwShaderBinary (GLsizei count, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->shaderBinary(count, shaders, binaryformat, binary, length);
}

void glwGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}

void glwDepthRangef (GLfloat n, GLfloat f)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->depthRangef(n, f);
}

void glwClearDepthf (GLfloat d)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clearDepthf(d);
}

void glwGetProgramBinary (GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getProgramBinary(program, bufSize, length, binaryFormat, binary);
}

void glwProgramBinary (GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programBinary(program, binaryFormat, binary, length);
}

void glwProgramParameteri (GLuint program, GLenum pname, GLint value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programParameteri(program, pname, value);
}

void glwUseProgramStages (GLuint pipeline, GLbitfield stages, GLuint program)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->useProgramStages(pipeline, stages, program);
}

void glwActiveShaderProgram (GLuint pipeline, GLuint program)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->activeShaderProgram(pipeline, program);
}

GLuint glwCreateShaderProgramv (GLenum type, GLsizei count, const GLchar* const* strings)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLuint)0;
	return gl->createShaderProgramv(type, count, strings);
}

void glwBindProgramPipeline (GLuint pipeline)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindProgramPipeline(pipeline);
}

void glwDeleteProgramPipelines (GLsizei n, const GLuint* pipelines)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->deleteProgramPipelines(n, pipelines);
}

void glwGenProgramPipelines (GLsizei n, GLuint* pipelines)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->genProgramPipelines(n, pipelines);
}

GLboolean glwIsProgramPipeline (GLuint pipeline)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLboolean)0;
	return gl->isProgramPipeline(pipeline);
}

void glwGetProgramPipelineiv (GLuint pipeline, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getProgramPipelineiv(pipeline, pname, params);
}

void glwProgramUniform1i (GLuint program, GLint location, GLint v0)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform1i(program, location, v0);
}

void glwProgramUniform1iv (GLuint program, GLint location, GLsizei count, const GLint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform1iv(program, location, count, value);
}

void glwProgramUniform1f (GLuint program, GLint location, GLfloat v0)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform1f(program, location, v0);
}

void glwProgramUniform1fv (GLuint program, GLint location, GLsizei count, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform1fv(program, location, count, value);
}

void glwProgramUniform1d (GLuint program, GLint location, GLdouble v0)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform1d(program, location, v0);
}

void glwProgramUniform1dv (GLuint program, GLint location, GLsizei count, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform1dv(program, location, count, value);
}

void glwProgramUniform1ui (GLuint program, GLint location, GLuint v0)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform1ui(program, location, v0);
}

void glwProgramUniform1uiv (GLuint program, GLint location, GLsizei count, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform1uiv(program, location, count, value);
}

void glwProgramUniform2i (GLuint program, GLint location, GLint v0, GLint v1)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform2i(program, location, v0, v1);
}

void glwProgramUniform2iv (GLuint program, GLint location, GLsizei count, const GLint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform2iv(program, location, count, value);
}

void glwProgramUniform2f (GLuint program, GLint location, GLfloat v0, GLfloat v1)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform2f(program, location, v0, v1);
}

void glwProgramUniform2fv (GLuint program, GLint location, GLsizei count, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform2fv(program, location, count, value);
}

void glwProgramUniform2d (GLuint program, GLint location, GLdouble v0, GLdouble v1)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform2d(program, location, v0, v1);
}

void glwProgramUniform2dv (GLuint program, GLint location, GLsizei count, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform2dv(program, location, count, value);
}

void glwProgramUniform2ui (GLuint program, GLint location, GLuint v0, GLuint v1)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform2ui(program, location, v0, v1);
}

void glwProgramUniform2uiv (GLuint program, GLint location, GLsizei count, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform2uiv(program, location, count, value);
}

void glwProgramUniform3i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform3i(program, location, v0, v1, v2);
}

void glwProgramUniform3iv (GLuint program, GLint location, GLsizei count, const GLint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform3iv(program, location, count, value);
}

void glwProgramUniform3f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform3f(program, location, v0, v1, v2);
}

void glwProgramUniform3fv (GLuint program, GLint location, GLsizei count, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform3fv(program, location, count, value);
}

void glwProgramUniform3d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform3d(program, location, v0, v1, v2);
}

void glwProgramUniform3dv (GLuint program, GLint location, GLsizei count, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform3dv(program, location, count, value);
}

void glwProgramUniform3ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform3ui(program, location, v0, v1, v2);
}

void glwProgramUniform3uiv (GLuint program, GLint location, GLsizei count, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform3uiv(program, location, count, value);
}

void glwProgramUniform4i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform4i(program, location, v0, v1, v2, v3);
}

void glwProgramUniform4iv (GLuint program, GLint location, GLsizei count, const GLint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform4iv(program, location, count, value);
}

void glwProgramUniform4f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform4f(program, location, v0, v1, v2, v3);
}

void glwProgramUniform4fv (GLuint program, GLint location, GLsizei count, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform4fv(program, location, count, value);
}

void glwProgramUniform4d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform4d(program, location, v0, v1, v2, v3);
}

void glwProgramUniform4dv (GLuint program, GLint location, GLsizei count, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform4dv(program, location, count, value);
}

void glwProgramUniform4ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform4ui(program, location, v0, v1, v2, v3);
}

void glwProgramUniform4uiv (GLuint program, GLint location, GLsizei count, const GLuint* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniform4uiv(program, location, count, value);
}

void glwProgramUniformMatrix2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix2fv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix3fv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix4fv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix2dv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix3dv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix4dv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix2x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix2x3fv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix3x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix3x2fv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix2x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix2x4fv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix4x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix4x2fv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix3x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix3x4fv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix4x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix4x3fv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix2x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix2x3dv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix3x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix3x2dv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix2x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix2x4dv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix4x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix4x2dv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix3x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix3x4dv(program, location, count, transpose, value);
}

void glwProgramUniformMatrix4x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->programUniformMatrix4x3dv(program, location, count, transpose, value);
}

void glwValidateProgramPipeline (GLuint pipeline)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->validateProgramPipeline(pipeline);
}

void glwGetProgramPipelineInfoLog (GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
}

void glwVertexAttribL1d (GLuint index, GLdouble x)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribL1d(index, x);
}

void glwVertexAttribL2d (GLuint index, GLdouble x, GLdouble y)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribL2d(index, x, y);
}

void glwVertexAttribL3d (GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribL3d(index, x, y, z);
}

void glwVertexAttribL4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribL4d(index, x, y, z, w);
}

void glwVertexAttribL1dv (GLuint index, const GLdouble* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribL1dv(index, v);
}

void glwVertexAttribL2dv (GLuint index, const GLdouble* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribL2dv(index, v);
}

void glwVertexAttribL3dv (GLuint index, const GLdouble* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribL3dv(index, v);
}

void glwVertexAttribL4dv (GLuint index, const GLdouble* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribL4dv(index, v);
}

void glwVertexAttribLPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribLPointer(index, size, type, stride, pointer);
}

void glwGetVertexAttribLdv (GLuint index, GLenum pname, GLdouble* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getVertexAttribLdv(index, pname, params);
}

void glwViewportArrayv (GLuint first, GLsizei count, const GLfloat* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->viewportArrayv(first, count, v);
}

void glwViewportIndexedf (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->viewportIndexedf(index, x, y, w, h);
}

void glwViewportIndexedfv (GLuint index, const GLfloat* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->viewportIndexedfv(index, v);
}

void glwScissorArrayv (GLuint first, GLsizei count, const GLint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->scissorArrayv(first, count, v);
}

void glwScissorIndexed (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->scissorIndexed(index, left, bottom, width, height);
}

void glwScissorIndexedv (GLuint index, const GLint* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->scissorIndexedv(index, v);
}

void glwDepthRangeArrayv (GLuint first, GLsizei count, const GLdouble* v)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->depthRangeArrayv(first, count, v);
}

void glwDepthRangeIndexed (GLuint index, GLdouble n, GLdouble f)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->depthRangeIndexed(index, n, f);
}

void glwGetFloati_v (GLenum target, GLuint index, GLfloat* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getFloati_v(target, index, data);
}

void glwGetDoublei_v (GLenum target, GLuint index, GLdouble* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getDoublei_v(target, index, data);
}

void glwDrawArraysInstancedBaseInstance (GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}

void glwDrawElementsInstancedBaseInstance (GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLuint baseinstance)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
}

void glwDrawElementsInstancedBaseVertexBaseInstance (GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
}

void glwDrawTransformFeedbackInstanced (GLenum mode, GLuint id, GLsizei instancecount)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawTransformFeedbackInstanced(mode, id, instancecount);
}

void glwDrawTransformFeedbackStreamInstanced (GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->drawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}

void glwGetInternalformativ (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getInternalformativ(target, internalformat, pname, bufSize, params);
}

void glwGetActiveAtomicCounterBufferiv (GLuint program, GLuint bufferIndex, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
}

void glwBindImageTexture (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindImageTexture(unit, texture, level, layered, layer, access, format);
}

void glwMemoryBarrier (GLbitfield barriers)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->memoryBarrier(barriers);
}

void glwTexStorage1D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texStorage1D(target, levels, internalformat, width);
}

void glwTexStorage2D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texStorage2D(target, levels, internalformat, width, height);
}

void glwTexStorage3D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texStorage3D(target, levels, internalformat, width, height, depth);
}

void glwClearBufferData (GLenum target, GLenum internalformat, GLenum format, GLenum type, const void* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clearBufferData(target, internalformat, format, type, data);
}

void glwClearBufferSubData (GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clearBufferSubData(target, internalformat, offset, size, format, type, data);
}

void glwDispatchCompute (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->dispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}

void glwDispatchComputeIndirect (GLintptr indirect)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->dispatchComputeIndirect(indirect);
}

void glwCopyImageSubData (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}

void glwDebugMessageControl (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->debugMessageControl(source, type, severity, count, ids, enabled);
}

void glwDebugMessageInsert (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* buf)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->debugMessageInsert(source, type, id, severity, length, buf);
}

void glwDebugMessageCallback (GLDEBUGPROC callback, const void* userParam)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->debugMessageCallback(callback, userParam);
}

GLuint glwGetDebugMessageLog (GLuint count, GLsizei bufsize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLuint)0;
	return gl->getDebugMessageLog(count, bufsize, sources, types, ids, severities, lengths, messageLog);
}

void glwPushDebugGroup (GLenum source, GLuint id, GLsizei length, const GLchar* message)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->pushDebugGroup(source, id, length, message);
}

void glwPopDebugGroup ()
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->popDebugGroup();
}

void glwObjectLabel (GLenum identifier, GLuint name, GLsizei length, const GLchar* label)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->objectLabel(identifier, name, length, label);
}

void glwGetObjectLabel (GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getObjectLabel(identifier, name, bufSize, length, label);
}

void glwObjectPtrLabel (const void* ptr, GLsizei length, const GLchar* label)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->objectPtrLabel(ptr, length, label);
}

void glwGetObjectPtrLabel (const void* ptr, GLsizei bufSize, GLsizei* length, GLchar* label)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getObjectPtrLabel(ptr, bufSize, length, label);
}

void glwFramebufferParameteri (GLenum target, GLenum pname, GLint param)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->framebufferParameteri(target, pname, param);
}

void glwGetFramebufferParameteriv (GLenum target, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getFramebufferParameteriv(target, pname, params);
}

void glwGetInternalformati64v (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getInternalformati64v(target, internalformat, pname, bufSize, params);
}

void glwInvalidateTexSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->invalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
}

void glwInvalidateTexImage (GLuint texture, GLint level)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->invalidateTexImage(texture, level);
}

void glwInvalidateBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr length)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->invalidateBufferSubData(buffer, offset, length);
}

void glwInvalidateBufferData (GLuint buffer)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->invalidateBufferData(buffer);
}

void glwInvalidateFramebuffer (GLenum target, GLsizei numAttachments, const GLenum* attachments)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->invalidateFramebuffer(target, numAttachments, attachments);
}

void glwInvalidateSubFramebuffer (GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
}

void glwMultiDrawArraysIndirect (GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->multiDrawArraysIndirect(mode, indirect, drawcount, stride);
}

void glwMultiDrawElementsIndirect (GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->multiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
}

void glwGetProgramInterfaceiv (GLuint program, GLenum programInterface, GLenum pname, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getProgramInterfaceiv(program, programInterface, pname, params);
}

GLuint glwGetProgramResourceIndex (GLuint program, GLenum programInterface, const GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLuint)0;
	return gl->getProgramResourceIndex(program, programInterface, name);
}

void glwGetProgramResourceName (GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getProgramResourceName(program, programInterface, index, bufSize, length, name);
}

void glwGetProgramResourceiv (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->getProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
}

GLint glwGetProgramResourceLocation (GLuint program, GLenum programInterface, const GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLint)0;
	return gl->getProgramResourceLocation(program, programInterface, name);
}

GLint glwGetProgramResourceLocationIndex (GLuint program, GLenum programInterface, const GLchar* name)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return (GLint)0;
	return gl->getProgramResourceLocationIndex(program, programInterface, name);
}

void glwShaderStorageBlockBinding (GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->shaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
}

void glwTexBufferRange (GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texBufferRange(target, internalformat, buffer, offset, size);
}

void glwTexStorage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
}

void glwTexStorage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->texStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
}

void glwTextureView (GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->textureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
}

void glwBindVertexBuffer (GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindVertexBuffer(bindingindex, buffer, offset, stride);
}

void glwVertexAttribFormat (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
}

void glwVertexAttribIFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribIFormat(attribindex, size, type, relativeoffset);
}

void glwVertexAttribLFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribLFormat(attribindex, size, type, relativeoffset);
}

void glwVertexAttribBinding (GLuint attribindex, GLuint bindingindex)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexAttribBinding(attribindex, bindingindex);
}

void glwVertexBindingDivisor (GLuint bindingindex, GLuint divisor)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->vertexBindingDivisor(bindingindex, divisor);
}

void glwBufferStorage (GLenum target, GLsizeiptr size, const void* data, GLbitfield flags)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bufferStorage(target, size, data, flags);
}

void glwClearTexImage (GLuint texture, GLint level, GLenum format, GLenum type, const void* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clearTexImage(texture, level, format, type, data);
}

void glwClearTexSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* data)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->clearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
}

void glwBindBuffersBase (GLenum target, GLuint first, GLsizei count, const GLuint* buffers)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindBuffersBase(target, first, count, buffers);
}

void glwBindBuffersRange (GLenum target, GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets, const GLsizeiptr* sizes)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindBuffersRange(target, first, count, buffers, offsets, sizes);
}

void glwBindTextures (GLuint first, GLsizei count, const GLuint* textures)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindTextures(first, count, textures);
}

void glwBindSamplers (GLuint first, GLsizei count, const GLuint* samplers)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindSamplers(first, count, samplers);
}

void glwBindImageTextures (GLuint first, GLsizei count, const GLuint* textures)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindImageTextures(first, count, textures);
}

void glwBindVertexBuffers (GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets, const GLsizei* strides)
{
	const glw::Functions* gl = glw::getCurrentThreadFunctions();
	if (!gl)
		 return;
	gl->bindVertexBuffers(first, count, buffers, offsets, strides);
}