path: root/host/libs/virglrenderer/GLESv3_dec/gles3.attrib

GLOBAL
    base_opcode 2048
    encoder_headers <string.h> "glUtils.h" "GL2EncoderUtils.h"

#void glBindAttribLocation(GLuint program, GLuint index, GLchar *name)
glBindAttribLocation
    len name (strlen(name) + 1)

#void glBufferData(GLenum target, GLsizeiptr size, GLvoid *data, GLenum usage)
glBufferData
    len data size
    var_flag data nullAllowed isLarge

#void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
glBufferSubData
    len data size
    var_flag data nullAllowed isLarge

#void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid *data)
glCompressedTexImage2D
    len data imageSize
    param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    var_flag data nullAllowed isLarge
    param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }

#void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid *data)
glCompressedTexSubImage2D
    len data imageSize
    param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    var_flag data nullAllowed isLarge
    param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }

#void glDeleteBuffers(GLsizei n, GLuint *buffers)
glDeleteBuffers
    len buffers (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

#void glDeleteFramebuffers(GLsizei n, GLuint *framebuffers)
glDeleteFramebuffers
    len framebuffers (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

#void glDeleteRenderbuffers(GLsizei n, GLuint *renderbuffers)
glDeleteRenderbuffers
    len renderbuffers (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

#void glDeleteTextures(GLsizei n, GLuint *textures)
glDeleteTextures
    len textures (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

#void glDrawElements(GLenum mode, GLsizei count, GLenum type, GLvoid *indices)
glDrawElements
    flag unsupported

#void glGenBuffers(GLsizei n, GLuint *buffers)
glGenBuffers
    len buffers (n * sizeof(GLuint))
    dir buffers out
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

#void glGenFramebuffers(GLsizei n, GLuint *framebuffers)
glGenFramebuffers
    len framebuffers (n * sizeof(GLuint))
    dir framebuffers out
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

#void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
glGenRenderbuffers
    len renderbuffers (n * sizeof(GLuint))
    dir renderbuffers out
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

#void glGenTextures(GLsizei n, GLuint *textures)
glGenTextures
    len textures (n * sizeof(GLuint))
    dir textures out
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

#void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
glGetActiveAttrib
    param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    len name bufsize
    dir name out
    var_flag name nullAllowed
    dir length out
    len length (sizeof(GLsizei))
    var_flag length nullAllowed
    dir size out
    len size (sizeof(GLint))
    var_flag size nullAllowed
    dir type out
    len type (sizeof(GLenum))
    var_flag type nullAllowed

#void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
glGetActiveUniform
    param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    len name bufsize
    dir name out
      var_flag name nullAllowed
    dir length out
    len length (sizeof(GLsizei))
    var_flag length nullAllowed
    dir size out
    len size (sizeof(GLint))
    var_flag size nullAllowed
    dir type out
    len type (sizeof(GLenum))
    var_flag type nullAllowed


#void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders)
glGetAttachedShaders
    len shaders (maxcount*sizeof(GLuint))
    dir shaders out
    dir count out
    var_flag count nullAllowed
    len count (sizeof(GLsizei))

#int glGetAttribLocation(GLuint program, GLchar *name)
glGetAttribLocation
    len name (strlen(name) + 1)

#void glGetBooleanv(GLenum pname, GLboolean *params)
glGetBooleanv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLboolean))

#void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
glGetBufferParameteriv
    len params (sizeof(GLint))
    dir params out

#void glGetFloatv(GLenum pname, GLfloat *params)
glGetFloatv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLfloat))

#void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
glGetFramebufferAttachmentParameteriv
    dir params out
    len params (sizeof(GLint))

#void glGetIntegerv(GLenum pname, GLint *params)
glGetIntegerv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLint))

#void glGetProgramiv(GLuint program, GLenum pname, GLint *params)
glGetProgramiv
    dir params out
    len params sizeof(GLint)
#XXX - might change if extension constants that return more then one value


#void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length, GLchar *infolog)
glGetProgramInfoLog
    dir infolog out
    len infolog bufsize
    param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    dir length out
    len length sizeof(GLsizei)
    var_flag length nullAllowed

#void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
glGetRenderbufferParameteriv
    dir params out
    len params sizeof(GLint)
