GLES接口

uint32_t CreateVmiGLESv2Encoder(uint32_t stream);

goldfish与指令流引擎连接时，调用此函数将两者的GLES接口绑定。

void DeleteVmiGLESv2Encoder(uint32_t handle);

goldfish与指令流引擎解除连接时，调用此函数将两者的GLES接口解绑。

void VmiGlActiveTexture(uint32_t handle, GLenum texture);

void glActiveTexture(GLenum texture);

void VmiGlAttachShader(uint32_t handle, GLuint program, GLuint shader);

void glAttachShader(GLuint program, GLuint shader);

void VmiGlBindAttribLocation(uint32_t handle, GLuint program, GLuint index, const GLchar *name);

void glBindAttribLocation(GLuint program, GLuint index, const GLchar* name);

void VmiGlBindBuffer(uint32_t handle, GLenum target, GLuint buffer);

void glBindBuffer(GLenum target, GLuint buffer);

void VmiGlBindFramebuffer(uint32_t handle, GLenum target, GLuint framebuffer);

void glBindFramebuffer(GLenum target, GLuint framebuffer);

void VmiGlBindRenderbuffer(uint32_t handle, GLenum target, GLuint renderbuffer);

void glBindRenderbuffer(GLenum target, GLuint renderbuffer);

void VmiGlBindTexture(uint32_t handle, GLenum target, GLuint texture);

void glBindTexture(GLenum target, GLuint texture);

void VmiGlBlendColor(uint32_t handle, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

void VmiGlBlendEquation(uint32_t handle, GLenum mode);

void glBlendEquation(GLenum mode);

void VmiGlBlendEquationSeparate(uint32_t handle, GLenum modeRGB, GLenum modeAlpha);

void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);

void VmiGlBlendFunc(uint32_t handle, GLenum sfactor, GLenum dfactor);

void glBlendFunc(GLenum sfactor, GLenum dfactor);

void VmiGlBlendFuncSeparate(uint32_t handle, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);

void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);

void VmiGlBufferData(uint32_t handle, GLenum target, GLsizeiptr size, const void *data, GLenum usage);

void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);

void VmiGlBufferSubData(uint32_t handle, GLenum target, GLintptr offset, GLsizeiptr size, const void *data);

void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);

GLenum VmiGlCheckFramebufferStatus(uint32_t handle, GLenum target);

GLenum glCheckFramebufferStatus(GLenum target);

void VmiGlClear(uint32_t handle, GLbitfield mask);

void glClear(GLbitfield mask);

void VmiGlClearColor(uint32_t handle, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

void VmiGlClearDepthf(uint32_t handle, GLfloat d);

void glClearDepthf(GLclampf depth);

void VmiGlClearStencil(uint32_t handle, GLint s);

void glClearStencil(GLint s);

void VmiGlColorMask(uint32_t handle, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);

void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);

void VmiGlCompileShader(uint32_t handle, GLuint shader);

void glCompileShader(GLuint shader);

void VmiGlCompressedTexImage2D(uint32_t handle, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);

void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data);

void VmiGlCompressedTexSubImage2D(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);

void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data);

void VmiGlCopyTexImage2D(uint32_t handle, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);

void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);

void VmiGlCopyTexSubImage2D(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);

void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);

GLuint VmiGlCreateProgram(uint32_t handle);

GLuint glCreateProgram();

GLuint VmiGlCreateShader(uint32_t handle, GLenum type);

GLuint glCreateShader(GLenum type);

void VmiGlCullFace(uint32_t handle, GLenum mode);

void glCullFace(GLenum mode);

void VmiGlDeleteBuffers(uint32_t handle, GLsizei n, const GLuint *buffers);

void glDeleteBuffers(GLsizei n, const GLuint* buffers);

void VmiGlDeleteFramebuffers(uint32_t handle, GLsizei n, const GLuint *framebuffers);

void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers);

void VmiGlDeleteProgram(uint32_t handle, GLuint program);

void glDeleteProgram(GLuint program);

void VmiGlDeleteRenderbuffers(uint32_t handle, GLsizei n, const GLuint *renderbuffers);

void glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers);

void VmiGlDeleteShader(uint32_t handle, GLuint shader);

void glDeleteShader(GLuint shader);

void VmiGlDeleteTextures(uint32_t handle, GLsizei n, const GLuint *textures);

void glDeleteTextures(GLsizei n, const GLuint* textures);

void VmiGlDepthFunc(uint32_t handle, GLenum func);

void glDepthFunc(GLenum func);

void VmiGlDepthMask(uint32_t handle, GLboolean flag);

void glDepthMask(GLboolean flag);

void VmiGlDepthRangef(uint32_t handle, GLfloat n, GLfloat f);

void glDepthRangef(GLclampf zNear, GLclampf zFar);

void VmiGlDetachShader(uint32_t handle, GLuint program, GLuint shader);

void glDetachShader(GLuint program, GLuint shader);

void VmiGlDisable(uint32_t handle, GLenum cap);

void glDisable(GLenum cap);

void VmiGlDisableVertexAttribArray(uint32_t handle, GLuint index);

void glDisableVertexAttribArray(GLuint index);

void VmiGlDrawArrays(uint32_t handle, GLenum mode, GLint first, GLsizei count);

void glDrawArrays(GLenum mode, GLint first, GLsizei count);

void VmiGlDrawElements(uint32_t handle, GLenum mode, GLsizei count, GLenum type, const void *indices);

void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);

void VmiGlEnable(uint32_t handle, GLenum cap);

void glEnable(GLenum cap);

void VmiGlEnableVertexAttribArray(uint32_t handle, GLuint index);

void glEnableVertexAttribArray(GLuint index);

void VmiGlFinish(uint32_t handle);

void glFinish();

void VmiGlFlush(uint32_t handle);

void glFlush();

void VmiGlFramebufferRenderbuffer(uint32_t handle, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);

void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);

void VmiGlFramebufferTexture2D(uint32_t handle, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);

void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);

void VmiGlFrontFace(uint32_t handle, GLenum mode);

void glFrontFace(GLenum mode);

void VmiGlGenBuffers(uint32_t handle, GLsizei n, GLuint *buffers);

void glGenBuffers(GLsizei n, GLuint* buffers);

void VmiGlGenerateMipmap(uint32_t handle, GLenum target);

void glGenerateMipmap(GLenum target);

void VmiGlGenFramebuffers(uint32_t handle, GLsizei n, GLuint *framebuffers);

void glGenFramebuffers(GLsizei n, GLuint* framebuffers);

void VmiGlGenRenderbuffers(uint32_t handle, GLsizei n, GLuint *renderbuffers);

void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers);

void VmiGlGenTextures(uint32_t handle, GLsizei n, GLuint *textures);

void glGenTextures(GLsizei n, GLuint* textures);

void VmiGlGetActiveAttrib(uint32_t handle, GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);

void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);

void VmiGlGetActiveUniform(uint32_t handle, GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);

void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);

void VmiGlGetAttachedShaders(uint32_t handle, GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);

void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);

GLint VmiGlGetAttribLocation(uint32_t handle, GLuint program, const GLchar *name);

int glGetAttribLocation(GLuint program, const GLchar* name);

void VmiGlGetBooleanv(uint32_t handle, GLenum pname, GLboolean *data);

void glGetBooleanv(GLenum pname, GLboolean* params);

void VmiGlGetBufferParameteriv(uint32_t handle, GLenum target, GLenum pname, GLint *params);

void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params);

GLenum VmiGlGetError(uint32_t handle);

GLenum glGetError();

void VmiGlGetFloatv(uint32_t handle, GLenum pname, GLfloat *data);

void glGetFloatv(GLenum pname, GLfloat* params);

