// SwiftShader Software Renderer
//
// Copyright(c) 2005-2013 TransGaming Inc.
//
// All rights reserved. No part of this software may be copied, distributed, transmitted,
// transcribed, stored in a retrieval system, translated into any human or computer
// language by any means, or disclosed to third parties without the explicit written
// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
// or implied, including but not limited to any patent rights, are granted to you.
//
// libGL.cpp: Implements the exported OpenGL functions.

#include "main.h"
#include "mathutil.h"
#include "utilities.h"
#include "Buffer.h"
#include "Context.h"
#include "Fence.h"
#include "Framebuffer.h"
#include "Program.h"
#include "Renderbuffer.h"
#include "Shader.h"
#include "Texture.h"
#include "Query.h"
#include "common/debug.h"
#include "Common/Version.h"
#include "Main/Register.hpp"

#define _GDI32_
#include <windows.h>
#include <GL/GL.h>
#include <GL/glext.h>
#include <csignal>

#include <limits>

static bool validImageSize(GLint level, GLsizei width, GLsizei height)
{
	if(level < 0 || level >= gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS || width < 0 || height < 0)
	{
		return false;
	}

	return true;
}

static bool validateSubImageParams(bool compressed, GLsizei width, GLsizei height, GLint xoffset, GLint yoffset, GLenum target, GLint level, GLenum format, gl::Texture *texture)
{
	if(!texture)
	{
		return error(GL_INVALID_OPERATION, false);
	}

	if(compressed != texture->isCompressed(target, level))
	{
		return error(GL_INVALID_OPERATION, false);
	}

	if(format != GL_NONE && (format != texture->getFormat(target, level) && target != GL_TEXTURE_1D))
	{
		return error(GL_INVALID_OPERATION, false);
	}

	if(compressed)
	{
		if((width % 4 != 0 && width != texture->getWidth(target, 0)) ||
		   (height % 4 != 0 && height != texture->getHeight(target, 0)))
		{
			return error(GL_INVALID_OPERATION, false);
		}
	}

	if(xoffset + width > texture->getWidth(target, level) ||
	   yoffset + height > texture->getHeight(target, level))
	{
		return error(GL_INVALID_VALUE, false);
	}

	return true;
}

// Check for combinations of format and type that are valid for ReadPixels
static bool validReadFormatType(GLenum format, GLenum type)
{
	switch(format)
	{
	case GL_RGBA:
		switch(type)
		{
		case GL_UNSIGNED_BYTE:
			break;
		default:
			return false;
		}
		break;
	case GL_BGRA_EXT:
		switch(type)
		{
		case GL_UNSIGNED_BYTE:
		case GL_UNSIGNED_SHORT_4_4_4_4_REV:
		case GL_UNSIGNED_SHORT_1_5_5_5_REV:
			break;
		default:
			return false;
		}
		break;
	case gl::IMPLEMENTATION_COLOR_READ_FORMAT:
		switch(type)
		{
		case gl::IMPLEMENTATION_COLOR_READ_TYPE:
			break;
		default:
			return false;
		}
		break;
	default:
		return false;
	}

	return true;
}

extern "C"
{

void APIENTRY glActiveTexture(GLenum texture)
{
	TRACE("(GLenum texture = 0x%X)", texture);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(texture < GL_TEXTURE0 || texture > GL_TEXTURE0 + gl::MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1)
		{
			return error(GL_INVALID_ENUM);
		}

		context->setActiveSampler(texture - GL_TEXTURE0);
	}
}