# XXX - might change if pname with value larger then one is added

#void glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
glGetShaderiv
    dir params out
    len params sizeof(GLint)
# XXX - might change if pname with value larger then one is added

#void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *infolog)
glGetShaderInfoLog
    dir length out
    len length (sizeof(GLsizei))
    var_flag length nullAllowed
    dir infolog out
    len infolog bufsize
    param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; }

#void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
glGetShaderPrecisionFormat
    dir range out
    len range (2 * sizeof(GLint))
    dir precision out
    len precision (sizeof(GLint))

#void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *source)
glGetShaderSource
    dir length out
    len length (sizeof(GLsizei))
    var_flag length nullAllowed
    dir source out
    len source bufsize
    param_check bufsize if(bufsize<0){ ctx->setError(GL_INVALID_VALUE); return; }

#GLubyte* glGetString(GLenum name)
glGetString
    flag unsupported

#void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
glGetTexParameterfv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLfloat))

#void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
glGetTexParameteriv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLint))

#void glGetUniformfv(GLuint program, GLint location, GLfloat *params)
glGetUniformfv
    dir params out
    len params glSizeof(glesv2_enc::uniformType(self, program, location))

#void glGetUniformiv(GLuint program, GLint location, GLint *params)
glGetUniformiv
    dir params out
    len params glSizeof(glesv2_enc::uniformType(self, program, location))

#int glGetUniformLocation(GLuint program, GLchar *name)
glGetUniformLocation
    len name (strlen(name) + 1)

# client-state shall be handled locally by the encoder in most cases.
# however, GL_CURRENT_VERTEX_ATTRIB and potential others are handled by the server side,
# thus we still need to implement it.
#void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
glGetVertexAttribfv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLfloat))

#see glGetVertexAttribfv for comments
#void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
glGetVertexAttribiv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLint))

#void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
glReadPixels
    dir pixels out
    len pixels glesv2_enc::pixelDataSize(self, width, height, format, type, 1)

glReadPixelsOffsetAEMU
    flag custom_decoder
    flag not_api

#void glShaderBinary(GLsizei n, GLuint *shaders, GLenum binaryformat, GLvoid *binary, GLsizei length)
glShaderBinary
    flag unsupported

#void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid *pixels)
glTexImage2D
    dir pixels in
    len pixels glesv2_enc::pixelDataSize(self, width, height, format, type, 0)
    var_flag pixels nullAllowed isLarge

#void glTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
glTexParameterfv
    len params (glUtilsParamSize(pname) * sizeof(GLfloat))
#void glTexParameteriv(GLenum target, GLenum pname, GLint *params)
glTexParameteriv
    len params (glUtilsParamSize(pname) * sizeof(GLint))

#void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
glTexSubImage2D
    len pixels glesv2_enc::pixelDataSize(self, width, height, format, type, 0)
    var_flag pixels nullAllowed isLarge

#void glUniform1fv(GLint location, GLsizei count, GLfloat *v)
glUniform1fv
    len v (count * sizeof(GLfloat))

#void glUniform1iv(GLint location, GLsizei count, GLint *v)
glUniform1iv
    len v (count * sizeof(GLint))

#void glUniform2fv(GLint location, GLsizei count, GLfloat *v)
glUniform2fv
    len v (count * 2 * sizeof(GLfloat))

#void glUniform2iv(GLint location, GLsizei count, GLint *v)
glUniform2iv
    len v (count * 2 * sizeof(GLint))

#void glUniform3fv(GLint location, GLsizei count, GLfloat *v)
glUniform3fv
    len v (count * 3 * sizeof(GLfloat))

#void glUniform3iv(GLint location, GLsizei count, GLint *v)
glUniform3iv
    len v (3 * count * sizeof(GLint))

#void glUniform4fv(GLint location, GLsizei count, GLfloat *v)
glUniform4fv
    len v (4 * count * sizeof(GLfloat))

#void glUniform4iv(GLint location, GLsizei count, GLint *v)
glUniform4iv
    len v (4 * count * sizeof(GLint))

#void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, GLfloat *value)
glUniformMatrix2fv
    len value (count * 4 * sizeof(GLfloat))

#void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, GLfloat *value)
glUniformMatrix3fv
    len value (count * 9 * sizeof(GLfloat))

