Adding trace and more verifications to new ES3 APi functions

src/OpenGL/libGLESv2/Texture.h

@@ -45,6 +45,8 @@ enum
 	IMPLEMENTATION_MAX_RENDERBUFFER_SIZE = OUTLINE_RESOLUTION,
 	IMPLEMENTATION_MAX_SAMPLES = 4,
 	IMPLEMENTATION_MAX_COLOR_ATTACHMENTS = 8,
+	IMPLEMENTATION_MAX_DRAW_BUFFERS = 8,
+	IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 4,
 };
 
 class Texture : public egl::Texture

src/OpenGL/libGLESv2/libGLESv3.cpp

@@ -12,6 +12,7 @@
 
 #include "main.h"
 #include "Framebuffer.h"
+#include "Program.h"
 #include "Texture.h"
 #include "common/debug.h"
 
@@ -530,7 +531,6 @@ void GL_APIENTRY glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLin
 			texture->subImage(level, xoffset, yoffset, zoffset, width, height, depth, format, type, context->getUnpackAlignment(), pixels);
 		}
 	}
-
 }
 
 void GL_APIENTRY glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
@@ -587,7 +587,6 @@ void GL_APIENTRY glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset,
 
 		texture->copySubImage(target, level, xoffset, yoffset, zoffset, x, y, width, height, framebuffer);
 	}
-
 }
 
 void GL_APIENTRY glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
@@ -619,15 +618,15 @@ void GL_APIENTRY glCompressedTexImage3D(GLenum target, GLint level, GLenum inter
 	switch(internalformat)
 	{
 	case GL_ETC1_RGB8_OES:
-	case GL_COMPRESSED_R11_EAC:
-	case GL_COMPRESSED_SIGNED_R11_EAC:
-	case GL_COMPRESSED_RG11_EAC:
-	case GL_COMPRESSED_SIGNED_RG11_EAC:
-	case GL_COMPRESSED_RGB8_ETC2:
-	case GL_COMPRESSED_SRGB8_ETC2:
-	case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
-	case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
-	case GL_COMPRESSED_RGBA8_ETC2_EAC:
+	case GL_COMPRESSED_R11_EAC:
+	case GL_COMPRESSED_SIGNED_R11_EAC:
+	case GL_COMPRESSED_RG11_EAC:
+	case GL_COMPRESSED_SIGNED_RG11_EAC:
+	case GL_COMPRESSED_RGB8_ETC2:
+	case GL_COMPRESSED_SRGB8_ETC2:
+	case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+	case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+	case GL_COMPRESSED_RGBA8_ETC2_EAC:
 	case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 		break;
 	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
@@ -693,15 +692,15 @@ void GL_APIENTRY glCompressedTexSubImage3D(GLenum target, GLint level, GLint xof
 	switch(format)
 	{
 	case GL_ETC1_RGB8_OES:
-	case GL_COMPRESSED_R11_EAC:
-	case GL_COMPRESSED_SIGNED_R11_EAC:
-	case GL_COMPRESSED_RG11_EAC:
-	case GL_COMPRESSED_SIGNED_RG11_EAC:
-	case GL_COMPRESSED_RGB8_ETC2:
-	case GL_COMPRESSED_SRGB8_ETC2:
-	case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
-	case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
-	case GL_COMPRESSED_RGBA8_ETC2_EAC:
+	case GL_COMPRESSED_R11_EAC:
+	case GL_COMPRESSED_SIGNED_R11_EAC:
+	case GL_COMPRESSED_RG11_EAC:
+	case GL_COMPRESSED_SIGNED_RG11_EAC:
+	case GL_COMPRESSED_RGB8_ETC2:
+	case GL_COMPRESSED_SRGB8_ETC2:
+	case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+	case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+	case GL_COMPRESSED_RGBA8_ETC2_EAC:
 	case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 		break;
 	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
@@ -858,31 +857,37 @@ void GL_APIENTRY glDrawBuffers(GLsizei n, const GLenum *bufs)
 
 void GL_APIENTRY glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
+	TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat *value = 0x%0.8p)", location, count, transpose, value);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
+	TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat *value = 0x%0.8p)", location, count, transpose, value);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
+	TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat *value = 0x%0.8p)", location, count, transpose, value);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
+	TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat *value = 0x%0.8p)", location, count, transpose, value);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
+	TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat *value = 0x%0.8p)", location, count, transpose, value);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
+	TRACE("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat *value = 0x%0.8p)", location, count, transpose, value);
 	UNIMPLEMENTED();
 }
 