void VmiGlGetFramebufferAttachmentParameteriv(uint32_t handle, GLenum target, GLenum attachment, GLenum pname, GLint *params);

void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params);

void VmiGlGetIntegerv(uint32_t handle, GLenum pname, GLint *data);

void glGetIntegerv(GLenum pname, GLint* params);

void VmiGlGetProgramiv(uint32_t handle, GLuint program, GLenum pname, GLint *params);

void glGetProgramiv(GLuint program, GLenum pname, GLint* params);

void VmiGlGetProgramInfoLog(uint32_t handle, GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);

void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog);

void VmiGlGetRenderbufferParameteriv(uint32_t handle, GLenum target, GLenum pname, GLint *params);

void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params);

void VmiGlGetShaderiv(uint32_t handle, GLuint shader, GLenum pname, GLint *params);

void glGetShaderiv(GLuint shader, GLenum pname, GLint* params);

void VmiGlGetShaderInfoLog(uint32_t handle, GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);

void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog);

void VmiGlGetShaderPrecisionFormat(uint32_t handle, GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);

void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);

void VmiGlGetShaderSource(uint32_t handle, GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);

void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source);

const GLubyte *VmiGlGetString(uint32_t handle, GLenum name);

const GLubyte* glGetString(GLenum name);

void VmiGlGetTexParameterfv(uint32_t handle, GLenum target, GLenum pname, GLfloat *params);

void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params);

void VmiGlGetTexParameteriv(uint32_t handle, GLenum target, GLenum pname, GLint *params);

void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params);

void VmiGlGetUniformfv(uint32_t handle, GLuint program, GLint location, GLfloat *params);

void glGetUniformfv(GLuint program, GLint location, GLfloat* params);

void VmiGlGetUniformiv(uint32_t handle, GLuint program, GLint location, GLint *params);

void glGetUniformiv(GLuint program, GLint location, GLint* params);

GLint VmiGlGetUniformLocation(uint32_t handle, GLuint program, const GLchar *name);

int glGetUniformLocation(GLuint program, const GLchar* name);

void VmiGlGetVertexAttribfv(uint32_t handle, GLuint index, GLenum pname, GLfloat *params);

void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params);

void VmiGlGetVertexAttribiv(uint32_t handle, GLuint index, GLenum pname, GLint *params);

void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params);

void VmiGlGetVertexAttribPointerv(uint32_t handle, GLuint index, GLenum pname, void **pointer);

void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer);

void VmiGlHint(uint32_t handle, GLenum target, GLenum mode);

void glHint(GLenum target, GLenum mode);

GLboolean VmiGlIsBuffer(uint32_t handle, GLuint buffer);

GLboolean glIsBuffer(GLuint buffer);

GLboolean VmiGlIsEnabled(uint32_t handle, GLenum cap);

GLboolean glIsEnabled(GLenum cap);

GLboolean VmiGlIsFramebuffer(uint32_t handle, GLuint framebuffer);

GLboolean glIsFramebuffer(GLuint framebuffer);

GLboolean VmiGlIsProgram(uint32_t handle, GLuint program);

GLboolean glIsProgram(GLuint program);

GLboolean VmiGlIsRenderbuffer(uint32_t handle, GLuint renderbuffer);

GLboolean glIsRenderbuffer(GLuint renderbuffer);

GLboolean VmiGlIsShader(uint32_t handle, GLuint shader);

GLboolean glIsShader(GLuint shader);

GLboolean VmiGlIsTexture(uint32_t handle, GLuint texture);

GLboolean glIsTexture(GLuint texture);

void VmiGlLineWidth(uint32_t handle, GLfloat width);

void glLineWidth(GLfloat width);

void VmiGlLinkProgram(uint32_t handle, GLuint program);

void glLinkProgram(GLuint program);

void VmiGlPixelStorei(uint32_t handle, GLenum pname, GLint param);

void glPixelStorei(GLenum pname, GLint param);

void VmiGlPolygonOffset(uint32_t handle, GLfloat factor, GLfloat units);

void glPolygonOffset(GLfloat factor, GLfloat units);

void VmiGlReadPixels(uint32_t handle, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);

void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);

void VmiGlReleaseShaderCompiler(uint32_t handle);

void glReleaseShaderCompiler();

void VmiGlRenderbufferStorage(uint32_t handle, GLenum target, GLenum internalformat, GLsizei width, GLsizei height);

void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);

void VmiGlSampleCoverage(uint32_t handle, GLfloat value, GLboolean invert);

void glSampleCoverage(GLclampf value, GLboolean invert);

void VmiGlScissor(uint32_t handle, GLint x, GLint y, GLsizei width, GLsizei height);

void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);

void VmiGlShaderBinary(uint32_t handle, GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length);

void glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length);

void VmiGlShaderSource(uint32_t handle, GLuint shader, GLsizei count, const GLchar * const * string, const GLint *length);

void glShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length);

void VmiGlStencilFunc(uint32_t handle, GLenum func, GLint ref, GLuint mask);

void glStencilFunc(GLenum func, GLint ref, GLuint mask);

void VmiGlStencilFuncSeparate(uint32_t handle, GLenum face, GLenum func, GLint ref, GLuint mask);

void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);

void VmiGlStencilMask(uint32_t handle, GLuint mask);

void glStencilMask(GLuint mask);

void VmiGlStencilMaskSeparate(uint32_t handle, GLenum face, GLuint mask);

void glStencilMaskSeparate(GLenum face, GLuint mask);

void VmiGlStencilOp(uint32_t handle, GLenum fail, GLenum zfail, GLenum zpass);

void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);

void VmiGlStencilOpSeparate(uint32_t handle, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);

void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);

void VmiGlTexImage2D(uint32_t handle, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);

void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);

void VmiGlTexParameterf(uint32_t handle, GLenum target, GLenum pname, GLfloat param);

void glTexParameterf(GLenum target, GLenum pname, GLfloat param);

void VmiGlTexParameterfv(uint32_t handle, GLenum target, GLenum pname, const GLfloat *params);

void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params);

void VmiGlTexParameteri(uint32_t handle, GLenum target, GLenum pname, GLint param);

void glTexParameteri(GLenum target, GLenum pname, GLint param);

void VmiGlTexParameteriv(uint32_t handle, GLenum target, GLenum pname, const GLint *params);

void glTexParameteriv(GLenum target, GLenum pname, const GLint* params);

void VmiGlTexSubImage2D(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);

void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);

void VmiGlUniform1f(uint32_t handle, GLint location, GLfloat v0);

void glUniform1f(GLint location, GLfloat x);

void VmiGlUniform1fv(uint32_t handle, GLint location, GLsizei count, const GLfloat *value);

void glUniform1fv(GLint location, GLsizei count, const GLfloat* v);

void VmiGlUniform1i(uint32_t handle, GLint location, GLint v0);

void glUniform1i(GLint location, GLint x);

void VmiGlUniform1iv(uint32_t handle, GLint location, GLsizei count, const GLint *value);

void glUniform1iv(GLint location, GLsizei count, const GLint* v);

void VmiGlUniform2f(uint32_t handle, GLint location, GLfloat v0, GLfloat v1);

void glUniform2f(GLint location, GLfloat x, GLfloat y);

void VmiGlUniform2fv(uint32_t handle, GLint location, GLsizei count, const GLfloat *value);

void glUniform2fv(GLint location, GLsizei count, const GLfloat* v);

void VmiGlUniform2i(uint32_t handle, GLint location, GLint v0, GLint v1);

void glUniform2i(GLint location, GLint x, GLint y);

void VmiGlUniform2iv(uint32_t handle, GLint location, GLsizei count, const GLint *value);

void glUniform2iv(GLint location, GLsizei count, const GLint* v);

void VmiGlUniform3f(uint32_t handle, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);

void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z);