#void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, GLfloat *value)
glUniformMatrix4fv
    len value (count * 16 * sizeof(GLfloat))

#void glVertexAttrib1fv(GLuint indx, GLfloat *values)
glVertexAttrib1fv
    len values (sizeof(GLfloat))
#void glVertexAttrib2fv(GLuint indx, GLfloat *values)
glVertexAttrib2fv
    len values (2 * sizeof(GLfloat))

#void glVertexAttrib3fv(GLuint indx, GLfloat *values)
glVertexAttrib3fv
    len values (3 * sizeof(GLfloat))

#void glVertexAttrib4fv(GLuint indx, GLfloat *values)
glVertexAttrib4fv
    len values (4 * sizeof(GLfloat))

#void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLvoid *ptr)
glVertexAttribPointer
    flag unsupported

#void glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
glGetProgramBinaryOES
    flag unsupported

#void glProgramBinaryOES(GLuint program, GLenum binaryFormat, GLvoid *binary, GLint length)
glProgramBinaryOES
    flag unsupported

#void* glMapBufferOES(GLenum target, GLenum access)
glMapBufferOES
    flag unsupported

#void glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLvoid *pixels)
glTexImage3DOES
    len pixels glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0)
    var_flag pixels nullAllowed isLarge

#void glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *pixels)
glTexSubImage3DOES
    len pixels glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0)
    var_flag pixels nullAllowed isLarge

#void glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLvoid *data)
glCompressedTexImage3DOES
    len data imageSize
    param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    var_flag data nullAllowed isLarge

#void glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLvoid *data)
glCompressedTexSubImage3DOES
    len data imageSize
    param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    var_flag data nullAllowed isLarge

#void glDeleteVertexArraysOES(GLsizei n, GLuint *arrays)
glDeleteVertexArraysOES
    len arrays (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

#void glGenVertexArraysOES(GLsizei n, GLuint *arrays)
glGenVertexArraysOES
    len arrays (n * sizeof(GLuint))
    dir arrays out
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }


#void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, GLenum *attachments)
glDiscardFramebufferEXT
    len attachments (numAttachments * sizeof(GLenum))

#void glMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
glMultiDrawArraysEXT
    flag unsupported
#void glMultiDrawElementsEXT(GLenum mode, GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei primcount)
glMultiDrawElementsEXT
    flag unsupported


# handled by encoder
#void glShaderSource(GLuint shader, GLsizei count, GLstr *string, const GLint *length)
glShaderSource
    flag unsupported


#void glGetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize, GLuint *groups)
glGetPerfMonitorGroupsAMD
    flag unsupported

#void glGetPerfMonitorCountersAMD(GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters)
glGetPerfMonitorCountersAMD
    flag unsupported

#void glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString)
glGetPerfMonitorGroupStringAMD
    flag unsupported

#void glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString)
glGetPerfMonitorCounterStringAMD
    flag unsupported

#void glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, GLvoid *data)
glGetPerfMonitorCounterInfoAMD
    flag unsupported

#void glGenPerfMonitorsAMD(GLsizei n, GLuint *monitors)
glGenPerfMonitorsAMD
    flag unsupported

#void glDeletePerfMonitorsAMD(GLsizei n, GLuint *monitors)
glDeletePerfMonitorsAMD
    flag unsupported

#void glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *countersList)
glSelectPerfMonitorCountersAMD
    flag unsupported

#void glBeginPerfMonitorAMD(GLuint monitor)
glBeginPerfMonitorAMD
    flag unsupported

#void glEndPerfMonitorAMD(GLuint monitor)
glEndPerfMonitorAMD
    flag unsupported

#void glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten)
glGetPerfMonitorCounterDataAMD
    flag unsupported

#void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
glRenderbufferStorageMultisampleIMG
    flag unsupported

#void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
glFramebufferTexture2DMultisampleIMG
    flag unsupported

#void glDeleteFencesNV(GLsizei n, GLuint *fences)
glDeleteFencesNV
    flag unsupported

#void glGenFencesNV(GLsizei n, GLuint *fences)
glGenFencesNV
    flag unsupported

#GLboolean glIsFenceNV(GLuint fence)
glIsFenceNV
    flag unsupported