@@ -1178,10 +1183,7 @@ void GL_APIENTRY glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 
 				for(unsigned int i = 0; i < numParams; ++i)
 				{
-					if(boolParams[i] == GL_FALSE)
-						data[i] = 0;
-					else
-						data[i] = 1;
+					data[i] = (boolParams[i] == GL_FALSE) ? 0 : 1;
 				}
 
 				delete[] boolParams;
@@ -1197,7 +1199,7 @@ void GL_APIENTRY glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 				{
 					if(target == GL_DEPTH_RANGE || target == GL_COLOR_CLEAR_VALUE || target == GL_DEPTH_CLEAR_VALUE || target == GL_BLEND_COLOR)
 					{
-						data[i] = (GLint)(((GLfloat)(0xFFFFFFFF) * floatParams[i] - 1.0f) / 2.0f);
+						data[i] = (GLint)(((GLfloat)(0xFFFFFFFF) * floatParams[i] - 1.0f) * 0.5f);
 					}
 					else
 					{
@@ -1269,293 +1271,744 @@ void GL_APIENTRY glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 
 void GL_APIENTRY glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode)
 {
+	TRACE("(GLuint program = %d, GLsizei count = %d, const GLchar *const*varyings = 0x%0.8p, GLenum bufferMode = 0x%X)",
+	      program, count, varyings, bufferMode);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
+	TRACE("(GLuint program = %d, GLuint index = %d, GLsizei bufSize = %d, GLsizei *length = 0x%0.8p, GLsizei *size = 0x%0.8p, GLenum *type = 0x%0.8p, GLchar *name = 0x%0.8p)",
+	      program, index, bufSize, length, size, type, name);
+
+	es2::Context *context = es2::getContext();
+
+	if(context)
+	{
+		es2::Program *programObject = context->getProgram(program);
+
+		if(!programObject)
+		{
+			return error(GL_INVALID_VALUE);
+		}
+	}
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
+	TRACE("(GLuint program = %d, GLuint index = %d, GLsizei bufSize = %d, GLsizei *length = 0x%0.8p, GLsizei *size = 0x%0.8p, GLenum *type = 0x%0.8p, GLchar *name = 0x%0.8p)",
+	      index, size, type, stride, pointer);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
+	TRACE("(GLuint index = %d, GLenum pname = 0x%X, GLint *params = 0x%0.8p)",
+	      index, pname, params);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
+	TRACE("(GLuint index = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.8p)",
+	      index, pname, params);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
+	TRACE("(GLuint index = %d, GLint x = %d, GLint y = %d, GLint z = %d, GLint w = %d)",
+	      index, x, y, z, w);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
+	TRACE("(GLuint index = %d, GLint x = %d, GLint y = %d, GLint z = %d, GLint w = %d)",
+	      index, x, y, z, w);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glVertexAttribI4iv(GLuint index, const GLint *v)
 {
+	TRACE("(GLuint index = %d, GLint *v = 0x%0.8p)", index, v);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glVertexAttribI4uiv(GLuint index, const GLuint *v)
 {
+	TRACE("(GLuint index = %d, GLint *v = 0x%0.8p)", index, v);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
+	TRACE("(GLuint program = %d, GLint location = %d, GLuint *params = 0x%0.8p)",
+	      program, location, params);
 	UNIMPLEMENTED();
 }
 
 GLint GL_APIENTRY glGetFragDataLocation(GLuint program, const GLchar *name)
 {
+	TRACE("(GLuint program = %d, const GLchar *name = 0x%0.8p)", program, name);
+
+	es2::Context *context = es2::getContext();
+
+	if(strstr(name, "gl_") == name)
+	{
+		return -1;
+	}
+
+	if(context)
+	{
+		es2::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);
+		}
+	}
+
 	UNIMPLEMENTED();
-	return 0;
+	return -1;
 }
 
 void GL_APIENTRY glUniform1ui(GLint location, GLuint v0)
 {
-	UNIMPLEMENTED();
+	glUniform1uiv(location, 1, &v0);
 }
 
 void GL_APIENTRY glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-	UNIMPLEMENTED();
+	GLuint xy[2] = { v0, v1 };
+
+	glUniform2uiv(location, 1, (GLuint*)&xy);
 }
 
 void GL_APIENTRY glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-	UNIMPLEMENTED();