void APIENTRY glAttachShader(GLuint program, GLuint shader)
{
	TRACE("(GLuint program = %d, GLuint shader = %d)", program, shader);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Program *programObject = context->getProgram(program);
		gl::Shader *shaderObject = context->getShader(shader);

		if(!programObject)
		{
			if(context->getShader(program))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		if(!shaderObject)
		{
			if(context->getProgram(shader))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		if(!programObject->attachShader(shaderObject))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glBeginQueryEXT(GLenum target, GLuint name)
{
	TRACE("(GLenum target = 0x%X, GLuint name = %d)", target, name);

	switch(target)
	{
	case GL_ANY_SAMPLES_PASSED:
	case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	if(name == 0)
	{
		return error(GL_INVALID_OPERATION);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->beginQuery(target, name);
	}
}

void APIENTRY glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
{
	TRACE("(GLuint program = %d, GLuint index = %d, const GLchar* name = %s)", program, index, name);

	if(index >= gl::MAX_VERTEX_ATTRIBS)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Program *programObject = context->getProgram(program);

		if(!programObject)
		{
			if(context->getShader(program))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		if(strncmp(name, "gl_", 3) == 0)
		{
			return error(GL_INVALID_OPERATION);
		}

		programObject->bindAttributeLocation(index, name);
	}
}

void APIENTRY glBindBuffer(GLenum target, GLuint buffer)
{
	TRACE("(GLenum target = 0x%X, GLuint buffer = %d)", target, buffer);

	gl::Context *context = gl::getContext();

	if(context)
	{
		switch(target)
		{
		case GL_ARRAY_BUFFER:
			context->bindArrayBuffer(buffer);
			return;
		case GL_ELEMENT_ARRAY_BUFFER:
			context->bindElementArrayBuffer(buffer);
			return;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glBindFramebuffer(GLenum target, GLuint framebuffer)
{
	TRACE("(GLenum target = 0x%X, GLuint framebuffer = %d)", target, framebuffer);

	if(target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_EXT && target != GL_READ_FRAMEBUFFER_EXT)
	{
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(target == GL_READ_FRAMEBUFFER_EXT || target == GL_FRAMEBUFFER)
		{
			context->bindReadFramebuffer(framebuffer);
		}
			
		if(target == GL_DRAW_FRAMEBUFFER_EXT || target == GL_FRAMEBUFFER)
		{
			context->bindDrawFramebuffer(framebuffer);
		}
	}
}

void APIENTRY glBindRenderbuffer(GLenum target, GLuint renderbuffer)
{
	TRACE("(GLenum target = 0x%X, GLuint renderbuffer = %d)", target, renderbuffer);

	if(target != GL_RENDERBUFFER)
	{
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->bindRenderbuffer(renderbuffer);
	}
}

void APIENTRY glBindTexture(GLenum target, GLuint texture)
{
	TRACE("(GLenum target = 0x%X, GLuint texture = %d)", target, texture);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Texture *textureObject = context->getTexture(texture);

		if(textureObject && textureObject->getTarget() != target && texture != 0)
		{
			return error(GL_INVALID_OPERATION);
		}

		switch(target)
		{
		case GL_TEXTURE_1D:
			context->bindTexture1D(texture);
			return;
		case GL_TEXTURE_2D:
			context->bindTexture2D(texture);
			return;
		case GL_TEXTURE_RECTANGLE:
			/*if(!context->getRectangleTextureEnable())
			{
				return error(GL_INVALID_VALUE);
			}*/
			context->bindTexture2D(texture);
			return;
		case GL_TEXTURE_CUBE_MAP:
			context->bindTextureCubeMap(texture);
			return;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
	TRACE("(GLclampf red = %f, GLclampf green = %f, GLclampf blue = %f, GLclampf alpha = %f)",
		  red, green, blue, alpha);

	gl::Context* context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setBlendColor(gl::clamp01(red), gl::clamp01(green), gl::clamp01(blue), gl::clamp01(alpha));
	}
}

void APIENTRY glBlendEquation(GLenum mode)
{
	glBlendEquationSeparate(mode, mode);
}

void APIENTRY glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
{
	TRACE("(GLenum modeRGB = 0x%X, GLenum modeAlpha = 0x%X)", modeRGB, modeAlpha);

	switch(modeRGB)
	{
	case GL_FUNC_ADD:
	case GL_FUNC_SUBTRACT:
	case GL_FUNC_REVERSE_SUBTRACT:
	case GL_MIN_EXT:
	case GL_MAX_EXT:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	switch(modeAlpha)
	{
	case GL_FUNC_ADD:
	case GL_FUNC_SUBTRACT:
	case GL_FUNC_REVERSE_SUBTRACT:
	case GL_MIN_EXT:
	case GL_MAX_EXT:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setBlendEquation(modeRGB, modeAlpha);
	}
}

void APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor)
{
	glBlendFuncSeparate(sfactor, dfactor, sfactor, dfactor);
}

void APIENTRY glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
	TRACE("(GLenum srcRGB = 0x%X, GLenum dstRGB = 0x%X, GLenum srcAlpha = 0x%X, GLenum dstAlpha = 0x%X)",
	      srcRGB, dstRGB, srcAlpha, dstAlpha);

	switch(srcRGB)
	{
	case GL_ZERO:
	case GL_ONE:
	case GL_SRC_COLOR:
	case GL_ONE_MINUS_SRC_COLOR:
	case GL_DST_COLOR:
	case GL_ONE_MINUS_DST_COLOR:
	case GL_SRC_ALPHA:
	case GL_ONE_MINUS_SRC_ALPHA:
	case GL_DST_ALPHA:
	case GL_ONE_MINUS_DST_ALPHA:
	case GL_CONSTANT_COLOR:
	case GL_ONE_MINUS_CONSTANT_COLOR:
	case GL_CONSTANT_ALPHA:
	case GL_ONE_MINUS_CONSTANT_ALPHA:
	case GL_SRC_ALPHA_SATURATE:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	switch(dstRGB)
	{
	case GL_ZERO:
	case GL_ONE:
	case GL_SRC_COLOR:
	case GL_ONE_MINUS_SRC_COLOR:
	case GL_DST_COLOR:
	case GL_ONE_MINUS_DST_COLOR:
	case GL_SRC_ALPHA:
	case GL_ONE_MINUS_SRC_ALPHA:
	case GL_DST_ALPHA:
	case GL_ONE_MINUS_DST_ALPHA:
	case GL_CONSTANT_COLOR:
	case GL_ONE_MINUS_CONSTANT_COLOR:
	case GL_CONSTANT_ALPHA:
	case GL_ONE_MINUS_CONSTANT_ALPHA:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	switch(srcAlpha)
	{
	case GL_ZERO:
	case GL_ONE:
	case GL_SRC_COLOR:
	case GL_ONE_MINUS_SRC_COLOR:
	case GL_DST_COLOR:
	case GL_ONE_MINUS_DST_COLOR:
	case GL_SRC_ALPHA:
	case GL_ONE_MINUS_SRC_ALPHA:
	case GL_DST_ALPHA:
	case GL_ONE_MINUS_DST_ALPHA:
	case GL_CONSTANT_COLOR:
	case GL_ONE_MINUS_CONSTANT_COLOR:
	case GL_CONSTANT_ALPHA:
	case GL_ONE_MINUS_CONSTANT_ALPHA:
	case GL_SRC_ALPHA_SATURATE:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	switch(dstAlpha)
	{
	case GL_ZERO:
	case GL_ONE:
	case GL_SRC_COLOR:
	case GL_ONE_MINUS_SRC_COLOR:
	case GL_DST_COLOR:
	case GL_ONE_MINUS_DST_COLOR:
	case GL_SRC_ALPHA:
	case GL_ONE_MINUS_SRC_ALPHA:
	case GL_DST_ALPHA:
	case GL_ONE_MINUS_DST_ALPHA:
	case GL_CONSTANT_COLOR:
	case GL_ONE_MINUS_CONSTANT_COLOR:
	case GL_CONSTANT_ALPHA:
	case GL_ONE_MINUS_CONSTANT_ALPHA:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setBlendFactors(srcRGB, dstRGB, srcAlpha, dstAlpha);
	}
}

void APIENTRY glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
{
	TRACE("(GLenum target = 0x%X, GLsizeiptr size = %d, const GLvoid* data = %p, GLenum usage = %d)",
	      target, size, data, usage);

	if(size < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	switch(usage)
	{
	case GL_STREAM_DRAW:
	case GL_STATIC_DRAW:
	case GL_DYNAMIC_DRAW:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Buffer *buffer;

		switch(target)
		{
		case GL_ARRAY_BUFFER:
			buffer = context->getArrayBuffer();
			break;
		case GL_ELEMENT_ARRAY_BUFFER:
			buffer = context->getElementArrayBuffer();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		if(!buffer)
		{
			return error(GL_INVALID_OPERATION);
		}

		buffer->bufferData(data, size, usage);
	}
}

void APIENTRY glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
{
	TRACE("(GLenum target = 0x%X, GLintptr offset = %d, GLsizeiptr size = %d, const GLvoid* data = %p)",
	      target, offset, size, data);

	if(size < 0 || offset < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(data == NULL)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Buffer *buffer;

		switch(target)
		{
		case GL_ARRAY_BUFFER:
			buffer = context->getArrayBuffer();
			break;
		case GL_ELEMENT_ARRAY_BUFFER:
			buffer = context->getElementArrayBuffer();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		if(!buffer)
		{
			return error(GL_INVALID_OPERATION);
		}

		if((size_t)size + offset > buffer->size())
		{
			return error(GL_INVALID_VALUE);
		}

		buffer->bufferSubData(data, size, offset);
	}
}

GLenum APIENTRY glCheckFramebufferStatus(GLenum target)
{
	TRACE("(GLenum target = 0x%X)", target);

	if(target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_EXT && target != GL_READ_FRAMEBUFFER_EXT)
	{
		return error(GL_INVALID_ENUM, 0);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Framebuffer *framebuffer = NULL;
		if(target == GL_READ_FRAMEBUFFER_EXT)
		{
			framebuffer = context->getReadFramebuffer();
		}
		else
		{
			framebuffer = context->getDrawFramebuffer();
		}

		return framebuffer->completeness();
	}

	return 0;
}

void APIENTRY glClear(GLbitfield mask)
{
	TRACE("(GLbitfield mask = %X)", mask);

	if((mask & ~(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			return context->listCommand(gl::newCommand(glClear, mask));
		}

		context->clear(mask);
	}
}

void APIENTRY glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
	TRACE("(GLclampf red = %f, GLclampf green = %f, GLclampf blue = %f, GLclampf alpha = %f)",
	      red, green, blue, alpha);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setClearColor(red, green, blue, alpha);
	}
}

void APIENTRY glClearDepthf(GLclampf depth)
{
	TRACE("(GLclampf depth = %f)", depth);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setClearDepth(depth);
	}
}

void APIENTRY glVertexAttrib1dv(GLuint index, const GLdouble *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib1sv(GLuint index, const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib2dv(GLuint index, const GLdouble *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}

void APIENTRY glVertexAttrib2sv(GLuint index, const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib3dv(GLuint index, const GLdouble *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib3sv(GLuint index, const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib4Niv(GLuint index, const GLint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib4Nsv(GLuint index, const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib4Nusv(GLuint index, const GLushort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glFogCoordfv(const GLfloat *coord)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glFogCoorddv(const GLdouble *coord)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3bv(const GLbyte *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3dv(const GLdouble *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3fv(const GLfloat *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3i(GLint red, GLint green, GLint blue)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3iv(const GLint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3sv(const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3ubv(const GLubyte *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3uiv(const GLuint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3usv(const GLushort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glWindowPos2dv(const GLdouble *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glWindowPos2fv(const GLfloat *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glWindowPos2iv(const GLint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glWindowPos2s(GLshort x, GLshort y)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glWindowPos2sv(const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glWindowPos3dv(const GLdouble *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glWindowPos3fv(const GLfloat *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glWindowPos3iv(const GLint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glWindowPos3s(GLshort x, GLshort y, GLshort z)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glWindowPos3sv(const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord1dv(GLenum target, const GLdouble *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord1fv(GLenum target, const GLfloat *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord1i(GLenum target, GLint s)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord1iv(GLenum target, const GLint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord1s(GLenum target, GLshort s)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord1sv(GLenum target, const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord2dv(GLenum target, const GLdouble *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord2fv(GLenum target, const GLfloat *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord2i(GLenum target, GLint s, GLint t)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord2iv(GLenum target, const GLint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord2sv(GLenum target, const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord3dv(GLenum target, const GLdouble *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord3fv(GLenum target, const GLfloat *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord3iv(GLenum target, const GLint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord3sv(GLenum target, const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord4dv(GLenum target, const GLdouble *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord4fv(GLenum target, const GLfloat *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord4iv(GLenum target, const GLint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glMultiTexCoord4sv(GLenum target, const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glBlendEquationEXT(GLenum mode)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3bvEXT(const GLbyte *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3dvEXT(const GLdouble *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3fvEXT(const GLfloat *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3ivEXT(const GLint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3svEXT(const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3ubvEXT(const GLubyte *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3uivEXT(const GLuint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColor3usvEXT(const GLushort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const void *pointer)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
	TRACE("*");
	UNIMPLEMENTED();
}


void APIENTRY glClearStencil(GLint s)
{
	TRACE("(GLint s = %d)", s);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setClearStencil(s);
	}
}

void APIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
	TRACE("(GLboolean red = %d, GLboolean green = %d, GLboolean blue = %d, GLboolean alpha = %d)",
	      red, green, blue, alpha);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setColorMask(red == GL_TRUE, green == GL_TRUE, blue == GL_TRUE, alpha == GL_TRUE);
	}
}

void APIENTRY glCompileShader(GLuint shader)
{
	TRACE("(GLuint shader = %d)", shader);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Shader *shaderObject = context->getShader(shader);

		if(!shaderObject)
		{
			if(context->getProgram(shader))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		shaderObject->compile();
	}
}

void APIENTRY glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
                                        GLint border, GLsizei imageSize, const GLvoid* data)
{
	TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = %d, "
	      "GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, const GLvoid* data = %p)",
	      target, level, internalformat, width, height, border, imageSize, data);

	if(!validImageSize(level, width, height) || border != 0 || imageSize < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	switch(internalformat)
	{
	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
	case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
	case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
	case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
		if(!S3TC_SUPPORT)
		{
			return error(GL_INVALID_ENUM);
		}
		break;
	case GL_DEPTH_COMPONENT:
	case GL_DEPTH_COMPONENT16:
	case GL_DEPTH_COMPONENT32:
	case GL_DEPTH_STENCIL_EXT:
	case GL_DEPTH24_STENCIL8_EXT:
		return error(GL_INVALID_OPERATION);
	default:
		return error(GL_INVALID_ENUM);
	}

	if(border != 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(level > gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
		{
			return error(GL_INVALID_VALUE);
		}

		switch(target)
		{
		case GL_TEXTURE_2D:
			if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
			   height > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level))
			{
				return error(GL_INVALID_VALUE);
			}
			break;
		case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
		case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
		case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
		case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
		case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
		case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
			if(width != height)
			{
				return error(GL_INVALID_VALUE);
			}

			if(width > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level) ||
			   height > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))
			{
				return error(GL_INVALID_VALUE);
			}
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		if(imageSize != gl::ComputeCompressedSize(width, height, internalformat))
		{
			return error(GL_INVALID_VALUE);
		}

		if(target == GL_TEXTURE_2D)
		{
			gl::Texture2D *texture = context->getTexture2D(target);

			if(!texture)
			{
				return error(GL_INVALID_OPERATION);
			}

			texture->setCompressedImage(level, internalformat, width, height, imageSize, data);
		}
		else
		{
			gl::TextureCubeMap *texture = context->getTextureCubeMap();

			if(!texture)
			{
				return error(GL_INVALID_OPERATION);
			}

			switch(target)
			{
			case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
			case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
			case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
			case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
			case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
			case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
				texture->setCompressedImage(target, level, internalformat, width, height, imageSize, data);
				break;
			default: UNREACHABLE();
			}
		}
	}
}

void APIENTRY glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
                                           GLenum format, GLsizei imageSize, const GLvoid* data)
{
	TRACE("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
	      "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, "
	      "GLsizei imageSize = %d, const GLvoid* data = %p)",
	      target, level, xoffset, yoffset, width, height, format, imageSize, data);

	if(!gl::IsTextureTarget(target))
	{
		return error(GL_INVALID_ENUM);
	}

	if(xoffset < 0 || yoffset < 0 || !validImageSize(level, width, height) || imageSize < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	switch(format)
	{
	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
	case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
	case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
	case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
		if(!S3TC_SUPPORT)
		{
			return error(GL_INVALID_ENUM);
		}
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	if(width == 0 || height == 0 || data == NULL)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(level > gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
		{
			return error(GL_INVALID_VALUE);
		}

		if(imageSize != gl::ComputeCompressedSize(width, height, format))
		{
			return error(GL_INVALID_VALUE);
		}

		if(xoffset % 4 != 0 || yoffset % 4 != 0)
		{
			// We wait to check the offsets until this point, because the multiple-of-four restriction does not exist unless DXT1 textures are supported
			return error(GL_INVALID_OPERATION);
		}

		if(target == GL_TEXTURE_2D)
		{
			gl::Texture2D *texture = context->getTexture2D(target);

			if(validateSubImageParams(true, width, height, xoffset, yoffset, target, level, format, texture))
			{
				texture->subImageCompressed(level, xoffset, yoffset, width, height, format, imageSize, data);
			}
		}
		else if(gl::IsCubemapTextureTarget(target))
		{
			gl::TextureCubeMap *texture = context->getTextureCubeMap();

			if(validateSubImageParams(true, width, height, xoffset, yoffset, target, level, format, texture))
			{
				texture->subImageCompressed(target, level, xoffset, yoffset, width, height, format, imageSize, data);
			}
		}
		else
		{
			UNREACHABLE();
		}
	}
}

void APIENTRY glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
	TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, "
	      "GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLint border = %d)",
	      target, level, internalformat, x, y, width, height, border);

	if(!validImageSize(level, width, height))
	{
		return error(GL_INVALID_VALUE);
	}

	if(border != 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		switch(target)
		{
		case GL_TEXTURE_2D:
			if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
			   height > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level))
			{
				return error(GL_INVALID_VALUE);
			}
			break;
		case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
		case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
		case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
		case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
		case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
		case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
			if(width != height)
			{
				return error(GL_INVALID_VALUE);
			}

			if(width > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level) ||
			   height > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))
			{
				return error(GL_INVALID_VALUE);
			}
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		gl::Framebuffer *framebuffer = context->getReadFramebuffer();

		if(framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
		{
			return error(GL_INVALID_FRAMEBUFFER_OPERATION);
		}

		if(context->getReadFramebufferName() != 0 && framebuffer->getColorbuffer()->getSamples() > 1)
		{
			return error(GL_INVALID_OPERATION);
		}

		gl::Renderbuffer *source = framebuffer->getColorbuffer();
		GLenum colorbufferFormat = source->getFormat();

		switch(internalformat)
		{
		case GL_ALPHA:
			if(colorbufferFormat != GL_ALPHA &&
			   colorbufferFormat != GL_RGBA &&
			   colorbufferFormat != GL_RGBA4 &&
			   colorbufferFormat != GL_RGB5_A1 &&
			   colorbufferFormat != GL_RGBA8_EXT)
			{
				return error(GL_INVALID_OPERATION);
			}
			break;
		case GL_LUMINANCE:
		case GL_RGB:
			if(colorbufferFormat != GL_RGB &&
			   colorbufferFormat != GL_RGB565 &&
			   colorbufferFormat != GL_RGB8_EXT &&
			   colorbufferFormat != GL_RGBA &&
			   colorbufferFormat != GL_RGBA4 &&
			   colorbufferFormat != GL_RGB5_A1 &&
			   colorbufferFormat != GL_RGBA8_EXT)
			{
				return error(GL_INVALID_OPERATION);
			}
			break;
		case GL_LUMINANCE_ALPHA:
		case GL_RGBA:
			if(colorbufferFormat != GL_RGBA &&
			   colorbufferFormat != GL_RGBA4 &&
			   colorbufferFormat != GL_RGB5_A1 &&
			   colorbufferFormat != GL_RGBA8_EXT)
			{
				return error(GL_INVALID_OPERATION);
			}
			break;
		case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
		case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
		case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
		case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
			if(S3TC_SUPPORT)
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_ENUM);
			}
		default:
			return error(GL_INVALID_ENUM);
		}

		if(target == GL_TEXTURE_2D)
		{
			gl::Texture2D *texture = context->getTexture2D(target);

			if(!texture)
			{
				return error(GL_INVALID_OPERATION);
			}

			texture->copyImage(level, internalformat, x, y, width, height, framebuffer);
		}
		else if(gl::IsCubemapTextureTarget(target))
		{
			gl::TextureCubeMap *texture = context->getTextureCubeMap();

			if(!texture)
			{
				return error(GL_INVALID_OPERATION);
			}

			texture->copyImage(target, level, internalformat, x, y, width, height, framebuffer);
		}
		else UNREACHABLE();
	}
}

void APIENTRY glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	TRACE("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
	      "GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
	      target, level, xoffset, yoffset, x, y, width, height);

	if(!gl::IsTextureTarget(target))
	{
		return error(GL_INVALID_ENUM);
	}

	if(level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
	{
		return error(GL_INVALID_VALUE);
	}

	if(width == 0 || height == 0)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(level > gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
		{
			return error(GL_INVALID_VALUE);
		}

		gl::Framebuffer *framebuffer = context->getReadFramebuffer();

		if(framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
		{
			return error(GL_INVALID_FRAMEBUFFER_OPERATION);
		}

		if(context->getReadFramebufferName() != 0 && framebuffer->getColorbuffer()->getSamples() > 1)
		{
			return error(GL_INVALID_OPERATION);
		}

		gl::Renderbuffer *source = framebuffer->getColorbuffer();
		GLenum colorbufferFormat = source->getFormat();
		gl::Texture *texture = NULL;

		if(target == GL_TEXTURE_2D)
		{
			texture = context->getTexture2D(target);
		}
		else if(gl::IsCubemapTextureTarget(target))
		{
			texture = context->getTextureCubeMap();
		}
		else UNREACHABLE();

		if(!validateSubImageParams(false, width, height, xoffset, yoffset, target, level, GL_NONE, texture))
		{
			return;
		}

		GLenum textureFormat = texture->getFormat(target, level);

		switch(textureFormat)
		{
		case GL_ALPHA:
			if(colorbufferFormat != GL_ALPHA &&
			   colorbufferFormat != GL_RGBA &&
			   colorbufferFormat != GL_RGBA4 &&
			   colorbufferFormat != GL_RGB5_A1 &&
			   colorbufferFormat != GL_RGBA8_EXT)
			{
				return error(GL_INVALID_OPERATION);
			}
			break;
		case GL_LUMINANCE:
		case GL_RGB:
			if(colorbufferFormat != GL_RGB &&
			   colorbufferFormat != GL_RGB565 &&
			   colorbufferFormat != GL_RGB8_EXT &&
			   colorbufferFormat != GL_RGBA &&
			   colorbufferFormat != GL_RGBA4 &&
			   colorbufferFormat != GL_RGB5_A1 &&
			   colorbufferFormat != GL_RGBA8_EXT)
			{
				return error(GL_INVALID_OPERATION);
			}
			break;
		case GL_LUMINANCE_ALPHA:
		case GL_RGBA:
			if(colorbufferFormat != GL_RGBA &&
			   colorbufferFormat != GL_RGBA4 &&
			   colorbufferFormat != GL_RGB5_A1 &&
			   colorbufferFormat != GL_RGBA8_EXT)
			{
				return error(GL_INVALID_OPERATION);
			}
			break;
		case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
		case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
		case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
		case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
			return error(GL_INVALID_OPERATION);
		case GL_DEPTH_COMPONENT:
		case GL_DEPTH_STENCIL_EXT:
			return error(GL_INVALID_OPERATION);
		case GL_BGRA_EXT:
			if(colorbufferFormat != GL_RGB8)
			{
				UNIMPLEMENTED();
				return error(GL_INVALID_OPERATION);
			}
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		texture->copySubImage(target, level, xoffset, yoffset, x, y, width, height, framebuffer);
	}
}

GLuint APIENTRY glCreateProgram(void)
{
	TRACE("()");

	gl::Context *context = gl::getContext();

	if(context)
	{
		return context->createProgram();
	}

	return 0;
}

GLuint APIENTRY glCreateShader(GLenum type)
{
	TRACE("(GLenum type = 0x%X)", type);

	gl::Context *context = gl::getContext();

	if(context)
	{
		switch(type)
		{
		case GL_FRAGMENT_SHADER:
		case GL_VERTEX_SHADER:
			return context->createShader(type);
		default:
			return error(GL_INVALID_ENUM, 0);
		}
	}

	return 0;
}

void APIENTRY glCullFace(GLenum mode)
{
	TRACE("(GLenum mode = 0x%X)", mode);

	switch(mode)
	{
	case GL_FRONT:
	case GL_BACK:
	case GL_FRONT_AND_BACK:
		{
			gl::Context *context = gl::getContext();

			if(context)
			{
				context->setCullMode(mode);
			}
		}
		break;
	default:
		return error(GL_INVALID_ENUM);
	}
}

void APIENTRY glDeleteBuffers(GLsizei n, const GLuint* buffers)
{
	TRACE("(GLsizei n = %d, const GLuint* buffers = %p)", n, buffers);

	if(n < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		for(int i = 0; i < n; i++)
		{
			context->deleteBuffer(buffers[i]);
		}
	}
}

void APIENTRY glDeleteFencesNV(GLsizei n, const GLuint* fences)
{
	TRACE("(GLsizei n = %d, const GLuint* fences = %p)", n, fences);

	if(n < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		for(int i = 0; i < n; i++)
		{
			context->deleteFence(fences[i]);
		}
	}
}

void APIENTRY glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
{
	TRACE("(GLsizei n = %d, const GLuint* framebuffers = %p)", n, framebuffers);

	if(n < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		for(int i = 0; i < n; i++)
		{
			if(framebuffers[i] != 0)
			{
				context->deleteFramebuffer(framebuffers[i]);
			}
		}
	}
}

void APIENTRY glDeleteProgram(GLuint program)
{
	TRACE("(GLuint program = %d)", program);

	if(program == 0)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(!context->getProgram(program))
		{
			if(context->getShader(program))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		context->deleteProgram(program);
	}
}

void APIENTRY glDeleteQueriesEXT(GLsizei n, const GLuint *ids)
{
	TRACE("(GLsizei n = %d, const GLuint *ids = %p)", n, ids);

	if(n < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		for(int i = 0; i < n; i++)
		{
			context->deleteQuery(ids[i]);
		}
	}
}

void APIENTRY glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
{
	TRACE("(GLsizei n = %d, const GLuint* renderbuffers = %p)", n, renderbuffers);

	if(n < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		for(int i = 0; i < n; i++)
		{
			context->deleteRenderbuffer(renderbuffers[i]);
		}
	}
}

void APIENTRY glDeleteShader(GLuint shader)
{
	TRACE("(GLuint shader = %d)", shader);

	if(shader == 0)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(!context->getShader(shader))
		{
			if(context->getProgram(shader))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		context->deleteShader(shader);
	}
}

void APIENTRY glDeleteTextures(GLsizei n, const GLuint* textures)
{
	TRACE("(GLsizei n = %d, const GLuint* textures = %p)", n, textures);

	if(n < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		for(int i = 0; i < n; i++)
		{
			if(textures[i] != 0)
			{
				context->deleteTexture(textures[i]);
			}
		}
	}
}

void APIENTRY glDepthFunc(GLenum func)
{
	TRACE("(GLenum func = 0x%X)", func);

	switch(func)
	{
	case GL_NEVER:
	case GL_ALWAYS:
	case GL_LESS:
	case GL_LEQUAL:
	case GL_EQUAL:
	case GL_GREATER:
	case GL_GEQUAL:
	case GL_NOTEQUAL:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setDepthFunc(func);
	}
}

void APIENTRY glDepthMask(GLboolean flag)
{
	TRACE("(GLboolean flag = %d)", flag);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setDepthMask(flag != GL_FALSE);
	}
}

void APIENTRY glDepthRangef(GLclampf zNear, GLclampf zFar)
{
	TRACE("(GLclampf zNear = %f, GLclampf zFar = %f)", zNear, zFar);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setDepthRange(zNear, zFar);
	}
}

void APIENTRY glDetachShader(GLuint program, GLuint shader)
{
	TRACE("(GLuint program = %d, GLuint shader = %d)", program, shader);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Program *programObject = context->getProgram(program);
		gl::Shader *shaderObject = context->getShader(shader);

		if(!programObject)
		{
			gl::Shader *shaderByProgramHandle;
			shaderByProgramHandle = context->getShader(program);
			if(!shaderByProgramHandle)
			{
				return error(GL_INVALID_VALUE);
			}
			else
			{
				return error(GL_INVALID_OPERATION);
			}
		}

		if(!shaderObject)
		{
			gl::Program *programByShaderHandle = context->getProgram(shader);
			if(!programByShaderHandle)
			{
				return error(GL_INVALID_VALUE);
			}
			else
			{
				return error(GL_INVALID_OPERATION);
			}
		}

		if(!programObject->detachShader(shaderObject))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glDisable(GLenum cap)
{
	TRACE("(GLenum cap = 0x%X)", cap);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		switch(cap)
		{
		case GL_CULL_FACE:                context->setCullFace(false);					break;
		case GL_POLYGON_OFFSET_FILL:      context->setPolygonOffsetFill(false);			break;
		case GL_SAMPLE_ALPHA_TO_COVERAGE: context->setSampleAlphaToCoverage(false);		break;
		case GL_SAMPLE_COVERAGE:          context->setSampleCoverage(false);			break;
		case GL_SCISSOR_TEST:             context->setScissorTest(false);				break;
		case GL_STENCIL_TEST:             context->setStencilTest(false);				break;
		case GL_DEPTH_TEST:               context->setDepthTest(false);					break;
		case GL_BLEND:                    context->setBlend(false);						break;
		case GL_DITHER:                   context->setDither(false);					break;
		case GL_LIGHTING:                 context->setLighting(false);					break;
		case GL_FOG:                      context->setFog(false);						break;
		case GL_ALPHA_TEST:               context->setAlphaTest(false);					break;
		case GL_TEXTURE_2D:               context->setTexture2D(false);					break;
		case GL_LIGHT0:                   context->setLight(0, false);					break;
		case GL_LIGHT1:                   context->setLight(1, false);					break;
		case GL_LIGHT2:                   context->setLight(2, false);					break;
		case GL_LIGHT3:                   context->setLight(3, false);					break;
		case GL_LIGHT4:                   context->setLight(4, false);					break;
		case GL_LIGHT5:                   context->setLight(5, false);					break;
		case GL_LIGHT6:                   context->setLight(6, false);					break;
		case GL_LIGHT7:                   context->setLight(7, false);					break;
		case GL_COLOR_MATERIAL:           context->setColorMaterial(false);				break;
		case GL_RESCALE_NORMAL:           context->setNormalizeNormals(false);			break;
		case GL_TEXTURE_RECTANGLE:		  context->setRectangleTextureEnable(false);	break;
		case GL_TEXTURE_1D:				  context->set1DTextureEnable(false);			break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glDisableVertexAttribArray(GLuint index)
{
	TRACE("(GLuint index = %d)", index);

	if(index >= gl::MAX_VERTEX_ATTRIBS)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		context->setEnableVertexAttribArray(index, false);
	}
}

void APIENTRY glCaptureAttribs()
{
	TRACE("()");

	gl::Context *context = gl::getContext();

	if(context)
	{
		context->captureAttribs();
	}
}

void APIENTRY glRestoreAttribs()
{
	TRACE("()");

	gl::Context *context = gl::getContext();

	if(context)
	{
		context->restoreAttribs();
	}
}

void APIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count)
{
	TRACE("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d)", mode, first, count);

	if(count < 0 || first < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			ASSERT(context->getListMode() != GL_COMPILE_AND_EXECUTE);   // UNIMPLEMENTED!

			context->listCommand(gl::newCommand(glCaptureAttribs));
			context->captureDrawArrays(mode, first, count);
			context->listCommand(gl::newCommand(glDrawArrays, mode, first, count));
			context->listCommand(gl::newCommand(glRestoreAttribs));

			return;
		}

		context->drawArrays(mode, first, count);
	}
}

void APIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
{
	TRACE("(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const GLvoid* indices = %p)",
	      mode, count, type, indices);

	if(count < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		switch(type)
		{
		case GL_UNSIGNED_BYTE:
		case GL_UNSIGNED_SHORT:
		case GL_UNSIGNED_INT:
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		context->drawElements(mode, count, type, indices);
	}
}

void APIENTRY glEnable(GLenum cap)
{
	TRACE("(GLenum cap = 0x%X)", cap);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		switch(cap)
		{
		case GL_CULL_FACE:                context->setCullFace(true);              break;
		case GL_POLYGON_OFFSET_FILL:      context->setPolygonOffsetFill(true);     break;
		case GL_SAMPLE_ALPHA_TO_COVERAGE: context->setSampleAlphaToCoverage(true); break;
		case GL_SAMPLE_COVERAGE:          context->setSampleCoverage(true);        break;
		case GL_SCISSOR_TEST:             context->setScissorTest(true);           break;
		case GL_STENCIL_TEST:             context->setStencilTest(true);           break;
		case GL_DEPTH_TEST:               context->setDepthTest(true);             break;
		case GL_BLEND:                    context->setBlend(true);                 break;
		case GL_DITHER:                   context->setDither(true);                break;
		case GL_TEXTURE_2D:               context->setTexture2D(true);             break;
		case GL_ALPHA_TEST:               context->setAlphaTest(true);             break;
		case GL_COLOR_MATERIAL:           context->setColorMaterial(true);         break;
		case GL_FOG:                      context->setFog(true);                   break;
		case GL_LIGHTING:                 context->setLighting(true);              break;
		case GL_LIGHT0:                   context->setLight(0, true);              break;
		case GL_LIGHT1:                   context->setLight(1, true);              break;
		case GL_LIGHT2:                   context->setLight(2, true);              break;
		case GL_LIGHT3:                   context->setLight(3, true);              break;
		case GL_LIGHT4:                   context->setLight(4, true);              break;
		case GL_LIGHT5:                   context->setLight(5, true);              break;
		case GL_LIGHT6:                   context->setLight(6, true);              break;
		case GL_LIGHT7:                   context->setLight(7, true);              break;
		case GL_RESCALE_NORMAL:           context->setNormalizeNormals(true);      break;
		case GL_TEXTURE_RECTANGLE:		  context->setRectangleTextureEnable(true);break;
		case GL_TEXTURE_1D:				  context->set1DTextureEnable(true);	   break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glEnableVertexAttribArray(GLuint index)
{
	TRACE("(GLuint index = %d)", index);

	if(index >= gl::MAX_VERTEX_ATTRIBS)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		context->setEnableVertexAttribArray(index, true);
	}
}

void APIENTRY glEndQueryEXT(GLenum target)
{
	TRACE("GLenum target = 0x%X)", target);

	switch(target)
	{
	case GL_ANY_SAMPLES_PASSED:
	case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->endQuery(target);
	}
}

void APIENTRY glFinishFenceNV(GLuint fence)
{
	TRACE("(GLuint fence = %d)", fence);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Fence* fenceObject = context->getFence(fence);

		if(fenceObject == NULL)
		{
			return error(GL_INVALID_OPERATION);
		}

		fenceObject->finishFence();
	}
}

void APIENTRY glFinish(void)
{
	TRACE("()");

	gl::Context *context = gl::getContext();

	if(context)
	{
		context->finish();
	}
}

void APIENTRY glFlush(void)
{
	TRACE("()");

	gl::Context *context = gl::getContext();

	if(context)
	{
		context->flush();
	}
}

void APIENTRY glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
	TRACE("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum renderbuffertarget = 0x%X, "
	      "GLuint renderbuffer = %d)", target, attachment, renderbuffertarget, renderbuffer);

	if((target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_EXT && target != GL_READ_FRAMEBUFFER_EXT) ||
	   (renderbuffertarget != GL_RENDERBUFFER && renderbuffer != 0))
	{
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Framebuffer *framebuffer = NULL;
		GLuint framebufferName = 0;
		if(target == GL_READ_FRAMEBUFFER_EXT)
		{
			framebuffer = context->getReadFramebuffer();
			framebufferName = context->getReadFramebufferName();
		}
		else
		{
			framebuffer = context->getDrawFramebuffer();
			framebufferName = context->getDrawFramebufferName();
		}

		if(!framebuffer || (framebufferName == 0 && renderbuffer != 0))
		{
			return error(GL_INVALID_OPERATION);
		}

		switch(attachment)
		{
		case GL_COLOR_ATTACHMENT0:
			framebuffer->setColorbuffer(GL_RENDERBUFFER, renderbuffer);
			break;
		case GL_DEPTH_ATTACHMENT:
			framebuffer->setDepthbuffer(GL_RENDERBUFFER, renderbuffer);
			break;
		case GL_STENCIL_ATTACHMENT:
			framebuffer->setStencilbuffer(GL_RENDERBUFFER, renderbuffer);
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
	UNIMPLEMENTED();
}

void APIENTRY glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
	TRACE("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum textarget = 0x%X, "
	      "GLuint texture = %d, GLint level = %d)", target, attachment, textarget, texture, level);

	if(target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_EXT && target != GL_READ_FRAMEBUFFER_EXT)
	{
		return error(GL_INVALID_ENUM);
	}

	switch(attachment)
	{
	case GL_COLOR_ATTACHMENT0:
	case GL_DEPTH_ATTACHMENT:
	case GL_STENCIL_ATTACHMENT:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(texture == 0)
		{
			textarget = GL_NONE;
		}
		else
		{
			gl::Texture *tex = context->getTexture(texture);

			if(tex == NULL)
			{
				return error(GL_INVALID_OPERATION);
			}

			if(tex->isCompressed(textarget, level))
			{
				return error(GL_INVALID_OPERATION);
			}

			switch(textarget)
			{
			case GL_TEXTURE_2D:
				if(tex->getTarget() != GL_TEXTURE_2D)
				{
					return error(GL_INVALID_OPERATION);
				}
				break;
			case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
			case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
			case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
			case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
			case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
			case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
				if(tex->getTarget() != GL_TEXTURE_CUBE_MAP)
				{
					return error(GL_INVALID_OPERATION);
				}
				break;
			default:
				return error(GL_INVALID_ENUM);
			}

			if(level != 0)
			{
				return error(GL_INVALID_VALUE);
			}
		}

		gl::Framebuffer *framebuffer = NULL;
		GLuint framebufferName = 0;
		if(target == GL_READ_FRAMEBUFFER_EXT)
		{
			framebuffer = context->getReadFramebuffer();
			framebufferName = context->getReadFramebufferName();
		}
		else
		{
			framebuffer = context->getDrawFramebuffer();
			framebufferName = context->getDrawFramebufferName();
		}

		if(framebufferName == 0 || !framebuffer)
		{
			return error(GL_INVALID_OPERATION);
		}

		switch(attachment)
		{
		case GL_COLOR_ATTACHMENT0:  framebuffer->setColorbuffer(textarget, texture);   break;
		case GL_DEPTH_ATTACHMENT:   framebuffer->setDepthbuffer(textarget, texture);   break;
		case GL_STENCIL_ATTACHMENT: framebuffer->setStencilbuffer(textarget, texture); break;
		}
	}
}

void APIENTRY glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
{
	UNIMPLEMENTED();
}

void APIENTRY glFrontFace(GLenum mode)
{
	TRACE("(GLenum mode = 0x%X)", mode);

	switch(mode)
	{
	case GL_CW:
	case GL_CCW:
		{
			gl::Context *context = gl::getContext();

			if(context)
			{
				context->setFrontFace(mode);
			}
		}
		break;
	default:
		return error(GL_INVALID_ENUM);
	}
}

void APIENTRY glGenBuffers(GLsizei n, GLuint* buffers)
{
	TRACE("(GLsizei n = %d, GLuint* buffers = %p)", n, buffers);

	if(n < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		for(int i = 0; i < n; i++)
		{
			buffers[i] = context->createBuffer();
		}
	}
}

void APIENTRY glGenerateMipmap(GLenum target)
{
	TRACE("(GLenum target = 0x%X)", target);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Texture *texture;

		switch(target)
		{
		case GL_TEXTURE_2D:
			texture = context->getTexture2D(target);
			break;
		case GL_TEXTURE_CUBE_MAP:
			texture = context->getTextureCubeMap();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		if(texture->isCompressed(target, 0) || texture->isDepth(target, 0))
		{
			return error(GL_INVALID_OPERATION);
		}

		texture->generateMipmaps();
	}
}

void APIENTRY glGenFencesNV(GLsizei n, GLuint* fences)
{
	TRACE("(GLsizei n = %d, GLuint* fences = %p)", n, fences);

	if(n < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		for(int i = 0; i < n; i++)
		{
			fences[i] = context->createFence();
		}
	}
}

void APIENTRY glGenFramebuffers(GLsizei n, GLuint* framebuffers)
{
	TRACE("(GLsizei n = %d, GLuint* framebuffers = %p)", n, framebuffers);

	if(n < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		for(int i = 0; i < n; i++)
		{
			framebuffers[i] = context->createFramebuffer();
		}
	}
}

void APIENTRY glGenQueriesEXT(GLsizei n, GLuint* ids)
{
	TRACE("(GLsizei n = %d, GLuint* ids = %p)", n, ids);

	if(n < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		for(int i = 0; i < n; i++)
		{
			ids[i] = context->createQuery();
		}
	}
}

void APIENTRY glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
{
	TRACE("(GLsizei n = %d, GLuint* renderbuffers = %p)", n, renderbuffers);

	if(n < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		for(int i = 0; i < n; i++)
		{
			renderbuffers[i] = context->createRenderbuffer();
		}
	}
}

void APIENTRY glGenTextures(GLsizei n, GLuint* textures)
{
	TRACE("(GLsizei n = %d, GLuint* textures = %p)", n, textures);

	if(n < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		for(int i = 0; i < n; i++)
		{
			textures[i] = context->createTexture();
		}
	}
}

void APIENTRY glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
{
	TRACE("(GLuint program = %d, GLuint index = %d, GLsizei bufsize = %d, GLsizei *length = %p, "
	      "GLint *size = %p, GLenum *type = %p, GLchar *name = %p)",
	      program, index, bufsize, length, size, type, name);

	if(bufsize < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Program *programObject = context->getProgram(program);

		if(!programObject)
		{
			if(context->getShader(program))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		if(index >= (GLuint)programObject->getActiveAttributeCount())
		{
			return error(GL_INVALID_VALUE);
		}

		programObject->getActiveAttribute(index, bufsize, length, size, type, name);
	}
}

void APIENTRY glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
{
	TRACE("(GLuint program = %d, GLuint index = %d, GLsizei bufsize = %d, "
	      "GLsizei* length = %p, GLint* size = %p, GLenum* type = %p, GLchar* name = %s)",
	      program, index, bufsize, length, size, type, name);

	if(bufsize < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Program *programObject = context->getProgram(program);

		if(!programObject)
		{
			if(context->getShader(program))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		if(index >= (GLuint)programObject->getActiveUniformCount())
		{
			return error(GL_INVALID_VALUE);
		}

		programObject->getActiveUniform(index, bufsize, length, size, type, name);
	}
}

void APIENTRY glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
{
	TRACE("(GLuint program = %d, GLsizei maxcount = %d, GLsizei* count = %p, GLuint* shaders = %p)",
	      program, maxcount, count, shaders);

	if(maxcount < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Program *programObject = context->getProgram(program);

		if(!programObject)
		{
			if(context->getShader(program))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		return programObject->getAttachedShaders(maxcount, count, shaders);
	}
}

int APIENTRY glGetAttribLocation(GLuint program, const GLchar* name)
{
	TRACE("(GLuint program = %d, const GLchar* name = %s)", program, name);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Program *programObject = context->getProgram(program);

		if(!programObject)
		{
			if(context->getShader(program))
			{
				return error(GL_INVALID_OPERATION, -1);
			}
			else
			{
				return error(GL_INVALID_VALUE, -1);
			}
		}

		if(!programObject->isLinked())
		{
			return error(GL_INVALID_OPERATION, -1);
		}

		return programObject->getAttributeLocation(name);
	}

	return -1;
}

void APIENTRY glGetBooleanv(GLenum pname, GLboolean* params)
{
	TRACE("(GLenum pname = 0x%X, GLboolean* params = %p)",  pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(!(context->getBooleanv(pname, params)))
		{
			GLenum nativeType;
			unsigned int numParams = 0;
			if(!context->getQueryParameterInfo(pname, &nativeType, &numParams))
				return error(GL_INVALID_ENUM);

			if(numParams == 0)
				return; // it is known that the pname is valid, but there are no parameters to return

			if(nativeType == GL_FLOAT)
			{
				GLfloat *floatParams = NULL;
				floatParams = new GLfloat[numParams];

				context->getFloatv(pname, floatParams);

				for(unsigned int i = 0; i < numParams; ++i)
				{
					if(floatParams[i] == 0.0f)
						params[i] = GL_FALSE;
					else
						params[i] = GL_TRUE;
				}

				delete [] floatParams;
			}
			else if(nativeType == GL_INT)
			{
				GLint *intParams = NULL;
				intParams = new GLint[numParams];

				context->getIntegerv(pname, intParams);

				for(unsigned int i = 0; i < numParams; ++i)
				{
					if(intParams[i] == 0)
						params[i] = GL_FALSE;
					else
						params[i] = GL_TRUE;
				}

				delete [] intParams;
			}
		}
	}
}

void APIENTRY glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
{
	TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = %p)", target, pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Buffer *buffer;

		switch(target)
		{
		case GL_ARRAY_BUFFER:
			buffer = context->getArrayBuffer();
			break;
		case GL_ELEMENT_ARRAY_BUFFER:
			buffer = context->getElementArrayBuffer();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		if(!buffer)
		{
			// A null buffer means that "0" is bound to the requested buffer target
			return error(GL_INVALID_OPERATION);
		}

		switch(pname)
		{
		case GL_BUFFER_USAGE:
			*params = buffer->usage();
			break;
		case GL_BUFFER_SIZE:
			*params = buffer->size();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

GLenum APIENTRY glGetError(void)
{
	TRACE("()");

	gl::Context *context = gl::getContext();

	if(context)
	{
		return context->getError();
	}

	return GL_NO_ERROR;
}

void APIENTRY glGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
{
	TRACE("(GLuint fence = %d, GLenum pname = 0x%X, GLint *params = %p)", fence, pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Fence *fenceObject = context->getFence(fence);

		if(fenceObject == NULL)
		{
			return error(GL_INVALID_OPERATION);
		}

		fenceObject->getFenceiv(pname, params);
	}
}

void APIENTRY glGetFloatv(GLenum pname, GLfloat* params)
{
	TRACE("(GLenum pname = 0x%X, GLfloat* params = %p)", pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(!(context->getFloatv(pname, params)))
		{
			GLenum nativeType;
			unsigned int numParams = 0;
			if(!context->getQueryParameterInfo(pname, &nativeType, &numParams))
				return error(GL_INVALID_ENUM);

			if(numParams == 0)
				return; // it is known that the pname is valid, but that there are no parameters to return.

			if(nativeType == GL_BOOL)
			{
				GLboolean *boolParams = NULL;
				boolParams = new GLboolean[numParams];

				context->getBooleanv(pname, boolParams);

				for(unsigned int i = 0; i < numParams; ++i)
				{
					if(boolParams[i] == GL_FALSE)
						params[i] = 0.0f;
					else
						params[i] = 1.0f;
				}

				delete [] boolParams;
			}
			else if(nativeType == GL_INT)
			{
				GLint *intParams = NULL;
				intParams = new GLint[numParams];

				context->getIntegerv(pname, intParams);

				for(unsigned int i = 0; i < numParams; ++i)
				{
					params[i] = (GLfloat)intParams[i];
				}

				delete [] intParams;
			}
		}
	}
}

void APIENTRY glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
{
	TRACE("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X, GLint* params = %p)",
	      target, attachment, pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_EXT && target != GL_READ_FRAMEBUFFER_EXT)
		{
			return error(GL_INVALID_ENUM);
		}

		gl::Framebuffer *framebuffer = NULL;
		if(target == GL_READ_FRAMEBUFFER_EXT)
		{
			if(context->getReadFramebufferName() == 0)
			{
				return error(GL_INVALID_OPERATION);
			}

			framebuffer = context->getReadFramebuffer();
		}
		else
		{
			if(context->getDrawFramebufferName() == 0)
			{
				return error(GL_INVALID_OPERATION);
			}

			framebuffer = context->getDrawFramebuffer();
		}

		GLenum attachmentType;
		GLuint attachmentHandle;
		switch(attachment)
		{
		case GL_COLOR_ATTACHMENT0:
			attachmentType = framebuffer->getColorbufferType();
			attachmentHandle = framebuffer->getColorbufferName();
			break;
		case GL_DEPTH_ATTACHMENT:
			attachmentType = framebuffer->getDepthbufferType();
			attachmentHandle = framebuffer->getDepthbufferName();
			break;
		case GL_STENCIL_ATTACHMENT:
			attachmentType = framebuffer->getStencilbufferType();
			attachmentHandle = framebuffer->getStencilbufferName();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		GLenum attachmentObjectType;   // Type category
		if(attachmentType == GL_NONE || attachmentType == GL_RENDERBUFFER)
		{
			attachmentObjectType = attachmentType;
		}
		else if(gl::IsTextureTarget(attachmentType))
		{
			attachmentObjectType = GL_TEXTURE;
		}
		else UNREACHABLE();

		switch(pname)
		{
		case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
			*params = attachmentObjectType;
			break;
		case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
			if(attachmentObjectType == GL_RENDERBUFFER || attachmentObjectType == GL_TEXTURE)
			{
				*params = attachmentHandle;
			}
			else
			{
				return error(GL_INVALID_ENUM);
			}
			break;
		case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
			if(attachmentObjectType == GL_TEXTURE)
			{
				*params = 0; // FramebufferTexture2D will not allow level to be set to anything else in GL ES 2.0
			}
			else
			{
				return error(GL_INVALID_ENUM);
			}
			break;
		case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
			if(attachmentObjectType == GL_TEXTURE)
			{
				if(gl::IsCubemapTextureTarget(attachmentType))
				{
					*params = attachmentType;
				}
				else
				{
					*params = 0;
				}
			}
			else
			{
				return error(GL_INVALID_ENUM);
			}
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

GLenum APIENTRY glGetGraphicsResetStatusEXT(void)
{
	TRACE("()");

	return GL_NO_ERROR;
}

void APIENTRY glGetIntegerv(GLenum pname, GLint* params)
{
	TRACE("(GLenum pname = 0x%X, GLint* params = %p)", pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(!(context->getIntegerv(pname, params)))
		{
			GLenum nativeType;
			unsigned int numParams = 0;
			if(!context->getQueryParameterInfo(pname, &nativeType, &numParams))
			{
				return error(GL_INVALID_ENUM);
			}

			if(numParams == 0)
				return; // it is known that pname is valid, but there are no parameters to return

			if(nativeType == GL_BOOL)
			{
				GLboolean *boolParams = NULL;
				boolParams = new GLboolean[numParams];

				context->getBooleanv(pname, boolParams);

				for(unsigned int i = 0; i < numParams; ++i)
				{
					if(boolParams[i] == GL_FALSE)
						params[i] = 0;
					else
						params[i] = 1;
				}

				delete [] boolParams;
			}
			else if(nativeType == GL_FLOAT)
			{
				GLfloat *floatParams = NULL;
				floatParams = new GLfloat[numParams];

				context->getFloatv(pname, floatParams);

				for(unsigned int i = 0; i < numParams; ++i)
				{
					if(pname == GL_DEPTH_RANGE || pname == GL_COLOR_CLEAR_VALUE || pname == GL_DEPTH_CLEAR_VALUE || pname == GL_BLEND_COLOR)
					{
						params[i] = (GLint)(((GLfloat)(0xFFFFFFFF) * floatParams[i] - 1.0f) / 2.0f);
					}
					else
					{
						params[i] = (GLint)(floatParams[i] > 0.0f ? floor(floatParams[i] + 0.5) : ceil(floatParams[i] - 0.5));
					}
				}

				delete [] floatParams;
			}
		}
	}
}

void APIENTRY glGetProgramiv(GLuint program, GLenum pname, GLint* params)
{
	TRACE("(GLuint program = %d, GLenum pname = 0x%X, GLint* params = %p)", program, pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Program *programObject = context->getProgram(program);

		if(!programObject)
		{
			return error(GL_INVALID_VALUE);
		}

		switch(pname)
		{
		case GL_DELETE_STATUS:
			*params = programObject->isFlaggedForDeletion();
			return;
		case GL_LINK_STATUS:
			*params = programObject->isLinked();
			return;
		case GL_VALIDATE_STATUS:
			*params = programObject->isValidated();
			return;
		case GL_INFO_LOG_LENGTH:
			*params = programObject->getInfoLogLength();
			return;
		case GL_ATTACHED_SHADERS:
			*params = programObject->getAttachedShadersCount();
			return;
		case GL_ACTIVE_ATTRIBUTES:
			*params = programObject->getActiveAttributeCount();
			return;
		case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
			*params = programObject->getActiveAttributeMaxLength();
			return;
		case GL_ACTIVE_UNIFORMS:
			*params = programObject->getActiveUniformCount();
			return;
		case GL_ACTIVE_UNIFORM_MAX_LENGTH:
			*params = programObject->getActiveUniformMaxLength();
			return;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)
{
	TRACE("(GLuint program = %d, GLsizei bufsize = %d, GLsizei* length = %p, GLchar* infolog = %p)",
	      program, bufsize, length, infolog);

	if(bufsize < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Program *programObject = context->getProgram(program);

		if(!programObject)
		{
			return error(GL_INVALID_VALUE);
		}

		programObject->getInfoLog(bufsize, length, infolog);
	}
}

void APIENTRY glGetQueryivEXT(GLenum target, GLenum pname, GLint *params)
{
	TRACE("GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = %p)", target, pname, params);

	switch(pname)
	{
	case GL_CURRENT_QUERY:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		params[0] = context->getActiveQuery(target);
	}
}

void APIENTRY glGetQueryObjectuivEXT(GLuint name, GLenum pname, GLuint *params)
{
	TRACE("(GLuint name = %d, GLenum pname = 0x%X, GLuint *params = %p)", name, pname, params);

	switch(pname)
	{
	case GL_QUERY_RESULT:
	case GL_QUERY_RESULT_AVAILABLE:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Query *queryObject = context->getQuery(name, false, GL_NONE);

		if(!queryObject)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(context->getActiveQuery(queryObject->getType()) == name)
		{
			return error(GL_INVALID_OPERATION);
		}

		switch(pname)
		{
		case GL_QUERY_RESULT:
			params[0] = queryObject->getResult();
			break;
		case GL_QUERY_RESULT_AVAILABLE:
			params[0] = queryObject->isResultAvailable();
			break;
		default:
			ASSERT(false);
		}
	}
}

void APIENTRY glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
{
	TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = %p)", target, pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(target != GL_RENDERBUFFER)
		{
			return error(GL_INVALID_ENUM);
		}

		if(context->getRenderbufferName() == 0)
		{
			return error(GL_INVALID_OPERATION);
		}

		gl::Renderbuffer *renderbuffer = context->getRenderbuffer(context->getRenderbufferName());

		switch(pname)
		{
		case GL_RENDERBUFFER_WIDTH:           *params = renderbuffer->getWidth();       break;
		case GL_RENDERBUFFER_HEIGHT:          *params = renderbuffer->getHeight();      break;
		case GL_RENDERBUFFER_INTERNAL_FORMAT: *params = renderbuffer->getFormat();      break;
		case GL_RENDERBUFFER_RED_SIZE:        *params = renderbuffer->getRedSize();     break;
		case GL_RENDERBUFFER_GREEN_SIZE:      *params = renderbuffer->getGreenSize();   break;
		case GL_RENDERBUFFER_BLUE_SIZE:       *params = renderbuffer->getBlueSize();    break;
		case GL_RENDERBUFFER_ALPHA_SIZE:      *params = renderbuffer->getAlphaSize();   break;
		case GL_RENDERBUFFER_DEPTH_SIZE:      *params = renderbuffer->getDepthSize();   break;
		case GL_RENDERBUFFER_STENCIL_SIZE:    *params = renderbuffer->getStencilSize(); break;
		case GL_RENDERBUFFER_SAMPLES_EXT:     *params = renderbuffer->getSamples();     break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
{
	TRACE("(GLuint shader = %d, GLenum pname = %d, GLint* params = %p)", shader, pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Shader *shaderObject = context->getShader(shader);

		if(!shaderObject)
		{
			return error(GL_INVALID_VALUE);
		}

		switch(pname)
		{
		case GL_SHADER_TYPE:
			*params = shaderObject->getType();
			return;
		case GL_DELETE_STATUS:
			*params = shaderObject->isFlaggedForDeletion();
			return;
		case GL_COMPILE_STATUS:
			*params = shaderObject->isCompiled() ? GL_TRUE : GL_FALSE;
			return;
		case GL_INFO_LOG_LENGTH:
			*params = shaderObject->getInfoLogLength();
			return;
		case GL_SHADER_SOURCE_LENGTH:
			*params = shaderObject->getSourceLength();
			return;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)
{
	TRACE("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = %p, GLchar* infolog = %p)",
	      shader, bufsize, length, infolog);

	if(bufsize < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Shader *shaderObject = context->getShader(shader);

		if(!shaderObject)
		{
			return error(GL_INVALID_VALUE);
		}

		shaderObject->getInfoLog(bufsize, length, infolog);
	}
}

void APIENTRY glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
{
	TRACE("(GLenum shadertype = 0x%X, GLenum precisiontype = 0x%X, GLint* range = %p, GLint* precision = %p)",
	      shadertype, precisiontype, range, precision);

	switch(shadertype)
	{
	case GL_VERTEX_SHADER:
	case GL_FRAGMENT_SHADER:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	switch(precisiontype)
	{
	case GL_LOW_FLOAT:
	case GL_MEDIUM_FLOAT:
	case GL_HIGH_FLOAT:
		// IEEE 754 single-precision
		range[0] = 127;
		range[1] = 127;
		*precision = 23;
		break;
	case GL_LOW_INT:
	case GL_MEDIUM_INT:
	case GL_HIGH_INT:
		// Single-precision floating-point numbers can accurately represent integers up to +/-16777216
		range[0] = 24;
		range[1] = 24;
		*precision = 0;
		break;
	default:
		return error(GL_INVALID_ENUM);
	}
}

void APIENTRY glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
{
	TRACE("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = %p, GLchar* source = %p)",
	      shader, bufsize, length, source);

	if(bufsize < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Shader *shaderObject = context->getShader(shader);

		if(!shaderObject)
		{
			return error(GL_INVALID_OPERATION);
		}

		shaderObject->getSource(bufsize, length, source);
	}
}

const GLubyte* APIENTRY glGetString(GLenum name)
{
	TRACE("(GLenum name = 0x%X)", name);

	switch(name)
	{
	case GL_VENDOR:
		return (GLubyte*)"NVIDIA Corporation";// "TransGaming Inc.";
	case GL_RENDERER:
		return (GLubyte*)"Quadro K600/PCIe/SSE2";// "SwiftShader";
	case GL_VERSION:
		return (GLubyte*)"2.1.2 NVIDIA 347.62";//"2.1.2 SwiftShader "VERSION_STRING;
	case GL_SHADING_LANGUAGE_VERSION:
		return (GLubyte*)/*"3.0.0 NVIDIA "VERSION_STRING;*/"4.50 NVIDIA";
	case GL_EXTENSIONS:
		// Keep list sorted in following order:
		// OES extensions
		// EXT extensions
		// Vendor extensions
		return (GLubyte*)
			////1.1
			//"GL_EXT_blend_logic_op "
			//"GL_EXT_copy_texture "
			//"GL_EXT_polygon_offset "
			//"GL_EXT_subtexture "
			//"GL_EXT_texture "
			//"GL_EXT_texture_object "
			////"GL_EXT_vertex_array "
			////1.2
			//"GL_EXT_bgra "
			//"GL_EXT_draw_range_elements "
			//"GL_EXT_packed_pixels "
			//"GL_EXT_rescale_normal "
			//"GL_EXT_separate_specular_color "
			//"GL_EXT_texture3D "
			//"GL_EXT_texture_edge_clamp "
			//"GL_SGIS_texture_edge_clamp "
			//"GL_SGIS_texture_lod "
			////1.3
			//"GL_ARB_multisample "
			//"GL_ARB_multitexture "
			//"GL_ARB_texture_border_clamp "
			//"GL_ARB_texture_compression "
			//"GL_ARB_texture_cube_map "
			//"GL_ARB_texture_env_add "
			//"GL_ARB_texture_env_combine "
			//"GL_ARB_texture_env_dot3 "
			//"GL_ARB_transpose_matrix "
			////1.4
			//"GL_ARB_depth_texture "
			//"GL_ARB_point_parameters "
			//"GL_ARB_shadow "
			//"GL_ARB_texture_env_crossbar "
			//"GL_ARB_texture_mirrored_repeat "
			//"GL_ARB_windows_pos "
			//"GL_EXT_blend_color "
			//"GL_EXT_blend_func_separate "
			//"GL_EXT_fog_coord "
			//"GL_EXT_multi_draw_arrays "
			//"GL_EXT_secondary_color "
			//"GL_EXT_stencil_wrap "
			//"GL_EXT_texture_lod_bias "
			//"GL_NV_blend_square "
			//"GL_SGIS_generate_mipmap "
			////1.5
			//"GL_ARB_occlusion_query "
			//"GL_ARB_vertex_buffer_object "
			//"GL_EXT_shadow_funcs "
			////2.0
			//"GL_ARB_draw_buffers "
			//"GL_ARB_fragment_shader "
			//"GL_ARB_point_sprite "
			//"GL_ARB_shader objects "
			//"GL_ARB_shading_language_100 "
			//"GL_ARB_texture_non_power_of_two "
			//"GL_ARB_vertex_shader "
			//"GL_EXT_blend_equation_separate "
			//"GL_EXT_stencil_two_side "

			////2.1
			//"GL_ARB_pixel_buffer_object "
			//"GL_EXT_texture_sRGB "

			//"GL_EXT_framebuffer_object "
			//"GL_ARB_framebuffer_object "
			//"GL_ARB_shader_atomic_counters "
			//"GL_ARB_shader_bit_encoding "
			//"GL_ARB_shader_draw_parameters "
			//"GL_ARB_shader_group_vote "
			//"GL_ARB_shader_image_load_store "
			//"GL_ARB_shader_image_size "
			//"GL_ARB_shader_objects "
			//"GL_ARB_shader_precision "
			//"GL_ARB_query_buffer_object "
			//"GL_ARB_shader_storage_buffer_object "
			//"GL_ARB_shader_subroutine "
			//"GL_ARB_shader_texture_lod "
			//"GL_ARB_shadow "
			//"GL_ARB_shading_language_420pack "
			//"GL_ARB_shading_language_include "
			//"GL_ARB_shading_language_packing ";


			//NVIDIA CARD EXTENSIONS
			"GL_AMD_multi_draw_indirect "
			"GL_AMD_seamless_cubemap_per_texture "
			"GL_ARB_arrays_of_arrays "
			"GL_ARB_base_instance "
			"GL_ARB_bindless_texture "
			"GL_ARB_blend_func_extended "
			"GL_ARB_buffer_storage "
			"GL_ARB_clear_buffer_object "
			"GL_ARB_clear_texture "
			"GL_ARB_clip_control "
			"GL_ARB_color_buffer_float "
			//"GL_ARB_compressed_texture_pixel_storage "
			"GL_ARB_compute_shader "
			"GL_ARB_compute_variable_group_size "
			"GL_ARB_conditional_render_inverted "
			"GL_ARB_conservative_depth "
			"GL_ARB_copy_buffer "
			"GL_ARB_copy_image "
			"GL_ARB_cull_distance "
			"GL_ARB_debug_output "
			"GL_ARB_depth_buffer_float "
			"GL_ARB_depth_clamp "
			"GL_ARB_depth_texture "
			"GL_ARB_derivative_control "
			"GL_ARB_direct_state_access "
			"GL_ARB_draw_buffers "
			"GL_ARB_draw_buffers_blend "
			"GL_ARB_draw_elements_base_vertex "
			"GL_ARB_draw_indirect "
			"GL_ARB_draw_instanced "
			"GL_ARB_enhanced_layouts "
			"GL_ARB_ES2_compatibility "
			"GL_ARB_ES3_1_compatibility "
			"GL_ARB_ES3_compatibility "
			"GL_ARB_explicit_attrib_location "
			"GL_ARB_explicit_uniform_location "
			"GL_ARB_fragment_coord_conventions "
			"GL_ARB_fragment_layer_viewport "
			"GL_ARB_fragment_program "
			"GL_ARB_fragment_program_shadow "
			"GL_ARB_fragment_shader "
			"GL_ARB_framebuffer_no_attachments "
			"GL_ARB_framebuffer_object "
			"GL_ARB_framebuffer_sRGB "
			"GL_ARB_geometry_shader4 "
			"GL_ARB_get_program_binary "
			"GL_ARB_get_texture_sub_image "
			"GL_ARB_gpu_shader5 "
			"GL_ARB_gpu_shader_fp64 "
			//"GL_ARB_half_float_pixel "
			"GL_ARB_half_float_vertex "
			"GL_ARB_imaging "
			"GL_ARB_indirect_parameters "
			"GL_ARB_instanced_arrays "
			"GL_ARB_internalformat_query "
			"GL_ARB_internalformat_query2 "
			"GL_ARB_invalidate_subdata "
			"GL_ARB_map_buffer_alignment "
			"GL_ARB_map_buffer_range "
			"GL_ARB_multi_bind "
			"GL_ARB_multi_draw_indirect "
			"GL_ARB_multisample "
			"GL_ARB_multitexture "
			"GL_ARB_occlusion_query "
			"GL_ARB_occlusion_query2 "
			"GL_ARB_pipeline_statistics_query "
			//"GL_ARB_pixel_buffer_object "
			"GL_ARB_point_parameters "
			"GL_ARB_point_sprite "
			"GL_ARB_program_interface_query "
			"GL_ARB_provoking_vertex "
			"GL_ARB_query_buffer_object "
			"GL_ARB_robust_buffer_access_behavior "
			"GL_ARB_robustness "
			"GL_ARB_sample_shading "
			"GL_ARB_sampler_objects "
			"GL_ARB_seamless_cube_map "
			"GL_ARB_seamless_cubemap_per_texture "
			"GL_ARB_separate_shader_objects "
			"GL_ARB_shader_atomic_counters "
			"GL_ARB_shader_bit_encoding "
			"GL_ARB_shader_draw_parameters "
			"GL_ARB_shader_group_vote "
			"GL_ARB_shader_image_load_store "
			"GL_ARB_shader_image_size "
			"GL_ARB_shader_objects "
			"GL_ARB_shader_precision "
			"GL_ARB_shader_storage_buffer_object "
			"GL_ARB_shader_subroutine "
			"GL_ARB_shader_texture_image_samples "
			"GL_ARB_shader_texture_lod "
			"GL_ARB_shading_language_100 "
			"GL_ARB_shading_language_420pack "
			"GL_ARB_shading_language_include "
			"GL_ARB_shading_language_packing "
			"GL_ARB_shadow "
			"GL_ARB_sparse_buffer "
			"GL_ARB_sparse_texture "
			"GL_ARB_stencil_texturing "
			"GL_ARB_sync "
			"GL_ARB_tessellation_shader "
			"GL_ARB_texture_barrier "
			"GL_ARB_texture_border_clamp "
			"GL_ARB_texture_buffer_object "
			"GL_ARB_texture_buffer_object_rgb32 "
			"GL_ARB_texture_buffer_range "
			"GL_ARB_texture_compression "
			"GL_ARB_texture_compression_bptc "
			"GL_ARB_texture_compression_rgtc "
			"GL_ARB_texture_cube_map "
			"GL_ARB_texture_cube_map_array "
			"GL_ARB_texture_env_add "
			"GL_ARB_texture_env_combine "
			"GL_ARB_texture_env_crossbar "
			"GL_ARB_texture_env_dot3 "
			"GL_ARB_texture_float "
			"GL_ARB_texture_gather "
			"GL_ARB_texture_mirror_clamp_to_edge "
			"GL_ARB_texture_mirrored_repeat "
			"GL_ARB_texture_multisample "
			"GL_ARB_texture_non_power_of_two "
			"GL_ARB_texture_query_levels "
			"GL_ARB_texture_query_lod "
			"GL_ARB_texture_rectangle "
			"GL_ARB_texture_rg "
			"GL_ARB_texture_rgb10_a2ui "
			"GL_ARB_texture_stencil8 "
			"GL_ARB_texture_storage "
			"GL_ARB_texture_storage_multisample "
			"GL_ARB_texture_swizzle "
			"GL_ARB_texture_view "
			"GL_ARB_timer_query "
			"GL_ARB_transform_feedback2 "
			"GL_ARB_transform_feedback3 "
			"GL_ARB_transform_feedback_instanced "
			"GL_ARB_transform_feedback_overflow_query "
			"GL_ARB_transpose_matrix "
			"GL_ARB_uniform_buffer_object "
			"GL_ARB_vertex_array_bgra "
			"GL_ARB_vertex_array_object "
			"GL_ARB_vertex_attrib_64bit "
			"GL_ARB_vertex_attrib_binding "
			"GL_ARB_vertex_buffer_object "
			"GL_ARB_vertex_program "
			"GL_ARB_vertex_shader "
			"GL_ARB_vertex_type_10f_11f_11f_rev "
			"GL_ARB_vertex_type_2_10_10_10_rev "
			"GL_ARB_viewport_array "
			"GL_ARB_window_pos "
			"GL_ATI_draw_buffers "
			"GL_ATI_texture_float "
			"GL_ATI_texture_mirror_once "
			"GL_EXT_abgr "
			"GL_EXT_bgra "
			"GL_EXT_bindable_uniform "
			"GL_EXT_blend_color "
			"GL_EXT_blend_equation_separate "
			"GL_EXT_blend_func_separate "
			"GL_EXT_blend_minmax "
			"GL_EXT_blend_subtract "
			"GL_EXT_Cg_shader "
			"GL_EXT_compiled_vertex_array "
			"GL_EXT_depth_bounds_test "
			"GL_EXT_direct_state_access "
			"GL_EXT_draw_buffers2 "
			"GL_EXT_draw_instanced "
			"GL_EXT_draw_range_elements "
			"GL_EXT_fog_coord "
			"GL_EXT_framebuffer_blit "
			"GL_EXT_framebuffer_multisample "
			"GL_EXT_framebuffer_multisample_blit_scaled "
			"GL_EXT_framebuffer_object "
			"GL_EXT_framebuffer_sRGB "
			"GL_EXT_geometry_shader4 "
			"GL_EXT_gpu_program_parameters "
			"GL_EXT_gpu_shader4 "
			"GL_EXT_import_sync_object "
			"GL_EXT_multi_draw_arrays "
			"GL_EXT_packed_depth_stencil "
			"GL_EXT_packed_float "
			//"GL_EXT_packed_pixels "
			//"GL_EXT_pixel_buffer_object "
			"GL_EXT_point_parameters "
			"GL_EXT_polygon_offset_clamp "
			"GL_EXT_provoking_vertex "
			"GL_EXT_rescale_normal "
			"GL_EXT_secondary_color "
			"GL_EXT_separate_shader_objects "
			"GL_EXT_separate_specular_color "
			"GL_EXT_shader_image_load_store "
			"GL_EXT_shader_integer_mix "
			"GL_EXT_shadow_funcs "
			"GL_EXT_stencil_two_side "
			"GL_EXT_stencil_wrap "
			"GL_EXT_texture3D "
			"GL_EXT_texture_array "
			"GL_EXT_texture_buffer_object "
			"GL_EXT_texture_compression_dxt1 "
			"GL_EXT_texture_compression_latc "
			"GL_EXT_texture_compression_rgtc "
			"GL_EXT_texture_compression_s3tc "
			"GL_EXT_texture_cube_map "
			"GL_EXT_texture_edge_clamp "
			"GL_EXT_texture_env_add "
			"GL_EXT_texture_env_combine "
			"GL_EXT_texture_env_dot3 "
			"GL_EXT_texture_filter_anisotropic "
			"GL_EXT_texture_integer "
			"GL_EXT_texture_lod "
			"GL_EXT_texture_lod_bias "
			"GL_EXT_texture_mirror_clamp "
			"GL_EXT_texture_object "
			"GL_EXT_texture_shared_exponent "
			"GL_EXT_texture_sRGB "
			"GL_EXT_texture_sRGB_decode "
			"GL_EXT_texture_storage "
			"GL_EXT_texture_swizzle "
			"GL_EXT_timer_query "
			"GL_EXT_transform_feedback2 "
			"GL_EXT_vertex_array "
			"GL_EXT_vertex_array_bgra "
			"GL_EXT_vertex_attrib_64bit "
			"GL_EXTX_framebuffer_mixed_formats "
			"GL_IBM_rasterpos_clip "
			"GL_IBM_texture_mirrored_repeat "
			"GL_KHR_blend_equation_advanced "
			"GL_KHR_context_flush_control "
			"GL_KHR_debug "
			"GL_KHR_robust_buffer_access_behavior "
			"GL_KHR_robustness "
			"GL_KTX_buffer_region "
			"GL_NV_bindless_multi_draw_indirect "
			"GL_NV_bindless_multi_draw_indirect_count "
			"GL_NV_bindless_texture "
			"GL_NV_blend_equation_advanced "
			"GL_NV_blend_square "
			"GL_NV_command_list "
			"GL_NV_compute_program5 "
			"GL_NV_conditional_render "
			"GL_NV_copy_depth_to_color "
			"GL_NV_copy_image "
			"GL_NV_deep_texture3D "
			"GL_NV_depth_buffer_float "
			"GL_NV_depth_clamp "
			"GL_NV_draw_texture "
			"GL_NV_ES1_1_compatibility "
			"GL_NV_ES3_1_compatibility "
			"GL_NV_explicit_multisample "
			"GL_NV_fence "
			"GL_NV_float_buffer "
			"GL_NV_fog_distance "
			"GL_NV_fragment_program "
			"GL_NV_fragment_program2 "
			"GL_NV_fragment_program_option "
			"GL_NV_framebuffer_multisample_coverage "
			"GL_NV_geometry_shader4 "
			"GL_NV_gpu_program4 "
			"GL_NV_gpu_program4_1 "
			"GL_NV_gpu_program5 "
			"GL_NV_gpu_program5_mem_extended "
			"GL_NV_gpu_program_fp64 "
			"GL_NV_gpu_shader5 "
			"GL_NV_half_float "
			"GL_NV_internalformat_sample_query "
			"GL_NV_light_max_exponent "
			"GL_NV_multisample_coverage "
			"GL_NV_multisample_filter_hint "
			"GL_NV_occlusion_query "
			"GL_NV_packed_depth_stencil "
			"GL_NV_parameter_buffer_object "
			"GL_NV_parameter_buffer_object2 "
			"GL_NV_path_rendering "
			//"GL_NV_pixel_data_range "
			"GL_NV_point_sprite "
			"GL_NV_primitive_restart "
			"GL_NV_register_combiners "
			"GL_NV_register_combiners2 "
			"GL_NV_shader_atomic_counters "
			"GL_NV_shader_atomic_float "
			"GL_NV_shader_buffer_load "
			"GL_NV_shader_storage_buffer_object "
			"GL_NV_shader_thread_group "
			"GL_NV_shader_thread_shuffle "
			"GL_NV_texgen_reflection "
			"GL_NV_texture_barrier "
			"GL_NV_texture_compression_vtc "
			"GL_NV_texture_env_combine4 "
			"GL_NV_texture_multisample "
			"GL_NV_texture_rectangle "
			"GL_NV_texture_shader "
			"GL_NV_texture_shader2 "
			"GL_NV_texture_shader3 "
			"GL_NV_transform_feedback "
			"GL_NV_transform_feedback2 "
			"GL_NV_uniform_buffer_unified_memory "
			"GL_NV_vertex_array_range "
			"GL_NV_vertex_array_range2 "
			"GL_NV_vertex_attrib_integer_64bit "
			"GL_NV_vertex_buffer_unified_memory "
			"GL_NV_vertex_program "
			"GL_NV_vertex_program1_1 "
			"GL_NV_vertex_program2 "
			"GL_NV_vertex_program2_option "
			"GL_NV_vertex_program3 "
			"GL_NV_video_capture "
			"GL_NVX_conditional_render "
			"GL_NVX_gpu_memory_info "
			"GL_NVX_nvenc_interop "
			"GL_S3_s3tc "
			"GL_SGIS_generate_mipmap "
			"GL_SGIS_texture_lod "
			"GL_SGIX_depth_texture "
			"GL_SGIX_shadow "
			"GL_SUN_slice_accum "
			//"GL_WIN_swap_hint "
			"WGL_ARB_buffer_region "
			"WGL_ARB_context_flush_control "
			"WGL_ARB_create_context "
			"WGL_ARB_create_context_profile "
			"WGL_ARB_create_context_robustness "
			"WGL_ARB_extensions_string "
			"WGL_ARB_make_current_read "
			"WGL_ARB_multisample "
			"WGL_ARB_pbuffer "
			//"WGL_ARB_pixel_format "
			//"WGL_ARB_pixel_format_float "
			"WGL_ARB_render_texture "
			//"WGL_ATI_pixel_format_float "
			"WGL_EXT_create_context_es2_profile "
			"WGL_EXT_create_context_es_profile "
			"WGL_EXT_extensions_string "
			"WGL_EXT_framebuffer_sRGB "
			//"WGL_EXT_pixel_format_packed_float "
			"WGL_EXT_swap_control "
			"WGL_EXT_swap_control_tear "
			"WGL_NV_copy_image "
			"WGL_NV_delay_before_swap "
			"WGL_NV_DX_interop "
			"WGL_NV_DX_interop2 "
			"WGL_NV_float_buffer "
			"WGL_NV_gpu_affinity "
			"WGL_NV_multisample_coverage "
			"WGL_NV_render_depth_texture "
			"WGL_NV_render_texture_rectangle "
			"WGL_NV_swap_group "
			"WGL_NV_video_capture "
			"WGL_NVX_DX_interop";


			/*"WGL_ARB_extensions_string "
			"GL_ARB_extensions_string "
			"WGL_ARB_create_context "
			"GL_ARB_create_context "
			"GL_ARB_texture_non_power_of_two "
			"GL_ARB_framebuffer_object "
			"GL_ARB_fragment_shader "
			"GL_ARB_vertex_shader "
			"GL_ARB_shader_objects "
			"GL_ARB_shading_language_100 "
			"GL_EXT_framebuffer_object "
			"GL_EXT_blend_minmax "
			"GL_EXT_depth_texture "
			"GL_EXT_depth_texture_cube_map "
			"GL_EXT_element_index_uint "
			"GL_EXT_packed_depth_stencil "
			"GL_EXT_rgb8_rgba8 "
			"GL_EXT_standard_derivatives "
			"GL_EXT_texture_float "
			"GL_EXT_texture_float_linear "
			"GL_EXT_texture_half_float "
			"GL_EXT_texture_half_float_linear "
			"GL_EXT_texture_npot "
			"GL_EXT_occlusion_query_boolean "
			"GL_EXT_read_format_bgra "
			#if (S3TC_SUPPORT)
			"GL_EXT_texture_compression_dxt1 "
			#endif
			"GL_EXT_blend_func_separate "
			"GL_EXT_secondary_color "
			"GL_EXT_texture_filter_anisotropic "
			"GL_EXT_texture_format_BGRA8888 "
			"GL_EXT_framebuffer_blit "
			"GL_EXT_framebuffer_multisample "
			#if (S3TC_SUPPORT)
			"GL_EXT_texture_compression_dxt3 "
			"GL_EXT_texture_compression_dxt5 "
			#endif
			"GL_NV_fence";*/



			/*"GL_AMD_multi_draw_indirect "
			"GL_AMD_seamless_cubemap_per_texture "
			"GL_ARB_arrays_of_arrays "
			"GL_ARB_base_instance "
			"GL_ARB_bindless_texture "
			"GL_ARB_blend_func_extended "
			"GL_ARB_buffer_storage "
			"GL_ARB_clear_buffer_object "
			"GL_ARB_clear_texture "
			"GL_ARB_color_buffer_float "
			"GL_ARB_compatibility "
			"GL_ARB_compressed_texture_pixel_storage "
			"GL_ARB_conservative_depth "
			"GL_ARB_compute_shader "
			"GL_ARB_compute_variable_group_size "
			"GL_ARB_copy_buffer "
			"GL_ARB_copy_image "
			"GL_ARB_debug_output "
			"GL_ARB_depth_buffer_float "
			"GL_ARB_depth_clamp "
			"GL_ARB_depth_texture "
			"GL_ARB_draw_buffers "
			"GL_ARB_draw_buffers_blend "
			"GL_ARB_draw_indirect "
			"GL_ARB_draw_elements_base_vertex "
			"GL_ARB_draw_instanced "
			"GL_ARB_enhanced_layouts "
			"GL_ARB_ES2_compatibility "
			"GL_ARB_ES3_compatibility "
			"GL_ARB_explicit_attrib_location "
			"GL_ARB_explicit_uniform_location "
			"GL_ARB_fragment_coord_conventions "
			"GL_ARB_fragment_layer_viewport "
			"GL_ARB_fragment_program "
			"GL_ARB_fragment_program_shadow "
			"GL_ARB_fragment_shader "
			"GL_ARB_framebuffer_no_attachments "
			"GL_ARB_framebuffer_object "
			"GL_ARB_framebuffer_sRGB "
			"GL_ARB_geometry_shader4 "
			"GL_ARB_get_program_binary "
			"GL_ARB_gpu_shader5 "
			"GL_ARB_gpu_shader_fp64 "
			"GL_ARB_half_float_pixel "
			"GL_ARB_half_float_vertex "
			"GL_ARB_indirect_parameters "
			"GL_ARB_instanced_arrays "
			"GL_ARB_internalformat_query "
			"GL_ARB_internalformat_query2 "
			"GL_ARB_invalidate_subdata "
			"GL_ARB_map_buffer_alignment "
			"GL_ARB_map_buffer_range "
			"GL_ARB_multi_bind "
			"GL_ARB_multi_draw_indirect "
			"GL_ARB_multisample "
			"GL_ARB_multitexture "
			"GL_ARB_occlusion_query "
			"GL_ARB_occlusion_query2 "
			"GL_ARB_pixel_buffer_object "
			"GL_ARB_point_parameters "
			"GL_ARB_point_sprite "
			"GL_ARB_program_interface_query "
			"GL_ARB_provoking_vertex "
			"GL_ARB_robust_buffer_access_behavior "
			"GL_ARB_robustness "
			"GL_ARB_sample_shading "
			"GL_ARB_sampler_objects "
			"GL_ARB_seamless_cube_map "
			"GL_ARB_seamless_cubemap_per_texture "
			"GL_ARB_separate_shader_objects "
			"GL_ARB_shader_atomic_counters "
			"GL_ARB_shader_bit_encoding "
			"GL_ARB_shader_draw_parameters "
			"GL_ARB_shader_group_vote "
			"GL_ARB_shader_image_load_store "
			"GL_ARB_shader_image_size "
			"GL_ARB_shader_objects "
			"GL_ARB_shader_precision "
			"GL_ARB_query_buffer_object "
			"GL_ARB_shader_storage_buffer_object "
			"GL_ARB_shader_subroutine "
			"GL_ARB_shader_texture_lod "
			"GL_ARB_shading_language_100 "
			"GL_ARB_shading_language_420pack "
			"GL_ARB_shading_language_include "
			"GL_ARB_shading_language_packing "
			"GL_ARB_shadow "
			"GL_ARB_sparse_texture "
			"GL_ARB_stencil_texturing "
			"GL_ARB_sync "
			"GL_ARB_tessellation_shader "
			"GL_ARB_texture_border_clamp "
			"GL_ARB_texture_buffer_object "
			"GL_ARB_texture_buffer_object_rgb32 "
			"GL_ARB_texture_buffer_range "
			"GL_ARB_texture_compression "
			"GL_ARB_texture_compression_bptc "
			"GL_ARB_texture_compression_rgtc "
			"GL_ARB_texture_cube_map "
			"GL_ARB_texture_cube_map_array "
			"GL_ARB_texture_env_add "
			"GL_ARB_texture_env_combine "
			"GL_ARB_texture_env_crossbar "
			"GL_ARB_texture_env_dot3 "
			"GL_ARB_texture_float "
			"GL_ARB_texture_gather "
			"GL_ARB_texture_mirror_clamp_to_edge "
			"GL_ARB_texture_mirrored_repeat "
			"GL_ARB_texture_multisample "
			"GL_ARB_texture_non_power_of_two "
			"GL_ARB_texture_query_levels "
			"GL_ARB_texture_query_lod "
			"GL_ARB_texture_rectangle "
			"GL_ARB_texture_rg "
			"GL_ARB_texture_rgb10_a2ui "
			"GL_ARB_texture_stencil8 "
			"GL_ARB_texture_storage "
			"GL_ARB_texture_storage_multisample "
			"GL_ARB_texture_swizzle "
			"GL_ARB_texture_view "
			"GL_ARB_timer_query "
			"GL_ARB_transform_feedback2 "
			"GL_ARB_transform_feedback3 "
			"GL_ARB_transform_feedback_instanced "
			"GL_ARB_transpose_matrix "
			"GL_ARB_uniform_buffer_object "
			"GL_ARB_vertex_array_bgra "
			"GL_ARB_vertex_array_object "
			"GL_ARB_vertex_attrib_64bit "
			"GL_ARB_vertex_attrib_binding "
			"GL_ARB_vertex_buffer_object "
			"GL_ARB_vertex_program "
			"GL_ARB_vertex_shader "
			"GL_ARB_vertex_type_10f_11f_11f_rev "
			"GL_ARB_vertex_type_2_10_10_10_rev "
			"GL_ARB_viewport_array "
			"GL_ARB_window_pos "
			"GL_ATI_draw_buffers "
			"GL_ATI_texture_float "
			"GL_ATI_texture_mirror_once "
			"GL_S3_s3tc "
			"GL_EXT_abgr "
			"GL_EXT_bgra "
			"GL_EXT_bindable_uniform "
			"GL_EXT_blend_color "
			"GL_EXT_blend_equation_separate "
			"GL_EXT_blend_func_separate "
			"GL_EXT_blend_minmax "
			"GL_EXT_blend_subtract "
			"GL_EXT_compiled_vertex_array "
			"GL_EXT_Cg_shader "
			"GL_EXT_depth_bounds_test "
			"GL_EXT_direct_state_access "
			"GL_EXT_draw_buffers2 "
			"GL_EXT_draw_instanced "
			"GL_EXT_draw_range_elements "
			"GL_EXT_fog_coord "
			"GL_EXT_framebuffer_blit "
			"GL_EXT_framebuffer_multisample "
			"GL_EXT_framebuffer_multisample_blit_scaled "
			"GL_EXT_framebuffer_object "
			"GL_EXT_framebuffer_sRGB "
			"GL_EXT_geometry_shader4 "
			"GL_EXT_gpu_program_parameters "
			"GL_EXT_gpu_shader4 "
			"GL_EXT_multi_draw_arrays "
			"GL_EXT_packed_depth_stencil "
			"GL_EXT_packed_float "
			"GL_EXT_packed_pixels "
			"GL_EXT_pixel_buffer_object "
			"GL_EXT_point_parameters "
			"GL_EXT_post_depth_coverage "
			"GL_EXT_provoking_vertex "
			"GL_EXT_rescale_normal "
			"GL_EXT_raster_multisample "
			"GL_EXT_secondary_color "
			"GL_EXT_separate_shader_objects "
			"GL_EXT_separate_specular_color "
			"GL_EXT_shader_image_load_formatted "
			"GL_EXT_shader_image_load_store "
			"GL_EXT_shader_integer_mix "
			"GL_EXT_shadow_funcs "
			"GL_EXT_sparse_texture2 "
			"GL_EXT_stencil_two_side "
			"GL_EXT_stencil_wrap "
			"GL_EXT_texture3D "
			"GL_EXT_texture_array "
			"GL_EXT_texture_buffer_object "
			"GL_EXT_texture_compression_dxt1 "
			"GL_EXT_texture_compression_latc "
			"GL_EXT_texture_compression_rgtc "
			"GL_EXT_texture_compression_s3tc "
			"GL_EXT_texture_cube_map "
			"GL_EXT_texture_edge_clamp "
			"GL_EXT_texture_env_add "
			"GL_EXT_texture_env_combine "
			"GL_EXT_texture_env_dot3 "
			"GL_EXT_texture_filter_anisotropic "
			"GL_EXT_texture_filter_minmax "
			"GL_EXT_texture_integer "
			"GL_EXT_texture_lod_bias "
			"GL_EXT_texture_mirror_clamp "
			"GL_EXT_texture_object "
			"GL_EXT_texture_shared_exponent "
			"GL_EXT_texture_sRGB "
			"GL_EXT_texture_sRGB_decode "
			"GL_EXT_texture_swizzle "
			"GL_EXT_timer_query "
			"GL_EXT_transform_feedback2 "
			"GL_EXT_vertex_array "
			"GL_EXT_vertex_array_bgra "
			"GL_EXT_vertex_attrib_64bit "
			"GL_EXT_import_sync_object "
			"GL_KHR_debug "
			"GL_NV_bindless_multi_draw_indirect "
			"GL_NV_bindless_texture "
			"GL_NV_blend_equation_advanced "
			"GL_NV_blend_square "
			"GL_NV_command_list "
			"GL_NV_compute_program5 "
			"GL_NV_conditional_render "
			"GL_NV_conservative_raster "
			"GL_NV_copy_depth_to_color "
			"GL_NV_copy_image "
			"GL_NV_deep_texture3D "
			"GL_NV_depth_buffer_float "
			"GL_NV_depth_clamp "
			"GL_NV_draw_texture "
			"GL_NV_explicit_multisample "
			"GL_NV_fence "
			"GL_NV_fill_rectangle "
			"GL_NV_float_buffer "
			"GL_NV_fog_distance "
			"GL_NV_fragment_coverage_to_color "
			"GL_NV_fragment_program "
			"GL_NV_fragment_program_option "
			"GL_NV_fragment_program2 "
			"GL_NV_fragment_shader_interlock "
			"GL_NV_framebuffer_mixed_samples "
			"GL_NV_framebuffer_multisample_coverage "
			"GL_NV_geometry_shader_passthrough "
			"GL_NV_geometry_shader4 "
			"GL_NV_gpu_program4 "
			"GL_NV_gpu_program5 "
			"GL_NV_gpu_program5_mem_extended "
			"GL_NV_gpu_shader5 "
			"GL_NV_half_float "
			"GL_NV_light_max_exponent "
			"GL_NV_multisample_coverage "
			"GL_NV_multisample_filter_hint "
			"GL_NV_occlusion_query "
			"GL_NV_packed_depth_stencil "
			"GL_NV_parameter_buffer_object "
			"GL_NV_parameter_buffer_object2 "
			"GL_NV_path_rendering "
			"GL_NV_path_rendering_shared_edge "
			"GL_NV_pixel_data_range "
			"GL_NV_point_sprite "
			"GL_NV_primitive_restart "
			"GL_NV_register_combiners "
			"GL_NV_register_combiners2 "
			"GL_NV_sample_locations "
			"GL_NV_sample_mask_override_coverage "
			"GL_NV_shader_atomic_counters "
			"GL_NV_shader_atomic_fp16_vector "
			"GL_NV_shader_atomic_float "
			"GL_NV_shader_buffer_load "
			"GL_NV_shader_storage_buffer_object "
			"GL_NV_shader_thread_group "
			"GL_NV_shader_thread_shuffle "
			"GL_NV_texgen_reflection "
			"GL_NV_texture_barrier "
			"GL_NV_texture_compression_vtc "
			"GL_NV_texture_env_combine4 "
			"GL_NV_texture_expand_normal "
			"GL_NV_texture_multisample "
			"GL_NV_texture_rectangle "
			"GL_NV_texture_shader "
			"GL_NV_texture_shader2 "
			"GL_NV_texture_shader3 "
			"GL_NV_transform_feedback "
			"GL_NV_transform_feedback2 "
			"GL_NV_vertex_array_range "
			"GL_NV_vertex_array_range2 "
			"GL_NV_vertex_attrib_integer_64bit "
			"GL_NV_vertex_buffer_unified_memory "
			"GL_NV_vertex_program "
			"GL_NV_vertex_program1_1 "
			"GL_NV_vertex_program2 "
			"GL_NV_vertex_program2_option "
			"GL_NV_vertex_program3 "
			"GL_NV_video_capture "
			"GL_NVX_conditional_render "
			"GL_NVX_gpu_memory_info "
			"GL_SGIS_generate_mipmap "
			"GL_SGIS_texture_lod "
			"GL_SGIX_depth_texture "
			"GL_SGIX_shadow "
			"GL_SUN_slice_accum "
			"WGL_ARB_buffer_region "
			"WGL_ARB_create_context "
			"WGL_ARB_extensions_string "
			"WGL_ARB_pbuffer "
			"WGL_ARB_pixel_format "
			"WGL ARB render texture "
			"WGL ATI pixel_format_float "
			"WGL_EXT_extensions_string "
			"WGL_EXT_pbuffer "
			"WGL_EXT_pixel_format "
			"WGL_EXT_swap_control "
			"WGL_EXT_swap_control_tear "
			"WGL_NV_dx_interop "
			"WGL_NV_gpu_affinity "
			"WGL NV render depth texture "
			"WGL NV render texture rectangle "
			"WGL_NV_swap_group "
			"WGL_NV_video_out";*/



	default:
		return error(GL_INVALID_ENUM, (GLubyte*)NULL);
	}

	return NULL;
}

void APIENTRY glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
{
	TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat* params = %p)", target, pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Texture *texture;

		switch(target)
		{
		case GL_TEXTURE_2D:
			texture = context->getTexture2D(target);
			break;
		case GL_TEXTURE_CUBE_MAP:
			texture = context->getTextureCubeMap();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		switch(pname)
		{
		case GL_TEXTURE_MAG_FILTER:
			*params = (GLfloat)texture->getMagFilter();
			break;
		case GL_TEXTURE_MIN_FILTER:
			*params = (GLfloat)texture->getMinFilter();
			break;
		case GL_TEXTURE_WRAP_S:
			*params = (GLfloat)texture->getWrapS();
			break;
		case GL_TEXTURE_WRAP_T:
			*params = (GLfloat)texture->getWrapT();
			break;
		case GL_TEXTURE_MAX_ANISOTROPY_EXT:
			*params = texture->getMaxAnisotropy();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
{
	TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = %p)", target, pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Texture *texture;

		switch(target)
		{
		case GL_TEXTURE_2D:
			texture = context->getTexture2D(target);
			break;
		case GL_TEXTURE_CUBE_MAP:
			texture = context->getTextureCubeMap();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		switch(pname)
		{
		case GL_TEXTURE_MAG_FILTER:
			*params = texture->getMagFilter();
			break;
		case GL_TEXTURE_MIN_FILTER:
			*params = texture->getMinFilter();
			break;
		case GL_TEXTURE_WRAP_S:
			*params = texture->getWrapS();
			break;
		case GL_TEXTURE_WRAP_T:
			*params = texture->getWrapT();
			break;
		case GL_TEXTURE_MAX_ANISOTROPY_EXT:
			*params = (GLint)texture->getMaxAnisotropy();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glGetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, GLfloat* params)
{
	TRACE("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLfloat* params = %p)",
	      program, location, bufSize, params);

	if(bufSize < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(program == 0)
		{
			return error(GL_INVALID_VALUE);
		}

		gl::Program *programObject = context->getProgram(program);

		if(!programObject || !programObject->isLinked())
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!programObject->getUniformfv(location, &bufSize, params))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glGetUniformfv(GLuint program, GLint location, GLfloat* params)
{
	TRACE("(GLuint program = %d, GLint location = %d, GLfloat* params = %p)", program, location, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(program == 0)
		{
			return error(GL_INVALID_VALUE);
		}

		gl::Program *programObject = context->getProgram(program);

		if(!programObject || !programObject->isLinked())
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!programObject->getUniformfv(location, NULL, params))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint* params)
{
	TRACE("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLint* params = %p)",
	      program, location, bufSize, params);

	if(bufSize < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(program == 0)
		{
			return error(GL_INVALID_VALUE);
		}

		gl::Program *programObject = context->getProgram(program);

		if(!programObject || !programObject->isLinked())
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!programObject)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!programObject->getUniformiv(location, &bufSize, params))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glGetUniformiv(GLuint program, GLint location, GLint* params)
{
	TRACE("(GLuint program = %d, GLint location = %d, GLint* params = %p)", program, location, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(program == 0)
		{
			return error(GL_INVALID_VALUE);
		}

		gl::Program *programObject = context->getProgram(program);

		if(!programObject || !programObject->isLinked())
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!programObject)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!programObject->getUniformiv(location, NULL, params))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

int APIENTRY glGetUniformLocation(GLuint program, const GLchar* name)
{
	TRACE("(GLuint program = %d, const GLchar* name = %s)", program, name);

	gl::Context *context = gl::getContext();

	if(strstr(name, "gl_") == name)
	{
		return -1;
	}

	if(context)
	{
		gl::Program *programObject = context->getProgram(program);

		if(!programObject)
		{
			if(context->getShader(program))
			{
				return error(GL_INVALID_OPERATION, -1);
			}
			else
			{
				return error(GL_INVALID_VALUE, -1);
			}
		}

		if(!programObject->isLinked())
		{
			return error(GL_INVALID_OPERATION, -1);
		}

		return programObject->getUniformLocation(name);
	}

	return -1;
}

void APIENTRY glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
{
	TRACE("(GLuint index = %d, GLenum pname = 0x%X, GLfloat* params = %p)", index, pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(index >= gl::MAX_VERTEX_ATTRIBS)
		{
			return error(GL_INVALID_VALUE);
		}

		const gl::VertexAttribute &attribState = context->getVertexAttribState(index);

		switch(pname)
		{
		case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
			*params = (GLfloat)(attribState.mArrayEnabled ? GL_TRUE : GL_FALSE);
			break;
		case GL_VERTEX_ATTRIB_ARRAY_SIZE:
			*params = (GLfloat)attribState.mSize;
			break;
		case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
			*params = (GLfloat)attribState.mStride;
			break;
		case GL_VERTEX_ATTRIB_ARRAY_TYPE:
			*params = (GLfloat)attribState.mType;
			break;
		case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
			*params = (GLfloat)(attribState.mNormalized ? GL_TRUE : GL_FALSE);
			break;
		case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
			*params = (GLfloat)attribState.mBoundBuffer.name();
			break;
		case GL_CURRENT_VERTEX_ATTRIB:
			for(int i = 0; i < 4; ++i)
			{
				params[i] = attribState.mCurrentValue[i];
			}
			break;
		default: return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
{
	TRACE("(GLuint index = %d, GLenum pname = 0x%X, GLint* params = %p)", index, pname, params);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(index >= gl::MAX_VERTEX_ATTRIBS)
		{
			return error(GL_INVALID_VALUE);
		}

		const gl::VertexAttribute &attribState = context->getVertexAttribState(index);

		switch(pname)
		{
		case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
			*params = (attribState.mArrayEnabled ? GL_TRUE : GL_FALSE);
			break;
		case GL_VERTEX_ATTRIB_ARRAY_SIZE:
			*params = attribState.mSize;
			break;
		case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
			*params = attribState.mStride;
			break;
		case GL_VERTEX_ATTRIB_ARRAY_TYPE:
			*params = attribState.mType;
			break;
		case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
			*params = (attribState.mNormalized ? GL_TRUE : GL_FALSE);
			break;
		case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
			*params = attribState.mBoundBuffer.name();
			break;
		case GL_CURRENT_VERTEX_ATTRIB:
			for(int i = 0; i < 4; ++i)
			{
				float currentValue = attribState.mCurrentValue[i];
				params[i] = (GLint)(currentValue > 0.0f ? floor(currentValue + 0.5f) : ceil(currentValue - 0.5f));
			}
			break;
		default: return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer)
{
	TRACE("(GLuint index = %d, GLenum pname = 0x%X, GLvoid** pointer = %p)", index, pname, pointer);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(index >= gl::MAX_VERTEX_ATTRIBS)
		{
			return error(GL_INVALID_VALUE);
		}

		if(pname != GL_VERTEX_ATTRIB_ARRAY_POINTER)
		{
			return error(GL_INVALID_ENUM);
		}

		*pointer = const_cast<GLvoid*>(context->getVertexAttribPointer(index));
	}
}

void APIENTRY glHint(GLenum target, GLenum mode)
{
	TRACE("(GLenum target = 0x%X, GLenum mode = 0x%X)", target, mode);

	switch(mode)
	{
	case GL_FASTEST:
	case GL_NICEST:
	case GL_DONT_CARE:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();
	switch(target)
	{
	case GL_GENERATE_MIPMAP_HINT:
		if(context) context->setGenerateMipmapHint(mode);
		break;
	case GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
		if(context) context->setFragmentShaderDerivativeHint(mode);
		break;
	default:
		return error(GL_INVALID_ENUM);
	}
}

GLboolean APIENTRY glIsBuffer(GLuint buffer)
{
	TRACE("(GLuint buffer = %d)", buffer);

	gl::Context *context = gl::getContext();

	if(context && buffer)
	{
		gl::Buffer *bufferObject = context->getBuffer(buffer);

		if(bufferObject)
		{
			return GL_TRUE;
		}
	}

	return GL_FALSE;
}

GLboolean APIENTRY glIsEnabled(GLenum cap)
{
	TRACE("(GLenum cap = 0x%X)", cap);

	gl::Context *context = gl::getContext();

	if(context)
	{
		switch(cap)
		{
		case GL_CULL_FACE:                return context->isCullFaceEnabled();
		case GL_POLYGON_OFFSET_FILL:      return context->isPolygonOffsetFillEnabled();
		case GL_SAMPLE_ALPHA_TO_COVERAGE: return context->isSampleAlphaToCoverageEnabled();
		case GL_SAMPLE_COVERAGE:          return context->isSampleCoverageEnabled();
		case GL_SCISSOR_TEST:             return context->isScissorTestEnabled();
		case GL_STENCIL_TEST:             return context->isStencilTestEnabled();
		case GL_DEPTH_TEST:               return context->isDepthTestEnabled();
		case GL_BLEND:                    return context->isBlendEnabled();
		case GL_DITHER:                   return context->isDitherEnabled();
		default:
			return error(GL_INVALID_ENUM, false);
		}
	}

	return false;
}

GLboolean APIENTRY glIsFenceNV(GLuint fence)
{
	TRACE("(GLuint fence = %d)", fence);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Fence *fenceObject = context->getFence(fence);

		if(fenceObject == NULL)
		{
			return GL_FALSE;
		}

		return fenceObject->isFence();
	}

	return GL_FALSE;
}

GLboolean APIENTRY glIsFramebuffer(GLuint framebuffer)
{
	TRACE("(GLuint framebuffer = %d)", framebuffer);

	gl::Context *context = gl::getContext();

	if(context && framebuffer)
	{
		gl::Framebuffer *framebufferObject = context->getFramebuffer(framebuffer);

		if(framebufferObject)
		{
			return GL_TRUE;
		}
	}

	return GL_FALSE;
}

GLboolean APIENTRY glIsProgram(GLuint program)
{
	TRACE("(GLuint program = %d)", program);

	gl::Context *context = gl::getContext();

	if(context && program)
	{
		gl::Program *programObject = context->getProgram(program);

		if(programObject)
		{
			return GL_TRUE;
		}
	}

	return GL_FALSE;
}

GLboolean APIENTRY glIsQueryEXT(GLuint name)
{
	TRACE("(GLuint name = %d)", name);

	if(name == 0)
	{
		return GL_FALSE;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Query *queryObject = context->getQuery(name, false, GL_NONE);

		if(queryObject)
		{
			return GL_TRUE;
		}
	}

	return GL_FALSE;
}

GLboolean APIENTRY glIsRenderbuffer(GLuint renderbuffer)
{
	TRACE("(GLuint renderbuffer = %d)", renderbuffer);

	gl::Context *context = gl::getContext();

	if(context && renderbuffer)
	{
		gl::Renderbuffer *renderbufferObject = context->getRenderbuffer(renderbuffer);

		if(renderbufferObject)
		{
			return GL_TRUE;
		}
	}

	return GL_FALSE;
}

GLboolean APIENTRY glIsShader(GLuint shader)
{
	TRACE("(GLuint shader = %d)", shader);

	gl::Context *context = gl::getContext();

	if(context && shader)
	{
		gl::Shader *shaderObject = context->getShader(shader);

		if(shaderObject)
		{
			return GL_TRUE;
		}
	}

	return GL_FALSE;
}

GLboolean APIENTRY glIsTexture(GLuint texture)
{
	TRACE("(GLuint texture = %d)", texture);

	gl::Context *context = gl::getContext();

	if(context && texture)
	{
		gl::Texture *textureObject = context->getTexture(texture);

		if(textureObject)
		{
			return GL_TRUE;
		}
	}

	return GL_FALSE;
}

void APIENTRY glLineWidth(GLfloat width)
{
	TRACE("(GLfloat width = %f)", width);

	if(width <= 0.0f)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setLineWidth(width);
	}
}

void APIENTRY glLinkProgram(GLuint program)
{
	TRACE("(GLuint program = %d)", program);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Program *programObject = context->getProgram(program);

		if(!programObject)
		{
			if(context->getShader(program))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		programObject->link();
	}
}

void APIENTRY glPixelStorei(GLenum pname, GLint param)
{
	TRACE("(GLenum pname = 0x%X, GLint param = %d)", pname, param);

	gl::Context *context = gl::getContext();

	if(context)
	{
		switch(pname)
		{
		case GL_UNPACK_SWAP_BYTES:
			if(param != GL_TRUE && param != GL_FALSE)
			{
				return error(GL_INVALID_VALUE);
			}
			context->setUnpackSwapBytes(param);
			if(param == GL_TRUE)
			{
				UNIMPLEMENTED();
			}
			break;
		case GL_UNPACK_LSB_FIRST:
			if(param != GL_TRUE && param != GL_FALSE)
			{
				return error(GL_INVALID_VALUE);
			}
			context->setUnpackLsbFirst(param);
			if(param == GL_TRUE)
			{
				UNIMPLEMENTED();
			}
			break;
		case GL_UNPACK_ROW_LENGTH:
			if(param < 0)
			{
				return error(GL_INVALID_VALUE);
			}
			context->setUnpackRowLength(param);
			break;
		case GL_UNPACK_SKIP_ROWS:
			if(param < 0)
			{
				return error(GL_INVALID_VALUE);
			}
			context->setUnpackSkipRows(param);
			break;
		case GL_UNPACK_SKIP_PIXELS:
			if(param < 0)
			{
				return error(GL_INVALID_VALUE);
			}
			context->setUnpackSkipPixels(param);
			break;
		case GL_UNPACK_ALIGNMENT:
			if(param != 1 && param != 2 && param != 4 && param != 8)
			{
				return error(GL_INVALID_VALUE);
			}
			context->setUnpackAlignment(param);
			break;
		case GL_PACK_ALIGNMENT:
			if(param != 1 && param != 2 && param != 4 && param != 8)
			{
				return error(GL_INVALID_VALUE);
			}
			context->setPackAlignment(param);
			break;
		case GL_UNPACK_SKIP_IMAGES:
			if(param < 0)
			{
				return error(GL_INVALID_VALUE);
			}
			context->setUnpackSkipImages(param);
			if(param != 0)
			{
				UNIMPLEMENTED();
			}
			break;
		case GL_UNPACK_IMAGE_HEIGHT:
			if(param < 0)
			{
				return error(GL_INVALID_VALUE);
			}
			context->setUnpackImageHeight(param);
			if(param != 0)
			{
				UNIMPLEMENTED();
			}
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glPolygonOffset(GLfloat factor, GLfloat units)
{
	TRACE("(GLfloat factor = %f, GLfloat units = %f)", factor, units);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setPolygonOffsetParams(factor, units);
	}
}

void APIENTRY glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height,
                                  GLenum format, GLenum type, GLsizei bufSize, GLvoid *data)
{
	TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
	      "GLenum format = 0x%X, GLenum type = 0x%X, GLsizei bufSize = 0x%d, GLvoid *data = %p)",
	      x, y, width, height, format, type, bufSize, data);

	if(width < 0 || height < 0 || bufSize < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(!validReadFormatType(format, type))
	{
		return error(GL_INVALID_OPERATION);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->readPixels(x, y, width, height, format, type, &bufSize, data);
	}
}

void APIENTRY glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
{
	TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
	      "GLenum format = 0x%X, GLenum type = 0x%X, GLvoid* pixels = %p)",
	      x, y, width, height, format, type,  pixels);

	if(width < 0 || height < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(!validReadFormatType(format, type))
	{
		return error(GL_INVALID_OPERATION);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		context->readPixels(x, y, width, height, format, type, NULL, pixels);
	}
}

void APIENTRY glReleaseShaderCompiler(void)
{
	TRACE("()");

	gl::Shader::releaseCompiler();
}

void APIENTRY glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
	TRACE("(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d)",
	      target, samples, internalformat, width, height);

	switch(target)
	{
	case GL_RENDERBUFFER:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	if(!gl::IsColorRenderable(internalformat) && !gl::IsDepthRenderable(internalformat) && !gl::IsStencilRenderable(internalformat))
	{
		return error(GL_INVALID_ENUM);
	}

	if(width < 0 || height < 0 || samples < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(width > gl::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE || 
		   height > gl::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE ||
		   samples > gl::IMPLEMENTATION_MAX_SAMPLES)
		{
			return error(GL_INVALID_VALUE);
		}

		GLuint handle = context->getRenderbufferName();
		if(handle == 0)
		{
			return error(GL_INVALID_OPERATION);
		}

		switch(internalformat)
		{
		case GL_DEPTH_COMPONENT16:
		case GL_DEPTH_COMPONENT24:
			context->setRenderbufferStorage(new gl::Depthbuffer(width, height, samples));
			break;
		case GL_RGBA4:
		case GL_RGB5_A1:
		case GL_RGB565:
		case GL_RGB8_EXT:
		case GL_RGBA8_EXT:
			context->setRenderbufferStorage(new gl::Colorbuffer(width, height, internalformat, samples));
			break;
		case GL_STENCIL_INDEX8:
			context->setRenderbufferStorage(new gl::Stencilbuffer(width, height, samples));
			break;
		case GL_DEPTH24_STENCIL8_EXT:
			context->setRenderbufferStorage(new gl::DepthStencilbuffer(width, height, samples));
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
	glRenderbufferStorageMultisampleANGLE(target, 0, internalformat, width, height);
}

void APIENTRY glSampleCoverage(GLclampf value, GLboolean invert)
{
	TRACE("(GLclampf value = %f, GLboolean invert = %d)", value, invert);

	gl::Context* context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setSampleCoverageParams(gl::clamp01(value), invert == GL_TRUE);
	}
}

void APIENTRY glSetFenceNV(GLuint fence, GLenum condition)
{
	TRACE("(GLuint fence = %d, GLenum condition = 0x%X)", fence, condition);

	if(condition != GL_ALL_COMPLETED_NV)
	{
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Fence *fenceObject = context->getFence(fence);

		if(fenceObject == NULL)
		{
			return error(GL_INVALID_OPERATION);
		}

		fenceObject->setFence(condition);
	}
}

void APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
	TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width, height);

	if(width < 0 || height < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context* context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setScissorParams(x, y, width, height);
	}
}

void APIENTRY glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length)
{
	TRACE("(GLsizei n = %d, const GLuint* shaders = %p, GLenum binaryformat = 0x%X, "
	      "const GLvoid* binary = %p, GLsizei length = %d)",
	      n, shaders, binaryformat, binary, length);

	// No binary shader formats are supported.
	return error(GL_INVALID_ENUM);
}

void APIENTRY glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
{
	TRACE("(GLuint shader = %d, GLsizei count = %d, const GLchar** string = %p, const GLint* length = %p)",
	      shader, count, string, length);

	if(count < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Shader *shaderObject = context->getShader(shader);

		if(!shaderObject)
		{
			if(context->getProgram(shader))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		shaderObject->setSource(count, string, length);
	}
}

void APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask)
{
	glStencilFuncSeparate(GL_FRONT_AND_BACK, func, ref, mask);
}

void APIENTRY glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
	TRACE("(GLenum face = 0x%X, GLenum func = 0x%X, GLint ref = %d, GLuint mask = %d)", face, func, ref, mask);

	switch(face)
	{
	case GL_FRONT:
	case GL_BACK:
	case GL_FRONT_AND_BACK:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	switch(func)
	{
	case GL_NEVER:
	case GL_ALWAYS:
	case GL_LESS:
	case GL_LEQUAL:
	case GL_EQUAL:
	case GL_GEQUAL:
	case GL_GREATER:
	case GL_NOTEQUAL:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(face == GL_FRONT || face == GL_FRONT_AND_BACK)
		{
			context->setStencilParams(func, ref, mask);
		}

		if(face == GL_BACK || face == GL_FRONT_AND_BACK)
		{
			context->setStencilBackParams(func, ref, mask);
		}
	}
}

void APIENTRY glStencilMask(GLuint mask)
{
	glStencilMaskSeparate(GL_FRONT_AND_BACK, mask);
}

void APIENTRY glStencilMaskSeparate(GLenum face, GLuint mask)
{
	TRACE("(GLenum face = 0x%X, GLuint mask = %d)", face, mask);

	switch(face)
	{
	case GL_FRONT:
	case GL_BACK:
	case GL_FRONT_AND_BACK:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(face == GL_FRONT || face == GL_FRONT_AND_BACK)
		{
			context->setStencilWritemask(mask);
		}

		if(face == GL_BACK || face == GL_FRONT_AND_BACK)
		{
			context->setStencilBackWritemask(mask);
		}
	}
}

void APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
	glStencilOpSeparate(GL_FRONT_AND_BACK, fail, zfail, zpass);
}

void APIENTRY glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
{
	TRACE("(GLenum face = 0x%X, GLenum fail = 0x%X, GLenum zfail = 0x%X, GLenum zpas = 0x%Xs)",
	      face, fail, zfail, zpass);

	switch(face)
	{
	case GL_FRONT:
	case GL_BACK:
	case GL_FRONT_AND_BACK:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	switch(fail)
	{
	case GL_ZERO:
	case GL_KEEP:
	case GL_REPLACE:
	case GL_INCR:
	case GL_DECR:
	case GL_INVERT:
	case GL_INCR_WRAP:
	case GL_DECR_WRAP:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	switch(zfail)
	{
	case GL_ZERO:
	case GL_KEEP:
	case GL_REPLACE:
	case GL_INCR:
	case GL_DECR:
	case GL_INVERT:
	case GL_INCR_WRAP:
	case GL_DECR_WRAP:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	switch(zpass)
	{
	case GL_ZERO:
	case GL_KEEP:
	case GL_REPLACE:
	case GL_INCR:
	case GL_DECR:
	case GL_INVERT:
	case GL_INCR_WRAP:
	case GL_DECR_WRAP:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(face == GL_FRONT || face == GL_FRONT_AND_BACK)
		{
			context->setStencilOperations(fail, zfail, zpass);
		}

		if(face == GL_BACK || face == GL_FRONT_AND_BACK)
		{
			context->setStencilBackOperations(fail, zfail, zpass);
		}
	}
}

GLboolean APIENTRY glTestFenceNV(GLuint fence)
{
	TRACE("(GLuint fence = %d)", fence);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Fence *fenceObject = context->getFence(fence);

		if(fenceObject == NULL)
		{
			return error(GL_INVALID_OPERATION, GL_TRUE);
		}

		return fenceObject->testFence();
	}

	return GL_TRUE;
}

void APIENTRY glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
                              GLint border, GLenum format, GLenum type, const GLvoid* pixels)
{
	TRACE("(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, GLsizei height = %d, "
	      "GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X, const GLvoid* pixels =  %p)",
	      target, level, internalformat, width, height, border, format, type, pixels);

	if(!validImageSize(level, width, height))
	{
		return error(GL_INVALID_VALUE);
	}

	if(internalformat != format)
	{
		//TRACE("UNIMPLEMENTED!!");
		//return error(GL_INVALID_OPERATION);
	}

	switch(format)
	{
	case GL_ALPHA:
	case GL_LUMINANCE:
	case GL_LUMINANCE_ALPHA:
		switch(type)
		{
		case GL_UNSIGNED_BYTE:
		case GL_FLOAT:
		case GL_HALF_FLOAT:
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
		break;
	case GL_RGB:
		switch(type)
		{
		case GL_UNSIGNED_BYTE:
		case GL_UNSIGNED_SHORT_5_6_5:
		case GL_FLOAT:
		case GL_HALF_FLOAT:
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
		break;
	case GL_RGBA:
		switch(type)
		{
		case GL_UNSIGNED_BYTE:
		case GL_UNSIGNED_SHORT_4_4_4_4:
		case GL_UNSIGNED_SHORT_5_5_5_1:
		case GL_FLOAT:
		case GL_HALF_FLOAT:
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
		break;
	case GL_BGRA_EXT:
		switch(type)
		{
		case GL_UNSIGNED_BYTE:
		case GL_UNSIGNED_SHORT_5_6_5:
		case GL_UNSIGNED_INT_8_8_8_8_REV:
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
		break;
	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:  // error cases for compressed textures are handled below
	case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
	case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
	case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
		break;
	case GL_DEPTH_COMPONENT:
		switch(type)
		{
		case GL_UNSIGNED_SHORT:
		case GL_UNSIGNED_INT:
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
		break;
	case GL_DEPTH_STENCIL_EXT:
		switch(type)
		{
		case GL_UNSIGNED_INT_24_8_EXT:
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
		break;
	default:
		return error(GL_INVALID_VALUE);
	}

	if(border != 0)
	{
		return error(GL_INVALID_VALUE);
	}

	switch(target)
	{
	case GL_TEXTURE_1D:
	case GL_TEXTURE_2D:
	case GL_TEXTURE_RECTANGLE:
		if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
		   height > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level))
		{
			return error(GL_INVALID_VALUE);
		}
		break;
	case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
	case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
	case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
	case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
		if(width != height)
		{
			return error(GL_INVALID_VALUE);
		}

		if(width > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level) ||
		   height > (gl::IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE >> level))
		{
			return error(GL_INVALID_VALUE);
		}
		break;
	case GL_PROXY_TEXTURE_2D:
		pixels = 0;

		if(width > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level) ||
		   height > (gl::IMPLEMENTATION_MAX_TEXTURE_SIZE >> level))
		{
			//UNIMPLEMENTED();
			width = 0;
			height = 0;
			internalformat = GL_NONE;
			format = GL_NONE;
			type = GL_NONE;

			//return;// error(GL_INVALID_VALUE);
		}
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	if(format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
	   format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||
	   format == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ||
	   format == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
	{
		if(S3TC_SUPPORT)
		{
			return error(GL_INVALID_OPERATION);
		}
		else
		{
			return error(GL_INVALID_ENUM);
		}
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(target == GL_TEXTURE_1D)
		{
			gl::Texture1D *texture = context->getTexture1D();

			if(!texture)
			{
				return error(GL_INVALID_OPERATION);
			}

			texture->setImage(level, width, height, format, type, context->getUnpackAlignment(), pixels);
		}
		else if(target == GL_TEXTURE_2D || target == GL_PROXY_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE)
		{
			gl::Texture2D *texture = context->getTexture2D(target);

			if(!texture)
			{
				return error(GL_INVALID_OPERATION);
			}

			texture->setImage(level, width, height, format, type, context->getUnpackAlignment(), pixels);
		}
		else
		{
			gl::TextureCubeMap *texture = context->getTextureCubeMap();

			if(!texture)
			{
				return error(GL_INVALID_OPERATION);
			}

			texture->setImage(target, level, width, height, format, type, context->getUnpackAlignment(), pixels);
		}
	}
}

void APIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param)
{
	TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", target, pname, param);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Texture *texture;

		switch(target)
		{
		case GL_TEXTURE_2D:
			texture = context->getTexture2D(target);
			break;
		case GL_TEXTURE_CUBE_MAP:
			texture = context->getTextureCubeMap();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		switch(pname)
		{
		case GL_TEXTURE_WRAP_S:
			if(!texture->setWrapS((GLenum)param))
			{
				return error(GL_INVALID_ENUM);
			}
			break;
		case GL_TEXTURE_WRAP_T:
			if(!texture->setWrapT((GLenum)param))
			{
				return error(GL_INVALID_ENUM);
			}
			break;
		case GL_TEXTURE_MIN_FILTER:
			if(!texture->setMinFilter((GLenum)param))
			{
				return error(GL_INVALID_ENUM);
			}
			break;
		case GL_TEXTURE_MAG_FILTER:
			if(!texture->setMagFilter((GLenum)param))
			{
				return error(GL_INVALID_ENUM);
			}
			break;
		case GL_TEXTURE_MAX_ANISOTROPY_EXT:
			if(!texture->setMaxAnisotropy(param))
			{
				return error(GL_INVALID_VALUE);
			}
			break;
		case GL_TEXTURE_MIN_LOD:
			//TRACE("() UNIMPLEMENTED!!");   // FIXME
			//UNIMPLEMENTED();
			break;
		case GL_TEXTURE_MAX_LOD:
			//TRACE("() UNIMPLEMENTED!!");   // FIXME
			//UNIMPLEMENTED();
			break;
		case GL_TEXTURE_LOD_BIAS:
			if(param != 0.0f)
			{
				UNIMPLEMENTED();
			}
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
{
	glTexParameterf(target, pname, *params);
}

void APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param)
{
	TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %d)", target, pname, param);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Texture *texture;

		switch(target)
		{
		case GL_TEXTURE_RECTANGLE:
			if(!context->getRectangleTextureEnable())
			{
				return error(GL_INVALID_VALUE);
			}
		case GL_TEXTURE_1D:
			texture = context->getTexture1D();
			break;
		case GL_TEXTURE_2D:
			texture = context->getTexture2D(target);
			break;
		case GL_TEXTURE_CUBE_MAP:
			texture = context->getTextureCubeMap();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}

		switch(pname)
		{
		case GL_TEXTURE_WRAP_S:
			if(!texture->setWrapS((GLenum)param))
			{
				return error(GL_INVALID_ENUM);
			}
			break;
		case GL_TEXTURE_WRAP_T:
			if(!texture->setWrapT((GLenum)param))
			{
				return error(GL_INVALID_ENUM);
			}
			break;
		case GL_TEXTURE_MIN_FILTER:
			if(!texture->setMinFilter((GLenum)param))
			{
				return error(GL_INVALID_ENUM);
			}
			break;
		case GL_TEXTURE_MAG_FILTER:
			if(!texture->setMagFilter((GLenum)param))
			{
				return error(GL_INVALID_ENUM);
			}
			break;
		case GL_TEXTURE_MAX_ANISOTROPY_EXT:
			if(!texture->setMaxAnisotropy((GLfloat)param))
			{
				return error(GL_INVALID_VALUE);
			}
			break;
		case GL_TEXTURE_MAX_LEVEL:
			if(!texture->setMaxLevel(param))
			{
				return error(GL_INVALID_ENUM);
			}
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
{
	glTexParameteri(target, pname, *params);
}

void APIENTRY glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
                              GLenum format, GLenum type, const GLvoid* pixels)
{
	TRACE("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
	      "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, GLenum type = 0x%X, "
	      "const GLvoid* pixels = %p)",
	      target, level, xoffset, yoffset, width, height, format, type, pixels);

	if(!gl::IsTextureTarget(target))
	{
		return error(GL_INVALID_ENUM);
	}

	if(level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
	{
		return error(GL_INVALID_VALUE);
	}

	if(!gl::CheckTextureFormatType(format, type))
	{
		return error(GL_INVALID_ENUM);
	}

	if(width == 0 || height == 0 || pixels == NULL)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(level > gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
		{
			return error(GL_INVALID_VALUE);
		}
		if(target == GL_TEXTURE_1D)
		{
			gl::Texture1D *texture = context->getTexture1D();

			if(validateSubImageParams(false, width, height, xoffset, yoffset, target, level, format, texture))
			{
				texture->subImage(level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
			}
		}
		else if(target == GL_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE)
		{
			gl::Texture2D *texture = context->getTexture2D(target);

			if(validateSubImageParams(false, width, height, xoffset, yoffset, target, level, format, texture))
			{
				texture->subImage(level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
			}
		}
		else if(gl::IsCubemapTextureTarget(target))
		{
			gl::TextureCubeMap *texture = context->getTextureCubeMap();

			if(validateSubImageParams(false, width, height, xoffset, yoffset, target, level, format, texture))
			{
				texture->subImage(target, level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
			}
		}
		else
		{
			UNREACHABLE();
		}
	}
}

void APIENTRY glUniform1f(GLint location, GLfloat x)
{
	glUniform1fv(location, 1, &x);
}

void APIENTRY glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
{
	TRACE("(GLint location = %d, GLsizei count = %d, const GLfloat* v = %p)", location, count, v);

	if(count < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(location == -1)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Program *program = context->getCurrentProgram();

		if(!program)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!program->setUniform1fv(location, count, v))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glUniform1i(GLint location, GLint x)
{
	glUniform1iv(location, 1, &x);
}

void APIENTRY glUniform1iv(GLint location, GLsizei count, const GLint* v)
{
	TRACE("(GLint location = %d, GLsizei count = %d, const GLint* v = %p)", location, count, v);

	if(count < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(location == -1)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Program *program = context->getCurrentProgram();

		if(!program)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!program->setUniform1iv(location, count, v))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glUniform2f(GLint location, GLfloat x, GLfloat y)
{
	GLfloat xy[2] = {x, y};

	glUniform2fv(location, 1, (GLfloat*)&xy);
}

void APIENTRY glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
{
	TRACE("(GLint location = %d, GLsizei count = %d, const GLfloat* v = %p)", location, count, v);

	if(count < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(location == -1)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Program *program = context->getCurrentProgram();

		if(!program)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!program->setUniform2fv(location, count, v))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glUniform2i(GLint location, GLint x, GLint y)
{
	GLint xy[4] = {x, y};

	glUniform2iv(location, 1, (GLint*)&xy);
}

void APIENTRY glUniform2iv(GLint location, GLsizei count, const GLint* v)
{
	TRACE("(GLint location = %d, GLsizei count = %d, const GLint* v = %p)", location, count, v);

	if(count < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(location == -1)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Program *program = context->getCurrentProgram();

		if(!program)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!program->setUniform2iv(location, count, v))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
{
	GLfloat xyz[3] = {x, y, z};

	glUniform3fv(location, 1, (GLfloat*)&xyz);
}

void APIENTRY glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
{
	TRACE("(GLint location = %d, GLsizei count = %d, const GLfloat* v = %p)", location, count, v);

	if(count < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(location == -1)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Program *program = context->getCurrentProgram();

		if(!program)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!program->setUniform3fv(location, count, v))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glUniform3i(GLint location, GLint x, GLint y, GLint z)
{
	GLint xyz[3] = {x, y, z};

	glUniform3iv(location, 1, (GLint*)&xyz);
}

void APIENTRY glUniform3iv(GLint location, GLsizei count, const GLint* v)
{
	TRACE("(GLint location = %d, GLsizei count = %d, const GLint* v = %p)", location, count, v);

	if(count < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(location == -1)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Program *program = context->getCurrentProgram();

		if(!program)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!program->setUniform3iv(location, count, v))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	GLfloat xyzw[4] = {x, y, z, w};

	glUniform4fv(location, 1, (GLfloat*)&xyzw);
}

void APIENTRY glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
{
	TRACE("(GLint location = %d, GLsizei count = %d, const GLfloat* v = %p)", location, count, v);

	if(count < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(location == -1)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Program *program = context->getCurrentProgram();

		if(!program)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!program->setUniform4fv(location, count, v))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
{
	GLint xyzw[4] = {x, y, z, w};

	glUniform4iv(location, 1, (GLint*)&xyzw);
}

void APIENTRY glUniform4iv(GLint location, GLsizei count, const GLint* v)
{
	TRACE("(GLint location = %d, GLsizei count = %d, const GLint* v = %p)", location, count, v);

	if(count < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(location == -1)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Program *program = context->getCurrentProgram();

		if(!program)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!program->setUniform4iv(location, count, v))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = %p)",
	      location, count, transpose, value);

	if(count < 0 || transpose != GL_FALSE)
	{
		return error(GL_INVALID_VALUE);
	}

	if(location == -1)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Program *program = context->getCurrentProgram();

		if(!program)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!program->setUniformMatrix2fv(location, count, value))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = %p)",
	      location, count, transpose, value);

	if(count < 0 || transpose != GL_FALSE)
	{
		return error(GL_INVALID_VALUE);
	}

	if(location == -1)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Program *program = context->getCurrentProgram();

		if(!program)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!program->setUniformMatrix3fv(location, count, value))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
	TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = %p)",
	      location, count, transpose, value);

	if(count < 0 || transpose != GL_FALSE)
	{
		return error(GL_INVALID_VALUE);
	}

	if(location == -1)
	{
		return;
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Program *program = context->getCurrentProgram();

		if(!program)
		{
			return error(GL_INVALID_OPERATION);
		}

		if(!program->setUniformMatrix4fv(location, count, value))
		{
			return error(GL_INVALID_OPERATION);
		}
	}
}

void APIENTRY glUseProgram(GLuint program)
{
	TRACE("(GLuint program = %d)", program);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Program *programObject = context->getProgram(program);

		if(!programObject && program != 0)
		{
			if(context->getShader(program))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		if(program != 0 && !programObject->isLinked())
		{
			return error(GL_INVALID_OPERATION);
		}

		context->useProgram(program);
	}
}

void APIENTRY glValidateProgram(GLuint program)
{
	TRACE("(GLuint program = %d)", program);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Program *programObject = context->getProgram(program);

		if(!programObject)
		{
			if(context->getShader(program))
			{
				return error(GL_INVALID_OPERATION);
			}
			else
			{
				return error(GL_INVALID_VALUE);
			}
		}

		programObject->validate();
	}
}

void APIENTRY glVertexAttrib1f(GLuint index, GLfloat x)
{
	TRACE("(GLuint index = %d, GLfloat x = %f)", index, x);

	if(index >= gl::MAX_VERTEX_ATTRIBS)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		//GLfloat vals[4] = { x, 0, 0, 1 };
		context->setVertexAttrib(index, x, 0, 0, 1);
	}
}

void APIENTRY glVertexAttrib1fv(GLuint index, const GLfloat* values)
{
	TRACE("(GLuint index = %d, const GLfloat* values = %p)", index, values);

	if(index >= gl::MAX_VERTEX_ATTRIBS)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		//GLfloat vals[4] = { values[0], 0, 0, 1 };
		context->setVertexAttrib(index, values[0], 0, 0, 1);
	}
}

void APIENTRY glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
	TRACE("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f)", index, x, y);

	if(index >= gl::MAX_VERTEX_ATTRIBS)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		//GLfloat vals[4] = { x, y, 0, 1 };
		context->setVertexAttrib(index, x, y, 0, 1);
	}
}

void APIENTRY glVertexAttrib2fv(GLuint index, const GLfloat* values)
{
	TRACE("(GLuint index = %d, const GLfloat* values = %p)", index, values);

	if(index >= gl::MAX_VERTEX_ATTRIBS)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		//GLfloat vals[4] = {  };
		context->setVertexAttrib(index, values[0], values[1], 0, 1);
	}
}

void APIENTRY glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
	TRACE("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", index, x, y, z);

	if(index >= gl::MAX_VERTEX_ATTRIBS)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		//GLfloat vals[4] = { x, y, z, 1 };
		context->setVertexAttrib(index, x, y, z, 1);
	}
}

void APIENTRY glVertexAttrib3fv(GLuint index, const GLfloat* values)
{
	TRACE("(GLuint index = %d, const GLfloat* values = %p)", index, values);

	if(index >= gl::MAX_VERTEX_ATTRIBS)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		//GLfloat vals[4] = { values[0], values[1], values[2], 1 };
		context->setVertexAttrib(index, values[0], values[1], values[2], 1);
	}
}

void APIENTRY glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	TRACE("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat w = %f)", index, x, y, z, w);

	if(index >= gl::MAX_VERTEX_ATTRIBS)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		//GLfloat vals[4] = { x, y, z, w };
		context->setVertexAttrib(index, x, y, z, w);
	}
}

void APIENTRY glVertexAttrib4fv(GLuint index, const GLfloat* values)
{
	TRACE("(GLuint index = %d, const GLfloat* values = %p)", index, values);

	if(index >= gl::MAX_VERTEX_ATTRIBS)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setVertexAttrib(index, values[0], values[1], values[2], values[3]);
	}
}

void APIENTRY glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr)
{
	TRACE("(GLuint index = %d, GLint size = %d, GLenum type = 0x%X, "
	      "GLboolean normalized = %d, GLsizei stride = %d, const GLvoid* ptr = %p)",
	      index, size, type, normalized, stride, ptr);

	if(index >= gl::MAX_VERTEX_ATTRIBS)
	{
		return error(GL_INVALID_VALUE);
	}

	if(size < 1 || size > 4)
	{
		return error(GL_INVALID_VALUE);
	}

	switch(type)
	{
	case GL_BYTE:
	case GL_UNSIGNED_BYTE:
	case GL_SHORT:
	case GL_UNSIGNED_SHORT:
	case GL_FIXED:
	case GL_FLOAT:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	if(stride < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		context->setVertexAttribState(index, context->getArrayBuffer(), size, type, (normalized == GL_TRUE), stride, ptr);
	}
}

void APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
	TRACE("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width, height);

	if(width < 0 || height < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setViewportParams(x, y, width, height);
	}
}

void APIENTRY glBlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
                                        GLbitfield mask, GLenum filter)
{
	TRACE("(GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, "
	      "GLint dstX0 = %d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, "
	      "GLbitfield mask = 0x%X, GLenum filter = 0x%X)",
	      srcX0, srcY0, srcX1, srcX1, dstX0, dstY0, dstX1, dstY1, mask, filter);

	switch(filter)
	{
	case GL_NEAREST:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	if((mask & ~(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)) != 0)
	{
		return error(GL_INVALID_VALUE);
	}

	if(srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0)
	{
		ERR("Scaling and flipping in BlitFramebufferANGLE not supported by this implementation");
		return error(GL_INVALID_OPERATION);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		if(context->getReadFramebufferName() == context->getDrawFramebufferName())
		{
			ERR("Blits with the same source and destination framebuffer are not supported by this implementation.");
			return error(GL_INVALID_OPERATION);
		}

		context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask);
	}
}

void APIENTRY glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
                                 GLint border, GLenum format, GLenum type, const GLvoid* pixels)
{
	TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, "
	      "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, "
	      "GLenum format = 0x%X, GLenum type = 0x%x, const GLvoid* pixels = %p)",
	      target, level, internalformat, width, height, depth, border, format, type, pixels);

	UNIMPLEMENTED();   // FIXME
}

void WINAPI GlmfBeginGlsBlock()
{
	UNIMPLEMENTED();
}

void WINAPI GlmfCloseMetaFile()
{
	UNIMPLEMENTED();
}

void WINAPI GlmfEndGlsBlock()
{
	UNIMPLEMENTED();
}

void WINAPI GlmfEndPlayback()
{
	UNIMPLEMENTED();
}

void WINAPI GlmfInitPlayback()
{
	UNIMPLEMENTED();
}

void WINAPI GlmfPlayGlsRecord()
{
	UNIMPLEMENTED();
}

void APIENTRY glAccum(GLenum op, GLfloat value)
{
	UNIMPLEMENTED();
}

void APIENTRY glAlphaFunc(GLenum func, GLclampf ref)
{
	TRACE("(GLenum func = 0x%X, GLclampf ref = %f)", func, ref);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->alphaFunc(func, ref);
	}
}

GLboolean APIENTRY glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
{
	UNIMPLEMENTED();
	return GL_FALSE;
}

void APIENTRY glArrayElement(GLint i)
{
	UNIMPLEMENTED();
}

void APIENTRY glBegin(GLenum mode)
{
	TRACE("(GLenum mode = 0x%X)", mode);
	
	switch(mode)
	{
	case GL_POINTS:
	case GL_LINES:
	case GL_LINE_STRIP:
	case GL_LINE_LOOP:
	case GL_TRIANGLES:
	case GL_TRIANGLE_STRIP:
	case GL_TRIANGLE_FAN:
	case GL_QUADS:
	case GL_QUAD_STRIP:
	case GL_POLYGON:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->begin(mode);
	}
}

void APIENTRY glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
{
	UNIMPLEMENTED();
}

void APIENTRY glCallList(GLuint list)
{
	TRACE("(GLuint list = %d)", list);

	if(list == 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->callList(list);
	}
}

void APIENTRY glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
{
	TRACE("(GLsizei n = %d, GLenum type = 0x%X, const GLvoid *lists)", n, type);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		for(int i = 0; i < n; i++)
		{
			switch(type)
			{
			case GL_UNSIGNED_INT: context->callList(((unsigned int*)lists)[i]); break;
			default:
				UNIMPLEMENTED();
				UNREACHABLE();
			}
		}
	}
}

void APIENTRY glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
	UNIMPLEMENTED();
}

void APIENTRY glClearDepth(GLclampd depth)
{
	TRACE("(GLclampd depth = %d)", depth);
	
	glClearDepthf((float)depth);   // FIXME
}

void APIENTRY glClearIndex(GLfloat c)
{
	UNIMPLEMENTED();
}

void APIENTRY glClipPlane(GLenum plane, const GLdouble *equation)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3b(GLbyte red, GLbyte green, GLbyte blue)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3bv(const GLbyte *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3d(GLdouble red, GLdouble green, GLdouble blue)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3f(GLfloat red, GLfloat green, GLfloat blue)
{
	TRACE("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f)", red, green, blue);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		//context->color(red, green, blue, 1.0f);
		//GLfloat vals[4] = {};
		context->setVertexAttrib(sw::Color0, red, green, blue, 1);
	}
}

void APIENTRY glColor3fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3i(GLint red, GLint green, GLint blue)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3s(GLshort red, GLshort green, GLshort blue)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3ubv(const GLubyte *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3ui(GLuint red, GLuint green, GLuint blue)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3uiv(const GLuint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3us(GLushort red, GLushort green, GLushort blue)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor3usv(const GLushort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4bv(const GLbyte *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
	TRACE("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f)", red, green, blue, alpha);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		//context->color(red, green, blue, alpha);
		//GLfloat vals[4] = {red, green, blue, alpha};
		context->setVertexAttrib(sw::Color0, red, green, blue, alpha);
	}
}

void APIENTRY glColor4fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4ubv(const GLubyte *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4uiv(const GLuint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
{
	UNIMPLEMENTED();
}

void APIENTRY glColor4usv(const GLushort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glColorMaterial(GLenum face, GLenum mode)
{
	TRACE("(GLenum face = 0x%X, GLenum mode = 0x%X)", face, mode);

	// FIXME: Validate enums

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		switch(face)
		{
		case GL_FRONT:
			context->setColorMaterialMode(mode);   // FIXME: Front only
			break;
		case GL_FRONT_AND_BACK:
			context->setColorMaterialMode(mode);
			break;
		default:
			UNIMPLEMENTED();
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
	TRACE("(*)");

	glVertexAttribPointer(sw::Color0, size, type, true, stride, pointer);
}

void APIENTRY glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
{
	UNIMPLEMENTED();
}

void APIENTRY glCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
{
	UNIMPLEMENTED();
}

void APIENTRY glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
	UNIMPLEMENTED();
}

void APIENTRY glDebugEntry()
{
	UNIMPLEMENTED();
}

void APIENTRY glDeleteLists(GLuint list, GLsizei range)
{
	TRACE("(GLuint list = %d, GLsizei range = %d)", list, range);

	if(range < 0)
	{
		return error(GL_INVALID_VALUE);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		for(GLuint i = list; i < list + range; i++)
		{
			context->deleteList(i);
		}
	}
}

void APIENTRY glDepthRange(GLclampd zNear, GLclampd zFar)
{
	UNIMPLEMENTED();
}

void APIENTRY glDisableClientState(GLenum array)
{
	TRACE("(GLenum array = 0x%X)", array);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		GLenum texture = context->getClientActiveTexture();

		switch(array)
		{
		case GL_VERTEX_ARRAY:        context->setEnableVertexAttribArray(sw::Position, false);                            break;
		case GL_COLOR_ARRAY:         context->setEnableVertexAttribArray(sw::Color0, false);                              break;
		case GL_TEXTURE_COORD_ARRAY: context->setEnableVertexAttribArray(sw::TexCoord0 + (texture - GL_TEXTURE0), false); break;
		case GL_NORMAL_ARRAY:        context->setEnableVertexAttribArray(sw::Normal, false);                              break;
		default:                     UNIMPLEMENTED();
		}
	}
}

void APIENTRY glDrawBuffer(GLenum mode)
{
	UNIMPLEMENTED();
}

void APIENTRY glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{
	UNIMPLEMENTED();
}

void APIENTRY glEdgeFlag(GLboolean flag)
{
	UNIMPLEMENTED();
}

void APIENTRY glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
{
	UNIMPLEMENTED();
}

void APIENTRY glEdgeFlagv(const GLboolean *flag)
{
	UNIMPLEMENTED();
}

void APIENTRY glEnableClientState(GLenum array)
{
	TRACE("(GLenum array = 0x%X)", array);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		GLenum texture = context->getClientActiveTexture();

		switch(array)
		{
		case GL_VERTEX_ARRAY:        context->setEnableVertexAttribArray(sw::Position, true);                            break;
		case GL_COLOR_ARRAY:         context->setEnableVertexAttribArray(sw::Color0, true);                              break;
		case GL_TEXTURE_COORD_ARRAY: context->setEnableVertexAttribArray(sw::TexCoord0 + (texture - GL_TEXTURE0), true); break;
		case GL_NORMAL_ARRAY:        context->setEnableVertexAttribArray(sw::Normal, true);                              break;
		default:                     UNIMPLEMENTED();
		}
	}
}

void APIENTRY glEnd()
{
	TRACE("()");
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->end();
	}
}

void APIENTRY glEndList()
{
	TRACE("()");
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		context->endList();
	}
}

void APIENTRY glEvalCoord1d(GLdouble u)
{
	UNIMPLEMENTED();
}

void APIENTRY glEvalCoord1dv(const GLdouble *u)
{
	UNIMPLEMENTED();
}

void APIENTRY glEvalCoord1f(GLfloat u)
{
	UNIMPLEMENTED();
}

void APIENTRY glEvalCoord1fv(const GLfloat *u)
{
	UNIMPLEMENTED();
}

void APIENTRY glEvalCoord2d(GLdouble u, GLdouble v)
{
	UNIMPLEMENTED();
}

void APIENTRY glEvalCoord2dv(const GLdouble *u)
{
	UNIMPLEMENTED();
}

void APIENTRY glEvalCoord2f(GLfloat u, GLfloat v)
{
	UNIMPLEMENTED();
}

void APIENTRY glEvalCoord2fv(const GLfloat *u)
{
	UNIMPLEMENTED();
}

void APIENTRY glEvalMesh1(GLenum mode, GLint i1, GLint i2)
{
	UNIMPLEMENTED();
}

void APIENTRY glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
{
	UNIMPLEMENTED();
}

void APIENTRY glEvalPoint1(GLint i)
{
	UNIMPLEMENTED();
}

void APIENTRY glEvalPoint2(GLint i, GLint j)
{
	UNIMPLEMENTED();
}

void APIENTRY glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
{
	UNIMPLEMENTED();
}

void APIENTRY glFogf(GLenum pname, GLfloat param)
{
	TRACE("(GLenum pname = 0x%X, GLfloat param = %f)", pname, param);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Device *device = gl::getDevice();   // FIXME

		switch(pname)
		{
		case GL_FOG_START: device->setFogStart(param); break;
		case GL_FOG_END:   device->setFogEnd(param);   break;
		default:
			UNIMPLEMENTED();
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glFogfv(GLenum pname, const GLfloat *params)
{
	TRACE("(GLenum pname = 0x%X, const GLfloat *params)", pname);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		switch(pname)
		{
		case GL_FOG_COLOR:
			{
				gl::Device *device = gl::getDevice();   // FIXME
				device->setFogColor(sw::Color<float>(params[0], params[1], params[2], params[3]));
			}
			break;
		default:
			UNIMPLEMENTED();
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glFogi(GLenum pname, GLint param)
{
	TRACE("(GLenum pname = 0x%X, GLint param = %d)", pname, param);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		switch(pname)
		{
		case GL_FOG_MODE:
			{
				gl::Device *device = gl::getDevice();   // FIXME
				switch(param)
				{
				case GL_LINEAR: device->setVertexFogMode(sw::FOG_LINEAR); break;
				default:
					UNIMPLEMENTED();
					return error(GL_INVALID_ENUM);
				}
			}
			break;
		default:
			UNIMPLEMENTED();
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glFogiv(GLenum pname, const GLint *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
	TRACE("(GLdouble left = %f, GLdouble right = %f, GLdouble bottom = %f, GLdouble top = %f, GLdouble zNear = %f, GLdouble zFar = %f)", left, right, bottom, top, zNear, zFar);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->frustum(left, right, bottom, top, zNear, zFar);
	}
}

GLuint APIENTRY glGenLists(GLsizei range)
{
	TRACE("(GLsizei range = %d)", range);

	if(range < 0)
	{
		return error(GL_INVALID_VALUE, 0);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		return context->genLists(range);
	}

	return 0;
}

void APIENTRY glGetClipPlane(GLenum plane, GLdouble *equation)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetDoublev(GLenum pname, GLdouble *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetLightiv(GLenum light, GLenum pname, GLint *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetMapdv(GLenum target, GLenum query, GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetMapfv(GLenum target, GLenum query, GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetMapiv(GLenum target, GLenum query, GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetPixelMapfv(GLenum map, GLfloat *values)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetPixelMapuiv(GLenum map, GLuint *values)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetPixelMapusv(GLenum map, GLushort *values)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetPointerv(GLenum pname, GLvoid* *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetPolygonStipple(GLubyte *mask)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
{
	TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum format = 0x%X, GLenum type = 0x%X, GLint *pixels%p)", target, level, format, type, pixels);

	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Texture *texture;

		switch(target)
		{
		case GL_TEXTURE_2D:
			texture = context->getTexture2D(target);
			break;
		case GL_TEXTURE_CUBE_MAP:
			texture = context->getTextureCubeMap();
			break;
		default:
			UNIMPLEMENTED();
			return error(GL_INVALID_ENUM);
		}

		if(format == texture->getFormat(target, level) && type == texture->getType(target, level))
		{
			gl::Image *image = texture->getRenderTarget(target, level);
			void *source = image->lock(0, 0, sw::LOCK_READONLY);
			memcpy(pixels, source, image->getPitch() * image->getHeight());
			image->unlock();
		}
		else 
		{
			UNIMPLEMENTED();
		}
	}
}

void APIENTRY glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
{
	TRACE("(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLint *params = %p)", target, level, pname, params);
 
	gl::Context *context = gl::getContext();

	if(context)
	{
		gl::Texture *texture;

		switch(target)
		{
		case GL_TEXTURE_2D:
		case GL_PROXY_TEXTURE_2D:
			texture = context->getTexture2D(target);
			break;
		case GL_TEXTURE_CUBE_MAP:
			texture = context->getTextureCubeMap();
			break;
		default:
			UNIMPLEMENTED();
			return error(GL_INVALID_ENUM);
		}

		switch(pname)
		{
		case GL_TEXTURE_MAG_FILTER:
			*params = texture->getMagFilter();
			break;
		case GL_TEXTURE_MIN_FILTER:
			*params = texture->getMinFilter();
			break;
		case GL_TEXTURE_WRAP_S:
			*params = texture->getWrapS();
			break;
		case GL_TEXTURE_WRAP_T:
			*params = texture->getWrapT();
			break;
		case GL_TEXTURE_WIDTH:
			*params = texture->getWidth(target, level);
			break;
		case GL_TEXTURE_HEIGHT:
			*params = texture->getHeight(target, level);
			break;
		case GL_TEXTURE_INTERNAL_FORMAT:
				*params = texture->getInternalFormat(target, level);
			break;
		case GL_TEXTURE_BORDER_COLOR:
			UNIMPLEMENTED();
			break;
		case GL_TEXTURE_BORDER:
			UNIMPLEMENTED();
			break;
		case GL_TEXTURE_MAX_ANISOTROPY_EXT:
			*params = (GLint)texture->getMaxAnisotropy();
			break;
		default:
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glIndexMask(GLuint mask)
{
	UNIMPLEMENTED();
}

void APIENTRY glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
{
	UNIMPLEMENTED();
}

void APIENTRY glIndexd(GLdouble c)
{
	UNIMPLEMENTED();
}

void APIENTRY glIndexdv(const GLdouble *c)
{
	UNIMPLEMENTED();
}

void APIENTRY glIndexf(GLfloat c)
{
	UNIMPLEMENTED();
}

void APIENTRY glIndexfv(const GLfloat *c)
{
	UNIMPLEMENTED();
}

void APIENTRY glIndexi(GLint c)
{
	UNIMPLEMENTED();
}

void APIENTRY glIndexiv(const GLint *c)
{
	UNIMPLEMENTED();
}

void APIENTRY glIndexs(GLshort c)
{
	UNIMPLEMENTED();
}

void APIENTRY glIndexsv(const GLshort *c)
{
	UNIMPLEMENTED();
}

void APIENTRY glIndexub(GLubyte c)
{
	UNIMPLEMENTED();
}

void APIENTRY glIndexubv(const GLubyte *c)
{
	UNIMPLEMENTED();
}

void APIENTRY glInitNames(void)
{
	UNIMPLEMENTED();
}

void APIENTRY glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
{
	UNIMPLEMENTED();
}

GLboolean APIENTRY glIsList(GLuint list)
{
	UNIMPLEMENTED();
	return GL_FALSE;
}

void APIENTRY glLightModelf(GLenum pname, GLfloat param)
{
	UNIMPLEMENTED();
}

void APIENTRY glLightModelfv(GLenum pname, const GLfloat *params)
{
	TRACE("(GLenum pname = 0x%X, const GLint *params)", pname);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Device *device = gl::getDevice();   // FIXME

		switch(pname)
		{
		case GL_LIGHT_MODEL_AMBIENT:
			device->setGlobalAmbient(sw::Color<float>(params[0], params[1], params[2], params[3]));
			break;
		default:
			UNIMPLEMENTED();
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glLightModeli(GLenum pname, GLint param)
{
	UNIMPLEMENTED();
}

void APIENTRY glLightModeliv(GLenum pname, const GLint *params)
{
	TRACE("(GLenum pname = 0x%X, const GLint *params)", pname);
	UNIMPLEMENTED();
}

void APIENTRY glLightf(GLenum light, GLenum pname, GLfloat param)
{
	UNIMPLEMENTED();
}

void APIENTRY glLightfv(GLenum light, GLenum pname, const GLfloat *params)
{
	TRACE("(GLenum light = 0x%X, GLenum pname = 0x%X, const GLint *params)", light, pname);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		gl::Device *device = gl::getDevice();   // FIXME

		switch(pname)
		{
		case GL_AMBIENT:  device->setLightAmbient(light - GL_LIGHT0, sw::Color<float>(params[0], params[1], params[2], params[3]));  break;
		case GL_DIFFUSE:  device->setLightDiffuse(light - GL_LIGHT0, sw::Color<float>(params[0], params[1], params[2], params[3]));  break;
		case GL_SPECULAR: device->setLightSpecular(light - GL_LIGHT0, sw::Color<float>(params[0], params[1], params[2], params[3])); break;
		case GL_POSITION:
			if(params[3] == 0.0f)   // Directional light
			{
				// Create a very far out point light
				float max = std::max(std::max(abs(params[0]), abs(params[1])), abs(params[2]));
				device->setLightPosition(light - GL_LIGHT0, sw::Point(params[0] / max * 1e10f, params[1] / max * 1e10f, params[2] / max * 1e10f));
			}
			else
			{
				device->setLightPosition(light - GL_LIGHT0, sw::Point(params[0] / params[3], params[1] / params[3], params[2] / params[3]));
			}
			break;
		default:
			UNIMPLEMENTED();
			return error(GL_INVALID_ENUM);
		}
	}
}

void APIENTRY glLighti(GLenum light, GLenum pname, GLint param)
{
	UNIMPLEMENTED();
}

void APIENTRY glLightiv(GLenum light, GLenum pname, const GLint *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glLineStipple(GLint factor, GLushort pattern)
{
	UNIMPLEMENTED();
}

void APIENTRY glListBase(GLuint base)
{
	UNIMPLEMENTED();
}

void APIENTRY glLoadIdentity()
{
	TRACE("()");

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->loadIdentity();
	}
}

void APIENTRY glLoadMatrixd(const GLdouble *m)
{
	UNIMPLEMENTED();
}

void APIENTRY glLoadMatrixf(const GLfloat *m)
{
	UNIMPLEMENTED();
}

void APIENTRY glLoadName(GLuint name)
{
	UNIMPLEMENTED();
}

void APIENTRY glLogicOp(GLenum opcode)
{
	UNIMPLEMENTED();
}

void APIENTRY glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
{
	UNIMPLEMENTED();
}

void APIENTRY glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
{
	UNIMPLEMENTED();
}

void APIENTRY glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
{
	UNIMPLEMENTED();
}

void APIENTRY glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
{
	UNIMPLEMENTED();
}

void APIENTRY glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
{
	UNIMPLEMENTED();
}

void APIENTRY glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
{
	UNIMPLEMENTED();
}

void APIENTRY glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
{
	UNIMPLEMENTED();
}

void APIENTRY glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
{
	UNIMPLEMENTED();
}

void APIENTRY glMaterialf(GLenum face, GLenum pname, GLfloat param)
{
	UNIMPLEMENTED();
}

void APIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glMateriali(GLenum face, GLenum pname, GLint param)
{
	UNIMPLEMENTED();
}

void APIENTRY glMaterialiv(GLenum face, GLenum pname, const GLint *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glMatrixMode(GLenum mode)
{
	TRACE("(*)");

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setMatrixMode(mode);
	}
}

void APIENTRY glMultMatrixd(const GLdouble *m)
{
	TRACE("(*)");

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->multiply(m);
	}
}

void APIENTRY glMultMatrixm(sw::Matrix m)
{
	gl::Context *context = gl::getContext();

	if(context)
	{
		context->multiply((GLfloat*)m.m);
	}
}

void APIENTRY glMultMatrixf(const GLfloat *m)
{
	TRACE("(*)");

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			return context->listCommand(gl::newCommand(glMultMatrixm, sw::Matrix(m)));
		}

		context->multiply(m);
	}
}

void APIENTRY glNewList(GLuint list, GLenum mode)
{
	TRACE("(GLuint list = %d, GLenum mode = 0x%X)", list, mode);

	if(list == 0)
	{
		return error(GL_INVALID_VALUE);
	}

	switch(mode)
	{
	case GL_COMPILE:
	case GL_COMPILE_AND_EXECUTE:
		break;
	default:
		return error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->newList(list, mode);
	}
}

void APIENTRY glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
{
	UNIMPLEMENTED();
}

void APIENTRY glNormal3bv(const GLbyte *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
{
	UNIMPLEMENTED();
}

void APIENTRY glNormal3dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
{
	TRACE("(GLfloat nx = %f, GLfloat ny = %f, GLfloat nz = %f)", nx, ny, nz);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		//context->normal(nx, ny, nz);
		context->setVertexAttrib(sw::Normal, nx, ny, nz, 0);
	}
}

void APIENTRY glNormal3fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glNormal3i(GLint nx, GLint ny, GLint nz)
{
	UNIMPLEMENTED();
}

void APIENTRY glNormal3iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glNormal3s(GLshort nx, GLshort ny, GLshort nz)
{
	UNIMPLEMENTED();
}

void APIENTRY glNormal3sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
{
	TRACE("(*)");

	glVertexAttribPointer(sw::Normal, 3, type, true, stride, pointer);
}

void APIENTRY glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
	TRACE("(*)");

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->ortho(left, right, bottom, top, zNear, zFar);
	}
}

void APIENTRY glPassThrough(GLfloat token)
{
	UNIMPLEMENTED();
}

void APIENTRY glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
{
	UNIMPLEMENTED();
}

void APIENTRY glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
{
	UNIMPLEMENTED();
}

void APIENTRY glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
{
	UNIMPLEMENTED();
}

void APIENTRY glPixelStoref(GLenum pname, GLfloat param)
{
	UNIMPLEMENTED();
}

void APIENTRY glPixelTransferf(GLenum pname, GLfloat param)
{
	UNIMPLEMENTED();
}

void APIENTRY glPixelTransferi(GLenum pname, GLint param)
{
	UNIMPLEMENTED();
}

void APIENTRY glPixelZoom(GLfloat xfactor, GLfloat yfactor)
{
	UNIMPLEMENTED();
}

void APIENTRY glPointSize(GLfloat size)
{
	UNIMPLEMENTED();
}

void APIENTRY glPolygonMode(GLenum face, GLenum mode)
{
	UNIMPLEMENTED();
}

void APIENTRY glPolygonStipple(const GLubyte *mask)
{
	UNIMPLEMENTED();
}

void APIENTRY glPopAttrib(void)
{
	TRACE("()");
	UNIMPLEMENTED();
}

void APIENTRY glPopClientAttrib(void)
{
	TRACE("()");
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->popClientAttrib();
	}
}

void APIENTRY glPopMatrix(void)
{
	TRACE("()");
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			return context->listCommand(gl::newCommand(glPopMatrix));
		}

		context->popMatrix();
	}
}

void APIENTRY glPopName(void)
{
	UNIMPLEMENTED();
}

void APIENTRY glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
{
	UNIMPLEMENTED();
}

void APIENTRY glPushAttrib(GLbitfield mask)
{
	TRACE("(GLbitfield mask = %u)", mask);
	//UNIMPLEMENTED();
}

void APIENTRY glPushClientAttrib(GLbitfield mask)
{
	TRACE("(GLbitfield mask = %u)", mask);

	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->pushClientAttrib(mask);
	}
}

void APIENTRY glPushMatrix(void)
{
	TRACE("()");
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			return context->listCommand(gl::newCommand(glPushMatrix));
		}

		context->pushMatrix();
	}
}

void APIENTRY glPushName(GLuint name)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos2d(GLdouble x, GLdouble y)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos2dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos2f(GLfloat x, GLfloat y)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos2fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos2i(GLint x, GLint y)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos2iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos2s(GLshort x, GLshort y)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos2sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos3dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos3fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos3i(GLint x, GLint y, GLint z)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos3iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos3s(GLshort x, GLshort y, GLshort z)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos3sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos4dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos4fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos4iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
	UNIMPLEMENTED();
}

void APIENTRY glRasterPos4sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glReadBuffer(GLenum mode)
{
	UNIMPLEMENTED();
}

void APIENTRY glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
{
	UNIMPLEMENTED();
}

void APIENTRY glRectdv(const GLdouble *v1, const GLdouble *v2)
{
	UNIMPLEMENTED();
}

void APIENTRY glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{
	UNIMPLEMENTED();
}

void APIENTRY glRectfv(const GLfloat *v1, const GLfloat *v2)
{
	UNIMPLEMENTED();
}

void APIENTRY glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
{
	UNIMPLEMENTED();
}

void APIENTRY glRectiv(const GLint *v1, const GLint *v2)
{
	UNIMPLEMENTED();
}

void APIENTRY glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
{
	UNIMPLEMENTED();
}

void APIENTRY glRectsv(const GLshort *v1, const GLshort *v2)
{
	UNIMPLEMENTED();
}

GLint APIENTRY glRenderMode(GLenum mode)
{
	UNIMPLEMENTED();
	return 0;
}

void APIENTRY glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
{
	UNIMPLEMENTED();
}

void APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
	TRACE("(*)");
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->rotate(angle, x, y, z);
	}
}

void APIENTRY glScaled(GLdouble x, GLdouble y, GLdouble z)
{
	UNIMPLEMENTED();
}

void APIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z)
{
	TRACE("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			return context->listCommand(gl::newCommand(glScalef, x, y, z));
		}

		context->scale(x, y, z);
	}
}

void APIENTRY glSelectBuffer(GLsizei size, GLuint *buffer)
{
	UNIMPLEMENTED();
}

void APIENTRY glShadeModel(GLenum mode)
{
	TRACE("(*)");
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->setShadeModel(mode);
	}
}

void APIENTRY glTexCoord1d(GLdouble s)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord1dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord1f(GLfloat s)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord1fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord1i(GLint s)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord1iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord1s(GLshort s)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord1sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord2d(GLdouble s, GLdouble t)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord2dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord2f(GLfloat s, GLfloat t)
{
	TRACE("(GLfloat s = %f, GLfloat t = %f)", s, t);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		//context->texCoord(s, t, 0.0f, 1.0f);
		unsigned int texture = context->getActiveTexture();
		context->setVertexAttrib(sw::TexCoord0/* + texture*/, s, t, 0.0f, 1.0f);
	}
}

void APIENTRY glTexCoord2fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord2i(GLint s, GLint t)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord2iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord2s(GLshort s, GLshort t)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord2sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord3dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord3fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord3i(GLint s, GLint t, GLint r)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord3iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord3s(GLshort s, GLshort t, GLshort r)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord3sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord4dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord4fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord4iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoord4sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
	TRACE("(*)");

	gl::Context *context = gl::getContext();

	if(context)
	{
		GLenum texture = context->getClientActiveTexture();

		glVertexAttribPointer(sw::TexCoord0 + (texture - GL_TEXTURE0), size, type, false, stride, pointer);
	}
}

void APIENTRY glTexEnvf(GLenum target, GLenum pname, GLfloat param)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexEnvi(GLenum target, GLenum pname, GLint param)
{
	TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %d)", target, pname, param);
	
	if(target != GL_TEXTURE_ENV || pname != GL_TEXTURE_ENV_MODE)
	{
		return error(GL_INVALID_ENUM);
	}

	switch((GLenum)param)
	{
	case GL_REPLACE:
	case GL_MODULATE:
	case GL_DECAL:
	case GL_BLEND:
		break;
	default:
		error(GL_INVALID_ENUM);
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		context->setTextureEnvMode((GLenum)param);
	}
}

void APIENTRY glTexEnviv(GLenum target, GLenum pname, const GLint *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexGend(GLenum coord, GLenum pname, GLdouble param)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexGenf(GLenum coord, GLenum pname, GLfloat param)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexGeni(GLenum coord, GLenum pname, GLint param)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
{
	UNIMPLEMENTED();
}

void APIENTRY glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
	TRACE("(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
		"GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X, const GLvoid* pixels =  %p)",
		target, level, internalformat, width, border, format, type, pixels);
	
	glTexImage2D(target, level, internalformat, width, 1, border, format, type, pixels);
}

void APIENTRY glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
{
	TRACE("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLsizei width = %d, "
		"GLenum format =  0x%X, GLenum type = 0x%X, const GLvoid* pixels =  %p)",
		target, level, xoffset, width, format, type, pixels);

	glTexSubImage2D(target, level, xoffset, 0, width, 1, format, type, pixels);
}

void APIENTRY glTranslated(GLdouble x, GLdouble y, GLdouble z)
{
	TRACE("(*)");
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			return context->listCommand(gl::newCommand(glTranslated, x, y, z));
		}

		context->translate(x, y, z);   // FIXME
	}
}

void APIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z)
{
	TRACE("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			return context->listCommand(gl::newCommand(glTranslatef, x, y, z));
		}

		context->translate(x, y, z);
	}
}

void APIENTRY glVertex2d(GLdouble x, GLdouble y)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex2dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex2f(GLfloat x, GLfloat y)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex2fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex2i(GLint x, GLint y)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex2iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex2s(GLshort x, GLshort y)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex2sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex3d(GLdouble x, GLdouble y, GLdouble z)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex3dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex3f(GLfloat x, GLfloat y, GLfloat z)
{
	TRACE("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		context->position(x, y, z, 1.0f);
	}
}

void APIENTRY glVertex3fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

GLAPI void APIENTRY glVertexAttrib4dv(GLuint index, const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex3i(GLint x, GLint y, GLint z)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex3iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex3s(GLshort x, GLshort y, GLshort z)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex3sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex4dv(const GLdouble *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex4fv(const GLfloat *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex4i(GLint x, GLint y, GLint z, GLint w)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex4iv(const GLint *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertex4sv(const GLshort *v)
{
	UNIMPLEMENTED();
}

void APIENTRY glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
	TRACE("(GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const GLvoid *pointer = %p)", size, type, stride, pointer);

	glVertexAttribPointer(sw::Position, size, type, false, stride, pointer);
}

void APIENTRY glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) {UNIMPLEMENTED();}
void APIENTRY glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) {UNIMPLEMENTED();}
void APIENTRY glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) {UNIMPLEMENTED();}
void APIENTRY glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {UNIMPLEMENTED();}

void APIENTRY glClientActiveTexture(GLenum texture)
{
	TRACE("(GLenum texture = 0x%X)", texture);
	
	switch(texture)
	{
	case GL_TEXTURE0:
	case GL_TEXTURE1:
		break;
	default:
		UNIMPLEMENTED();
		UNREACHABLE();
	}

	gl::Context *context = gl::getContext();

	if(context)
	{
		context->clientActiveTexture(texture);
	}
}

void APIENTRY glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data) {UNIMPLEMENTED();}
void APIENTRY glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) {UNIMPLEMENTED();}
void APIENTRY glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data) {UNIMPLEMENTED();}
void APIENTRY glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) {UNIMPLEMENTED();}
void APIENTRY glGetCompressedTexImage(GLenum target, GLint level, void *img) {UNIMPLEMENTED();}
void APIENTRY glMultiTexCoord1f(GLenum target, GLfloat s) {UNIMPLEMENTED();}
void APIENTRY glMultiTexCoord1d(GLenum target, GLdouble s) {UNIMPLEMENTED();}

void APIENTRY glMultiTexCoord2f(GLenum texture, GLfloat s, GLfloat t)
{
	TRACE("(GLenum texture = 0x%X, GLfloat s = %f, GLfloat t = %f)", texture, s, t);
	
	gl::Context *context = gl::getContext();

	if(context)
	{
		if(context->getListIndex() != 0)
		{
			UNIMPLEMENTED();
		}

		//context->texCoord(s, t, 0.0f, 1.0f);
		context->setVertexAttrib(sw::TexCoord0 + (texture - GL_TEXTURE0), s, t, 0.0f, 1.0f);
	}
}

void APIENTRY glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t) {UNIMPLEMENTED();}
void APIENTRY glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) {UNIMPLEMENTED();}
void APIENTRY glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r) {UNIMPLEMENTED();}
void APIENTRY glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {UNIMPLEMENTED();}
void APIENTRY glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) {UNIMPLEMENTED();}
void APIENTRY glLoadTransposeMatrixf(const GLfloat *m) {UNIMPLEMENTED();}
void APIENTRY glLoadTransposeMatrixd(const GLdouble *m) {UNIMPLEMENTED();}
void APIENTRY glMultTransposeMatrixf(const GLfloat *m) {UNIMPLEMENTED();}
void APIENTRY glMultTransposeMatrixd(const GLdouble *m) {UNIMPLEMENTED();}
void APIENTRY glFogCoordf(GLfloat coord) {UNIMPLEMENTED();}
void APIENTRY glFogCoordd(GLdouble coord) {UNIMPLEMENTED();}
void APIENTRY glFogCoordPointer(GLenum type, GLsizei stride, const void *pointer) {UNIMPLEMENTED();}
void APIENTRY glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount) {UNIMPLEMENTED();}
void APIENTRY glPointParameteri(GLenum pname, GLint param) {UNIMPLEMENTED();}
void APIENTRY glPointParameterf(GLenum pname, GLfloat param) {UNIMPLEMENTED();}
void APIENTRY glPointParameteriv(GLenum pname, const GLint *params) {UNIMPLEMENTED();}
void APIENTRY glPointParameterfv(GLenum pname, const GLfloat *params) {UNIMPLEMENTED();}
void APIENTRY glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue) {UNIMPLEMENTED();}
void APIENTRY glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue) {UNIMPLEMENTED();}
void APIENTRY glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue) {UNIMPLEMENTED();}
void APIENTRY glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue) {UNIMPLEMENTED();}
void APIENTRY glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {UNIMPLEMENTED();}
void APIENTRY glWindowPos2f(GLfloat x, GLfloat y) {UNIMPLEMENTED();}
void APIENTRY glWindowPos2d(GLdouble x, GLdouble y) {UNIMPLEMENTED();}
void APIENTRY glWindowPos2i(GLint x, GLint y) {UNIMPLEMENTED();}
void APIENTRY glWindowPos3f(GLfloat x, GLfloat y, GLfloat z) {UNIMPLEMENTED();}
void APIENTRY glWindowPos3d(GLdouble x, GLdouble y, GLdouble z) {UNIMPLEMENTED();}
void APIENTRY glWindowPos3i(GLint x, GLint y, GLint z) {UNIMPLEMENTED();}
void APIENTRY glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data) {UNIMPLEMENTED();}
void *APIENTRY glMapBuffer(GLenum target, GLenum access) {UNIMPLEMENTED(); return 0;}
GLboolean APIENTRY glUnmapBuffer(GLenum target) {UNIMPLEMENTED(); return GL_FALSE;}
void APIENTRY glGetBufferPointerv(GLenum target, GLenum pname, void **params) {UNIMPLEMENTED();}
void APIENTRY glGenQueries(GLsizei n, GLuint *ids) {UNIMPLEMENTED();}
void APIENTRY glDeleteQueries(GLsizei n, const GLuint *ids) {UNIMPLEMENTED();}
GLboolean APIENTRY glIsQuery(GLuint id) {UNIMPLEMENTED(); return 0;}
void APIENTRY glBeginQuery(GLenum target, GLuint id) {UNIMPLEMENTED();}
void APIENTRY glEndQuery(GLenum target) {UNIMPLEMENTED();}
void APIENTRY glGetQueryiv(GLenum target, GLenum pname, GLint *params) {UNIMPLEMENTED();}
void APIENTRY glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params) {UNIMPLEMENTED();}
void APIENTRY glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) {UNIMPLEMENTED();}
void APIENTRY glVertexAttrib1s(GLuint index, GLshort x) {UNIMPLEMENTED();}
void APIENTRY glVertexAttrib1d(GLuint index, GLdouble x) {UNIMPLEMENTED();}
void APIENTRY glVertexAttrib2s(GLuint index, GLshort x, GLshort y) {UNIMPLEMENTED();}
void APIENTRY glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y) {UNIMPLEMENTED();}
void APIENTRY glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z) {UNIMPLEMENTED();}
void APIENTRY glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) {UNIMPLEMENTED();}
void APIENTRY glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {UNIMPLEMENTED();}
void APIENTRY glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {UNIMPLEMENTED();}
void APIENTRY glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {UNIMPLEMENTED();}
void APIENTRY glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) {UNIMPLEMENTED();}
void APIENTRY glDrawBuffers(GLsizei n, const GLenum *bufs) {UNIMPLEMENTED();}
void APIENTRY glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {UNIMPLEMENTED();}
void APIENTRY glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {UNIMPLEMENTED();}
void APIENTRY glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {UNIMPLEMENTED();}
void APIENTRY glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {UNIMPLEMENTED();}
void APIENTRY glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {UNIMPLEMENTED();}
void APIENTRY glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {UNIMPLEMENTED();}

void APIENTRY glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {UNIMPLEMENTED();}
void APIENTRY glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {UNIMPLEMENTED();}
void APIENTRY glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {UNIMPLEMENTED();}

void WINAPI glBindAttribLocationARB(GLhandleARB programObj, GLuint index, const GLcharARB *name) { UNIMPLEMENTED(); }
void WINAPI glGetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name) { UNIMPLEMENTED(); }
GLint WINAPI glGetAttribLocationARB(GLhandleARB programObj, const GLcharARB *name) { UNIMPLEMENTED(); return 0; }
GLAPI void APIENTRY glDeleteObjectARB(GLhandleARB obj){ UNIMPLEMENTED(); }
GLAPI GLhandleARB APIENTRY glGetHandleARB(GLenum pname){ UNIMPLEMENTED(); return 0; }
GLAPI void APIENTRY glDetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj){ UNIMPLEMENTED(); }
GLAPI GLhandleARB APIENTRY glCreateShaderObjectARB(GLenum shaderType){ UNIMPLEMENTED(); return 0; }
GLAPI void APIENTRY glShaderSourceARB(GLhandleARB shaderObj, GLsizei count, const GLcharARB **string, const GLint *length){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glCompileShaderARB(GLhandleARB shaderObj){ UNIMPLEMENTED(); }
GLAPI GLhandleARB APIENTRY glCreateProgramObjectARB(void){ UNIMPLEMENTED(); return 0; }
GLAPI void APIENTRY glAttachObjectARB(GLhandleARB containerObj, GLhandleARB obj){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glLinkProgramARB(GLhandleARB programObj){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUseProgramObjectARB(GLhandleARB programObj){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glValidateProgramARB(GLhandleARB programObj){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform1fARB(GLint location, GLfloat v0){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform2fARB(GLint location, GLfloat v0, GLfloat v1){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform1iARB(GLint location, GLint v0){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform2iARB(GLint location, GLint v0, GLint v1){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform3iARB(GLint location, GLint v0, GLint v1, GLint v2){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform1fvARB(GLint location, GLsizei count, const GLfloat *value){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform2fvARB(GLint location, GLsizei count, const GLfloat *value){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform3fvARB(GLint location, GLsizei count, const GLfloat *value){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform4fvARB(GLint location, GLsizei count, const GLfloat *value){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform1ivARB(GLint location, GLsizei count, const GLint *value){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform2ivARB(GLint location, GLsizei count, const GLint *value){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform3ivARB(GLint location, GLsizei count, const GLint *value){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniform4ivARB(GLint location, GLsizei count, const GLint *value){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glUniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glGetObjectParameterfvARB(GLhandleARB obj, GLenum pname, GLfloat *params){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glGetObjectParameterivARB(GLhandleARB obj, GLenum pname, GLint *params){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glGetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj){ UNIMPLEMENTED(); }
GLAPI GLint APIENTRY glGetUniformLocationARB(GLhandleARB programObj, const GLcharARB *name){ UNIMPLEMENTED(); return 0; }
GLAPI void APIENTRY glGetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glGetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat *params){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glGetUniformivARB(GLhandleARB programObj, GLint location, GLint *params){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glGetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source){ UNIMPLEMENTED(); }

GLAPI GLboolean APIENTRY glIsRenderbufferEXT(GLuint renderbuffer){ UNIMPLEMENTED(); return 0; }
GLAPI void APIENTRY glBindRenderbufferEXT(GLenum target, GLuint renderbuffer){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glDeleteRenderbuffersEXT(GLsizei n, const GLuint *renderbuffers){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glGenRenderbuffersEXT(GLsizei n, GLuint *renderbuffers){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint *params){ UNIMPLEMENTED(); }
GLAPI GLboolean APIENTRY glIsFramebufferEXT(GLuint framebuffer){ UNIMPLEMENTED(); return 0; }
GLAPI void APIENTRY glBindFramebufferEXT(GLenum target, GLuint framebuffer){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glDeleteFramebuffersEXT(GLsizei n, const GLuint *framebuffers)
{ 
	TRACE("(GLsizei n = %d, const GLuint* framebuffers = %p)", n, framebuffers);
	
	glDeleteFramebuffers(n, framebuffers);
}
GLAPI void APIENTRY glGenFramebuffersEXT(GLsizei n, GLuint *framebuffers)
{ 
	TRACE("(GLsizei n = %d, GLuint* framebuffers = %p)", n, framebuffers);

	glGenFramebuffers(n, framebuffers);
}
GLAPI GLenum APIENTRY glCheckFramebufferStatusEXT(GLenum target){ UNIMPLEMENTED(); return 0; }
GLAPI void APIENTRY glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint *params){ UNIMPLEMENTED(); }
GLAPI void APIENTRY glGenerateMipmapEXT(GLenum target){ UNIMPLEMENTED(); }

HGLRC WINAPI wglCreateContextAttribsARB(HDC hDC, HGLRC hShareContext, const int *attribList)
{
	return wglCreateContext(hDC);
}

HANDLE WINAPI wglCreateBufferRegionARB(HDC hDC, int iLayerPlane, UINT uType) { UNIMPLEMENTED(); return 0; }
VOID WINAPI wglDeleteBufferRegionARB(HANDLE hRegion) { UNIMPLEMENTED(); }
BOOL WINAPI wglSaveBufferRegionARB(HANDLE hRegion, int x, int y, int width, int height) { UNIMPLEMENTED(); return FALSE; }
BOOL WINAPI wglRestoreBufferRegionARB(HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc) { UNIMPLEMENTED(); return FALSE; }

void APIENTRY glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetBooleani_v(GLenum target, GLuint index, GLboolean *data){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetIntegeri_v(GLenum target, GLuint index, GLint *data){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEnablei(GLenum target, GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDisablei(GLenum target, GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glIsEnabledi(GLenum target, GLuint index){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glBeginTransformFeedback(GLenum primitiveMode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEndTransformFeedback(void){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBindBufferBase(GLenum target, GLuint index, GLuint buffer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glClampColor(GLenum target, GLenum clamp){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBeginConditionalRender(GLuint id, GLenum mode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEndConditionalRender(void){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI1i(GLuint index, GLint x){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI2i(GLuint index, GLint x, GLint y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI1ui(GLuint index, GLuint x){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI2ui(GLuint index, GLuint x, GLuint y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI1iv(GLuint index, const GLint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI2iv(GLuint index, const GLint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI3iv(GLuint index, const GLint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4iv(GLuint index, const GLint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI1uiv(GLuint index, const GLuint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI2uiv(GLuint index, const GLuint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI3uiv(GLuint index, const GLuint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4uiv(GLuint index, const GLuint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4bv(GLuint index, const GLbyte *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4sv(GLuint index, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4ubv(GLuint index, const GLubyte *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4usv(GLuint index, const GLushort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetUniformuiv(GLuint program, GLint location, GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name){ TRACE("*"); UNIMPLEMENTED(); }
GLint APIENTRY glGetFragDataLocation(GLuint program, const GLchar *name){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glUniform1ui(GLint location, GLuint v0){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform2ui(GLint location, GLuint v0, GLuint v1){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform1uiv(GLint location, GLsizei count, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform2uiv(GLint location, GLsizei count, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform3uiv(GLint location, GLsizei count, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform4uiv(GLint location, GLsizei count, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexParameterIiv(GLenum target, GLenum pname, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil){ TRACE("*"); UNIMPLEMENTED(); }
const GLubyte *APIENTRY glGetStringi(GLenum name, GLuint index){ TRACE("*"); UNIMPLEMENTED(); return (GLubyte*)""; return 0; }
void *APIENTRY glMapNamedBufferEXT(GLuint buffer, GLenum access){ TRACE("*"); UNIMPLEMENTED(); return 0; }
GLboolean APIENTRY glUnmapNamedBufferEXT(GLuint buffer){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glGetNamedBufferParameterivEXT(GLuint buffer, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glcuR0d4nX(GLint* i1)
{ 
	i1[1] = 0;
}
//
//000007FEE763807A  lea         rax, [rsp + 20h]
//000007FEE763807F  lea         rcx, [rsp + 38h]
//000007FEE7638084  mov         qword ptr[rsp + 20h], rbp
//000007FEE7638089  mov         qword ptr[rsp + 28h], rsi
//000007FEE763808E  mov         dword ptr[rsp + 38h], 0Dh
//000007FEE7638096  mov         dword ptr[rsp + 3Ch], 8
//000007FEE763809E  mov         qword ptr[rsp + 50h], rax
//000007FEE76380A3  mov         dword ptr[rsp + 48h], 7
//000007FEE76380AB  mov         qword ptr[rsp + 40h], 0
//000007FEE76380B4  call        qword ptr[7FEE81F6890h]

void APIENTRY glCopyTexImage1DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyTexImage2DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glPolygonOffsetEXT(GLfloat factor, GLfloat bias) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) { TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glAreTexturesResidentEXT(GLsizei n, const GLuint *textures, GLboolean *residences) { TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glBindTextureEXT(GLenum target, GLuint texture) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDeleteTexturesEXT(GLsizei n, const GLuint *textures) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGenTexturesEXT(GLsizei n, GLuint *textures) { TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glIsTextureEXT(GLuint texture) { TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glSampleCoverageARB(GLfloat value, GLboolean invert) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glActiveTextureARB(GLenum texture) 
{ 
	TRACE("(GLenum texture = 0x%X)", texture);
	glActiveTexture(texture);
}
void APIENTRY glClientActiveTextureARB(GLenum texture) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord1dARB(GLenum target, GLdouble s) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord1dvARB(GLenum target, const GLdouble *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord1fARB(GLenum target, GLfloat s) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord1fvARB(GLenum target, const GLfloat *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord1iARB(GLenum target, GLint s) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord1ivARB(GLenum target, const GLint *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord1sARB(GLenum target, GLshort s) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord1svARB(GLenum target, const GLshort *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord2dvARB(GLenum target, const GLdouble *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord2fvARB(GLenum target, const GLfloat *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord2iARB(GLenum target, GLint s, GLint t) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord2ivARB(GLenum target, const GLint *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord2svARB(GLenum target, const GLshort *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord3dvARB(GLenum target, const GLdouble *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord3fvARB(GLenum target, const GLfloat *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord3ivARB(GLenum target, const GLint *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord3svARB(GLenum target, const GLshort *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord4dvARB(GLenum target, const GLdouble *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord4fvARB(GLenum target, const GLfloat *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord4ivARB(GLenum target, const GLint *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord4svARB(GLenum target, const GLshort *v) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedTexImage3DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedTexImage2DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedTexImage1DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetCompressedTexImageARB(GLenum target, GLint level, void *img) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glPointParameterfARB(GLenum pname, GLfloat param) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glPointParameterfvARB(GLenum pname, const GLfloat *params) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBlendColorEXT(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFogCoordfEXT(GLfloat coord) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFogCoordfvEXT(const GLfloat *coord) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFogCoorddEXT(GLdouble coord) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFogCoorddvEXT(const GLdouble *coord) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFogCoordPointerEXT(GLenum type, GLsizei stride, const void *pointer) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGenQueriesARB(GLsizei n, GLuint *ids) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDeleteQueriesARB(GLsizei n, const GLuint *ids) { TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glIsQueryARB(GLuint id) { TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glBeginQueryARB(GLenum target, GLuint id) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEndQueryARB(GLenum target) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetQueryivARB(GLenum target, GLenum pname, GLint *params) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetQueryObjectivARB(GLuint id, GLenum pname, GLint *params) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint *params) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBindBufferARB(GLenum target, GLuint buffer) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDeleteBuffersARB(GLsizei n, const GLuint *buffers) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGenBuffersARB(GLsizei n, GLuint *buffers) { TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glIsBufferARB(GLuint buffer) { TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glBufferDataARB(GLenum target, GLsizeiptrARB size, const void *data, GLenum usage) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void *data) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, void *data) { TRACE("*"); UNIMPLEMENTED(); }
void *APIENTRY glMapBufferARB(GLenum target, GLenum access) { TRACE("*"); UNIMPLEMENTED(); return 0; }
GLboolean APIENTRY glUnmapBufferARB(GLenum target) { TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glGetBufferParameterivARB(GLenum target, GLenum pname, GLint *params) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetBufferPointervARB(GLenum target, GLenum pname, void **params) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDrawBuffersARB(GLsizei n, const GLenum *bufs) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeAlpha) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glActiveStencilFaceEXT(GLenum face) { TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glClampColorARB(GLenum target, GLenum clamp){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDrawArraysInstancedARB(GLenum mode, GLint first, GLsizei count, GLsizei primcount){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDrawElementsInstancedARB(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramParameteriARB(GLuint program, GLenum pname, GLint value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFramebufferTextureARB(GLenum target, GLenum attachment, GLuint texture, GLint level){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFramebufferTextureLayerARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFramebufferTextureFaceARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetColorTable(GLenum target, GLenum format, GLenum type, void *table){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glConvolutionParameteri(GLenum target, GLenum pname, GLint params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, void *image){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetSeparableFilter(GLenum target, GLenum format, GLenum type, void *row, void *column, void *span){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMinmax(GLenum target, GLenum internalformat, GLboolean sink){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glResetHistogram(GLenum target){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glResetMinmax(GLenum target){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribDivisorARB(GLuint index, GLuint divisor){ TRACE("*"); UNIMPLEMENTED(); }
void *APIENTRY glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexBufferARB(GLenum target, GLenum internalformat, GLuint buffer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBindVertexArray(GLuint array){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDeleteVertexArrays(GLsizei n, const GLuint *arrays){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGenVertexArrays(GLsizei n, GLuint *arrays){ TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glIsVertexArray(GLuint array){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glProgramStringARB(GLenum target, GLenum format, GLsizei len, const void *string){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBindProgramARB(GLenum target, GLuint program){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDeleteProgramsARB(GLsizei n, const GLuint *programs){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGenProgramsARB(GLsizei n, GLuint *programs){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramivARB(GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramStringARB(GLenum target, GLenum pname, void *string){ TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glIsProgramARB(GLuint program){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glEnableVertexAttribArrayARB(GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDisableVertexAttribArrayARB(GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexAttribivARB(GLuint index, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexAttribPointervARB(GLuint index, GLenum pname, void **pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1dARB(GLuint index, GLdouble x){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1dvARB(GLuint index, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1fARB(GLuint index, GLfloat x){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1fvARB(GLuint index, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1sARB(GLuint index, GLshort x){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1svARB(GLuint index, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2dvARB(GLuint index, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2fvARB(GLuint index, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2svARB(GLuint index, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3dvARB(GLuint index, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3fvARB(GLuint index, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3svARB(GLuint index, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4NbvARB(GLuint index, const GLbyte *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4NivARB(GLuint index, const GLint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4NsvARB(GLuint index, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4NubvARB(GLuint index, const GLubyte *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4NuivARB(GLuint index, const GLuint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4NusvARB(GLuint index, const GLushort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4bvARB(GLuint index, const GLbyte *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4dvARB(GLuint index, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4fvARB(GLuint index, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4ivARB(GLuint index, const GLint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4svARB(GLuint index, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4ubvARB(GLuint index, const GLubyte *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4uivARB(GLuint index, const GLuint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4usvARB(GLuint index, const GLushort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos2dARB(GLdouble x, GLdouble y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos2dvARB(const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos2fARB(GLfloat x, GLfloat y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos2fvARB(const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos2iARB(GLint x, GLint y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos2ivARB(const GLint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos2sARB(GLshort x, GLshort y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos2svARB(const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos3dARB(GLdouble x, GLdouble y, GLdouble z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos3dvARB(const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos3fARB(GLfloat x, GLfloat y, GLfloat z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos3fvARB(const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos3iARB(GLint x, GLint y, GLint z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos3ivARB(const GLint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos3sARB(GLshort x, GLshort y, GLshort z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glWindowPos3svARB(const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDrawBuffersATI(GLsizei n, const GLenum *bufs){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniformBufferEXT(GLuint program, GLint location, GLuint buffer){ TRACE("*"); UNIMPLEMENTED(); }
GLint APIENTRY glGetUniformBufferSizeEXT(GLuint program, GLint location){ TRACE("*"); UNIMPLEMENTED();  return 0; }
GLintptr APIENTRY glGetUniformOffsetEXT(GLuint program, GLint location){ TRACE("*"); UNIMPLEMENTED();  return 0; }
void APIENTRY glLockArraysEXT(GLint first, GLsizei count){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUnlockArraysEXT(void){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDepthBoundsEXT(GLclampd zmin, GLclampd zmax){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixLoadfEXT(GLenum mode, const GLfloat *m){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixLoaddEXT(GLenum mode, const GLdouble *m){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixMultfEXT(GLenum mode, const GLfloat *m){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixMultdEXT(GLenum mode, const GLdouble *m){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixLoadIdentityEXT(GLenum mode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixRotatefEXT(GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixRotatedEXT(GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixScalefEXT(GLenum mode, GLfloat x, GLfloat y, GLfloat z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixScaledEXT(GLenum mode, GLdouble x, GLdouble y, GLdouble z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixTranslatefEXT(GLenum mode, GLfloat x, GLfloat y, GLfloat z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixTranslatedEXT(GLenum mode, GLdouble x, GLdouble y, GLdouble z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixFrustumEXT(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixOrthoEXT(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixPopEXT(GLenum mode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixPushEXT(GLenum mode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glClientAttribDefaultEXT(GLbitfield mask){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glPushClientAttribDefaultEXT(GLbitfield mask){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTextureLevelParameterfvEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTextureLevelParameterivEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBindMultiTextureEXT(GLenum texunit, GLenum target, GLuint texture){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoordPointerEXT(GLenum texunit, GLint size, GLenum type, GLsizei stride, const void *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexEnvfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexEnviEXT(GLenum texunit, GLenum target, GLenum pname, GLint param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexGendEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexGenfEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexGeniEXT(GLenum texunit, GLenum coord, GLenum pname, GLint param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexParameteriEXT(GLenum texunit, GLenum target, GLenum pname, GLint param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexParameterfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultiTexImageEXT(GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultiTexLevelParameterfvEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultiTexLevelParameterivEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCopyMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEnableClientStateIndexedEXT(GLenum array, GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDisableClientStateIndexedEXT(GLenum array, GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetFloatIndexedvEXT(GLenum target, GLuint index, GLfloat *data){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetDoubleIndexedvEXT(GLenum target, GLuint index, GLdouble *data){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetPointerIndexedvEXT(GLenum target, GLuint index, void **data){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEnableIndexedEXT(GLenum target, GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDisableIndexedEXT(GLenum target, GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glIsEnabledIndexedEXT(GLenum target, GLuint index){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glGetIntegerIndexedvEXT(GLenum target, GLuint index, GLint *data){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetBooleanIndexedvEXT(GLenum target, GLuint index, GLboolean *data){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetCompressedTextureImageEXT(GLuint texture, GLenum target, GLint lod, void *img){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCompressedMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetCompressedMultiTexImageEXT(GLenum texunit, GLenum target, GLint lod, void *img){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixLoadTransposefEXT(GLenum mode, const GLfloat *m){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixLoadTransposedEXT(GLenum mode, const GLdouble *m){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixMultTransposefEXT(GLenum mode, const GLfloat *m){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMatrixMultTransposedEXT(GLenum mode, const GLdouble *m){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetNamedBufferPointervEXT(GLuint buffer, GLenum pname, void **params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, void *data){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform4fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform1iEXT(GLuint program, GLint location, GLint v0){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix2x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix3x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix2x4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix4x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix3x4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix4x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureBufferEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexBufferEXT(GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, const GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, const GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform1uiEXT(GLuint program, GLint location, GLuint v0){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform2uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform3uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform4uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform1uivEXT(GLuint program, GLint location, GLsizei count, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform2uivEXT(GLuint program, GLint location, GLsizei count, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform3uivEXT(GLuint program, GLint location, GLsizei count, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform4uivEXT(GLuint program, GLint location, GLsizei count, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedProgramLocalParameters4fvEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedProgramLocalParameterI4iEXT(GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedProgramLocalParameterI4ivEXT(GLuint program, GLenum target, GLuint index, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedProgramLocalParametersI4ivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedProgramLocalParameterI4uiEXT(GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedProgramLocalParameterI4uivEXT(GLuint program, GLenum target, GLuint index, const GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedProgramLocalParametersI4uivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetNamedProgramLocalParameterIivEXT(GLuint program, GLenum target, GLuint index, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetNamedProgramLocalParameterIuivEXT(GLuint program, GLenum target, GLuint index, GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEnableClientStateiEXT(GLenum array, GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDisableClientStateiEXT(GLenum array, GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetFloati_vEXT(GLenum pname, GLuint index, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetDoublei_vEXT(GLenum pname, GLuint index, GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetPointeri_vEXT(GLenum pname, GLuint index, void **params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedProgramStringEXT(GLuint program, GLenum target, GLenum format, GLsizei len, const void *string){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedProgramLocalParameter4dEXT(GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedProgramLocalParameter4dvEXT(GLuint program, GLenum target, GLuint index, const GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedProgramLocalParameter4fEXT(GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedProgramLocalParameter4fvEXT(GLuint program, GLenum target, GLuint index, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetNamedProgramLocalParameterdvEXT(GLuint program, GLenum target, GLuint index, GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetNamedProgramLocalParameterfvEXT(GLuint program, GLenum target, GLuint index, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetNamedProgramivEXT(GLuint program, GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetNamedProgramStringEXT(GLuint program, GLenum target, GLenum pname, void *string){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedRenderbufferStorageEXT(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetNamedRenderbufferParameterivEXT(GLuint renderbuffer, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedRenderbufferStorageMultisampleEXT(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedRenderbufferStorageMultisampleCoverageEXT(GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height){ TRACE("*"); UNIMPLEMENTED(); }
GLenum APIENTRY glCheckNamedFramebufferStatusEXT(GLuint framebuffer, GLenum target){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glNamedFramebufferTexture1DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedFramebufferTexture2DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedFramebufferTexture3DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedFramebufferRenderbufferEXT(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetNamedFramebufferAttachmentParameterivEXT(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGenerateTextureMipmapEXT(GLuint texture, GLenum target){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGenerateMultiTexMipmapEXT(GLenum texunit, GLenum target){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFramebufferDrawBufferEXT(GLuint framebuffer, GLenum mode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFramebufferDrawBuffersEXT(GLuint framebuffer, GLsizei n, const GLenum *bufs){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFramebufferReadBufferEXT(GLuint framebuffer, GLenum mode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetFramebufferParameterivEXT(GLuint framebuffer, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedCopyBufferSubDataEXT(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedFramebufferTextureEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedFramebufferTextureLayerEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedFramebufferTextureFaceEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureRenderbufferEXT(GLuint texture, GLenum target, GLuint renderbuffer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexRenderbufferEXT(GLenum texunit, GLenum target, GLuint renderbuffer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayVertexOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayColorOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayEdgeFlagOffsetEXT(GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayIndexOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayNormalOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayTexCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayMultiTexCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayFogCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArraySecondaryColorOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayVertexAttribOffsetEXT(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayVertexAttribIOffsetEXT(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEnableVertexArrayEXT(GLuint vaobj, GLenum array){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDisableVertexArrayEXT(GLuint vaobj, GLenum array){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEnableVertexArrayAttribEXT(GLuint vaobj, GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDisableVertexArrayAttribEXT(GLuint vaobj, GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexArrayIntegervEXT(GLuint vaobj, GLenum pname, GLint *param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexArrayPointervEXT(GLuint vaobj, GLenum pname, void **param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexArrayIntegeri_vEXT(GLuint vaobj, GLuint index, GLenum pname, GLint *param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexArrayPointeri_vEXT(GLuint vaobj, GLuint index, GLenum pname, void **param){ TRACE("*"); UNIMPLEMENTED(); }
void *APIENTRY glMapNamedBufferRangeEXT(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glFlushMappedNamedBufferRangeEXT(GLuint buffer, GLintptr offset, GLsizeiptr length){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedBufferStorageEXT(GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glClearNamedBufferDataEXT(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glClearNamedBufferSubDataEXT(GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNamedFramebufferParameteriEXT(GLuint framebuffer, GLenum pname, GLint param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetNamedFramebufferParameterivEXT(GLuint framebuffer, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform1dEXT(GLuint program, GLint location, GLdouble x){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform2dEXT(GLuint program, GLint location, GLdouble x, GLdouble y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform3dEXT(GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform4dEXT(GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform1dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform2dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform3dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniform4dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix2x3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix2x4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix3x2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix3x4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix4x2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformMatrix4x3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureStorage2DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTextureStorage3DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayBindVertexBufferEXT(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayVertexAttribFormatEXT(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayVertexAttribIFormatEXT(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayVertexAttribLFormatEXT(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayVertexAttribBindingEXT(GLuint vaobj, GLuint attribindex, GLuint bindingindex){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayVertexBindingDivisorEXT(GLuint vaobj, GLuint bindingindex, GLuint divisor){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayVertexAttribLOffsetEXT(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexturePageCommitmentEXT(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean resident){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayVertexAttribDivisorEXT(GLuint vaobj, GLuint index, GLuint divisor){ TRACE("*"); UNIMPLEMENTED(); }


void APIENTRY glColorMaskIndexedEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDrawArraysInstancedEXT(GLenum mode, GLint start, GLsizei count, GLsizei primcount){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDrawElementsInstancedEXT(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramParameteriEXT(GLuint program, GLenum pname, GLint value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFramebufferTextureEXT(GLenum target, GLenum attachment, GLuint texture, GLint level){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFramebufferTextureLayerEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFramebufferTextureFaceEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetUniformuivEXT(GLuint program, GLint location, GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBindFragDataLocationEXT(GLuint program, GLuint color, const GLchar *name){ TRACE("*"); UNIMPLEMENTED(); }
GLint APIENTRY glGetFragDataLocationEXT(GLuint program, const GLchar *name){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glUniform1uiEXT(GLint location, GLuint v0){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform2uiEXT(GLint location, GLuint v0, GLuint v1){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform3uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform4uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform1uivEXT(GLint location, GLsizei count, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform2uivEXT(GLint location, GLsizei count, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform3uivEXT(GLint location, GLsizei count, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniform4uivEXT(GLint location, GLsizei count, const GLuint *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI1iEXT(GLuint index, GLint x){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI2iEXT(GLuint index, GLint x, GLint y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI3iEXT(GLuint index, GLint x, GLint y, GLint z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4iEXT(GLuint index, GLint x, GLint y, GLint z, GLint w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI1uiEXT(GLuint index, GLuint x){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI2uiEXT(GLuint index, GLuint x, GLuint y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI3uiEXT(GLuint index, GLuint x, GLuint y, GLuint z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4uiEXT(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI1ivEXT(GLuint index, const GLint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI2ivEXT(GLuint index, const GLint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI3ivEXT(GLuint index, const GLint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4ivEXT(GLuint index, const GLint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI1uivEXT(GLuint index, const GLuint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI2uivEXT(GLuint index, const GLuint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI3uivEXT(GLuint index, const GLuint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4uivEXT(GLuint index, const GLuint *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4bvEXT(GLuint index, const GLbyte *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4svEXT(GLuint index, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4ubvEXT(GLuint index, const GLubyte *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribI4usvEXT(GLuint index, const GLushort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribIPointerEXT(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexAttribIivEXT(GLuint index, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexAttribIuivEXT(GLuint index, GLenum pname, GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glPointParameterfEXT(GLenum pname, GLfloat param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glPointParameterfvEXT(GLenum pname, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexParameterIivEXT(GLenum target, GLenum pname, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexParameterIuivEXT(GLenum target, GLenum pname, const GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTexParameterIivEXT(GLenum target, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glClearColorIiEXT(GLint red, GLint green, GLint blue, GLint alpha){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glClearColorIuiEXT(GLuint red, GLuint green, GLuint blue, GLuint alpha){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params){ TRACE("*"); UNIMPLEMENTED(); }
#define GL_GLEXT_PROTOTYPES
void APIENTRY glArrayElementEXT(GLint i){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDrawArraysEXT(GLenum mode, GLint first, GLsizei count){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetPointervEXT(GLenum pname, void **params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const void *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const void *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBeginConditionalRenderNV(GLuint id, GLenum mode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEndConditionalRenderNV(void){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDepthRangedNV(GLdouble zNear, GLdouble zFar){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glClearDepthdNV(GLdouble depth){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDepthBoundsdNV(GLdouble zmin, GLdouble zmax){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetMultisamplefvNV(GLenum pname, GLuint index, GLfloat *val){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glSampleMaskIndexedNV(GLuint index, GLbitfield mask){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexRenderbufferNV(GLenum target, GLuint renderbuffer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glRenderbufferStorageMultisampleCoverageNV(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramLocalParameterI4iNV(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramLocalParameterI4ivNV(GLenum target, GLuint index, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramLocalParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramLocalParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramLocalParameterI4uivNV(GLenum target, GLuint index, const GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramLocalParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramEnvParameterI4iNV(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramEnvParameterI4ivNV(GLenum target, GLuint index, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramEnvParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramEnvParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramEnvParameterI4uivNV(GLenum target, GLuint index, const GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramEnvParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramLocalParameterIivNV(GLenum target, GLuint index, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramLocalParameterIuivNV(GLenum target, GLuint index, GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramEnvParameterIivNV(GLenum target, GLuint index, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramEnvParameterIuivNV(GLenum target, GLuint index, GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertex2hNV(GLhalfNV x, GLhalfNV y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertex2hvNV(const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertex3hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertex3hvNV(const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertex4hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertex4hvNV(const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNormal3hNV(GLhalfNV nx, GLhalfNV ny, GLhalfNV nz){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNormal3hvNV(const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glColor3hvNV(const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glColor4hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glColor4hvNV(const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexCoord1hNV(GLhalfNV s){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexCoord1hvNV(const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexCoord2hNV(GLhalfNV s, GLhalfNV t){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexCoord2hvNV(const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexCoord3hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexCoord3hvNV(const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexCoord4hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexCoord4hvNV(const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord1hNV(GLenum target, GLhalfNV s){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord1hvNV(GLenum target, const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord2hNV(GLenum target, GLhalfNV s, GLhalfNV t){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord2hvNV(GLenum target, const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord3hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord3hvNV(GLenum target, const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord4hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMultiTexCoord4hvNV(GLenum target, const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFogCoordhNV(GLhalfNV fog){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFogCoordhvNV(const GLhalfNV *fog){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glSecondaryColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glSecondaryColor3hvNV(const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexWeighthNV(GLhalfNV weight){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexWeighthvNV(const GLhalfNV *weight){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1hNV(GLuint index, GLhalfNV x){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1hvNV(GLuint index, const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2hNV(GLuint index, GLhalfNV x, GLhalfNV y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2hvNV(GLuint index, const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3hvNV(GLuint index, const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4hvNV(GLuint index, const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs1hvNV(GLuint index, GLsizei n, const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs2hvNV(GLuint index, GLsizei n, const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs3hvNV(GLuint index, GLsizei n, const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs4hvNV(GLuint index, GLsizei n, const GLhalfNV *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBeginOcclusionQueryNV(GLuint id){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEndOcclusionQueryNV(void){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetOcclusionQueryivNV(GLuint id, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetOcclusionQueryuivNV(GLuint id, GLenum pname, GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGenOcclusionQueriesNV(GLsizei n, GLuint *ids){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDeleteOcclusionQueriesNV(GLsizei n, const GLuint *ids){ TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glIsOcclusionQueryNV(GLuint id){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glProgramBufferParametersfvNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramBufferParametersIivNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramBufferParametersIuivNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLuint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glPixelDataRangeNV(GLenum target, GLsizei length, const void *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFlushPixelDataRangeNV(GLenum target){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glPointParameteriNV(GLenum pname, GLint param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glPointParameterivNV(GLenum pname, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glPrimitiveRestartNV(void){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glPrimitiveRestartIndexNV(GLuint index){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCombinerParameterfvNV(GLenum pname, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCombinerParameterfNV(GLenum pname, GLfloat param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCombinerParameterivNV(GLenum pname, const GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCombinerParameteriNV(GLenum pname, GLint param){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCombinerInputNV(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCombinerOutputNV(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFinalCombinerInputNV(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glCombinerStageParameterfvNV(GLenum stage, GLenum pname, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetCombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMakeBufferResidentNV(GLenum target, GLenum access){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMakeBufferNonResidentNV(GLenum target){ TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glIsBufferResidentNV(GLenum target){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glMakeNamedBufferResidentNV(GLuint buffer, GLenum access){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glMakeNamedBufferNonResidentNV(GLuint buffer){ TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glIsNamedBufferResidentNV(GLuint buffer){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glGetBufferParameterui64vNV(GLenum target, GLenum pname, GLuint64EXT *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetNamedBufferParameterui64vNV(GLuint buffer, GLenum pname, GLuint64EXT *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetIntegerui64vNV(GLenum value, GLuint64EXT *result){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniformui64NV(GLint location, GLuint64EXT value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glUniformui64vNV(GLint location, GLsizei count, const GLuint64EXT *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetUniformui64vNV(GLuint program, GLint location, GLuint64EXT *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformui64NV(GLuint program, GLint location, GLuint64EXT value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramUniformui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT *value){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBeginTransformFeedbackNV(GLenum primitiveMode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEndTransformFeedbackNV(void){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTransformFeedbackAttribsNV(GLuint count, const GLint *attribs, GLenum bufferMode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBindBufferRangeNV(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBindBufferOffsetNV(GLenum target, GLuint index, GLuint buffer, GLintptr offset){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBindBufferBaseNV(GLenum target, GLuint index, GLuint buffer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTransformFeedbackVaryingsNV(GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glActiveVaryingNV(GLuint program, const GLchar *name){ TRACE("*"); UNIMPLEMENTED(); }
GLint APIENTRY glGetVaryingLocationNV(GLuint program, const GLchar *name){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glGetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTransformFeedbackVaryingNV(GLuint program, GLuint index, GLint *location){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTransformFeedbackStreamAttribsNV(GLsizei count, const GLint *attribs, GLsizei nbuffers, const GLint *bufstreams, GLenum bufferMode){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFlushVertexArrayRangeNV(void){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexArrayRangeNV(GLsizei length, const void *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glBufferAddressRangeNV(GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexFormatNV(GLint size, GLenum type, GLsizei stride){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glNormalFormatNV(GLenum type, GLsizei stride){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glColorFormatNV(GLint size, GLenum type, GLsizei stride){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glIndexFormatNV(GLenum type, GLsizei stride){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTexCoordFormatNV(GLint size, GLenum type, GLsizei stride){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glEdgeFlagFormatNV(GLsizei stride){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glSecondaryColorFormatNV(GLint size, GLenum type, GLsizei stride){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glFogCoordFormatNV(GLenum type, GLsizei stride){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribFormatNV(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribIFormatNV(GLuint index, GLint size, GLenum type, GLsizei stride){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetIntegerui64i_vNV(GLenum value, GLuint index, GLuint64EXT *result){ TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glAreProgramsResidentNV(GLsizei n, const GLuint *programs, GLboolean *residences){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glBindProgramNV(GLenum target, GLuint id){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glDeleteProgramsNV(GLsizei n, const GLuint *programs){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGenProgramsNV(GLsizei n, GLuint *programs){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramivNV(GLuint id, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetProgramStringNV(GLuint id, GLenum pname, GLubyte *program){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexAttribivNV(GLuint index, GLenum pname, GLint *params){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glGetVertexAttribPointervNV(GLuint index, GLenum pname, void **pointer){ TRACE("*"); UNIMPLEMENTED(); }
GLboolean APIENTRY glIsProgramNV(GLuint id){ TRACE("*"); UNIMPLEMENTED(); return 0; }
void APIENTRY glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte *program){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramParameters4dvNV(GLenum target, GLuint index, GLsizei count, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glProgramParameters4fvNV(GLenum target, GLuint index, GLsizei count, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glRequestResidentProgramsNV(GLsizei n, const GLuint *programs){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const void *pointer){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1dNV(GLuint index, GLdouble x){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1dvNV(GLuint index, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1fNV(GLuint index, GLfloat x){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1fvNV(GLuint index, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1sNV(GLuint index, GLshort x){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib1svNV(GLuint index, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2dvNV(GLuint index, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2fvNV(GLuint index, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib2svNV(GLuint index, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3dvNV(GLuint index, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3fvNV(GLuint index, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib3svNV(GLuint index, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4dvNV(GLuint index, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4fvNV(GLuint index, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4svNV(GLuint index, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttrib4ubvNV(GLuint index, const GLubyte *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs1dvNV(GLuint index, GLsizei count, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs1fvNV(GLuint index, GLsizei count, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs1svNV(GLuint index, GLsizei count, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs2dvNV(GLuint index, GLsizei count, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs2fvNV(GLuint index, GLsizei count, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs2svNV(GLuint index, GLsizei count, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs3dvNV(GLuint index, GLsizei count, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs3fvNV(GLuint index, GLsizei count, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs3svNV(GLuint index, GLsizei count, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs4dvNV(GLuint index, GLsizei count, const GLdouble *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs4fvNV(GLuint index, GLsizei count, const GLfloat *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs4svNV(GLuint index, GLsizei count, const GLshort *v){ TRACE("*"); UNIMPLEMENTED(); }
void APIENTRY glVertexAttribs4ubvNV(GLuint index, GLsizei count, const GLubyte *v){ TRACE("*"); UNIMPLEMENTED(); }

GLboolean APIENTRY wgl1fx34c0da() 
{ 
	return -1;// UNIMPLEMENTED();
}

BOOL WINAPI wglSwapIntervalEXT(int interval)
{
	gl::Surface *drawSurface = static_cast<gl::Surface*>(gl::getCurrentDrawSurface());

	if(drawSurface)
	{
		drawSurface->setSwapInterval(interval);
		return TRUE;
	}
	
	SetLastError(ERROR_DC_NOT_FOUND);
	return FALSE;
}

int WINAPI wglGetSwapIntervalEXT(void)
{
	TRACE("(*)");
	UNIMPLEMENTED();
	return 1;
}

int WINAPI wglChoosePixelFormat(HDC hdc, const PIXELFORMATDESCRIPTOR *ppfd)
{
	TRACE("(*)");

	return 1;
}

BOOL WINAPI wglCopyContext(HGLRC, HGLRC, UINT)
{
	UNIMPLEMENTED();
	return FALSE;
}

HGLRC WINAPI wglCreateContext(HDC hdc)
{
	TRACE("(*)");

	gl::Display *display = gl::Display::getDisplay(hdc);
	display->initialize();

	gl::Context *context = display->createContext(nullptr);

	return (HGLRC)context;
}

HGLRC WINAPI wglCreateLayerContext(HDC, int)
{
	UNIMPLEMENTED();
	return 0;
}

BOOL WINAPI wglDeleteContext(HGLRC context)
{
	gl::Display *display = gl::getDisplay();

	if(display && context)
	{
		display->destroyContext(reinterpret_cast<gl::Context*>(context));

		return TRUE;
	}

	return TRUE;// FALSE;
}

BOOL WINAPI wglDescribeLayerPlane(HDC, int, int, UINT, LPLAYERPLANEDESCRIPTOR)
{
	UNIMPLEMENTED();
	return FALSE;
}



void APIENTRY glVertexAttrib4bv(GLuint index, const GLbyte *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib4iv(GLuint index, const GLint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib4sv(GLuint index, const GLshort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib4ubv(GLuint index, const GLubyte *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib4uiv(GLuint index, const GLuint *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}
void APIENTRY glVertexAttrib4usv(GLuint index, const GLushort *v)
{
	TRACE("*");
	UNIMPLEMENTED();
}


int WINAPI wglDescribePixelFormat(HDC hdc, int iPixelFormat, UINT nBytes, LPPIXELFORMATDESCRIPTOR ppfd)
{
	TRACE("(*)");

	ASSERT(nBytes == sizeof(PIXELFORMATDESCRIPTOR));   // FIXME

	ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
	ppfd->nVersion = 1;
	ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
	ppfd->iPixelType = PFD_TYPE_RGBA;
	ppfd->cColorBits = 32;
	ppfd->cRedBits = 8;
	ppfd->cRedShift = 16;
	ppfd->cGreenBits = 8;
	ppfd->cGreenShift = 8;
	ppfd->cBlueBits = 8;
	ppfd->cBlueShift = 0;
	ppfd->cAlphaBits = 0;
	ppfd->cAlphaShift = 24;
	ppfd->cAccumBits = 0;
	ppfd->cAccumRedBits = 0;
	ppfd->cAccumGreenBits = 0;
	ppfd->cAccumBlueBits = 0;
	ppfd->cAccumAlphaBits = 0;
	ppfd->cDepthBits = 24;
	ppfd->cStencilBits = 0;
	ppfd->cAuxBuffers = 0;
	ppfd->iLayerType = 0;
	ppfd->bReserved = 0;
	ppfd->dwLayerMask = 0;
	ppfd->dwVisibleMask = 0;
	ppfd->dwDamageMask = 0;

	return 1;
}

HGLRC WINAPI wglGetCurrentContext(VOID)
{
	TRACE("(*)");
	return (HGLRC)gl::getContext();
}

HDC WINAPI wglGetCurrentDC(VOID)
{
	TRACE("(*)");
	gl::Display *display = gl::getDisplay();
	return display ? display->getNativeDisplay() : 0;
}

void WINAPI wglGetDefaultProcAddress()
{
	UNIMPLEMENTED();
}

int WINAPI wglGetLayerPaletteEntries(HDC, int, int, int, COLORREF*)
{
	UNIMPLEMENTED();
	return 0;
}

void WINAPI wglGetPixelFormat()
{
	UNIMPLEMENTED();
}

const char *WINAPI wglGetExtensionsStringARB(HDC hdc)
{
	TRACE("(*)");

	return "GL_ARB_texture_non_power_of_two "
		"GL_ARB_framebuffer_object "
		"GL_ARB_fragment_shader "
		"GL_ARB_vertex_shader "
		"GL_ARB_shader_objects "
		"GL_ARB_shading_language_100 "
		"GL_EXT_framebuffer_object";
		//"wglCreateContextAttribsARB";
	//NVIDIA CARD
	"WGL_ARB_buffer_region WGL_ARB_create_context WGL_ARB_create_context_profile WGL_ARB_create_context_robustness WGL_ARB_context_flush_control WGL_ARB_extensions_string WGL_ARB_make_current_read WGL_ARB_multisample WGL_ARB_pbuffer WGL_ARB_pixel_format WGL_ARB_pixel_format_float WGL_ARB_render_texture WGL_ATI_pixel_format_float WGL_EXT_create_context_es_profile WGL_EXT_create_context_es2_profile WGL_EXT_extensions_string WGL_EXT_framebuffer_sRGB WGL_EXT_pixel_format_packed_float WGL_EXT_swap_control WGL_EXT_swap_control_tear WGL_NVX_DX_interop WGL_NV_DX_interop WGL_NV_DX_interop2 WGL_NV_copy_image WGL_NV_delay_before_swap WGL_NV_float_buffer WGL_NV_gpu_affinity WGL_NV_multisample_coverage WGL_NV_render_depth_texture WGL_NV_render_texture_rectangle WGL_NV_swap_group WGL_NV_video_capture";
}

const char *WINAPI wglGetExtensionsStringEXT()
{
	TRACE("(*)");
	return wglGetExtensionsStringARB(0);
}

PROC WINAPI wglGetProcAddress(LPCSTR lpszProc)
{
	TRACE("(LPCSTR lpszProc = \"%s\")", lpszProc);

	struct Extension
	{
		const char *name;
		PROC address;
	};

	static const Extension glExtensions[] =
	{
		#define EXT(function) {#function, (PROC)function}
		
		// Core 2.1
		EXT(glDrawRangeElements),
		EXT(glTexImage3D),
		EXT(glTexSubImage3D),
		EXT(glCopyTexSubImage3D),
		EXT(glActiveTexture),
		EXT(glClientActiveTexture),
		EXT(glCompressedTexImage1D),
		EXT(glCompressedTexImage2D),
		EXT(glCompressedTexImage3D),
		EXT(glCompressedTexSubImage1D),
		EXT(glCompressedTexSubImage2D),
		EXT(glCompressedTexSubImage3D),
		EXT(glGetCompressedTexImage),
		EXT(glMultiTexCoord1f),
		EXT(glMultiTexCoord1d),
		EXT(glMultiTexCoord2f),
		EXT(glMultiTexCoord2d),
		EXT(glMultiTexCoord3f),
		EXT(glMultiTexCoord3d),
		EXT(glMultiTexCoord4f),
		EXT(glMultiTexCoord4d),
		EXT(glLoadTransposeMatrixf),
		EXT(glLoadTransposeMatrixd),
		EXT(glMultTransposeMatrixf),
		EXT(glMultTransposeMatrixd),
		EXT(glSampleCoverage),
		EXT(glBlendEquation),
		EXT(glBlendColor),
		EXT(glFogCoordf),
		EXT(glFogCoordd),
		EXT(glFogCoordPointer),
		EXT(glMultiDrawArrays),
		EXT(glPointParameteri),
		EXT(glPointParameterf),
		EXT(glPointParameteriv),
		EXT(glPointParameterfv),
		EXT(glSecondaryColor3b),
		EXT(glSecondaryColor3f),
		EXT(glSecondaryColor3d),
		EXT(glSecondaryColor3ub),
		EXT(glSecondaryColorPointer),
		EXT(glBlendFuncSeparate),
		EXT(glWindowPos2f),
		EXT(glWindowPos2d),
		EXT(glWindowPos2i),
		EXT(glWindowPos3f),
		EXT(glWindowPos3d),
		EXT(glWindowPos3i),
		EXT(glBindBuffer),
		EXT(glDeleteBuffers),
		EXT(glGenBuffers),
		EXT(glIsBuffer),
		EXT(glBufferData),
		EXT(glBufferSubData),
		EXT(glGetBufferSubData),
		EXT(glMapBuffer),
		EXT(glUnmapBuffer),
		EXT(glGetBufferParameteriv),
		EXT(glGetBufferPointerv),
		EXT(glGenQueries),
		EXT(glDeleteQueries),
		EXT(glIsQuery),
		EXT(glBeginQuery),
		EXT(glEndQuery),
		EXT(glGetQueryiv),
		EXT(glGetQueryObjectiv),
		EXT(glGetQueryObjectuiv),
		EXT(glShaderSource),
		EXT(glCreateShader),
		EXT(glIsShader),
		EXT(glCompileShader),
		EXT(glDeleteShader),
		EXT(glCreateProgram),
		EXT(glIsProgram),
		EXT(glAttachShader),
		EXT(glDetachShader),
		EXT(glLinkProgram),
		EXT(glUseProgram),
		EXT(glValidateProgram),
		EXT(glDeleteProgram),
		EXT(glUniform1f),
		EXT(glUniform2f),
		EXT(glUniform3f),
		EXT(glUniform4f),
		EXT(glUniform1i),
		EXT(glUniform2i),
		EXT(glUniform3i),
		EXT(glUniform4i),
		EXT(glUniform1fv),
		EXT(glUniform2fv),
		EXT(glUniform3fv),
		EXT(glUniform4fv),
		EXT(glUniform1iv),
		EXT(glUniform2iv),
		EXT(glUniform3iv),
		EXT(glUniform4iv),
		EXT(glUniformMatrix2fv),
		EXT(glUniformMatrix3fv),
		EXT(glUniformMatrix4fv),
		EXT(glGetShaderiv),
		EXT(glGetProgramiv),
		EXT(glGetShaderInfoLog),
		EXT(glGetProgramInfoLog),
		EXT(glGetAttachedShaders),
		EXT(glGetUniformLocation),
		EXT(glGetActiveUniform),
		EXT(glGetUniformfv),
		EXT(glGetUniformiv),
		EXT(glGetShaderSource),
		EXT(glVertexAttrib1s),
		EXT(glVertexAttrib1f),
		EXT(glVertexAttrib1d),
		EXT(glVertexAttrib2s),
		EXT(glVertexAttrib2f),
		EXT(glVertexAttrib2d),
		EXT(glVertexAttrib3s),
		EXT(glVertexAttrib3f),
		EXT(glVertexAttrib3d),
		EXT(glVertexAttrib4s),
		EXT(glVertexAttrib4f),
		EXT(glVertexAttrib4d),
		EXT(glVertexAttrib4Nub),
		EXT(glVertexAttribPointer),
		EXT(glEnableVertexAttribArray),
		EXT(glDisableVertexAttribArray),
		EXT(glGetVertexAttribfv),
		EXT(glGetVertexAttribdv),
		EXT(glGetVertexAttribiv),
		EXT(glGetVertexAttribPointerv),
		EXT(glBindAttribLocation),
		EXT(glGetActiveAttrib),
		EXT(glGetAttribLocation),
		EXT(glDrawBuffers),
		EXT(glStencilOpSeparate),
		EXT(glStencilFuncSeparate),
		EXT(glStencilMaskSeparate),
		EXT(glBlendEquationSeparate),
		EXT(glUniformMatrix2x3fv),
		EXT(glUniformMatrix3x2fv),
		EXT(glUniformMatrix2x4fv),
		EXT(glUniformMatrix4x2fv),
		EXT(glUniformMatrix3x4fv),
		EXT(glUniformMatrix4x3fv),
		EXT(glGenFencesNV),
		EXT(glDeleteFencesNV),
		EXT(glSetFenceNV),
		EXT(glTestFenceNV),
		EXT(glFinishFenceNV),
		EXT(glIsFenceNV),
		EXT(glGetFenceivNV),
	
		EXT(glIsRenderbuffer),
		EXT(glBindRenderbuffer),
		EXT(glDeleteRenderbuffers),
		EXT(glGenRenderbuffers),
		EXT(glRenderbufferStorage),
		EXT(glGetRenderbufferParameteriv),
		EXT(glIsFramebuffer),
		EXT(glBindFramebuffer),
		EXT(glDeleteFramebuffers),
		EXT(glGenFramebuffers),
		EXT(glCheckFramebufferStatus),
		EXT(glFramebufferTexture1D),
		EXT(glFramebufferTexture2D),
		EXT(glFramebufferTexture3D),
		EXT(glFramebufferRenderbuffer),
		EXT(glGetFramebufferAttachmentParameteriv),
		EXT(glGenerateMipmap),
		EXT(glReleaseShaderCompiler),
		EXT(glShaderBinary),
		EXT(glGetShaderPrecisionFormat),
		EXT(glDepthRangef),
		EXT(glClearDepthf),

		// UNIMPLEMENTED
		EXT(glVertexAttrib1dv),
		EXT(glVertexAttrib1fv),
		EXT(glVertexAttrib1sv),
		EXT(glVertexAttrib2dv),
		EXT(glVertexAttrib2fv),
		EXT(glVertexAttrib2sv),
		EXT(glVertexAttrib3dv),
		EXT(glVertexAttrib3fv),
		EXT(glVertexAttrib3sv),
		EXT(glVertexAttrib4Nbv),
		EXT(glVertexAttrib4Niv),
		EXT(glVertexAttrib4Nsv),
		EXT(glVertexAttrib4Nubv),
		EXT(glVertexAttrib4Nuiv),
		EXT(glVertexAttrib4Nusv),
		EXT(glVertexAttrib4bv),
		EXT(glVertexAttrib4dv),
		EXT(glVertexAttrib4iv),
		EXT(glVertexAttrib4sv),
		EXT(glVertexAttrib4ubv),
		EXT(glVertexAttrib4uiv),
		EXT(glVertexAttrib4usv),
		EXT(glVertexAttrib4fv),
		EXT(glFogCoordfv),
		EXT(glFogCoorddv),
		EXT(glMultiDrawElements),
		EXT(glSecondaryColor3bv),
		EXT(glSecondaryColor3dv),
		EXT(glSecondaryColor3fv),
		EXT(glSecondaryColor3i),
		EXT(glSecondaryColor3iv),
		EXT(glSecondaryColor3s),
		EXT(glSecondaryColor3sv),
		EXT(glSecondaryColor3ubv),
		EXT(glSecondaryColor3ui),
		EXT(glSecondaryColor3uiv),
		EXT(glSecondaryColor3us),
		EXT(glSecondaryColor3usv),
		EXT(glWindowPos2s),
		EXT(glWindowPos2dv),
		EXT(glWindowPos2fv),
		EXT(glWindowPos2iv),
		EXT(glWindowPos2sv),
		EXT(glWindowPos3s),
		EXT(glWindowPos3dv),
		EXT(glWindowPos3fv),
		EXT(glWindowPos3iv),
		EXT(glWindowPos3sv),
		EXT(glMultiTexCoord1dv),
		EXT(glMultiTexCoord1fv),
		EXT(glMultiTexCoord1i),
		EXT(glMultiTexCoord1iv),
		EXT(glMultiTexCoord1s),
		EXT(glMultiTexCoord1sv),
		EXT(glMultiTexCoord2dv),
		EXT(glMultiTexCoord2fv),
		EXT(glMultiTexCoord2i),
		EXT(glMultiTexCoord2iv),
		EXT(glMultiTexCoord2s),
		EXT(glMultiTexCoord2sv),
		EXT(glMultiTexCoord3dv),
		EXT(glMultiTexCoord3fv),
		EXT(glMultiTexCoord3i),
		EXT(glMultiTexCoord3iv),
		EXT(glMultiTexCoord3s),
		EXT(glMultiTexCoord3sv),
		EXT(glMultiTexCoord4dv),
		EXT(glMultiTexCoord4fv),
		EXT(glMultiTexCoord4i),
		EXT(glMultiTexCoord4iv),
		EXT(glMultiTexCoord4s),
		EXT(glMultiTexCoord4sv),
		EXT(glBlendEquationEXT),
		EXT(glBlendFuncSeparateEXT),
		EXT(glSecondaryColor3bEXT),
		EXT(glSecondaryColor3bvEXT),
		EXT(glSecondaryColor3dEXT),
		EXT(glSecondaryColor3dvEXT),
		EXT(glSecondaryColor3fEXT),
		EXT(glSecondaryColor3fvEXT),
		EXT(glSecondaryColor3iEXT),
		EXT(glSecondaryColor3ivEXT),
		EXT(glSecondaryColor3sEXT),
		EXT(glSecondaryColor3svEXT),
		EXT(glSecondaryColor3ubEXT),
		EXT(glSecondaryColor3ubvEXT),
		EXT(glSecondaryColor3uiEXT),
		EXT(glSecondaryColor3uivEXT),
		EXT(glSecondaryColor3usEXT),
		EXT(glSecondaryColor3usvEXT),
		EXT(glSecondaryColorPointerEXT),
		EXT(glBlitFramebufferEXT),
		EXT(glRenderbufferStorageMultisampleEXT),
		EXT(glSecondaryColor3i),
		EXT(glSecondaryColor3s),
		EXT(glSecondaryColor3ui),
		EXT(glSecondaryColor3us),
		EXT(glSecondaryColor3bv),
		EXT(glSecondaryColor3fv),
		EXT(glSecondaryColor3dv),
		EXT(glSecondaryColor3ubv),
		EXT(glSecondaryColor3iv),
		EXT(glSecondaryColor3sv),
		EXT(glSecondaryColor3uiv),
		EXT(glSecondaryColor3usv),
		EXT(glBindAttribLocationARB),
		EXT(glGetActiveAttribARB),
		EXT(glGetAttribLocationARB),
		EXT(glAttachObjectARB),
		EXT(glCompileShaderARB),
		EXT(glCreateProgramObjectARB),
		EXT(glCreateShaderObjectARB),
		EXT(glDeleteObjectARB),
		EXT(glDetachObjectARB),
		EXT(glGetActiveUniformARB),
		EXT(glGetAttachedObjectsARB),
		EXT(glGetHandleARB),
		EXT(glGetInfoLogARB),
		EXT(glGetObjectParameterfvARB),
		EXT(glGetObjectParameterivARB),
		EXT(glGetShaderSourceARB),
		EXT(glGetUniformLocationARB),
		EXT(glGetUniformfvARB),
		EXT(glGetUniformivARB),
		EXT(glLinkProgramARB),
		EXT(glShaderSourceARB),
		EXT(glUniform1fARB),
		EXT(glUniform1fvARB),
		EXT(glUniform1iARB),
		EXT(glUniform1ivARB),
		EXT(glUniform2fARB),
		EXT(glUniform2fvARB),
		EXT(glUniform2iARB),
		EXT(glUniform2ivARB),
		EXT(glUniform3fARB),
		EXT(glUniform3fvARB),
		EXT(glUniform3iARB),
		EXT(glUniform3ivARB),
		EXT(glUniform4fARB),
		EXT(glUniform4fvARB),
		EXT(glUniform4iARB),
		EXT(glUniform4ivARB),
		EXT(glUniformMatrix2fvARB),
		EXT(glUniformMatrix3fvARB),
		EXT(glUniformMatrix4fvARB),
		EXT(glUseProgramObjectARB),
		EXT(glValidateProgramARB),
		EXT(glIsRenderbufferEXT),
		EXT(glBindRenderbufferEXT),
		EXT(glDeleteRenderbuffersEXT),
		EXT(glGenRenderbuffersEXT),
		EXT(glRenderbufferStorageEXT),
		EXT(glGetRenderbufferParameterivEXT),
		EXT(glIsFramebufferEXT),
		EXT(glBindFramebufferEXT),
		EXT(glDeleteFramebuffersEXT),
		EXT(glGenFramebuffersEXT),
		EXT(glCheckFramebufferStatusEXT),
		EXT(glFramebufferTexture1DEXT),
		EXT(glFramebufferTexture2DEXT),
		EXT(glFramebufferTexture3DEXT),
		EXT(glFramebufferRenderbufferEXT),
		EXT(glGetFramebufferAttachmentParameterivEXT),
		EXT(glGenerateMipmapEXT),
		EXT(glColorMaski),
		EXT(glGetBooleani_v),
		EXT(glGetIntegeri_v),
		EXT(glEnablei),
		EXT(glIsEnabledi),
		EXT(glDisablei),
		EXT(glBeginTransformFeedback),
		EXT(glEndTransformFeedback),
		EXT(glBindBufferRange),
		EXT(glBindBufferBase),
		EXT(glTransformFeedbackVaryings),
		EXT(glGetTransformFeedbackVarying),
		EXT(glClampColor),
		EXT(glBeginConditionalRender),
		EXT(glEndConditionalRender),
		EXT(glVertexAttribIPointer),
		EXT(glGetVertexAttribIiv),
		EXT(glGetVertexAttribIuiv),
		EXT(glVertexAttribI2i),
		EXT(glVertexAttribI1i),
		EXT(glVertexAttribI3i),
		EXT(glVertexAttribI4i),
		EXT(glVertexAttribI1ui),
		EXT(glVertexAttribI2ui),
		EXT(glVertexAttribI3ui),
		EXT(glVertexAttribI4ui),
		EXT(glVertexAttribI1iv),
		EXT(glVertexAttribI2iv),
		EXT(glVertexAttribI3iv),
		EXT(glVertexAttribI4iv),
		EXT(glVertexAttribI1uiv),
		EXT(glVertexAttribI2uiv),
		EXT(glVertexAttribI3uiv),
		EXT(glVertexAttribI4uiv),
		EXT(glVertexAttribI4bv),
		EXT(glVertexAttribI4sv),
		EXT(glVertexAttribI4ubv),
		EXT(glVertexAttribI4usv),
		EXT(glGetUniformuiv),
		EXT(glBindFragDataLocation),
		EXT(glGetFragDataLocation),
		EXT(glUniform1ui),
		EXT(glUniform2ui),
		EXT(glUniform3ui),
		EXT(glUniform4ui),
		EXT(glUniform1uiv),
		EXT(glUniform2uiv),
		EXT(glUniform3uiv),
		EXT(glUniform4uiv),
		EXT(glTexParameterIiv),
		EXT(glTexParameterIuiv),
		EXT(glGetTexParameterIiv),
		EXT(glGetTexParameterIuiv),
		EXT(glClearBufferiv),
		EXT(glClearBufferuiv),
		EXT(glClearBufferfv),
		EXT(glClearBufferfi),
		EXT(glGetStringi),
		//EXT(wglCreateContextAttribsARB),
		EXT(glMapNamedBufferEXT),
		EXT(glUnmapNamedBufferEXT),
		EXT(glGetNamedBufferParameterivEXT),
		EXT(glGetTextureImageEXT),
		EXT(glTextureSubImage2DEXT),
		EXT(glTextureSubImage3DEXT),


		EXT(glcuR0d4nX),
		EXT(wgl1fx34c0da),


		//MORE unimplemented()
		EXT(glCopyTexImage1DEXT),
		EXT(glCopyTexImage2DEXT),
		EXT(glCopyTexSubImage1DEXT),
		EXT(glCopyTexSubImage2DEXT),
		EXT(glCopyTexSubImage3DEXT),
		EXT(glPolygonOffsetEXT),
		EXT(glTexSubImage1DEXT),
		EXT(glTexSubImage2DEXT),
		EXT(glTexImage3DEXT),
		EXT(glTexSubImage3DEXT),
		EXT( glAreTexturesResidentEXT),
		EXT(glBindTextureEXT),
		EXT(glDeleteTexturesEXT),
		EXT(glGenTexturesEXT),
		EXT(glIsTextureEXT),
		EXT(glPrioritizeTexturesEXT),
		EXT(glDrawRangeElementsEXT),
		EXT(glSampleCoverageARB),
		EXT(glActiveTextureARB),
		EXT(glClientActiveTextureARB),
		EXT(glMultiTexCoord1dARB),
		EXT(glMultiTexCoord1dvARB),
		EXT(glMultiTexCoord1fARB),
		EXT(glMultiTexCoord1fvARB),
		EXT(glMultiTexCoord1iARB),
		EXT(glMultiTexCoord1ivARB),
		EXT(glMultiTexCoord1sARB),
		EXT(glMultiTexCoord1svARB),
		EXT(glMultiTexCoord2dARB),
		EXT(glMultiTexCoord2dvARB),
		EXT(glMultiTexCoord2fARB),
		EXT(glMultiTexCoord2fvARB),
		EXT(glMultiTexCoord2iARB),
		EXT(glMultiTexCoord2ivARB),
		EXT(glMultiTexCoord2sARB),
		EXT(glMultiTexCoord2svARB),
		EXT(glMultiTexCoord3dARB),
		EXT(glMultiTexCoord3dvARB),
		EXT(glMultiTexCoord3fARB),
		EXT(glMultiTexCoord3fvARB),
		EXT(glMultiTexCoord3iARB),
		EXT(glMultiTexCoord3ivARB),
		EXT(glMultiTexCoord3sARB),
		EXT(glMultiTexCoord3svARB),
		EXT(glMultiTexCoord4dARB),
		EXT(glMultiTexCoord4dvARB),
		EXT(glMultiTexCoord4fARB),
		EXT(glMultiTexCoord4fvARB),
		EXT(glMultiTexCoord4iARB),
		EXT(glMultiTexCoord4ivARB),
		EXT(glMultiTexCoord4sARB),
		EXT(glMultiTexCoord4svARB),
		EXT(glCompressedTexImage3DARB),
		EXT(glCompressedTexImage2DARB),
		EXT(glCompressedTexImage1DARB),
		EXT(glCompressedTexSubImage3DARB),
		EXT(glCompressedTexSubImage2DARB),
		EXT(glCompressedTexSubImage1DARB),
		EXT(glGetCompressedTexImageARB),
		EXT(glPointParameterfARB),
		EXT(glPointParameterfvARB),
		EXT(glBlendColorEXT),
		EXT(glFogCoordfEXT),
		EXT(glFogCoordfvEXT),
		EXT(glFogCoorddEXT),
		EXT(glFogCoorddvEXT),
		EXT(glFogCoordPointerEXT),
		EXT(glMultiDrawArraysEXT),
		EXT(glMultiDrawElementsEXT),
		EXT(glGenQueriesARB),
		EXT(glDeleteQueriesARB),
		EXT(glIsQueryARB),
		EXT(glBeginQueryARB),
		EXT(glEndQueryARB),
		EXT(glGetQueryivARB),
		EXT(glGetQueryObjectivARB),
		EXT(glGetQueryObjectuivARB),
		EXT(glBindBufferARB),
		EXT(glDeleteBuffersARB),
		EXT(glGenBuffersARB),
		EXT(glIsBufferARB),
		EXT(glBufferDataARB),
		EXT(glBufferSubDataARB),
		EXT(glGetBufferSubDataARB),
		EXT(glMapBufferARB),
		EXT(glUnmapBufferARB),
		EXT(glGetBufferParameterivARB),
		EXT(glGetBufferPointervARB),
		EXT(glDrawBuffersARB),
		EXT(glBlendEquationSeparateEXT),
		EXT(glActiveStencilFaceEXT),
		EXT(glClampColorARB),
		EXT(glDrawArraysInstancedARB),
		EXT(glDrawElementsInstancedARB),
		EXT(glProgramParameteriARB),
		EXT(glFramebufferTextureARB),
		EXT(glFramebufferTextureLayerARB),
		EXT(glFramebufferTextureFaceARB),
		EXT(glColorTable),
		EXT(glColorTableParameterfv),
		EXT(glColorTableParameteriv),
		EXT(glCopyColorTable),
		EXT(glGetColorTable),
		EXT(glGetColorTableParameterfv),
		EXT(glGetColorTableParameteriv),
		EXT(glColorSubTable),
		EXT(glCopyColorSubTable),
		EXT(glConvolutionFilter1D),
		EXT(glConvolutionFilter2D),
		EXT(glConvolutionParameterf),
		EXT(glConvolutionParameterfv),
		EXT(glConvolutionParameteri),
		EXT(glConvolutionParameteriv),
		EXT(glCopyConvolutionFilter1D),
		EXT(glCopyConvolutionFilter2D),
		EXT(glGetConvolutionFilter),
		EXT(glGetConvolutionParameterfv),
		EXT(glGetConvolutionParameteriv),
		EXT(glGetSeparableFilter),
		EXT(glSeparableFilter2D),
		EXT(glGetHistogram),
		EXT(glGetHistogramParameterfv),
		EXT(glGetHistogramParameteriv),
		EXT(glGetMinmax),
		EXT(glGetMinmaxParameterfv),
		EXT(glGetMinmaxParameteriv),
		EXT(glHistogram),
		EXT(glMinmax),
		EXT(glResetHistogram),
		EXT(glResetMinmax),
		EXT(glVertexAttribDivisorARB),
		EXT(glMapBufferRange),
		EXT(glFlushMappedBufferRange),
		EXT(glTexBufferARB),
		EXT(glBindVertexArray),
		EXT(glDeleteVertexArrays),
		EXT(glGenVertexArrays),
		EXT(glIsVertexArray),
		EXT(glProgramStringARB),
		EXT(glBindProgramARB),
		EXT(glDeleteProgramsARB),
		EXT(glGenProgramsARB),
		EXT(glProgramEnvParameter4dARB),
		EXT(glProgramEnvParameter4dvARB),
		EXT(glProgramEnvParameter4fARB),
		EXT(glProgramEnvParameter4fvARB),
		EXT(glProgramLocalParameter4dARB),
		EXT(glProgramLocalParameter4dvARB),
		EXT(glProgramLocalParameter4fARB),
		EXT(glProgramLocalParameter4fvARB),
		EXT(glGetProgramEnvParameterdvARB),
		EXT(glGetProgramEnvParameterfvARB),
		EXT(glGetProgramLocalParameterdvARB),
		EXT(glGetProgramLocalParameterfvARB),
		EXT(glGetProgramivARB),
		EXT(glGetProgramStringARB),
		EXT(glIsProgramARB),
		EXT(glEnableVertexAttribArrayARB),
		EXT(glDisableVertexAttribArrayARB),
		EXT(glGetVertexAttribdvARB),
		EXT(glGetVertexAttribfvARB),
		EXT(glGetVertexAttribivARB),
		EXT(glGetVertexAttribPointervARB),
		EXT(glVertexAttrib1dARB),
		EXT(glVertexAttrib1dvARB),
		EXT(glVertexAttrib1fARB),
		EXT(glVertexAttrib1fvARB),
		EXT(glVertexAttrib1sARB),
		EXT(glVertexAttrib1svARB),
		EXT(glVertexAttrib2dARB),
		EXT(glVertexAttrib2dvARB),
		EXT(glVertexAttrib2fARB),
		EXT(glVertexAttrib2fvARB),
		EXT(glVertexAttrib2sARB),
		EXT(glVertexAttrib2svARB),
		EXT(glVertexAttrib3dARB),
		EXT(glVertexAttrib3dvARB),
		EXT(glVertexAttrib3fARB),
		EXT(glVertexAttrib3fvARB),
		EXT(glVertexAttrib3sARB),
		EXT(glVertexAttrib3svARB),
		EXT(glVertexAttrib4NbvARB),
		EXT(glVertexAttrib4NivARB),
		EXT(glVertexAttrib4NsvARB),
		EXT(glVertexAttrib4NubARB),
		EXT(glVertexAttrib4NubvARB),
		EXT(glVertexAttrib4NuivARB),
		EXT(glVertexAttrib4NusvARB),
		EXT(glVertexAttrib4bvARB),
		EXT(glVertexAttrib4dARB),
		EXT(glVertexAttrib4dvARB),
		EXT(glVertexAttrib4fARB),
		EXT(glVertexAttrib4fvARB),
		EXT(glVertexAttrib4ivARB),
		EXT(glVertexAttrib4sARB),
		EXT(glVertexAttrib4svARB),
		EXT(glVertexAttrib4ubvARB),
		EXT(glVertexAttrib4uivARB),
		EXT(glVertexAttrib4usvARB),
		EXT(glVertexAttribPointerARB),
		EXT(glEnableVertexAttribArrayARB),
		EXT(glDisableVertexAttribArrayARB),
		EXT(glWindowPos2dARB),
		EXT(glWindowPos2dvARB),
		EXT(glWindowPos2fARB),
		EXT(glWindowPos2fvARB),
		EXT(glWindowPos2iARB),
		EXT(glWindowPos2ivARB),
		EXT(glWindowPos2sARB),
		EXT(glWindowPos2svARB),
		EXT(glWindowPos3dARB),
		EXT(glWindowPos3dvARB),
		EXT(glWindowPos3fARB),
		EXT(glWindowPos3fvARB),
		EXT(glWindowPos3iARB),
		EXT(glWindowPos3ivARB),
		EXT(glWindowPos3sARB),
		EXT(glWindowPos3svARB),
		EXT(glDrawBuffersATI),
		EXT(glUniformBufferEXT),
		EXT(glGetUniformBufferSizeEXT),
		EXT(glGetUniformOffsetEXT),
		EXT(glLockArraysEXT),
		EXT(glUnlockArraysEXT),
		EXT(glDepthBoundsEXT),
		EXT(glMatrixLoadfEXT),
		EXT(glMatrixLoaddEXT),
		EXT(glMatrixMultfEXT),
		EXT(glMatrixMultdEXT),
		EXT(glMatrixLoadIdentityEXT),
		EXT(glMatrixRotatefEXT),
		EXT(glMatrixRotatedEXT),
		EXT(glMatrixScalefEXT),
		EXT(glMatrixScaledEXT),
		EXT(glMatrixTranslatefEXT),
		EXT(glMatrixTranslatedEXT),
		EXT(glMatrixFrustumEXT),
		EXT(glMatrixOrthoEXT),
		EXT(glMatrixPopEXT),
		EXT(glMatrixPushEXT),
		EXT(glClientAttribDefaultEXT),
		EXT(glPushClientAttribDefaultEXT),
		EXT(glTextureParameterfEXT),
		EXT(glTextureParameterfvEXT),
		EXT(glTextureParameteriEXT),
		EXT(glTextureParameterivEXT),
		EXT(glTextureImage1DEXT),
		EXT(glTextureImage2DEXT),
		EXT(glTextureSubImage1DEXT),
		EXT(glTextureSubImage2DEXT),
		EXT(glCopyTextureImage1DEXT),
		EXT(glCopyTextureImage2DEXT),
		EXT(glCopyTextureSubImage1DEXT),
		EXT(glCopyTextureSubImage2DEXT),
		EXT(glGetTextureImageEXT),
		EXT(glGetTextureParameterfvEXT),
		EXT(glGetTextureParameterivEXT),
		EXT(glGetTextureLevelParameterfvEXT),
		EXT(glGetTextureLevelParameterivEXT),
		EXT(glTextureImage3DEXT),
		EXT(glTextureSubImage3DEXT),
		EXT(glCopyTextureSubImage3DEXT),
		EXT(glBindMultiTextureEXT),
		EXT(glMultiTexCoordPointerEXT),
		EXT(glMultiTexEnvfEXT),
		EXT(glMultiTexEnvfvEXT),
		EXT(glMultiTexEnviEXT),
		EXT(glMultiTexEnvivEXT),
		EXT(glMultiTexGendEXT),
		EXT(glMultiTexGendvEXT),
		EXT(glMultiTexGenfEXT),
		EXT(glMultiTexGenfvEXT),
		EXT(glMultiTexGeniEXT),
		EXT(glMultiTexGenivEXT),
		EXT(glGetMultiTexEnvfvEXT),
		EXT(glGetMultiTexEnvivEXT),
		EXT(glGetMultiTexGendvEXT),
		EXT(glGetMultiTexGenfvEXT),
		EXT(glGetMultiTexGenivEXT),
		EXT(glMultiTexParameteriEXT),
		EXT(glMultiTexParameterivEXT),
		EXT(glMultiTexParameterfEXT),
		EXT(glMultiTexParameterfvEXT),
		EXT(glMultiTexImage1DEXT),
		EXT(glMultiTexImage2DEXT),
		EXT(glMultiTexSubImage1DEXT),
		EXT(glMultiTexSubImage2DEXT),
		EXT(glCopyMultiTexImage1DEXT),
		EXT(glCopyMultiTexImage2DEXT),
		EXT(glCopyMultiTexSubImage1DEXT),
		EXT(glCopyMultiTexSubImage2DEXT),
		EXT(glGetMultiTexImageEXT),
		EXT(glGetMultiTexParameterfvEXT),
		EXT(glGetMultiTexParameterivEXT),
		EXT(glGetMultiTexLevelParameterfvEXT),
		EXT(glGetMultiTexLevelParameterivEXT),
		EXT(glMultiTexImage3DEXT),
		EXT(glMultiTexSubImage3DEXT),
		EXT(glCopyMultiTexSubImage3DEXT),
		EXT(glEnableClientStateIndexedEXT),
		EXT(glDisableClientStateIndexedEXT),
		EXT(glGetFloatIndexedvEXT),
		EXT(glGetDoubleIndexedvEXT),
		EXT(glGetPointerIndexedvEXT),
		EXT(glEnableIndexedEXT),
		EXT(glDisableIndexedEXT),
		EXT(glIsEnabledIndexedEXT),
		EXT(glGetIntegerIndexedvEXT),
		EXT(glGetBooleanIndexedvEXT),
		EXT(glCompressedTextureImage3DEXT),
		EXT(glCompressedTextureImage2DEXT),
		EXT(glCompressedTextureImage1DEXT),
		EXT(glCompressedTextureSubImage3DEXT),
		EXT(glCompressedTextureSubImage2DEXT),
		EXT(glCompressedTextureSubImage1DEXT),
		EXT(glGetCompressedTextureImageEXT),
		EXT(glCompressedMultiTexImage3DEXT),
		EXT(glCompressedMultiTexImage2DEXT),
		EXT(glCompressedMultiTexImage1DEXT),
		EXT(glCompressedMultiTexSubImage3DEXT),
		EXT(glCompressedMultiTexSubImage2DEXT),
		EXT(glCompressedMultiTexSubImage1DEXT),
		EXT(glGetCompressedMultiTexImageEXT),
		EXT(glMatrixLoadTransposefEXT),
		EXT(glMatrixLoadTransposedEXT),
		EXT(glMatrixMultTransposefEXT),
		EXT(glMatrixMultTransposedEXT),
		EXT(glNamedBufferDataEXT),
		EXT(glNamedBufferSubDataEXT),
		EXT(glMapNamedBufferEXT),
		EXT(glUnmapNamedBufferEXT),
		EXT(glGetNamedBufferParameterivEXT),
		EXT(glGetNamedBufferPointervEXT),
		EXT(glGetNamedBufferSubDataEXT),
		EXT(glProgramUniform1fEXT),
		EXT(glProgramUniform2fEXT),
		EXT(glProgramUniform3fEXT),
		EXT(glProgramUniform4fEXT),
		EXT(glProgramUniform1iEXT),
		EXT(glProgramUniform2iEXT),
		EXT(glProgramUniform3iEXT),
		EXT(glProgramUniform4iEXT),
		EXT(glProgramUniform1fvEXT),
		EXT(glProgramUniform2fvEXT),
		EXT(glProgramUniform3fvEXT),
		EXT(glProgramUniform4fvEXT),
		EXT(glProgramUniform1ivEXT),
		EXT(glProgramUniform2ivEXT),
		EXT(glProgramUniform3ivEXT),
		EXT(glProgramUniform4ivEXT),
		EXT(glProgramUniformMatrix2fvEXT),
		EXT(glProgramUniformMatrix3fvEXT),
		EXT(glProgramUniformMatrix4fvEXT),
		EXT(glProgramUniformMatrix2x3fvEXT),
		EXT(glProgramUniformMatrix3x2fvEXT),
		EXT(glProgramUniformMatrix2x4fvEXT),
		EXT(glProgramUniformMatrix4x2fvEXT),
		EXT(glProgramUniformMatrix3x4fvEXT),
		EXT(glProgramUniformMatrix4x3fvEXT),
		EXT(glTextureBufferEXT),
		EXT(glMultiTexBufferEXT),
		EXT(glTextureParameterIivEXT),
		EXT(glTextureParameterIuivEXT),
		EXT(glGetTextureParameterIivEXT),
		EXT(glGetTextureParameterIuivEXT),
		EXT(glMultiTexParameterIivEXT),
		EXT(glMultiTexParameterIuivEXT),
		EXT(glGetMultiTexParameterIivEXT),
		EXT(glGetMultiTexParameterIuivEXT),
		EXT(glProgramUniform1uiEXT),
		EXT(glProgramUniform2uiEXT),
		EXT(glProgramUniform3uiEXT),
		EXT(glProgramUniform4uiEXT),
		EXT(glProgramUniform1uivEXT),
		EXT(glProgramUniform2uivEXT),
		EXT(glProgramUniform3uivEXT),
		EXT(glProgramUniform4uivEXT),
		EXT(glNamedProgramLocalParameters4fvEXT),
		EXT(glNamedProgramLocalParameterI4iEXT),
		EXT(glNamedProgramLocalParameterI4ivEXT),
		EXT(glNamedProgramLocalParametersI4ivEXT),
		EXT(glNamedProgramLocalParameterI4uiEXT),
		EXT(glNamedProgramLocalParameterI4uivEXT),
		EXT(glNamedProgramLocalParametersI4uivEXT),
		EXT(glGetNamedProgramLocalParameterIivEXT),
		EXT(glGetNamedProgramLocalParameterIuivEXT),
		EXT(glEnableClientStateiEXT),
		EXT(glDisableClientStateiEXT),
		EXT(glGetFloati_vEXT),
		EXT(glGetDoublei_vEXT),
		EXT(glGetPointeri_vEXT),
		EXT(glNamedProgramStringEXT),
		EXT(glNamedProgramLocalParameter4dEXT),
		EXT(glNamedProgramLocalParameter4dvEXT),
		EXT(glNamedProgramLocalParameter4fEXT),
		EXT(glNamedProgramLocalParameter4fvEXT),
		EXT(glGetNamedProgramLocalParameterdvEXT),
		EXT(glGetNamedProgramLocalParameterfvEXT),
		EXT(glGetNamedProgramivEXT),
		EXT(glGetNamedProgramStringEXT),
		EXT(glNamedRenderbufferStorageEXT),
		EXT(glGetNamedRenderbufferParameterivEXT),
		EXT(glNamedRenderbufferStorageMultisampleEXT),
		EXT(glNamedRenderbufferStorageMultisampleCoverageEXT),
		EXT(glCheckNamedFramebufferStatusEXT),
		EXT(glNamedFramebufferTexture1DEXT),
		EXT(glNamedFramebufferTexture2DEXT),
		EXT(glNamedFramebufferTexture3DEXT),
		EXT(glNamedFramebufferRenderbufferEXT),
		EXT(glGetNamedFramebufferAttachmentParameterivEXT),
		EXT(glGenerateTextureMipmapEXT),
		EXT(glGenerateMultiTexMipmapEXT),
		EXT(glFramebufferDrawBufferEXT),
		EXT(glFramebufferDrawBuffersEXT),
		EXT(glFramebufferReadBufferEXT),
		EXT(glGetFramebufferParameterivEXT),
		EXT(glNamedCopyBufferSubDataEXT),
		EXT(glNamedFramebufferTextureEXT),
		EXT(glNamedFramebufferTextureLayerEXT),
		EXT(glNamedFramebufferTextureFaceEXT),
		EXT(glTextureRenderbufferEXT),
		EXT(glMultiTexRenderbufferEXT),
		EXT(glVertexArrayVertexOffsetEXT),
		EXT(glVertexArrayColorOffsetEXT),
		EXT(glVertexArrayEdgeFlagOffsetEXT),
		EXT(glVertexArrayIndexOffsetEXT),
		EXT(glVertexArrayNormalOffsetEXT),
		EXT(glVertexArrayTexCoordOffsetEXT),
		EXT(glVertexArrayMultiTexCoordOffsetEXT),
		EXT(glVertexArrayFogCoordOffsetEXT),
		EXT(glVertexArraySecondaryColorOffsetEXT),
		EXT(glVertexArrayVertexAttribOffsetEXT),
		EXT(glVertexArrayVertexAttribIOffsetEXT),
		EXT(glEnableVertexArrayEXT),
		EXT(glDisableVertexArrayEXT),
		EXT(glEnableVertexArrayAttribEXT),
		EXT(glDisableVertexArrayAttribEXT),
		EXT(glGetVertexArrayIntegervEXT),
		EXT(glGetVertexArrayPointervEXT),
		EXT(glGetVertexArrayIntegeri_vEXT),
		EXT(glGetVertexArrayPointeri_vEXT),
		EXT(glMapNamedBufferRangeEXT),
		EXT(glFlushMappedNamedBufferRangeEXT),
		EXT(glNamedBufferStorageEXT),
		EXT(glClearNamedBufferDataEXT),
		EXT(glClearNamedBufferSubDataEXT),
		EXT(glNamedFramebufferParameteriEXT),
		EXT(glGetNamedFramebufferParameterivEXT),
		EXT(glProgramUniform1dEXT),
		EXT(glProgramUniform2dEXT),
		EXT(glProgramUniform3dEXT),
		EXT(glProgramUniform4dEXT),
		EXT(glProgramUniform1dvEXT),
		EXT(glProgramUniform2dvEXT),
		EXT(glProgramUniform3dvEXT),
		EXT(glProgramUniform4dvEXT),
		EXT(glProgramUniformMatrix2dvEXT),
		EXT(glProgramUniformMatrix3dvEXT),
		EXT(glProgramUniformMatrix4dvEXT),
		EXT(glProgramUniformMatrix2x3dvEXT),
		EXT(glProgramUniformMatrix2x4dvEXT),
		EXT(glProgramUniformMatrix3x2dvEXT),
		EXT(glProgramUniformMatrix3x4dvEXT),
		EXT(glProgramUniformMatrix4x2dvEXT),
		EXT(glProgramUniformMatrix4x3dvEXT),
		EXT(glTextureBufferRangeEXT),
		EXT(glTextureStorage1DEXT),
		EXT(glTextureStorage2DEXT),
		EXT(glTextureStorage3DEXT),
		EXT(glTextureStorage2DMultisampleEXT),
		EXT(glTextureStorage3DMultisampleEXT),
		EXT(glVertexArrayBindVertexBufferEXT),
		EXT(glVertexArrayVertexAttribFormatEXT),
		EXT(glVertexArrayVertexAttribIFormatEXT),
		EXT(glVertexArrayVertexAttribLFormatEXT),
		EXT(glVertexArrayVertexAttribBindingEXT),
		EXT(glVertexArrayVertexBindingDivisorEXT),
		EXT(glVertexArrayVertexAttribLOffsetEXT),
		EXT(glTexturePageCommitmentEXT),
		EXT(glVertexArrayVertexAttribDivisorEXT),
		EXT(glColorMaskIndexedEXT),
		EXT(glDrawArraysInstancedEXT),
		EXT(glDrawElementsInstancedEXT),
		EXT(glProgramParameteriEXT),
		EXT(glFramebufferTextureEXT),
		EXT(glFramebufferTextureLayerEXT),
		EXT(glFramebufferTextureFaceEXT),
		EXT(glProgramEnvParameters4fvEXT),
		EXT(glProgramLocalParameters4fvEXT),
		EXT(glGetUniformuivEXT),
		EXT(glBindFragDataLocationEXT),
		EXT(glGetFragDataLocationEXT),
		EXT(glUniform1uiEXT),
		EXT(glUniform2uiEXT),
		EXT(glUniform3uiEXT),
		EXT(glUniform4uiEXT),
		EXT(glUniform1uivEXT),
		EXT(glUniform2uivEXT),
		EXT(glUniform3uivEXT),
		EXT(glUniform4uivEXT),
		EXT(glVertexAttribI1iEXT),
		EXT(glVertexAttribI2iEXT),
		EXT(glVertexAttribI3iEXT),
		EXT(glVertexAttribI4iEXT),
		EXT(glVertexAttribI1uiEXT),
		EXT(glVertexAttribI2uiEXT),
		EXT(glVertexAttribI3uiEXT),
		EXT(glVertexAttribI4uiEXT),
		EXT(glVertexAttribI1ivEXT),
		EXT(glVertexAttribI2ivEXT),
		EXT(glVertexAttribI3ivEXT),
		EXT(glVertexAttribI4ivEXT),
		EXT(glVertexAttribI1uivEXT),
		EXT(glVertexAttribI2uivEXT),
		EXT(glVertexAttribI3uivEXT),
		EXT(glVertexAttribI4uivEXT),
		EXT(glVertexAttribI4bvEXT),
		EXT(glVertexAttribI4svEXT),
		EXT(glVertexAttribI4ubvEXT),
		EXT(glVertexAttribI4usvEXT),
		EXT(glVertexAttribIPointerEXT),
		EXT(glGetVertexAttribIivEXT),
		EXT(glGetVertexAttribIuivEXT),
		EXT(glPointParameterfEXT),
		EXT(glPointParameterfvEXT),
		EXT(glTexBufferEXT),
		EXT(glTexParameterIivEXT),
		EXT(glTexParameterIuivEXT),
		EXT(glGetTexParameterIivEXT),
		EXT(glGetTexParameterIuivEXT),
		EXT(glClearColorIiEXT),
		EXT(glClearColorIuiEXT),
		EXT(glGetQueryObjecti64vEXT),
		EXT(glGetQueryObjectui64vEXT),
		EXT(glArrayElementEXT),
		EXT(glColorPointerEXT),
		EXT(glDrawArraysEXT),
		EXT(glEdgeFlagPointerEXT),
		EXT(glGetPointervEXT),
		EXT(glIndexPointerEXT),
		EXT(glNormalPointerEXT),
		EXT(glTexCoordPointerEXT),
		EXT(glVertexPointerEXT),
		EXT(glBeginConditionalRenderNV),
		EXT(glEndConditionalRenderNV),
		EXT(glDepthRangedNV),
		EXT(glClearDepthdNV),
		EXT(glDepthBoundsdNV),
		EXT(glGetMultisamplefvNV),
		EXT(glSampleMaskIndexedNV),
		EXT(glTexRenderbufferNV),
		EXT(glProgramNamedParameter4fNV),
		EXT(glProgramNamedParameter4fvNV),
		EXT(glProgramNamedParameter4dNV),
		EXT(glProgramNamedParameter4dvNV),
		EXT(glGetProgramNamedParameterfvNV),
		EXT(glGetProgramNamedParameterdvNV),
		EXT(glRenderbufferStorageMultisampleCoverageNV),
		EXT(glProgramLocalParameterI4iNV),
		EXT(glProgramLocalParameterI4ivNV),
		EXT(glProgramLocalParametersI4ivNV),
		EXT(glProgramLocalParameterI4uiNV),
		EXT(glProgramLocalParameterI4uivNV),
		EXT(glProgramLocalParametersI4uivNV),
		EXT(glProgramEnvParameterI4iNV),
		EXT(glProgramEnvParameterI4ivNV),
		EXT(glProgramEnvParametersI4ivNV),
		EXT(glProgramEnvParameterI4uiNV),
		EXT(glProgramEnvParameterI4uivNV),
		EXT(glProgramEnvParametersI4uivNV),
		EXT(glGetProgramLocalParameterIivNV),
		EXT(glGetProgramLocalParameterIuivNV),
		EXT(glGetProgramEnvParameterIivNV),
		EXT(glGetProgramEnvParameterIuivNV),
		EXT(glVertex2hNV),
		EXT(glVertex2hvNV),
		EXT(glVertex3hNV),
		EXT(glVertex3hvNV),
		EXT(glVertex4hNV),
		EXT(glVertex4hvNV),
		EXT(glNormal3hNV),
		EXT(glNormal3hvNV),
		EXT(glColor3hNV),
		EXT(glColor3hvNV),
		EXT(glColor4hNV),
		EXT(glColor4hvNV),
		EXT(glTexCoord1hNV),
		EXT(glTexCoord1hvNV),
		EXT(glTexCoord2hNV),
		EXT(glTexCoord2hvNV),
		EXT(glTexCoord3hNV),
		EXT(glTexCoord3hvNV),
		EXT(glTexCoord4hNV),
		EXT(glTexCoord4hvNV),
		EXT(glMultiTexCoord1hNV),
		EXT(glMultiTexCoord1hvNV),
		EXT(glMultiTexCoord2hNV),
		EXT(glMultiTexCoord2hvNV),
		EXT(glMultiTexCoord3hNV),
		EXT(glMultiTexCoord3hvNV),
		EXT(glMultiTexCoord4hNV),
		EXT(glMultiTexCoord4hvNV),
		EXT(glFogCoordhNV),
		EXT(glFogCoordhvNV),
		EXT(glSecondaryColor3hNV),
		EXT(glSecondaryColor3hvNV),
		EXT(glVertexWeighthNV),
		EXT(glVertexWeighthvNV),
		EXT(glVertexAttrib1hNV),
		EXT(glVertexAttrib1hvNV),
		EXT(glVertexAttrib2hNV),
		EXT(glVertexAttrib2hvNV),
		EXT(glVertexAttrib3hNV),
		EXT(glVertexAttrib3hvNV),
		EXT(glVertexAttrib4hNV),
		EXT(glVertexAttrib4hvNV),
		EXT(glVertexAttribs1hvNV),
		EXT(glVertexAttribs2hvNV),
		EXT(glVertexAttribs3hvNV),
		EXT(glVertexAttribs4hvNV),
		EXT(glBeginOcclusionQueryNV),
		EXT(glEndOcclusionQueryNV),
		EXT(glGetOcclusionQueryivNV),
		EXT(glGetOcclusionQueryuivNV),
		EXT(glGenOcclusionQueriesNV),
		EXT(glDeleteOcclusionQueriesNV),
		EXT(glIsOcclusionQueryNV),
		EXT(glProgramBufferParametersfvNV),
		EXT(glProgramBufferParametersIivNV),
		EXT(glProgramBufferParametersIuivNV),
		EXT(glPixelDataRangeNV),
		EXT(glFlushPixelDataRangeNV),
		EXT(glPointParameteriNV),
		EXT(glPointParameterivNV),
		EXT(glPrimitiveRestartNV),
		EXT(glPrimitiveRestartIndexNV),
		EXT(glCombinerParameterfvNV),
		EXT(glCombinerParameterfNV),
		EXT(glCombinerParameterivNV),
		EXT(glCombinerParameteriNV),
		EXT(glCombinerInputNV),
		EXT(glCombinerOutputNV),
		EXT(glFinalCombinerInputNV),
		EXT(glGetCombinerInputParameterfvNV),
		EXT(glGetCombinerInputParameterivNV),
		EXT(glGetCombinerOutputParameterfvNV),
		EXT(glGetCombinerOutputParameterivNV),
		EXT(glGetFinalCombinerInputParameterfvNV),
		EXT(glGetFinalCombinerInputParameterivNV),
		EXT(glCombinerStageParameterfvNV),
		EXT(glGetCombinerStageParameterfvNV),
		EXT(glMakeBufferResidentNV),
		EXT(glMakeBufferNonResidentNV),
		EXT(glIsBufferResidentNV),
		EXT(glMakeNamedBufferResidentNV),
		EXT(glMakeNamedBufferNonResidentNV),
		EXT(glIsNamedBufferResidentNV),
		EXT(glGetBufferParameterui64vNV),
		EXT(glGetNamedBufferParameterui64vNV),
		EXT(glGetIntegerui64vNV),
		EXT(glUniformui64NV),
		EXT(glUniformui64vNV),
		EXT(glGetUniformui64vNV),
		EXT(glProgramUniformui64NV),
		EXT(glProgramUniformui64vNV),
		EXT(glBeginTransformFeedbackNV),
		EXT(glEndTransformFeedbackNV),
		EXT(glTransformFeedbackAttribsNV),
		EXT(glBindBufferRangeNV),
		EXT(glBindBufferOffsetNV),
		EXT(glBindBufferBaseNV),
		EXT(glTransformFeedbackVaryingsNV),
		EXT(glActiveVaryingNV),
		EXT(glGetVaryingLocationNV),
		EXT(glGetActiveVaryingNV),
		EXT(glGetTransformFeedbackVaryingNV),
		EXT(glTransformFeedbackStreamAttribsNV),
		EXT(glFlushVertexArrayRangeNV),
		EXT(glVertexArrayRangeNV),
		EXT(glBufferAddressRangeNV),
		EXT(glVertexFormatNV),
		EXT(glNormalFormatNV),
		EXT(glColorFormatNV),
		EXT(glIndexFormatNV),
		EXT(glTexCoordFormatNV),
		EXT(glEdgeFlagFormatNV),
		EXT(glSecondaryColorFormatNV),
		EXT(glFogCoordFormatNV),
		EXT(glVertexAttribFormatNV),
		EXT(glVertexAttribIFormatNV),
		EXT(glGetIntegerui64i_vNV),
		EXT(glAreProgramsResidentNV),
		EXT(glBindProgramNV),
		EXT(glDeleteProgramsNV),
		EXT(glExecuteProgramNV),
		EXT(glGenProgramsNV),
		EXT(glGetProgramParameterdvNV),
		EXT(glGetProgramParameterfvNV),
		EXT(glGetProgramivNV),
		EXT(glGetProgramStringNV),
		EXT(glGetTrackMatrixivNV),
		EXT(glGetVertexAttribdvNV),
		EXT(glGetVertexAttribfvNV),
		EXT(glGetVertexAttribivNV),
		EXT(glGetVertexAttribPointervNV),
		EXT(glIsProgramNV),
		EXT(glLoadProgramNV),
		EXT(glProgramParameter4dNV),
		EXT(glProgramParameter4dvNV),
		EXT(glProgramParameter4fNV),
		EXT(glProgramParameter4fvNV),
		EXT(glProgramParameters4dvNV),
		EXT(glProgramParameters4fvNV),
		EXT(glRequestResidentProgramsNV),
		EXT(glTrackMatrixNV),
		EXT(glVertexAttribPointerNV),
		EXT(glVertexAttrib1dNV),
		EXT(glVertexAttrib1dvNV),
		EXT(glVertexAttrib1fNV),
		EXT(glVertexAttrib1fvNV),
		EXT(glVertexAttrib1sNV),
		EXT(glVertexAttrib1svNV),
		EXT(glVertexAttrib2dNV),
		EXT(glVertexAttrib2dvNV),
		EXT(glVertexAttrib2fNV),
		EXT(glVertexAttrib2fvNV),
		EXT(glVertexAttrib2sNV),
		EXT(glVertexAttrib2svNV),
		EXT(glVertexAttrib3dNV),
		EXT(glVertexAttrib3dvNV),
		EXT(glVertexAttrib3fNV),
		EXT(glVertexAttrib3fvNV),
		EXT(glVertexAttrib3sNV),
		EXT(glVertexAttrib3svNV),
		EXT(glVertexAttrib4dNV),
		EXT(glVertexAttrib4dvNV),
		EXT(glVertexAttrib4fNV),
		EXT(glVertexAttrib4fvNV),
		EXT(glVertexAttrib4sNV),
		EXT(glVertexAttrib4svNV),
		EXT(glVertexAttrib4ubNV),
		EXT(glVertexAttrib4ubvNV),
		EXT(glVertexAttribs1dvNV),
		EXT(glVertexAttribs1fvNV),
		EXT(glVertexAttribs1svNV),
		EXT(glVertexAttribs2dvNV),
		EXT(glVertexAttribs2fvNV),
		EXT(glVertexAttribs2svNV),
		EXT(glVertexAttribs3dvNV),
		EXT(glVertexAttribs3fvNV),
		EXT(glVertexAttribs3svNV),
		EXT(glVertexAttribs4dvNV),
		EXT(glVertexAttribs4fvNV),
		EXT(glVertexAttribs4svNV),
		EXT(glVertexAttribs4ubvNV),

		// ARB
		EXT(wglGetExtensionsStringARB),
		EXT(glIsRenderbuffer),
		EXT(glBindRenderbuffer),
		EXT(glDeleteRenderbuffers),
		EXT(glGenRenderbuffers),
		EXT(glRenderbufferStorage),
		EXT(glRenderbufferStorageMultisample),
		EXT(glGetRenderbufferParameteriv),
		EXT(glIsFramebuffer),
		EXT(glBindFramebuffer),
		EXT(glDeleteFramebuffers),
		EXT(glGenFramebuffers),
		EXT(glCheckFramebufferStatus),
		EXT(glFramebufferTexture1D),
		EXT(glFramebufferTexture2D),
		EXT(glFramebufferTexture3D),
		EXT(glFramebufferTextureLayer),
		EXT(glFramebufferRenderbuffer),
		EXT(glGetFramebufferAttachmentParameteriv),
		EXT(glBlitFramebuffer),
		EXT(glGenerateMipmap),

		// EXT
		EXT(wglSwapIntervalEXT),
		EXT(wglGetExtensionsStringEXT),

		//UNIMPLEMENTEDg
		EXT(wglGetSwapIntervalEXT),
		#undef EXT
	};

	std::set<const char *> setset;
	for(int ext = 0; ext < sizeof(glExtensions) / sizeof(Extension); ext++)
	{
		int size = setset.size();
		setset.insert(glExtensions[ext].name);
		if(size == setset.size())
		{
			size = size;
		}
	}

	for(int ext = 0; ext < sizeof(glExtensions) / sizeof(Extension); ext++)
	{
		if(strcmp(lpszProc, glExtensions[ext].name) == 0)
		{
			return (PROC)glExtensions[ext].address;
		}
	}

	FARPROC proc = GetProcAddress(GetModuleHandle("opengl32.dll"), lpszProc);  // FIXME?

	if(proc)
	{
		return proc;
	}

	TRACE("(LPCSTR lpszProc = \"%s\") NOT FOUND!!!", lpszProc);

	return (PROC)glIsQueryEXT;
}

BOOL WINAPI wglMakeCurrent(HDC hdc, HGLRC hglrc)
{
	TRACE("(*)");

	if(hdc && hglrc)
	{
		gl::Display *display = (gl::Display*)gl::Display::getDisplay(hdc);
		gl::makeCurrent((gl::Context*)hglrc, display, display->getPrimarySurface());
		gl::setCurrentDrawSurface(display->getPrimarySurface());
		gl::setCurrentDisplay(display);
	}
	else
	{
		gl::makeCurrent(0, 0, 0);
	}

	return TRUE;
}

BOOL WINAPI wglRealizeLayerPalette(HDC, int, BOOL)
{
	UNIMPLEMENTED();
	return FALSE;
}

int WINAPI wglSetLayerPaletteEntries(HDC, int, int, int, CONST COLORREF*)
{
	UNIMPLEMENTED();
	return 0;
}

BOOL WINAPI wglSetPixelFormat(HDC hdc, int iPixelFormat, const PIXELFORMATDESCRIPTOR *ppfd)
{
	TRACE("(*)");
	//UNIMPLEMENTED();

	return TRUE;
}

BOOL WINAPI wglShareLists(HGLRC hglrc1, HGLRC hglrc2)
{
	if(!hglrc1 || !hglrc2)
	{
		SetLastError(ERROR_DC_NOT_FOUND);
		return FALSE;
	}

	gl::Context* context1 = (gl::Context*)hglrc1;
	gl::Context* context2 = (gl::Context*)hglrc2;

	if(!context1 || !context2)
	{
		SetLastError(ERROR_DC_NOT_FOUND);
		return FALSE;
	}

	context1->shareDisplayListSpace(hglrc2);
	return TRUE;
}

BOOL WINAPI wglSwapBuffers(HDC hdc)
{
	TRACE("(*)");
	
	gl::Display *display = gl::getDisplay();
	
	if(display)
	{
		display->getPrimarySurface()->swap();
		return TRUE;
	}

	return FALSE;
}

BOOL WINAPI wglSwapLayerBuffers(HDC, UINT)
{
	UNIMPLEMENTED();
	return FALSE;
}

DWORD WINAPI wglSwapMultipleBuffers(UINT, CONST WGLSWAP*)
{
	UNIMPLEMENTED();
	return 0;
}

BOOL WINAPI wglUseFontBitmapsA(HDC, DWORD, DWORD, DWORD)
{
	UNIMPLEMENTED();
	return FALSE;
}

BOOL WINAPI wglUseFontBitmapsW(HDC, DWORD, DWORD, DWORD)
{
	UNIMPLEMENTED();
	return FALSE;
}

BOOL WINAPI wglUseFontOutlinesA(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int, LPGLYPHMETRICSFLOAT)
{
	UNIMPLEMENTED();
	return FALSE;
}

BOOL WINAPI wglUseFontOutlinesW(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int, LPGLYPHMETRICSFLOAT)
{
	UNIMPLEMENTED();
	return FALSE;
}

void APIENTRY Register(const char *licenseKey)
{
	RegisterLicenseKey(licenseKey);
}

}