#GLboolean glTestFenceNV(GLuint fence)
glTestFenceNV
    flag unsupported

#void glGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
glGetFenceivNV
    flag unsupported

#void glFinishFenceNV(GLuint fence)
glFinishFenceNV
    flag unsupported

#void glSetFenceNV(GLuint fence, GLenum condition)
glSetFenceNV
    flag unsupported

#void glCoverageMaskNV(GLboolean mask)
glCoverageMaskNV
    flag unsupported

#void glCoverageOperationNV(GLenum operation)
glCoverageOperationNV
    flag unsupported

#void glGetDriverControlsQCOM(GLint *num, GLsizei size, GLuint *driverControls)
glGetDriverControlsQCOM
    flag unsupported

#void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString)
glGetDriverControlStringQCOM
    flag unsupported

#void glEnableDriverControlQCOM(GLuint driverControl)
glEnableDriverControlQCOM
    flag unsupported

#void glDisableDriverControlQCOM(GLuint driverControl)
glDisableDriverControlQCOM
    flag unsupported

#void glExtGetTexturesQCOM(GLuint *textures, GLint maxTextures, GLint *numTextures)
glExtGetTexturesQCOM
    flag unsupported

#void glExtGetBuffersQCOM(GLuint *buffers, GLint maxBuffers, GLint *numBuffers)
glExtGetBuffersQCOM
    flag unsupported

#void glExtGetRenderbuffersQCOM(GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers)
glExtGetRenderbuffersQCOM
    flag unsupported

#void glExtGetFramebuffersQCOM(GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers)
glExtGetFramebuffersQCOM
    flag unsupported

#void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params)
glExtGetTexLevelParameterivQCOM
    flag unsupported

#void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param)
glExtTexObjectStateOverrideiQCOM
    flag unsupported

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

#void glExtGetBufferPointervQCOM(GLenum target, GLvoidptr *params)
glExtGetBufferPointervQCOM
    flag unsupported

#void glExtGetShadersQCOM(GLuint *shaders, GLint maxShaders, GLint *numShaders)
glExtGetShadersQCOM
    flag unsupported

#void glExtGetProgramsQCOM(GLuint *programs, GLint maxPrograms, GLint *numPrograms)
glExtGetProgramsQCOM
    flag unsupported

#GLboolean glExtIsProgramBinaryQCOM(GLuint program)
glExtIsProgramBinaryQCOM
    flag unsupported

#void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar *source, GLint *length)
glExtGetProgramBinarySourceQCOM
    flag unsupported

#void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask)
glStartTilingQCOM
    flag unsupported

#void glEndTilingQCOM(GLbitfield preserveMask)
glEndTilingQCOM
    flag unsupported


#void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride,  void * data, GLuint datalen)
glVertexAttribPointerData
    len data datalen
    custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen)
    flag custom_decoder
    flag not_api

glVertexAttribPointerOffset
    flag custom_decoder
    flag not_api

#client-state, handled by the encoder
#GL_ENTRY(void, glGetVertexAttribPointerv, GLuint index, GLenum pname, GLvoid** pointer)
glGetVertexAttribPointerv
    flag unsupported

glDrawElementsData
    len data datalen
    flag custom_decoder
    flag not_api

glDrawElementsOffset
    flag custom_decoder
    flag not_api

#GL_ENTRY(void, glGetCompressedTextureFormats, int count, GLint *formats)
glGetCompressedTextureFormats
    dir formats out
    len formats (count * sizeof(GLint))
    flag custom_decoder
    flag not_api

#GL_ENTRY(void, glShaderString, GLuint shader, GLchar *string, GLsizei len)
glShaderString
    len string len
    flag custom_decoder
    flag not_api

glFinishRoundTrip
    flag custom_decoder
    flag not_api

# GLES 3.0

glGenVertexArrays
    len arrays (n * sizeof(GLuint))
    dir arrays out
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