+	GLuint xyz[3] = { v0, v1, v2 };
+
+	glUniform3uiv(location, 1, (GLuint*)&xyz);
 }
 
 void GL_APIENTRY glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-	UNIMPLEMENTED();
+	GLuint xyzw[4] = { v0, v1, v2, v3 };
+
+	glUniform4uiv(location, 1, (GLuint*)&xyzw);
 }
 
 void GL_APIENTRY glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
+	TRACE("(GLint location = %d, GLsizei count = %d, const GLuint *value = 0x%0.8p)",
+	      location, count, value);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
+	TRACE("(GLint location = %d, GLsizei count = %d, const GLuint *value = 0x%0.8p)",
+	      location, count, value);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
+	TRACE("(GLint location = %d, GLsizei count = %d, const GLuint *value = 0x%0.8p)",
+	      location, count, value);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
+	TRACE("(GLint location = %d, GLsizei count = %d, const GLuint *value = 0x%0.8p)",
+	      location, count, value);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
+	TRACE("(GLenum buffer = 0x%X, GLint drawbuffer = %d, const GLint *value = 0x%0.8p)",
+	      buffer, drawbuffer, value);
+
+	switch(buffer)
+	{
+	case GL_COLOR:
+		if(drawbuffer > es2::IMPLEMENTATION_MAX_DRAW_BUFFERS)
+		{
+			return error(GL_INVALID_VALUE);
+		}
+		break;
+	case GL_STENCIL:
+		if(drawbuffer != 0)
+		{
+			return error(GL_INVALID_VALUE);
+		}
+		break;
+	default:
+		return error(GL_INVALID_ENUM);
+	}
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
+	TRACE("(GLenum buffer = 0x%X, GLint drawbuffer = %d, const GLuint *value = 0x%0.8p)",
+	      buffer, drawbuffer, value);
+
+	switch(buffer)
+	{
+	case GL_COLOR:
+		if(drawbuffer > es2::IMPLEMENTATION_MAX_DRAW_BUFFERS)
+		{
+			return error(GL_INVALID_VALUE);
+		}
+		break;
+	default:
+		return error(GL_INVALID_ENUM);
+	}
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
+	TRACE("(GLenum buffer = 0x%X, GLint drawbuffer = %d, const GLfloat *value = 0x%0.8p)",
+	      buffer, drawbuffer, value);
+
+	switch(buffer)
+	{
+	case GL_COLOR:
+		if(drawbuffer > es2::IMPLEMENTATION_MAX_DRAW_BUFFERS)
+		{
+			return error(GL_INVALID_VALUE);
+		}
+		break;
+	case GL_DEPTH:
+		if(drawbuffer != 0)
+		{
+			return error(GL_INVALID_VALUE);
+		}
+		break;
+	default:
+		return error(GL_INVALID_ENUM);
+	}
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
+	TRACE("(GLenum buffer = 0x%X, GLint drawbuffer = %d, GLfloat depth = %f, GLint stencil = %d)",
+	      buffer, drawbuffer, depth, stencil);
+
+	switch(buffer)
+	{
+	case GL_DEPTH_STENCIL:
+		if(drawbuffer != 0)
+		{
+			return error(GL_INVALID_VALUE);
+		}
+		break;
+	default:
+		return error(GL_INVALID_ENUM);
+	}
+
 	UNIMPLEMENTED();
 }
 
 const GLubyte *GL_APIENTRY glGetStringi(GLenum name, GLuint index)
 {
+	TRACE("(GLenum name = 0x%X, GLuint index = %d)", name, index);
+
 	UNIMPLEMENTED();
 	return nullptr;
 }
 
 void GL_APIENTRY glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