void VmiGlUniform3fv(uint32_t handle, GLint location, GLsizei count, const GLfloat *value);

void glUniform3fv(GLint location, GLsizei count, const GLfloat* v);

void VmiGlUniform3i(uint32_t handle, GLint location, GLint v0, GLint v1, GLint v2);

void glUniform3i(GLint location, GLint x, GLint y, GLint z);

void VmiGlUniform3iv(uint32_t handle, GLint location, GLsizei count, const GLint *value);

void glUniform3iv(GLint location, GLsizei count, const GLint* v);

void VmiGlUniform4f(uint32_t handle, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);

void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

void VmiGlUniform4fv(uint32_t handle, GLint location, GLsizei count, const GLfloat *value);

void glUniform4fv(GLint location, GLsizei count, const GLfloat* v);

void VmiGlUniform4i(uint32_t handle, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);

void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w);

void VmiGlUniform4iv(uint32_t handle, GLint location, GLsizei count, const GLint *value);

void glUniform4iv(GLint location, GLsizei count, const GLint* v);

void VmiGlUniformMatrix2fv(uint32_t handle, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlUniformMatrix3fv(uint32_t handle, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlUniformMatrix4fv(uint32_t handle, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlUseProgram(uint32_t handle, GLuint program);

void glUseProgram(GLuint program);

void VmiGlValidateProgram(uint32_t handle, GLuint program);

void glValidateProgram(GLuint program);

void VmiGlVertexAttrib1f(uint32_t handle, GLuint index, GLfloat x);

void glVertexAttrib1f(GLuint indx, GLfloat x);

void VmiGlVertexAttrib1fv(uint32_t handle, GLuint index, const GLfloat *v);

void glVertexAttrib1fv(GLuint indx, const GLfloat* values);

void VmiGlVertexAttrib2f(uint32_t handle, GLuint index, GLfloat x, GLfloat y);

void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);

void VmiGlVertexAttrib2fv(uint32_t handle, GLuint index, const GLfloat *v);

void glVertexAttrib2fv(GLuint indx, const GLfloat* values);

void VmiGlVertexAttrib3f(uint32_t handle, GLuint index, GLfloat x, GLfloat y, GLfloat z);

void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);

void VmiGlVertexAttrib3fv(uint32_t handle, GLuint index, const GLfloat *v);

void glVertexAttrib3fv(GLuint indx, const GLfloat* values);

void VmiGlVertexAttrib4f(uint32_t handle, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

void VmiGlVertexAttrib4fv(uint32_t handle, GLuint index, const GLfloat *v);

void glVertexAttrib4fv(GLuint indx, const GLfloat* values);

void VmiGlVertexAttribPointer(uint32_t handle, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);

void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr);

void VmiGlViewport(uint32_t handle, GLint x, GLint y, GLsizei width, GLsizei height);

void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);

void VmiGlEGLImageTargetTexture2DOES(uint32_t handle, GLenum target, GLeglImageOES image);

void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image);

void VmiGlEGLImageTargetRenderbufferStorageOES(uint32_t handle, GLenum target, GLeglImageOES image);

void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image);

void VmiGlGetProgramBinaryOES(uint32_t handle, GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);

void glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary);

void VmiGlProgramBinaryOES(uint32_t handle, GLuint program, GLenum binaryFormat, const void *binary, GLint length);

void glProgramBinaryOES(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLint length);

void *VmiGlMapBufferOES(uint32_t handle, GLenum target, GLenum access);

void* glMapBufferOES(GLenum target, GLenum access);

GLboolean VmiGlUnmapBufferOES(uint32_t handle, GLenum target);

GLboolean glUnmapBufferOES(GLenum target);

void VmiGlTexImage3DOES(uint32_t handle, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);

void glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels);

void VmiGlTexSubImage3DOES(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);

void glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels);

void VmiGlCopyTexSubImage3DOES(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);

void glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);

void VmiGlCompressedTexImage3DOES(uint32_t handle, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);

void glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data);

void VmiGlCompressedTexSubImage3DOES(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);

void glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data);

void VmiGlFramebufferTexture3DOES(uint32_t handle, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);

void glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);

void VmiGlBindVertexArrayOES(uint32_t handle, GLuint array);

void glBindVertexArrayOES(GLuint array);

void VmiGlDeleteVertexArraysOES(uint32_t handle, GLsizei n, const GLuint *arrays);

void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays);

void VmiGlGenVertexArraysOES(uint32_t handle, GLsizei n, GLuint *arrays);

void glGenVertexArraysOES(GLsizei n, GLuint* arrays);

GLboolean VmiGlIsVertexArrayOES(uint32_t handle, GLuint array);

GLboolean glIsVertexArrayOES(GLuint array);

void VmiGlDiscardFramebufferEXT(uint32_t handle, GLenum target, GLsizei numAttachments, const GLenum *attachments);

void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments);

void VmiGlMultiDrawArraysEXT(uint32_t handle, GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);

void glMultiDrawArraysEXT(GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount);

void VmiGlMultiDrawElementsEXT(uint32_t handle, GLenum mode, const GLsizei *count, GLenum type, const void * const * indices, GLsizei primcount);

void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei primcount);

void VmiGlGetPerfMonitorGroupsAMD(uint32_t handle, GLint *numGroups, GLsizei groupsSize, GLuint *groups);

void glGetPerfMonitorGroupsAMD(GLint* numGroups, GLsizei groupsSize, GLuint* groups);

void VmiGlGetPerfMonitorCountersAMD(uint32_t handle, GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters);

void glGetPerfMonitorCountersAMD(GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters);

void VmiGlGetPerfMonitorGroupStringAMD(uint32_t handle, GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString);

void glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei* length, GLchar* groupString);

void VmiGlGetPerfMonitorCounterStringAMD(uint32_t handle, GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString);

void glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, GLchar* counterString);

void VmiGlGetPerfMonitorCounterInfoAMD(uint32_t handle, GLuint group, GLuint counter, GLenum pname, void *data);

void glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, GLvoid* data);

void VmiGlGenPerfMonitorsAMD(uint32_t handle, GLsizei n, GLuint *monitors);

void glGenPerfMonitorsAMD(GLsizei n, GLuint* monitors);

void VmiGlDeletePerfMonitorsAMD(uint32_t handle, GLsizei n, GLuint *monitors);

void glDeletePerfMonitorsAMD(GLsizei n, GLuint* monitors);

void VmiGlSelectPerfMonitorCountersAMD(uint32_t handle, GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *counterList);

void glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* countersList);

void VmiGlBeginPerfMonitorAMD(uint32_t handle, GLuint monitor);

void glBeginPerfMonitorAMD(GLuint monitor);

void VmiGlEndPerfMonitorAMD(uint32_t handle, GLuint monitor);

void glEndPerfMonitorAMD(GLuint monitor);

void VmiGlGetPerfMonitorCounterDataAMD(uint32_t handle, GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten);

void glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten);

void VmiGlRenderbufferStorageMultisampleIMG(uint32_t handle, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);

void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);

void VmiGlFramebufferTexture2DMultisampleIMG(uint32_t handle, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples);

void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples);

void VmiGlDeleteFencesNV(uint32_t handle, GLsizei n, const GLuint *fences);

void glDeleteFencesNV(GLsizei n, const GLuint* fences);

void VmiGlGenFencesNV(uint32_t handle, GLsizei n, GLuint *fences);

void glGenFencesNV(GLsizei n, GLuint* fences);

GLboolean VmiGlIsFenceNV(uint32_t handle, GLuint fence);

GLboolean glIsFenceNV(GLuint fence);

GLboolean VmiGlTestFenceNV(uint32_t handle, GLuint fence);