glDeleteVertexArrays
    len arrays (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

glMapBufferRange
    flag unsupported
glUnmapBuffer
    flag unsupported
glFlushMappedBufferRange
    flag unsupported

glMapBufferRangeAEMU
    dir mapped out
    len mapped length
    var_flag mapped nullAllowed
    flag custom_decoder
    flag not_api

glUnmapBufferAEMU
    dir guest_buffer in
    len guest_buffer length
    var_flag guest_buffer nullAllowed
    dir out_res out
    len out_res (sizeof(GLboolean))
    flag custom_decoder
    flag not_api

glFlushMappedBufferRangeAEMU
    dir guest_buffer in
    len guest_buffer length
    var_flag guest_buffer nullAllowed
    flag custom_decoder
    flag not_api

glReadPixelsOffsetAEMU
    flag custom_decoder
    flag not_api

glCompressedTexImage2DOffsetAEMU
    flag custom_decoder
    flag not_api

glCompressedTexSubImage2DOffsetAEMU
    flag custom_decoder
    flag not_api

glTexImage2DOffsetAEMU
    flag custom_decoder
    flag not_api

glTexSubImage2DOffsetAEMU
    flag custom_decoder
    flag not_api

glCopyBufferSubData
    flag flushOnEncode

glClearBufferiv
    dir value in
    len value (sizeof(GLint) * glesv2_enc::clearBufferNumElts(self, buffer))

glClearBufferuiv
    dir value in
    len value (sizeof(GLuint) * glesv2_enc::clearBufferNumElts(self, buffer))

glClearBufferfv
    dir value in
    len value (sizeof(GLfloat) * glesv2_enc::clearBufferNumElts(self, buffer))

glGetBufferParameteri64v
    flag unsupported

glGetBufferPointerv
    flag unsupported

glGetUniformBlockIndex
    len uniformBlockName (strlen(uniformBlockName) + 1)

glGetUniformIndices
    flag unsupported

glGetUniformIndicesAEMU
    dir packedUniformNames in
    len packedUniformNames packedLen
    dir uniformIndices out
    len uniformIndices (uniformCount * sizeof(GLuint))
    flag custom_decoder
    flag not_api

glGetActiveUniformBlockiv
    dir params out
    len params (glesv2_enc::glActiveUniformBlockivParamSize(self, program, uniformBlockIndex, pname) * sizeof(GLint))

glGetActiveUniformBlockName
    dir uniformBlockName out
    len uniformBlockName bufSize
    param_check bufSize if(bufSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    var_flag uniformBlockName nullAllowed
    dir length out
    len length (sizeof(GLsizei))
    var_flag length nullAllowed

glUniform1uiv
    len value (count * sizeof(GLuint))

glUniform2uiv
    len value (count * 2 * sizeof(GLuint))

glUniform3uiv
    len value (count * 3 * sizeof(GLuint))

glUniform4uiv
    len value (count * 4 * sizeof(GLuint))

glUniformMatrix2x3fv
    len value (count * 6 * sizeof(GLfloat))

glUniformMatrix3x2fv
    len value (count * 6 * sizeof(GLfloat))

glUniformMatrix2x4fv
    len value (count * 8 * sizeof(GLfloat))

glUniformMatrix4x2fv
    len value (count * 8 * sizeof(GLfloat))

glUniformMatrix3x4fv
    len value (count * 12 * sizeof(GLfloat))

glUniformMatrix4x3fv
    len value (count * 12 * sizeof(GLfloat))

glGetUniformuiv
    dir params out
    len params glSizeof(glesv2_enc::uniformType(self, program, location))

glGetActiveUniformsiv
    len uniformIndices (uniformCount * sizeof(GLuint))
    dir params out
    len params (uniformCount * sizeof(GLint))

glVertexAttribI4iv
    len v (4 * sizeof(GLint))

glVertexAttribI4uiv
    len v (4 * sizeof(GLuint))

glVertexAttribIPointer
    flag unsupported

glVertexAttribIPointerOffsetAEMU
    flag custom_decoder
    flag not_api

glVertexAttribIPointerDataAEMU
    len data datalen
    custom_pack data glUtilsPackPointerData((unsigned char *)ptr, (unsigned char *)data, size, type, stride, datalen)
    flag custom_decoder
    flag not_api

glGetVertexAttribIiv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLint))

glGetVertexAttribIuiv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLuint))

glDrawElementsInstanced
    flag unsupported

glDrawElementsInstancedDataAEMU
    len indices datalen
    flag custom_decoder
    flag not_api