+	TRACE("(GLenum readTarget = 0x%X, GLenum writeTarget = 0x%X,  GLintptr readOffset = %d, GLintptr writeOffset = %d, GLsizeiptr size = %d)",
+	      readTarget, writeTarget, readOffset, writeOffset, size);
+
+	switch(readTarget)
+	{
+	case GL_ARRAY_BUFFER:
+	case GL_COPY_READ_BUFFER:
+	case GL_COPY_WRITE_BUFFER:
+	case GL_ELEMENT_ARRAY_BUFFER:
+	case GL_PIXEL_PACK_BUFFER:
+	case GL_PIXEL_UNPACK_BUFFER:
+	case GL_TRANSFORM_FEEDBACK_BUFFER:
+	case GL_UNIFORM_BUFFER:
+		break;
+	default:
+		return error(GL_INVALID_ENUM);
+	}
+
+	switch(writeTarget)
+	{
+	case GL_ARRAY_BUFFER:
+	case GL_COPY_READ_BUFFER:
+	case GL_COPY_WRITE_BUFFER:
+	case GL_ELEMENT_ARRAY_BUFFER:
+	case GL_PIXEL_PACK_BUFFER:
+	case GL_PIXEL_UNPACK_BUFFER:
+	case GL_TRANSFORM_FEEDBACK_BUFFER:
+	case GL_UNIFORM_BUFFER:
+		break;
+	default:
+		return error(GL_INVALID_ENUM);
+	}
+
+	if(readOffset < 0 || writeOffset < 0 || size < 0)
+	{
+		return error(GL_INVALID_VALUE);
+	}
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices)
 {
+	TRACE("(GLuint program = %d, GLsizei uniformCount = %d, const GLchar *const*uniformNames = 0x%0.8p, GLuint *uniformIndices = 0x%0.8p)",
+	      program, uniformCount, uniformNames, uniformIndices);
+
+	es2::Context *context = es2::getContext();
+
+	if(context)
+	{
+		es2::Program *program = context->getCurrentProgram();
+
+		if(!program)
+		{
+			return error(GL_INVALID_OPERATION);
+		}
+	}
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
+	TRACE("(GLuint program = %d, GLsizei uniformCount = %d, const GLchar *const*uniformNames = 0x%0.8p, GLenum pname = 0x%X, GLuint *uniformIndices = 0x%0.8p)",
+	      program, uniformCount, uniformIndices, pname, uniformIndices);
+
+	switch(pname)
+	{
+	case GL_UNIFORM_TYPE:
+	case GL_UNIFORM_SIZE:
+	case GL_UNIFORM_NAME_LENGTH:
+	case GL_UNIFORM_BLOCK_INDEX:
+	case GL_UNIFORM_OFFSET:
+	case GL_UNIFORM_ARRAY_STRIDE:
+	case GL_UNIFORM_MATRIX_STRIDE:
+	case GL_UNIFORM_IS_ROW_MAJOR:
+		break;
+	default:
+		return error(GL_INVALID_ENUM);
+	}
+
+	es2::Context *context = es2::getContext();
+
+	if(context)
+	{
+		es2::Program *program = context->getCurrentProgram();
+
+		if(!program)
+		{
+			return error(GL_INVALID_OPERATION);
+		}
+	}
+
 	UNIMPLEMENTED();
 }
 
 GLuint GL_APIENTRY glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