GLboolean glTestFenceNV(GLuint fence);

void VmiGlGetFenceivNV(uint32_t handle, GLuint fence, GLenum pname, GLint *params);

void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params);

void VmiGlFinishFenceNV(uint32_t handle, GLuint fence);

void glFinishFenceNV(GLuint fence);

void VmiGlSetFenceNV(uint32_t handle, GLuint fence, GLenum condition);

void glSetFenceNV(GLuint fence, GLenum condition);

void VmiGlCoverageMaskNV(uint32_t handle, GLboolean mask);

void glCoverageMaskNV(GLboolean mask);

void VmiGlCoverageOperationNV(uint32_t handle, GLenum operation);

void glCoverageOperationNV(GLenum operation);

void VmiGlGetDriverControlsQCOM(uint32_t handle, GLint *num, GLsizei size, GLuint *driverControls);

void glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls);

void VmiGlGetDriverControlStringQCOM(uint32_t handle, GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString);

void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString);

void VmiGlEnableDriverControlQCOM(uint32_t handle, GLuint driverControl);

void glEnableDriverControlQCOM(GLuint driverControl);

void VmiGlDisableDriverControlQCOM(uint32_t handle, GLuint driverControl);

void glDisableDriverControlQCOM(GLuint driverControl);

void VmiGlExtGetTexturesQCOM(uint32_t handle, GLuint *textures, GLint maxTextures, GLint *numTextures);

void glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures);

void VmiGlExtGetBuffersQCOM(uint32_t handle, GLuint *buffers, GLint maxBuffers, GLint *numBuffers);

void glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers);

void VmiGlExtGetRenderbuffersQCOM(uint32_t handle, GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers);

void glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers);

void VmiGlExtGetFramebuffersQCOM(uint32_t handle, GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers);

void glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers);

void VmiGlExtGetTexLevelParameterivQCOM(uint32_t handle, GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params);

void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params);

void VmiGlExtTexObjectStateOverrideiQCOM(uint32_t handle, GLenum target, GLenum pname, GLint param);

void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param);

void VmiGlExtGetTexSubImageQCOM(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, void *texels);

void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels);

void VmiGlExtGetBufferPointervQCOM(uint32_t handle, GLenum target, void **params);

void glExtGetBufferPointervQCOM(GLenum target, GLvoidptr* params);

void VmiGlExtGetShadersQCOM(uint32_t handle, GLuint *shaders, GLint maxShaders, GLint *numShaders);

void glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders);

void VmiGlExtGetProgramsQCOM(uint32_t handle, GLuint *programs, GLint maxPrograms, GLint *numPrograms);

void glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms);

GLboolean VmiGlExtIsProgramBinaryQCOM(uint32_t handle, GLuint program);

GLboolean glExtIsProgramBinaryQCOM(GLuint program);

void VmiGlExtGetProgramBinarySourceQCOM(uint32_t handle, GLuint program, GLenum shadertype, GLchar *source, GLint *length);

void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar* source, GLint* length);

void VmiGlStartTilingQCOM(uint32_t handle, GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask);

void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask);

void VmiGlEndTilingQCOM(uint32_t handle, GLbitfield preserveMask);

void glEndTilingQCOM(GLbitfield preserveMask);

void VmiGlGenVertexArrays(uint32_t handle, GLsizei n, GLuint *arrays);

void glGenVertexArrays(GLsizei n, GLuint* arrays);

void VmiGlBindVertexArray(uint32_t handle, GLuint array);

void glBindVertexArray(GLuint array);

void VmiGlDeleteVertexArrays(uint32_t handle, GLsizei n, const GLuint *arrays);

void glDeleteVertexArrays(GLsizei n, const GLuint* arrays);

GLboolean VmiGlIsVertexArray(uint32_t handle, GLuint array);

GLboolean glIsVertexArray(GLuint array);

void *VmiGlMapBufferRange(uint32_t handle, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);

void* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);

GLboolean VmiGlUnmapBuffer(uint32_t handle, GLenum target);

GLboolean glUnmapBuffer(GLenum target);

void VmiGlFlushMappedBufferRange(uint32_t handle, GLenum target, GLintptr offset, GLsizeiptr length);

void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);

void VmiGlBindBufferRange(uint32_t handle, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);

void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);

void VmiGlBindBufferBase(uint32_t handle, GLenum target, GLuint index, GLuint buffer);

void glBindBufferBase(GLenum target, GLuint index, GLuint buffer);

void VmiGlCopyBufferSubData(uint32_t handle, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);

void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);

void VmiGlClearBufferiv(uint32_t handle, GLenum buffer, GLint drawbuffer, const GLint *value);

void glClearBufferiv(GLenum buffer, GLint drawBuffer, const GLint* value);

void VmiGlClearBufferuiv(uint32_t handle, GLenum buffer, GLint drawbuffer, const GLuint *value);

void glClearBufferuiv(GLenum buffer, GLint drawBuffer, const GLuint* value);

void VmiGlClearBufferfv(uint32_t handle, GLenum buffer, GLint drawbuffer, const GLfloat *value);

void glClearBufferfv(GLenum buffer, GLint drawBuffer, const GLfloat* value);

void VmiGlClearBufferfi(uint32_t handle, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);

void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);

void VmiGlGetBufferParameteri64v(uint32_t handle, GLenum target, GLenum pname, GLint64 *params);

void glGetBufferParameteri64v(GLenum target, GLenum value, GLint64* data);

void VmiGlGetBufferPointerv(uint32_t handle, GLenum target, GLenum pname, void **params);

void glGetBufferPointerv(GLenum target, GLenum pname, GLvoid** params);

void VmiGlUniformBlockBinding(uint32_t handle, GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);

void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);

GLuint VmiGlGetUniformBlockIndex(uint32_t handle, GLuint program, const GLchar *uniformBlockName);

GLuint glGetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName);

void VmiGlGetUniformIndices(uint32_t handle, GLuint program, GLsizei uniformCount, const GLchar * const * uniformNames, GLuint *uniformIndices);

void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint* uniformIndices);

void VmiGlGetActiveUniformBlockiv(uint32_t handle, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);

void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params);

void VmiGlGetActiveUniformBlockName(uint32_t handle, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);

void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName);

void VmiGlUniform1ui(uint32_t handle, GLint location, GLuint v0);

void glUniform1ui(GLint location, GLuint v0);

void VmiGlUniform2ui(uint32_t handle, GLint location, GLuint v0, GLuint v1);

void glUniform2ui(GLint location, GLuint v0, GLuint v1);

void VmiGlUniform3ui(uint32_t handle, GLint location, GLuint v0, GLuint v1, GLuint v2);

void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);

void VmiGlUniform4ui(uint32_t handle, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);

void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);

void VmiGlUniform1uiv(uint32_t handle, GLint location, GLsizei count, const GLuint *value);

void glUniform1uiv(GLint location, GLsizei count, const GLuint* value);

void VmiGlUniform2uiv(uint32_t handle, GLint location, GLsizei count, const GLuint *value);

void glUniform2uiv(GLint location, GLsizei count, const GLuint* value);

void VmiGlUniform3uiv(uint32_t handle, GLint location, GLsizei count, const GLuint *value);

void glUniform3uiv(GLint location, GLsizei count, const GLuint* value);

void VmiGlUniform4uiv(uint32_t handle, GLint location, GLsizei count, const GLuint *value);

void glUniform4uiv(GLint location, GLsizei count, const GLuint* value);