glDrawElementsInstancedOffsetAEMU
    flag custom_decoder
    flag not_api

glDrawRangeElements
    flag unsupported

glDrawRangeElementsDataAEMU
    len indices datalen
    flag custom_decoder
    flag not_api

glDrawRangeElementsOffsetAEMU
    flag custom_decoder
    flag not_api

glFenceSync
    flag unsupported

glClientWaitSync
    flag unsupported

glWaitSync
    flag unsupported

glDeleteSync
    flag unsupported

glIsSync
    flag unsupported

glGetSynciv
    flag unsupported

glFenceSyncAEMU
    flag custom_decoder
    flag not_api

glClientWaitSyncAEMU
    flag custom_decoder
    flag not_api

glWaitSyncAEMU
    flag custom_decoder
    flag not_api

glDeleteSyncAEMU
    flag custom_decoder
    flag not_api

glIsSyncAEMU
    flag custom_decoder
    flag not_api

glGetSyncivAEMU
    flag custom_decoder
    flag not_api
    dir length out
    len length (sizeof(GLsizei))
    dir values out
    len values bufSize
    param_check bufSize if(bufSize<0){ ctx->setError(GL_INVALID_VALUE); return; }

glGetInternalformativ
    dir params out
    len params (sizeof(GLint) * bufSize)

glDrawBuffers
    len bufs (n * sizeof(GLenum))

glInvalidateFramebuffer
    len attachments (numAttachments * sizeof(GLenum))

glInvalidateSubFramebuffer
    len attachments (numAttachments * sizeof(GLenum))

glGenTransformFeedbacks
    dir ids out
    len ids (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

glDeleteTransformFeedbacks
    len ids (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

glTransformFeedbackVaryings
    flag unsupported

glTransformFeedbackVaryingsAEMU
    dir packedVaryings in
    len packedVaryings packedVaryingsLen
    flag custom_decoder
    flag not_api

glGetTransformFeedbackVarying
    dir name out
    len name bufSize
    param_check bufSize if(bufSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    var_flag name nullAllowed
    dir length out
    len length (sizeof(GLsizei))
    var_flag length nullAllowed
    dir size out
    len size (sizeof(GLsizei))
    var_flag type nullAllowed
    dir type out
    len type (sizeof(GLenum))
    var_flag type nullAllowed

glGenSamplers
    dir samplers out
    len samplers (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

glDeleteSamplers
    len samplers (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

glSamplerParameterfv
    len params (glUtilsParamSize(pname) * sizeof(GLfloat))

glSamplerParameteriv
    len params (glUtilsParamSize(pname) * sizeof(GLint))

glGetSamplerParameterfv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLfloat))

glGetSamplerParameteriv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLint))

glGenQueries
    dir queries out
    len queries (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

glDeleteQueries
    len queries (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

glGetQueryiv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLint))

glGetQueryObjectuiv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLuint))

glProgramBinary
    len binary length

glGetProgramBinary
    param_check bufSize if(bufSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    dir binary out
    len binary bufSize
    dir binaryFormat out
    len binaryFormat (sizeof(GLenum))
    dir length out
    len length (sizeof(GLsizei))

glGetFragDataLocation
    len name (strlen(name) + 1)

glGetInteger64v
    dir data out
    len data (glUtilsParamSize(pname) * sizeof(GLint64))

# No need to account for custom sizes since indexed variants
# are all on indxed buffers like transform feedback buffers,
# UBOs, or SSBOs, and querying their sizes and offsets.
glGetIntegeri_v
    dir data out
    len data (sizeof(GLint))

glGetInteger64i_v
    dir data out
    len data (sizeof(GLint64))

glTexImage3D
    dir data in
    len data glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0)
    var_flag data nullAllowed isLarge

glTexImage3DOffsetAEMU
    flag custom_decoder
    flag not_api

glTexSubImage3D
    len data glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0)
    var_flag data nullAllowed isLarge

glTexSubImage3DOffsetAEMU
    flag custom_decoder
    flag not_api

glCompressedTexImage3D
    len data imageSize
    param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    var_flag data nullAllowed isLarge

glCompressedTexImage3DOffsetAEMU
    flag custom_decoder
    flag not_api