+	TRACE("(GLuint program = %d, const GLchar *uniformBlockName = 0x%0.8p)",
+	      program, uniformBlockName);
+
+	es2::Context *context = es2::getContext();
+
+	if(context)
+	{
+		es2::Program *program = context->getCurrentProgram();
+
+		if(!program)
+		{
+			return error(GL_INVALID_OPERATION, GL_INVALID_INDEX);
+		}
+	}
+
 	UNIMPLEMENTED();
-	return 0;
+	return GL_INVALID_INDEX;
 }
 
 void GL_APIENTRY glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
+	TRACE("(GLuint program = %d, GLuint uniformBlockIndex = %d, GLenum pname = 0x%X, GLint *params = 0x%0.8p)",
+	      program, uniformBlockIndex, pname, params);
+
+	switch(pname)
+	{
+	case GL_UNIFORM_BLOCK_BINDING:
+	case GL_UNIFORM_BLOCK_DATA_SIZE:
+	case GL_UNIFORM_BLOCK_NAME_LENGTH:
+	case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
+	case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
+	case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
+	case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
+		break;
+	default:
+		return error(GL_INVALID_ENUM);
+	}
+
+	es2::Context *context = es2::getContext();
+
+	if(context)
+	{
+		es2::Program *program = context->getCurrentProgram();
+
+		if(!program)
+		{
+			return error(GL_INVALID_OPERATION);
+		}
+	}
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
+	TRACE("(GLuint program = %d, GLuint uniformBlockIndex = %d, GLsizei bufSize = %d, GLsizei *length = 0x%0.8p, GLchar *uniformBlockName = 0x%0.8p)",
+	      program, uniformBlockIndex, bufSize, length, uniformBlockName);
+
+	es2::Context *context = es2::getContext();
+
+	if(context)
+	{
+		es2::Program *program = context->getCurrentProgram();
+
+		if(!program)
+		{
+			return error(GL_INVALID_OPERATION);
+		}
+	}
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
+	TRACE("(GLuint program = %d, GLuint uniformBlockIndex = %d, GLuint uniformBlockBinding = %d)",
+	      program, uniformBlockIndex, uniformBlockBinding);
+
+	es2::Context *context = es2::getContext();
+
+	if(context)
+	{
+		es2::Program *program = context->getCurrentProgram();
+
+		if(!program)
+		{
+			return error(GL_INVALID_OPERATION);
+		}
+	}
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
+	TRACE("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d, GLsizei instancecount = %d)",
+	      mode, first, count, instancecount);
+
+	switch(mode)
+	{
+	case GL_POINTS:
+	case GL_LINES:
+	case GL_LINE_LOOP:
+	case GL_LINE_STRIP:
+	case GL_TRIANGLES:
+	case GL_TRIANGLE_FAN:
+	case GL_TRIANGLE_STRIP:
+		break;
+	default:
+		return error(GL_INVALID_ENUM);
+	}
+
+	if(count < 0 || instancecount < 0)
+	{
+		return error(GL_INVALID_VALUE);
+	}
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
 {
+	TRACE("(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const void *indices = 0x%0.8p, GLsizei instancecount = %d)",
+	      mode, count, type, indices, instancecount);
+
+	switch(mode)
+	{
+	case GL_POINTS:
+	case GL_LINES:
+	case GL_LINE_LOOP:
+	case GL_LINE_STRIP:
+	case GL_TRIANGLES:
+	case GL_TRIANGLE_FAN:
+	case GL_TRIANGLE_STRIP:
+		break;
+	default:
+		return error(GL_INVALID_ENUM);
+	}
+
+	switch(type)
+	{
+	case GL_UNSIGNED_BYTE:
+	case GL_UNSIGNED_SHORT:
+	case GL_UNSIGNED_INT:
+		break;
+	default:
+		return error(GL_INVALID_ENUM);
+	}
+
+	if(count < 0 || instancecount < 0)
+	{
+		return error(GL_INVALID_VALUE);
+	}
+
 	UNIMPLEMENTED();
 }
 
 GLsync GL_APIENTRY glFenceSync(GLenum condition, GLbitfield flags)
 {
+	TRACE("(GLenum condition = 0x%X, GLbitfield flags = %X)", condition, flags);
+
+	switch(condition)
+	{
+	case GL_SYNC_GPU_COMMANDS_COMPLETE:
+		break;
+	default:
+		return error(GL_INVALID_ENUM, nullptr);
+	}
+
+	if(flags != 0)
+	{
+		return error(GL_INVALID_VALUE, nullptr);
+	}
+
 	UNIMPLEMENTED();
 	return nullptr;
 }
 
 GLboolean GL_APIENTRY glIsSync(GLsync sync)
 {
+	TRACE("(GLsync sync = 0x%0.8p)", sync);
+
 	UNIMPLEMENTED();
 	return GL_FALSE;
 }
 
 void GL_APIENTRY glDeleteSync(GLsync sync)
 {
+	TRACE("(GLsync sync = 0x%0.8p)", sync);
+
 	UNIMPLEMENTED();
 }
 
 GLenum GL_APIENTRY glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