void VmiGlUniformMatrix2x3fv(uint32_t handle, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlUniformMatrix3x2fv(uint32_t handle, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlUniformMatrix2x4fv(uint32_t handle, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlUniformMatrix4x2fv(uint32_t handle, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlUniformMatrix3x4fv(uint32_t handle, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlUniformMatrix4x3fv(uint32_t handle, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlGetUniformuiv(uint32_t handle, GLuint program, GLint location, GLuint *params);

void glGetUniformuiv(GLuint program, GLint location, GLuint* params);

void VmiGlGetActiveUniformsiv(uint32_t handle, GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);

void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params);

void VmiGlVertexAttribI4i(uint32_t handle, GLuint index, GLint x, GLint y, GLint z, GLint w);

void glVertexAttribI4i(GLuint index, GLint v0, GLint v1, GLint v2, GLint v3);

void VmiGlVertexAttribI4ui(uint32_t handle, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);

void glVertexAttribI4ui(GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3);

void VmiGlVertexAttribI4iv(uint32_t handle, GLuint index, const GLint *v);

void glVertexAttribI4iv(GLuint index, const GLint* v);

void VmiGlVertexAttribI4uiv(uint32_t handle, GLuint index, const GLuint *v);

void glVertexAttribI4uiv(GLuint index, const GLuint* v);

void VmiGlVertexAttribIPointer(uint32_t handle, GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);

void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);

void VmiGlGetVertexAttribIiv(uint32_t handle, GLuint index, GLenum pname, GLint *params);

void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint* params);

void VmiGlGetVertexAttribIuiv(uint32_t handle, GLuint index, GLenum pname, GLuint *params);

void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params);

void VmiGlVertexAttribDivisor(uint32_t handle, GLuint index, GLuint divisor);

void glVertexAttribDivisor(GLuint index, GLuint divisor);

void VmiGlDrawArraysInstanced(uint32_t handle, GLenum mode, GLint first, GLsizei count, GLsizei instancecount);

void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei primcount);

void VmiGlDrawElementsInstanced(uint32_t handle, GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount);

void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount);

void VmiGlDrawRangeElements(uint32_t handle, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);

void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices);

GLsync VmiGlFenceSync(uint32_t handle, GLenum condition, GLbitfield flags);

GLsync glFenceSync(GLenum condition, GLbitfield flags);

GLenum VmiGlClientWaitSync(uint32_t handle, GLsync sync, GLbitfield flags, GLuint64 timeout);

GLenum glClientWaitSync(GLsync wait_on, GLbitfield flags, GLuint64 timeout);

void VmiGlWaitSync(uint32_t handle, GLsync sync, GLbitfield flags, GLuint64 timeout);

void glWaitSync(GLsync wait_on, GLbitfield flags, GLuint64 timeout);

void VmiGlDeleteSync(uint32_t handle, GLsync sync);

void glDeleteSync(GLsync to_delete);

GLboolean VmiGlIsSync(uint32_t handle, GLsync sync);

GLboolean glIsSync(GLsync sync);

void VmiGlGetSynciv(uint32_t handle, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);

void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values);

void VmiGlDrawBuffers(uint32_t handle, GLsizei n, const GLenum *bufs);

void glDrawBuffers(GLsizei n, const GLenum* bufs);

void VmiGlReadBuffer(uint32_t handle, GLenum src);

void glReadBuffer(GLenum src);

void VmiGlBlitFramebuffer(uint32_t handle, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);

void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);

void VmiGlInvalidateFramebuffer(uint32_t handle, GLenum target, GLsizei numAttachments, const GLenum *attachments);

void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments);

void VmiGlInvalidateSubFramebuffer(uint32_t handle, GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);

void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height);

void VmiGlFramebufferTextureLayer(uint32_t handle, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);

void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);

void VmiGlRenderbufferStorageMultisample(uint32_t handle, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);

void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);

void VmiGlTexStorage2D(uint32_t handle, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);

void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);

void VmiGlGetInternalformativ(uint32_t handle, GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);

void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params);

void VmiGlBeginTransformFeedback(uint32_t handle, GLenum primitiveMode);

void glBeginTransformFeedback(GLenum primitiveMode);

void VmiGlEndTransformFeedback(uint32_t handle);

void glEndTransformFeedback();

void VmiGlGenTransformFeedbacks(uint32_t handle, GLsizei n, GLuint *ids);

void glGenTransformFeedbacks(GLsizei n, GLuint* ids);

void VmiGlDeleteTransformFeedbacks(uint32_t handle, GLsizei n, const GLuint *ids);

void glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids);

void VmiGlBindTransformFeedback(uint32_t handle, GLenum target, GLuint id);

void glBindTransformFeedback(GLenum target, GLuint id);

void VmiGlPauseTransformFeedback(uint32_t handle);

void glPauseTransformFeedback();

void VmiGlResumeTransformFeedback(uint32_t handle);

void glResumeTransformFeedback();

GLboolean VmiGlIsTransformFeedback(uint32_t handle, GLuint id);

GLboolean glIsTransformFeedback(GLuint id);

void VmiGlTransformFeedbackVaryings(uint32_t handle, GLuint program, GLsizei count, const GLchar * const * varyings, GLenum bufferMode);

void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode);

void VmiGlGetTransformFeedbackVarying(uint32_t handle, GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);

void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, char* name);

void VmiGlGenSamplers(uint32_t handle, GLsizei count, GLuint *samplers);

void glGenSamplers(GLsizei n, GLuint* samplers);

void VmiGlDeleteSamplers(uint32_t handle, GLsizei count, const GLuint *samplers);

void glDeleteSamplers(GLsizei n, const GLuint* samplers);

void VmiGlBindSampler(uint32_t handle, GLuint unit, GLuint sampler);

void glBindSampler(GLuint unit, GLuint sampler);

void VmiGlSamplerParameterf(uint32_t handle, GLuint sampler, GLenum pname, GLfloat param);

void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);

void VmiGlSamplerParameteri(uint32_t handle, GLuint sampler, GLenum pname, GLint param);

void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param);

void VmiGlSamplerParameterfv(uint32_t handle, GLuint sampler, GLenum pname, const GLfloat *param);

void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* params);

void VmiGlSamplerParameteriv(uint32_t handle, GLuint sampler, GLenum pname, const GLint *param);

void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint* params);

void VmiGlGetSamplerParameterfv(uint32_t handle, GLuint sampler, GLenum pname, GLfloat *params);

void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params);

void VmiGlGetSamplerParameteriv(uint32_t handle, GLuint sampler, GLenum pname, GLint *params);

void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params);

GLboolean VmiGlIsSampler(uint32_t handle, GLuint sampler);

GLboolean glIsSampler(GLuint sampler);

void VmiGlGenQueries(uint32_t handle, GLsizei n, GLuint *ids);

void glGenQueries(GLsizei n, GLuint* queries);

void VmiGlDeleteQueries(uint32_t handle, GLsizei n, const GLuint *ids);

void glDeleteQueries(GLsizei n, const GLuint* queries);

void VmiGlBeginQuery(uint32_t handle, GLenum target, GLuint id);

void glBeginQuery(GLenum target, GLuint query);

void VmiGlEndQuery(uint32_t handle, GLenum target);

void glEndQuery(GLenum target);

void VmiGlGetQueryiv(uint32_t handle, GLenum target, GLenum pname, GLint *params);

void glGetQueryiv(GLenum target, GLenum pname, GLint* params);

void VmiGlGetQueryObjectuiv(uint32_t handle, GLuint id, GLenum pname, GLuint *params);

void glGetQueryObjectuiv(GLuint query, GLenum pname, GLuint* params);

GLboolean VmiGlIsQuery(uint32_t handle, GLuint id);

GLboolean glIsQuery(GLuint query);

void VmiGlProgramParameteri(uint32_t handle, GLuint program, GLenum pname, GLint value);

void glProgramParameteri(GLuint program, GLenum pname, GLint value);

void VmiGlProgramBinary(uint32_t handle, GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);