glCompressedTexSubImage3D
    param_check imageSize if(imageSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    len data imageSize
    var_flag data nullAllowed isLarge

glCompressedTexSubImage3DOffsetAEMU
    flag custom_decoder
    flag not_api

glGetStringi
    flag unsupported

# GLES 3.1

glGetBooleani_v
    dir data out
    len data (sizeof(GLboolean))

glGenProgramPipelines
    dir pipelines out
    len pipelines (n * sizeof(GLuint))

glDeleteProgramPipelines
    len pipelines (n * sizeof(GLuint))
    param_check n if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }

glGetProgramPipelineiv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLint))

glGetProgramPipelineInfoLog
    dir infoLog out
    len infoLog bufSize
    param_check bufSize if(bufSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    dir length out
    len length sizeof(GLsizei)
    var_flag length nullAllowed

glCreateShaderProgramv
    flag unsupported

glCreateShaderProgramvAEMU
    len packedStrings packedLen
    flag custom_decoder
    flag not_api

glProgramUniform1fv
    len value (count * sizeof(GLfloat))

glProgramUniform2fv
    len value (count * sizeof(GLfloat))

glProgramUniform3fv
    len value (count * sizeof(GLfloat))

glProgramUniform4fv
    len value (count * sizeof(GLfloat))

glProgramUniform1iv
    len value (count * sizeof(GLint))

glProgramUniform2iv
    len value (count * sizeof(GLint))

glProgramUniform3iv
    len value (count * sizeof(GLint))

glProgramUniform4iv
    len value (count * sizeof(GLint))

glProgramUniform1uiv
    len value (count * sizeof(GLuint))

glProgramUniform2uiv
    len value (count * sizeof(GLuint))

glProgramUniform3uiv
    len value (count * sizeof(GLuint))

glProgramUniform4uiv
    len value (count * sizeof(GLuint))

glProgramUniformMatrix2fv
    len value (count * 4 * sizeof(GLfloat))

glProgramUniformMatrix3fv
    len value (count * 9 * sizeof(GLfloat))

glProgramUniformMatrix4fv
    len value (count * 16 * sizeof(GLfloat))

glProgramUniformMatrix2x3fv
    len value (count * 6 * sizeof(GLfloat))

glProgramUniformMatrix3x2fv
    len value (count * 6 * sizeof(GLfloat))

glProgramUniformMatrix2x4fv
    len value (count * 8 * sizeof(GLfloat))

glProgramUniformMatrix4x2fv
    len value (count * 8 * sizeof(GLfloat))

glProgramUniformMatrix3x4fv
    len value (count * 12 * sizeof(GLfloat))

glProgramUniformMatrix4x3fv
    len value (count * 12 * sizeof(GLfloat))

glGetProgramInterfaceiv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLint))

glGetProgramResourceiv
    dir params out
    len params (bufSize * sizeof(GLint))
    param_check bufSize if(bufSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    var_flag length nullAllowed
    dir length out
    len length (sizeof(GLsizei))
    len props (propCount * sizeof(GLenum))

glGetProgramResourceIndex
    len name (strlen(name) + 1)

glGetProgramResourceLocation
    len name (strlen(name) + 1)

glGetProgramResourceName
    dir name out
    len name bufSize
    param_check bufSize if(bufSize<0){ ctx->setError(GL_INVALID_VALUE); return; }
    var_flag length nullAllowed
    dir length out
    len length (sizeof(GLsizei))

glDrawArraysIndirect
    flag unsupported

glDrawArraysIndirectDataAEMU
    len indirect datalen
    flag custom_decoder
    flag not_api

glDrawArraysIndirectOffsetAEMU
    flag custom_decoder
    flag not_api

glDrawElementsIndirect
    flag unsupported

glDrawElementsIndirectDataAEMU
    len indirect datalen
    flag custom_decoder
    flag not_api

glDrawElementsIndirectOffsetAEMU
    flag custom_decoder
    flag not_api

glGetMultisamplefv
    dir val out
    len val (glUtilsParamSize(pname) * sizeof(GLfloat))

glGetFramebufferParameteriv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLint))

glGetTexLevelParameterfv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLfloat))

glGetTexLevelParameteriv
    dir params out
    len params (glUtilsParamSize(pname) * sizeof(GLint))