+	TRACE("(GLsync sync = 0x%0.8p, GLbitfield flags = %X, GLuint64 timeout = %llu)", sync, flags, timeout);
+
+	if((flags & ~(GL_SYNC_FLUSH_COMMANDS_BIT)) != 0)
+	{
+		error(GL_INVALID_VALUE);
+	}
+
 	UNIMPLEMENTED();
 	return GL_FALSE;
 }
 
 void GL_APIENTRY glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
+	TRACE("(GLsync sync = 0x%0.8p, GLbitfield flags = %X, GLuint64 timeout = %llu)", sync, flags, timeout);
+
+	if(flags != 0)
+	{
+		return error(GL_INVALID_VALUE);
+	}
+
+	if(timeout != GL_TIMEOUT_IGNORED)
+	{
+		return error(GL_INVALID_VALUE);
+	}
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetInteger64v(GLenum pname, GLint64 *data)
 {
+	TRACE("(GLenum pname = 0x%X, GLint64 *data = 0x%0.8p)", pname, data);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
+	TRACE("(GLsync sync = 0x%0.8p, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei *length = 0x%0.8p, GLint *values = 0x%0.8p)",
+	      sync, pname, bufSize, length, values);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
+	TRACE("(GLenum target = 0x%X, GLuint index = %d, GLint64 *data = 0x%0.8p)", target, index, data);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
+	TRACE("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint64 *params = 0x%0.8p)", target, pname, params);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGenSamplers(GLsizei count, GLuint *samplers)
 {
+	TRACE("(GLsizei count = %d, GLuint *samplers = 0x%0.8p)", count, samplers);
+
+	if(count < 0)
+	{
+		return error(GL_INVALID_VALUE);
+	}
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
+	TRACE("(GLsizei count = %d, GLuint *samplers = 0x%0.8p)", count, samplers);
+
+	if(count < 0)
+	{
+		return error(GL_INVALID_VALUE);
+	}
+
 	UNIMPLEMENTED();
 }
 
 GLboolean GL_APIENTRY glIsSampler(GLuint sampler)
 {
+	TRACE("(GLuint sampler = %d)", sampler);
+
 	UNIMPLEMENTED();
 	return GL_FALSE;
 }
 
 void GL_APIENTRY glBindSampler(GLuint unit, GLuint sampler)
 {
+	TRACE("(GLuint unit = %d, GLuint sampler = %d)", unit, sampler);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-	UNIMPLEMENTED();
+	TRACE("(GLuint sampler = %d, GLenum pname = 0x%X, GLint param = %d)",
+	      sampler, pname, param);
+
+	glSamplerParameteriv(sampler, pname, &param);
 }
 
 void GL_APIENTRY glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
+	TRACE("(GLuint sampler = %d, GLenum pname = 0x%X, const GLint *param = 0x%0.8p)",
+	      sampler, pname, param);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-	UNIMPLEMENTED();
+	TRACE("(GLuint sampler = %d, GLenum pname = 0x%X, GLfloat param = %f)",
+	      sampler, pname, param);
+
+	glSamplerParameterfv(sampler, pname, &param);
 }
 
 void GL_APIENTRY glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