void glProgramBinary(GLuint program, GLenum binaryFormat, const void* binary, GLsizei length);

void VmiGlGetProgramBinary(uint32_t handle, GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);

void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary);

GLint VmiGlGetFragDataLocation(uint32_t handle, GLuint program, const GLchar *name);

GLint glGetFragDataLocation(GLuint program, const char* name);

void VmiGlGetInteger64v(uint32_t handle, GLenum pname, GLint64 *data);

void glGetInteger64v(GLenum pname, GLint64* data);

void VmiGlGetIntegeri_v(uint32_t handle, GLenum target, GLuint index, GLint *data);

void glGetIntegeri_v(GLenum target, GLuint index, GLint* data);

void VmiGlGetInteger64i_v(uint32_t handle, GLenum target, GLuint index, GLint64 *data);

void glGetInteger64i_v(GLenum target, GLuint index, GLint64* data);

void VmiGlTexImage3D(uint32_t handle, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);

void glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* data);

void VmiGlTexStorage3D(uint32_t handle, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);

void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);

void VmiGlTexSubImage3D(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);

void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* data);

void VmiGlCompressedTexImage3D(uint32_t handle, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);

void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data);

void VmiGlCompressedTexSubImage3D(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);

void glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data);

void VmiGlCopyTexSubImage3D(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);

void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);

const GLubyte *VmiGlGetStringi(uint32_t handle, GLenum name, GLuint index);

const GLubyte* glGetStringi(GLenum name, GLuint index);

void VmiGlGetBooleani_v(uint32_t handle, GLenum target, GLuint index, GLboolean *data);

void glGetBooleani_v(GLenum target, GLuint index, GLboolean* data);

void VmiGlMemoryBarrier(uint32_t handle, GLbitfield barriers);

void glMemoryBarrier(GLbitfield barriers);

void VmiGlMemoryBarrierByRegion(uint32_t handle, GLbitfield barriers);

void glMemoryBarrierByRegion(GLbitfield barriers);

void VmiGlGenProgramPipelines(uint32_t handle, GLsizei n, GLuint *pipelines);

void glGenProgramPipelines(GLsizei n, GLuint* pipelines);

void VmiGlDeleteProgramPipelines(uint32_t handle, GLsizei n, const GLuint *pipelines);

void glDeleteProgramPipelines(GLsizei n, const GLuint* pipelines);

void VmiGlBindProgramPipeline(uint32_t handle, GLuint pipeline);

void glBindProgramPipeline(GLuint pipeline);

void VmiGlGetProgramPipelineiv(uint32_t handle, GLuint pipeline, GLenum pname, GLint *params);

void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint* params);

void VmiGlGetProgramPipelineInfoLog(uint32_t handle, GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);

void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog);

void VmiGlValidateProgramPipeline(uint32_t handle, GLuint pipeline);

void glValidateProgramPipeline(GLuint pipeline);

GLboolean VmiGlIsProgramPipeline(uint32_t handle, GLuint pipeline);

GLboolean glIsProgramPipeline(GLuint pipeline);

void VmiGlUseProgramStages(uint32_t handle, GLuint pipeline, GLbitfield stages, GLuint program);

void glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);

void VmiGlActiveShaderProgram(uint32_t handle, GLuint pipeline, GLuint program);

void glActiveShaderProgram(GLuint pipeline, GLuint program);

GLuint VmiGlCreateShaderProgramv(uint32_t handle, GLenum type, GLsizei count, const GLchar * const * strings);

GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const* strings);

void VmiGlProgramUniform1f(uint32_t handle, GLuint program, GLint location, GLfloat v0);

void glProgramUniform1f(GLuint program, GLint location, GLfloat v0);

void VmiGlProgramUniform2f(uint32_t handle, GLuint program, GLint location, GLfloat v0, GLfloat v1);

void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1);

void VmiGlProgramUniform3f(uint32_t handle, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);

void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);

void VmiGlProgramUniform4f(uint32_t handle, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);

void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);

void VmiGlProgramUniform1i(uint32_t handle, GLuint program, GLint location, GLint v0);

void glProgramUniform1i(GLuint program, GLint location, GLint v0);

void VmiGlProgramUniform2i(uint32_t handle, GLuint program, GLint location, GLint v0, GLint v1);

void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);

void VmiGlProgramUniform3i(uint32_t handle, GLuint program, GLint location, GLint v0, GLint v1, GLint v2);

void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);

void VmiGlProgramUniform4i(uint32_t handle, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);

void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);

void VmiGlProgramUniform1ui(uint32_t handle, GLuint program, GLint location, GLuint v0);

void glProgramUniform1ui(GLuint program, GLint location, GLuint v0);

void VmiGlProgramUniform2ui(uint32_t handle, GLuint program, GLint location, GLuint v0, GLuint v1);

void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1);

void VmiGlProgramUniform3ui(uint32_t handle, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);

void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);

void VmiGlProgramUniform4ui(uint32_t handle, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);

void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);

void VmiGlProgramUniform1fv(uint32_t handle, GLuint program, GLint location, GLsizei count, const GLfloat *value);

void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat* value);

void VmiGlProgramUniform2fv(uint32_t handle, GLuint program, GLint location, GLsizei count, const GLfloat *value);

void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat* value);

void VmiGlProgramUniform3fv(uint32_t handle, GLuint program, GLint location, GLsizei count, const GLfloat *value);

void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat* value);

void VmiGlProgramUniform4fv(uint32_t handle, GLuint program, GLint location, GLsizei count, const GLfloat *value);

void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat* value);

void VmiGlProgramUniform1iv(uint32_t handle, GLuint program, GLint location, GLsizei count, const GLint *value);

void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint* value);

void VmiGlProgramUniform2iv(uint32_t handle, GLuint program, GLint location, GLsizei count, const GLint *value);

void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint* value);

void VmiGlProgramUniform3iv(uint32_t handle, GLuint program, GLint location, GLsizei count, const GLint *value);

void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint* value);

void VmiGlProgramUniform4iv(uint32_t handle, GLuint program, GLint location, GLsizei count, const GLint *value);

void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint* value);

void VmiGlProgramUniform1uiv(uint32_t handle, GLuint program, GLint location, GLsizei count, const GLuint *value);

void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint* value);

void VmiGlProgramUniform2uiv(uint32_t handle, GLuint program, GLint location, GLsizei count, const GLuint *value);

void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint* value);

void VmiGlProgramUniform3uiv(uint32_t handle, GLuint program, GLint location, GLsizei count, const GLuint *value);

void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint* value);

void VmiGlProgramUniform4uiv(uint32_t handle, GLuint program, GLint location, GLsizei count, const GLuint *value);

void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint* value);

void VmiGlProgramUniformMatrix2fv(uint32_t handle, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlProgramUniformMatrix3fv(uint32_t handle, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlProgramUniformMatrix4fv(uint32_t handle, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlProgramUniformMatrix2x3fv(uint32_t handle, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlProgramUniformMatrix3x2fv(uint32_t handle, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlProgramUniformMatrix2x4fv(uint32_t handle, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlProgramUniformMatrix4x2fv(uint32_t handle, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlProgramUniformMatrix3x4fv(uint32_t handle, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlProgramUniformMatrix4x3fv(uint32_t handle, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

void VmiGlGetProgramInterfaceiv(uint32_t handle, GLuint program, GLenum programInterface, GLenum pname, GLint *params);

void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint* params);

void VmiGlGetProgramResourceiv(uint32_t handle, GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);

void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params);

GLuint VmiGlGetProgramResourceIndex(uint32_t handle, GLuint program, GLenum programInterface, const GLchar *name);

GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const char* name);

GLint VmiGlGetProgramResourceLocation(uint32_t handle, GLuint program, GLenum programInterface, const GLchar *name);

GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const char* name);

void VmiGlGetProgramResourceName(uint32_t handle, GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);

void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, char* name);

void VmiGlBindImageTexture(uint32_t handle, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);

void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);

void VmiGlDispatchCompute(uint32_t handle, GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);

void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);

void VmiGlDispatchComputeIndirect(uint32_t handle, GLintptr indirect);

void glDispatchComputeIndirect(GLintptr indirect);

void VmiGlBindVertexBuffer(uint32_t handle, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);

void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);

void VmiGlVertexAttribBinding(uint32_t handle, GLuint attribindex, GLuint bindingindex);

void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex);