+	TRACE("(GLuint sampler = %d, GLenum pname = 0x%X, const GLfloat *param = 0x%0.8p)",
+	      sampler, pname, param);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
+	TRACE("(GLuint sampler = %d, GLenum pname = 0x%X, GLint *params = 0x%0.8p)",
+	      sampler, pname, params);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
+	TRACE("(GLuint sampler = %d, GLenum pname = 0x%X, GLfloat *params = 0x%0.8p)",
+	      sampler, pname, params);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
+	TRACE("(GLuint index = %d, GLuint divisor = %d)", index, divisor);
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glBindTransformFeedback(GLenum target, GLuint id)
 {
+	TRACE("(GLenum target = 0x%X, GLuint id = %d)", target, id);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
+	TRACE("(GLsizei n = %d, const GLuint *ids = 0x%0.8p)", n, ids);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
+	TRACE("(GLsizei n = %d, const GLuint *ids = 0x%0.8p)", n, ids);
+
 	UNIMPLEMENTED();
 }
 
 GLboolean GL_APIENTRY glIsTransformFeedback(GLuint id)
 {
+	TRACE("(GLuint id = %d)", id);
+
 	UNIMPLEMENTED();
 	return GL_FALSE;
 }
@@ -1572,44 +2025,66 @@ void GL_APIENTRY glResumeTransformFeedback(void)
 
 void GL_APIENTRY glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
 {
+	TRACE("(GLuint program = %d, GLsizei bufSize = %d, GLsizei *length = 0x%0.8p, GLenum *binaryFormat = 0x%0.8p, void *binary = 0x%0.8p)",
+	      program, bufSize, length, binaryFormat, binary);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
 {
+	TRACE("(GLuint program = %d, GLenum binaryFormat = 0x%X, const void *binary = 0x%0.8p, GLsizei length = %d)",
+	      program, binaryFormat, binaryFormat, length);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glProgramParameteri(GLuint program, GLenum pname, GLint value)
 {
+	TRACE("(GLuint program = %d, GLenum pname = 0x%X, GLint value = %d)",
+	      program, pname, value);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
 {
+	TRACE("(GLenum target = 0x%X, GLsizei numAttachments = %d, const GLenum *attachments = 0x%0.8p)",
+	      target, numAttachments, attachments);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
 {
+	TRACE("(GLenum target = 0x%X, GLsizei numAttachments = %d, const GLenum *attachments = 0x%0.8p, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
+	      target, numAttachments, attachments, x, y, width, height);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
+	TRACE("(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d)",
+	      target, levels, internalformat, width, height);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
+	TRACE("(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d)",
+	      target, levels, internalformat, width, height, depth);
+
 	UNIMPLEMENTED();
 }
 
 void GL_APIENTRY glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
 {
+	TRACE("(GLenum target = 0x%X, GLenum internalformat = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLint *params = 0x%0.8p)",
+	      target, internalformat, pname, bufSize, params);
+
 	UNIMPLEMENTED();
 }
 
-
-
 }