void VmiGlVertexAttribFormat(uint32_t handle, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);

void glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);

void VmiGlVertexAttribIFormat(uint32_t handle, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);

void glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);

void VmiGlVertexBindingDivisor(uint32_t handle, GLuint bindingindex, GLuint divisor);

void glVertexBindingDivisor(GLuint bindingindex, GLuint divisor);

void VmiGlDrawArraysIndirect(uint32_t handle, GLenum mode, const void *indirect);

void glDrawArraysIndirect(GLenum mode, const void* indirect);

void VmiGlDrawElementsIndirect(uint32_t handle, GLenum mode, GLenum type, const void *indirect);

void glDrawElementsIndirect(GLenum mode, GLenum type, const void* indirect);

void VmiGlTexStorage2DMultisample(uint32_t handle, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);

void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);

void VmiGlSampleMaski(uint32_t handle, GLuint maskNumber, GLbitfield mask);

void glSampleMaski(GLuint maskNumber, GLbitfield mask);

void VmiGlGetMultisamplefv(uint32_t handle, GLenum pname, GLuint index, GLfloat *val);

void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat* val);

void VmiGlFramebufferParameteri(uint32_t handle, GLenum target, GLenum pname, GLint param);

void glFramebufferParameteri(GLenum target, GLenum pname, GLint param);

void VmiGlGetFramebufferParameteriv(uint32_t handle, GLenum target, GLenum pname, GLint *params);

void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint* params);

void VmiGlGetTexLevelParameterfv(uint32_t handle, GLenum target, GLint level, GLenum pname, GLfloat *params);

void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat* params);

void VmiGlGetTexLevelParameteriv(uint32_t handle, GLenum target, GLint level, GLenum pname, GLint *params);

void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint* params);

void VmiGlEnableiEXT(uint32_t handle, GLenum target, GLuint index);

void glEnableiEXT(GLenum target, GLuint index);

void VmiGlDisableiEXT(uint32_t handle, GLenum target, GLuint index);

void glDisableiEXT(GLenum target, GLuint index);

void VmiGlBlendEquationiEXT(uint32_t handle, GLuint buf, GLenum mode);

void glBlendEquationiEXT(GLuint buf, GLenum mode);

void VmiGlBlendEquationSeparateiEXT(uint32_t handle, GLuint buf, GLenum modeRGB, GLenum modeAlpha);

void glBlendEquationSeparateiEXT(GLuint buf, GLenum modeRGB, GLenum modeAlpha);

void VmiGlBlendFunciEXT(uint32_t handle, GLuint buf, GLenum src, GLenum dst);

void glBlendFunciEXT(GLuint buf, GLenum src, GLenum dst);

void VmiGlBlendFuncSeparateiEXT(uint32_t handle, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);

void glBlendFuncSeparateiEXT(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);

void VmiGlColorMaskiEXT(uint32_t handle, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);

void glColorMaskiEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);

GLboolean VmiGlIsEnablediEXT(uint32_t handle, GLenum target, GLuint index);

GLboolean glIsEnablediEXT(GLenum target, GLuint index);

void VmiGlCopyImageSubDataEXT(uint32_t handle, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);

void glCopyImageSubDataEXT(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);

void VmiGlBlendBarrierKHR(uint32_t handle);

void glBlendBarrierKHR(void);

void VmiGlTexParameterIivEXT(uint32_t handle, GLenum target, GLenum pname, const GLint *params);

void glTexParameterIivEXT(GLenum target, GLenum pname, const GLint *params);

void VmiGlTexParameterIuivEXT(uint32_t handle, GLenum target, GLenum pname, const GLuint *params);

void glTexParameterIuivEXT(GLenum target, GLenum pname, const GLuint *params);

void VmiGlGetTexParameterIivEXT(uint32_t handle, GLenum target, GLenum pname, GLint *params);

void glGetTexParameterIivEXT(GLenum target, GLenum pname, GLint *params);

void VmiGlGetTexParameterIuivEXT(uint32_t handle, GLenum target, GLenum pname, GLuint *params);

void glGetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint *params);

void VmiGlSamplerParameterIivEXT(uint32_t handle, GLuint sampler, GLenum pname, const GLint *param);

void glSamplerParameterIivEXT(GLuint sampler, GLenum pname, const GLint *param);

void VmiGlSamplerParameterIuivEXT(uint32_t handle, GLuint sampler, GLenum pname, const GLuint *param);

void glSamplerParameterIuivEXT(GLuint sampler, GLenum pname, const GLuint *param);

void VmiGlGetSamplerParameterIivEXT(uint32_t handle, GLuint sampler, GLenum pname, GLint *params);

void glGetSamplerParameterIivEXT(GLuint sampler, GLenum pname, GLint *params);

void VmiGlGetSamplerParameterIuivEXT(uint32_t handle, GLuint sampler, GLenum pname, GLuint *params);

void glGetSamplerParameterIuivEXT(GLuint sampler, GLenum pname, GLuint *params);

void VmiGlVertexAttribPointerData(uint32_t handle, GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void *data, GLuint datalen);

void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* data, GLuint datalen);

void VmiGlVertexAttribPointerOffset(uint32_t handle, GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint offset);

void glVertexAttribPointerOffset(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint offset);

void VmiGlDrawElementsOffset(uint32_t handle, GLenum mode, GLsizei count, GLenum type, GLuint offset);

void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset);

void VmiGlDrawElementsData(uint32_t handle, GLenum mode, GLsizei count, GLenum type, void *data, GLuint datalen);

void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen);

void VmiGlGetCompressedTextureFormats(uint32_t handle, int count, GLint *formats);

void glGetCompressedTextureFormats(int count, GLint* formats);

void VmiGlShaderString(uint32_t handle, GLuint shader, const GLchar *string, GLsizei len);

void glShaderString(GLuint shader, const GLchar* string, GLsizei len);

int VmiGlFinishRoundTrip(uint32_t handle);

int glFinishRoundTrip();

void VmiGlMapBufferRangeAEMU(uint32_t handle, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void *mapped);

void glMapBufferRangeAEMU(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void* mapped);

void VmiGlUnmapBufferAEMU(uint32_t handle, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void *guestBuffer, GLboolean *outRes);

void glUnmapBufferAEMU(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void* guest_buffer, GLboolean* out_res);

void VmiGlFlushMappedBufferRangeAEMU(uint32_t handle, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void *guestBuffer);

void glFlushMappedBufferRangeAEMU(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void* guest_buffer);

void VmiGlReadPixelsOffsetAEMU(uint32_t handle, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLuint offset);

void glReadPixelsOffsetAEMU(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLuint offset);

void VmiGlCompressedTexImage2DOffsetAEMU(uint32_t handle, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLuint offset);

void glCompressedTexImage2DOffsetAEMU(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLuint offset);

void VmiGlCompressedTexSubImage2DOffsetAEMU(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLuint offset);

void glCompressedTexSubImage2DOffsetAEMU(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLuint offset);

void VmiGlTexImage2DOffsetAEMU(uint32_t handle, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLuint offset);

void glTexImage2DOffsetAEMU(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLuint offset);

void VmiGlTexSubImage2DOffsetAEMU(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLuint offset);

void glTexSubImage2DOffsetAEMU(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLuint offset);

void VmiGlGetUniformIndicesAEMU(uint32_t handle, GLuint program, GLsizei uniformCount, const GLchar *packedUniformNames, GLsizei packedLen, GLuint *uniformIndices);

void glGetUniformIndicesAEMU(GLuint program, GLsizei uniformCount, const GLchar* packedUniformNames, GLsizei packedLen, GLuint* uniformIndices);

void VmiGlVertexAttribIPointerOffsetAEMU(uint32_t handle, GLuint index, GLint size, GLenum type, GLsizei stride, GLuint offset);

void glVertexAttribIPointerOffsetAEMU(GLuint index, GLint size, GLenum type, GLsizei stride, GLuint offset);

void VmiGlVertexAttribIPointerDataAEMU(uint32_t handle, GLuint index, GLint size, GLenum type, GLsizei stride, void *data, GLuint datalen);

void glVertexAttribIPointerDataAEMU(GLuint index, GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen);

void VmiGlDrawElementsInstancedDataAEMU(uint32_t handle, GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount, GLsizei datalen);

void glDrawElementsInstancedDataAEMU(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount, GLsizei datalen);

void VmiGlDrawElementsInstancedOffsetAEMU(uint32_t handle, GLenum mode, GLsizei count, GLenum type, GLuint offset, GLsizei primcount);

void glDrawElementsInstancedOffsetAEMU(GLenum mode, GLsizei count, GLenum type, GLuint offset, GLsizei primcount);

void VmiGlDrawRangeElementsDataAEMU(uint32_t handle, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLsizei datalen);

void glDrawRangeElementsDataAEMU(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices, GLsizei datalen);

void VmiGlDrawRangeElementsOffsetAEMU(uint32_t handle, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLuint offset);

void glDrawRangeElementsOffsetAEMU(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLuint offset);

uint64_t VmiGlFenceSyncAEMU(uint32_t handle, GLenum condition, GLbitfield flags);

uint64_t glFenceSyncAEMU(GLenum condition, GLbitfield flags);

GLenum VmiGlClientWaitSyncAEMU(uint32_t handle, uint64_t waitOn, GLbitfield flags, GLuint64 timeout);

GLenum glClientWaitSyncAEMU(uint64_t wait_on, GLbitfield flags, GLuint64 timeout);

void VmiGlWaitSyncAEMU(uint32_t handle, uint64_t waitOn, GLbitfield flags, GLuint64 timeout);

void glWaitSyncAEMU(uint64_t wait_on, GLbitfield flags, GLuint64 timeout);

void VmiGlDeleteSyncAEMU(uint32_t handle, uint64_t toDelete);

void glDeleteSyncAEMU(uint64_t to_delete);

GLboolean VmiGlIsSyncAEMU(uint32_t handle, uint64_t sync);

GLboolean glIsSyncAEMU(uint64_t sync);

void VmiGlGetSyncivAEMU(uint32_t handle, uint64_t sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);

void glGetSyncivAEMU(uint64_t sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values);

void VmiGlTransformFeedbackVaryingsAEMU(uint32_t handle, GLuint program, GLsizei count, const char *packedVaryings, GLuint packedVaryingsLen, GLenum bufferMode);

void glTransformFeedbackVaryingsAEMU(GLuint program, GLsizei count, const char* packedVaryings, GLuint packedVaryingsLen, GLenum bufferMode);

void VmiGlTexImage3DOffsetAEMU(uint32_t handle, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLuint offset);

void glTexImage3DOffsetAEMU(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLuint offset);

void VmiGlTexSubImage3DOffsetAEMU(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLuint offset);

void glTexSubImage3DOffsetAEMU(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLuint offset);

void VmiGlCompressedTexImage3DOffsetAEMU(uint32_t handle, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLuint offset);

void glCompressedTexImage3DOffsetAEMU(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLuint offset);

void VmiGlCompressedTexSubImage3DOffsetAEMU(uint32_t handle, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLuint data);

void glCompressedTexSubImage3DOffsetAEMU(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLuint data);

GLuint VmiGlCreateShaderProgramvAEMU(uint32_t handle, GLenum type, GLsizei count, const char *packedStrings, GLuint packedLen);

GLuint glCreateShaderProgramvAEMU(GLenum type, GLsizei count, const char* packedStrings, GLuint packedLen);

void VmiGlDrawArraysIndirectDataAEMU(uint32_t handle, GLenum mode, const void *indirect, GLuint datalen);

void glDrawArraysIndirectDataAEMU(GLenum mode, const void* indirect, GLuint datalen);

void VmiGlDrawArraysIndirectOffsetAEMU(uint32_t handle, GLenum mode, GLuint offset);

void glDrawArraysIndirectOffsetAEMU(GLenum mode, GLuint offset);

void VmiGlDrawElementsIndirectDataAEMU(uint32_t handle, GLenum mode, GLenum type, const void *indirect, GLuint datalen);

void glDrawElementsIndirectDataAEMU(GLenum mode, GLenum type, const void* indirect, GLuint datalen);

void VmiGlDrawElementsIndirectOffsetAEMU(uint32_t handle, GLenum mode, GLenum type, GLuint offset);

void glDrawElementsIndirectOffsetAEMU(GLenum mode, GLenum type, GLuint offset);

void VmiGlMinSampleShading(uint32_t handle, GLfloat value);

void glMinSampleShading(GLfloat value);

void VmiGlFramebufferTexture(uint32_t handle, GLenum target, GLenum attachment, GLuint texture, GLint level);

void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);

void VmiGlPatchParameteri(uint32_t handle, GLenum pname, GLint value);

void glPatchParameteri(GLenum pname, GLint value);

void VmiGlTexBuffer(uint32_t handle, GLenum target, GLenum internalFormat, GLuint buffer);

void glTexBuffer(GLenum target, GLenum internalFormat, GLuint buffer);

void VmiTexBufferRange(uint32_t handle, GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size);

void glTexBufferRange(GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size);

void VmiGlPrimitiveBoundingBox(uint32_t handle, GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW);

void glPrimitiveBoundingBox(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW);

void VmiGlTexStorage3DMultisample(uint32_t handle, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);

void glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);

void VmiGlDrawElementsBaseVertexOffset(uint32_thandle, GLenummode, GLsizeicount, GLenumtype,

GLuintoffset, GLintbasevertex);

void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, void *indices, GLint basevertex);

void VmiGlDrawElementsBaseVertexData(uint32_thandle, GLenummode, GLsizeicount, GLenumtype, void*data,

GLuintdatalen, GLintbasevertex);

void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, void *indices, GLint basevertex);

void VmiGlDrawElementsInstancedBaseVertexOffsetAEMU(uint32_thandle, GLenummode, GLsizeicount, GLenumtype,

GLuintoffset, GLsizeiprimcount, GLintbasevertex);

void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, void *indices, GLsizei primcount, GLint basevertex);

void VmiGlDrawElementsInstancedBaseVertexDataAEMU(uint32_thandle, GLenummode, GLsizeicount, GLenumtype,

constvoid*indices, GLsizeiprimcount, GLsizeidatalen, GLintbasevertex);

void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, void *indices, GLsizei primcount, GLint basevertex);

void VmiGlGetnUniformfv(uint32_t handle, GLuint program, GLint location, GLsizei bufSize, GLfloat *params);

void glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params);

void VmiGlGetnUniformiv(uint32_t handle, GLuint program, GLint location, GLsizei bufSize, GLint *params);

void glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params);

void VmiGlGetnUniformuiv(uint32_t handle, GLuint program, GLint location, GLsizei bufSize, GLuint *params);

void glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params);