////////////////////////////////////////////////////////////////////////////////
// Do not modify!
// Generated by codergen
////////////////////////////////////////////////////////////////////////////////

package gles

import (
	"android.googlesource.com/platform/tools/gpu/framework/binary"
	"android.googlesource.com/platform/tools/gpu/framework/binary/registry"
	"android.googlesource.com/platform/tools/gpu/framework/id"
	"android.googlesource.com/platform/tools/gpu/gapid/atom"
	"android.googlesource.com/platform/tools/gpu/gapid/memory"
)

// Make sure schema init() runs first
import _ "android.googlesource.com/platform/tools/gpu/framework/binary/schema"

// force use the id package, because our imports handling is wrong
var _ id.ID

const (
	ixǁActiveAttribute = iota
	ixǁActiveUniform
	ixǁBlendState
	ixǁVec4f
	ixǁBoundingBox
	ixǁU8ˢ
	ixǁU8ᵖ
	ixǁBuffer
	ixǁBufferBinding
	ixǁBufferBindings
	ixǁBufferDataPointer
	ixǁBufferIdˢ
	ixǁBufferIdᵖ
	ixǁBufferIdᶜᵖ
	ixǁCGLContextObj
	ixǁCGLContextObjˢ
	ixǁCGLContextObjᵖ
	ixǁCGLTexelFormatObj
	ixǁCGLCreateContext
	ixǁCGLFlushDrawable
	ixǁCGSConnectionIDᵖ
	ixǁCGSWindowIDᵖ
	ixǁCGSSurfaceIDᵖ
	ixǁCGLGetSurface
	ixǁCGLSetCurrentContext
	ixǁCGSConnectionID
	ixǁCGSConnectionIDˢ
	ixǁF64ᵖ
	ixǁCGSGetSurfaceBounds
	ixǁCGSSurfaceIDˢ
	ixǁCGSWindowIDˢ
	ixǁCharˢ
	ixǁCharᵖ
	ixǁCharᶜᵖ
	ixǁColor
	ixǁGLfloatː2ᵃ
	ixǁGLintː2ᵃ
	ixǁPrecisionFormat
	ixǁShaderPrecisionFormat
	ixǁGLintː3ᵃ
	ixǁConstants
	ixǁContextCreationInfo
	ixǁGLDEBUGPROC
	ixǁVoidᶜᵖ
	ixǁDebugState
	ixǁRect
	ixǁVec2f
	ixǁRasterizationState
	ixǁScissorState
	ixǁStencilState
	ixǁDepthState
	ixǁFragmentOperationsState
	ixǁVec4b
	ixǁFramebufferState
	ixǁVertexAttributeValue
	ixǁTextureUnit
	ixǁImageUnit
	ixǁPixelStorageState
	ixǁMiscellaneousState
	ixǁRenderbuffer
	ixǁImage
	ixǁCubemapLevel
	ixǁTexture
	ixǁDefaultTextureObjects
	ixǁFramebufferAttachment
	ixǁFramebuffer
	ixǁSampler
	ixǁGLcharˢ
	ixǁShader
	ixǁUniform
	ixǁProgram
	ixǁPipeline
	ixǁVertexBufferBinding
	ixǁVertexPointer
	ixǁVertexAttributeArray
	ixǁVertexArray
	ixǁQuery
	ixǁTransformFeedback
	ixǁGLsync
	ixǁSyncObject
	ixǁObjects
	ixǁContext
	ixǁGLenumᵖ
	ixǁU32ᵖ
	ixǁContextInfo
	ixǁDeviceInfo
	ixǁDynamicContextState
	ixǁEGLClientBuffer
	ixǁEGLConfig
	ixǁEGLConfigˢ
	ixǁEGLConfigᵖ
	ixǁEGLContext
	ixǁEGLDisplay
	ixǁEGLImageKHR
	ixǁEGLNativePixmapType
	ixǁEGLNativeWindowType
	ixǁEGLSurface
	ixǁEGLSyncKHR
	ixǁEGLintˢ
	ixǁEGLintᵖ
	ixǁEGLintᶜᵖ
	ixǁERR_CONTEXT_DOES_NOT_EXIST
	ixǁERR_CRITICAL
	ixǁERR_FIELD_DOES_NOT_EXIST
	ixǁERR_FRAMEBUFFER_UNAVAILABLE
	ixǁERR_INCORRECT_MAP_KEY_TYPE
	ixǁERR_INVALID_ENUM_VALUE
	ixǁERR_INVALID_OPERATION
	ixǁERR_INVALID_VALUE
	ixǁERR_MAP_KEY_DOES_NOT_EXIST
	ixǁERR_MESH_NOT_AVAILABLE
	ixǁERR_MESSAGE
	ixǁERR_NIL_POINTER_DEREFERENCE
	ixǁERR_NO_CONTEXT_BOUND
	ixǁERR_NO_TEXTURE_DATA
	ixǁERR_REPLAY_DRIVER
	ixǁERR_SLICE_OUT_OF_BOUNDS
	ixǁERR_STATE_UNAVAILABLE
	ixǁERR_TRACE_ASSERT
	ixǁERR_TYPE_NOT_ARRAY_INDEXABLE
	ixǁERR_TYPE_NOT_MAP_INDEXABLE
	ixǁERR_TYPE_NOT_SLICEABLE
	ixǁERR_UNKNOWN_DEVICE
	ixǁERR_UNSUPPORTED_CONVERSION
	ixǁERR_VALUE_GE_LIMIT
	ixǁERR_VALUE_NEG
	ixǁERR_VALUE_OUT_OF_BOUNDS
	ixǁERR_WRONG_CONTEXT_VERSION
	ixǁEglBindAPI
	ixǁEglBindTexImage
	ixǁEglChooseConfig
	ixǁEglClientWaitSyncKHR
	ixǁEglCopyBuffers
	ixǁEglCreateContext
	ixǁEglCreateImageKHR
	ixǁEglCreatePbufferFromClientBuffer
	ixǁEglCreatePbufferSurface
	ixǁEglCreatePixmapSurface
	ixǁEglCreateSyncKHR
	ixǁEglCreateWindowSurface
	ixǁEglDestroyContext
	ixǁEglDestroyImageKHR
	ixǁEglDestroySurface
	ixǁEglDestroySyncKHR
	ixǁEglGetConfigAttrib
	ixǁEglGetConfigs
	ixǁEglGetCurrentContext
	ixǁEglGetCurrentDisplay
	ixǁEglGetCurrentSurface
	ixǁEglGetDisplay
	ixǁEglGetError
	ixǁEglGetSyncAttribKHR
	ixǁEglInitialize
	ixǁEglMakeCurrent
	ixǁEglQueryAPI
	ixǁEglQueryContext
	ixǁEglQueryString
	ixǁEglQuerySurface
	ixǁEglReleaseTexImage
	ixǁEglReleaseThread
	ixǁEglSignalSyncKHR
	ixǁEglSurfaceAttrib
	ixǁVoidᵖ
	ixǁEglSwapBuffers
	ixǁEglSwapBuffersWithDamageKHR
	ixǁEglSwapInterval
	ixǁEglTerminate
	ixǁEglWaitClient
	ixǁEglWaitGL
	ixǁEglWaitNative
	ixǁErrorState
	ixǁF64ˢ
	ixǁFlushPostBuffer
	ixǁFramebufferIdˢ
	ixǁFramebufferIdᵖ
	ixǁFramebufferIdᶜᵖ
	ixǁGLXContext
	ixǁGLXDrawable
	ixǁGLbooleanː4ᵃ
	ixǁGLbooleanˢ
	ixǁGLbooleanᵖ
	ixǁGLcharᵖ
	ixǁGLcharᶜᵖ
	ixǁGLcharᶜᵖˢ
	ixǁGLcharᶜᵖᵖ
	ixǁGLcharᶜᵖᶜᵖ
	ixǁGLeglImageOES
	ixǁGLenumˢ
	ixǁGLenumᶜᵖ
	ixǁGLfixedˢ
	ixǁGLfixedᵖ
	ixǁGLfixedᶜᵖ
	ixǁGLfloatː1ᵃ
	ixǁGLfloatː3ᵃ
	ixǁGLfloatː4ᵃ
	ixǁGLfloatˢ
	ixǁGLfloatᵖ
	ixǁGLfloatᶜᵖ
	ixǁGLint64ˢ
	ixǁGLint64ᵖ
	ixǁGLintː1ᵃ
	ixǁGLintː4ᵃ
	ixǁGLintˢ
	ixǁGLintᵖ
	ixǁGLintᶜᵖ
	ixǁGLshortˢ
	ixǁGLshortᵖ
	ixǁGLshortᶜᵖ
	ixǁGLsizeiˢ
	ixǁGLsizeiᵖ
	ixǁGLsizeiᶜᵖ
	ixǁGLubyteˢ
	ixǁGLubyteᵖ
	ixǁGLubyteᶜᵖ
	ixǁGLuint64ˢ
	ixǁGLuint64ᵖ
	ixǁGLuint64ᶜᵖ
	ixǁGLuintː2ᵃ
	ixǁGLuintː3ᵃ
	ixǁGLuintː4ᵃ
	ixǁGLuintˢ
	ixǁGLuintᵖ
	ixǁGLuintᶜᵖ
	ixǁGLvoidˢ
	ixǁGLvoidᵖ
	ixǁGlActiveShaderProgram
	ixǁGlActiveShaderProgramEXT
	ixǁGlActiveTexture
	ixǁGlAlphaFunc
	ixǁGlAlphaFuncQCOM
	ixǁGlAlphaFuncx
	ixǁGlAlphaFuncxOES
	ixǁGlApplyFramebufferAttachmentCMAAINTEL
	ixǁGlAttachShader
	ixǁGlBeginConditionalRenderNV
	ixǁGlBeginPerfMonitorAMD
	ixǁGlBeginPerfQueryINTEL
	ixǁGlBeginQuery
	ixǁGlBeginQueryEXT
	ixǁGlBeginTransformFeedback
	ixǁGlBindAttribLocation
	ixǁGlBindBuffer
	ixǁGlBindBufferBase
	ixǁGlBindBufferRange
	ixǁGlBindFragDataLocation
	ixǁGlBindFragDataLocationEXT
	ixǁGlBindFragDataLocationIndexedEXT
	ixǁGlBindFramebuffer
	ixǁGlBindFramebufferOES
	ixǁGlBindImageTexture
	ixǁGlBindProgramPipeline
	ixǁGlBindProgramPipelineEXT
	ixǁGlBindRenderbuffer
	ixǁGlBindRenderbufferOES
	ixǁGlBindSampler
	ixǁGlBindTexture
	ixǁGlBindTransformFeedback
	ixǁGlBindVertexArray
	ixǁGlBindVertexArrayOES
	ixǁGlBindVertexBuffer
	ixǁGlBlendBarrier
	ixǁGlBlendBarrierKHR
	ixǁGlBlendBarrierNV
	ixǁGlBlendColor
	ixǁGlBlendEquation
	ixǁGlBlendEquationOES
	ixǁGlBlendEquationSeparate
	ixǁGlBlendEquationSeparateOES
	ixǁGlBlendEquationSeparatei
	ixǁGlBlendEquationSeparateiEXT
	ixǁGlBlendEquationSeparateiOES
	ixǁGlBlendEquationi
	ixǁGlBlendEquationiEXT
	ixǁGlBlendEquationiOES
	ixǁGlBlendFunc
	ixǁGlBlendFuncSeparate
	ixǁGlBlendFuncSeparateOES
	ixǁGlBlendFuncSeparatei
	ixǁGlBlendFuncSeparateiEXT
	ixǁGlBlendFuncSeparateiOES
	ixǁGlBlendFunci
	ixǁGlBlendFunciEXT
	ixǁGlBlendFunciOES
	ixǁGlBlendParameteriNV
	ixǁGlBlitFramebuffer
	ixǁGlBlitFramebufferANGLE
	ixǁGlBlitFramebufferNV
	ixǁGlBufferData
	ixǁGlBufferStorageEXT
	ixǁGlBufferSubData
	ixǁGlCheckFramebufferStatus
	ixǁGlCheckFramebufferStatusOES
	ixǁGlClear
	ixǁGlClearBufferfi
	ixǁGlClearBufferfv
	ixǁGlClearBufferiv
	ixǁGlClearBufferuiv
	ixǁGlClearColor
	ixǁGlClearColorx
	ixǁGlClearColorxOES
	ixǁGlClearDepthf
	ixǁGlClearDepthfOES
	ixǁGlClearDepthx
	ixǁGlClearDepthxOES
	ixǁGlClearStencil
	ixǁGlClientActiveTexture
	ixǁGlClientWaitSync
	ixǁGlClientWaitSyncAPPLE
	ixǁGlClipPlanef
	ixǁGlClipPlanefIMG
	ixǁGlClipPlanefOES
	ixǁGlClipPlanex
	ixǁGlClipPlanexIMG
	ixǁGlClipPlanexOES
	ixǁGlColor4f
	ixǁGlColor4ub
	ixǁGlColor4x
	ixǁGlColor4xOES
	ixǁGlColorMask
	ixǁGlColorMaski
	ixǁGlColorMaskiEXT
	ixǁGlColorMaskiOES
	ixǁGlColorPointer
	ixǁGlColorPointerBounds
	ixǁGlCompileShader
	ixǁTexturePointer
	ixǁGlCompressedTexImage2D
	ixǁGlCompressedTexImage3D
	ixǁGlCompressedTexImage3DOES
	ixǁGlCompressedTexSubImage2D
	ixǁGlCompressedTexSubImage3D
	ixǁGlCompressedTexSubImage3DOES
	ixǁGlCopyBufferSubData
	ixǁGlCopyBufferSubDataNV
	ixǁGlCopyImageSubData
	ixǁGlCopyImageSubDataEXT
	ixǁGlCopyImageSubDataOES
	ixǁGlCopyPathNV
	ixǁGlCopyTexImage2D
	ixǁGlCopyTexSubImage2D
	ixǁGlCopyTexSubImage3D
	ixǁGlCopyTexSubImage3DOES
	ixǁGlCopyTextureLevelsAPPLE
	ixǁGlCoverFillPathInstancedNV
	ixǁGlCoverFillPathNV
	ixǁGlCoverStrokePathInstancedNV
	ixǁGlCoverStrokePathNV
	ixǁGlCoverageMaskNV
	ixǁGlCoverageModulationNV
	ixǁGlCoverageModulationTableNV
	ixǁGlCoverageOperationNV
	ixǁGlCreatePerfQueryINTEL
	ixǁGlCreateProgram
	ixǁGlCreateShader
	ixǁGlCreateShaderProgramv
	ixǁGlCreateShaderProgramvEXT
	ixǁGlCullFace
	ixǁGlCurrentPaletteMatrixOES
	ixǁGlDebugMessageCallback
	ixǁGlDebugMessageCallbackKHR
	ixǁGlDebugMessageControl
	ixǁGlDebugMessageControlKHR
	ixǁGlDebugMessageInsert
	ixǁGlDebugMessageInsertKHR
	ixǁGlDeleteBuffers
	ixǁGlDeleteFencesNV
	ixǁGlDeleteFramebuffers
	ixǁGlDeleteFramebuffersOES
	ixǁGlDeletePathsNV
	ixǁGlDeletePerfMonitorsAMD
	ixǁGlDeletePerfQueryINTEL
	ixǁGlDeleteProgram
	ixǁPipelineIdᶜᵖ
	ixǁGlDeleteProgramPipelines
	ixǁGlDeleteProgramPipelinesEXT
	ixǁQueryIdᶜᵖ
	ixǁGlDeleteQueries
	ixǁGlDeleteQueriesEXT
	ixǁRenderbufferIdᶜᵖ
	ixǁGlDeleteRenderbuffers
	ixǁGlDeleteRenderbuffersOES
	ixǁSamplerIdᶜᵖ
	ixǁGlDeleteSamplers
	ixǁGlDeleteShader
	ixǁGlDeleteSync
	ixǁGlDeleteSyncAPPLE
	ixǁTextureIdᶜᵖ
	ixǁGlDeleteTextures
	ixǁTransformFeedbackIdᶜᵖ
	ixǁGlDeleteTransformFeedbacks
	ixǁVertexArrayIdᶜᵖ
	ixǁGlDeleteVertexArrays
	ixǁGlDeleteVertexArraysOES
	ixǁGlDepthFunc
	ixǁGlDepthMask
	ixǁGlDepthRangeArrayfvNV
	ixǁGlDepthRangeIndexedfNV
	ixǁGlDepthRangef
	ixǁGlDepthRangefOES
	ixǁGlDepthRangex
	ixǁGlDepthRangexOES
	ixǁGlDetachShader
	ixǁGlDisable
	ixǁGlDisableClientState
	ixǁGlDisableDriverControlQCOM
	ixǁGlDisableVertexAttribArray
	ixǁGlDisablei
	ixǁGlDisableiEXT
	ixǁGlDisableiNV
	ixǁGlDisableiOES
	ixǁGlDiscardFramebufferEXT
	ixǁGlDispatchCompute
	ixǁGlDispatchComputeIndirect
	ixǁGlDrawArrays
	ixǁGlDrawArraysIndirect
	ixǁGlDrawArraysInstanced
	ixǁGlDrawArraysInstancedANGLE
	ixǁGlDrawArraysInstancedBaseInstanceEXT
	ixǁGlDrawArraysInstancedEXT
	ixǁGlDrawArraysInstancedNV
	ixǁGlDrawBuffers
	ixǁGlDrawBuffersEXT
	ixǁGlDrawBuffersIndexedEXT
	ixǁGlDrawBuffersNV
	ixǁIndicesPointer
	ixǁGlDrawElements
	ixǁGlDrawElementsBaseVertex
	ixǁGlDrawElementsBaseVertexEXT
	ixǁGlDrawElementsBaseVertexOES
	ixǁGlDrawElementsIndirect
	ixǁGlDrawElementsInstanced
	ixǁGlDrawElementsInstancedANGLE
	ixǁGlDrawElementsInstancedBaseInstanceEXT
	ixǁGlDrawElementsInstancedBaseVertex
	ixǁGlDrawElementsInstancedBaseVertexBaseInstanceEXT
	ixǁGlDrawElementsInstancedBaseVertexEXT
	ixǁGlDrawElementsInstancedBaseVertexOES
	ixǁGlDrawElementsInstancedEXT
	ixǁGlDrawElementsInstancedNV
	ixǁGlDrawRangeElements
	ixǁGlDrawRangeElementsBaseVertex
	ixǁGlDrawRangeElementsBaseVertexEXT
	ixǁGlDrawRangeElementsBaseVertexOES
	ixǁGlDrawTexfOES
	ixǁGlDrawTexfvOES
	ixǁGlDrawTexiOES
	ixǁGlDrawTexivOES
	ixǁGlDrawTexsOES
	ixǁGlDrawTexsvOES
	ixǁGlDrawTexxOES
	ixǁGlDrawTexxvOES
	ixǁGlEGLImageTargetRenderbufferStorageOES
	ixǁGlEGLImageTargetTexture2DOES
	ixǁGlEnable
	ixǁGlEnableClientState
	ixǁGlEnableDriverControlQCOM
	ixǁGlEnableVertexAttribArray
	ixǁGlEnablei
	ixǁGlEnableiEXT
	ixǁGlEnableiNV
	ixǁGlEnableiOES
	ixǁGlEndConditionalRenderNV
	ixǁGlEndPerfMonitorAMD
	ixǁGlEndPerfQueryINTEL
	ixǁGlEndQuery
	ixǁGlEndQueryEXT
	ixǁGlEndTilingQCOM
	ixǁGlEndTransformFeedback
	ixǁVoidᵖᵖ
	ixǁGlExtGetBufferPointervQCOM
	ixǁGlExtGetBuffersQCOM
	ixǁGlExtGetFramebuffersQCOM
	ixǁGlExtGetProgramBinarySourceQCOM
	ixǁProgramIdᵖ
	ixǁGlExtGetProgramsQCOM
	ixǁRenderbufferIdᵖ
	ixǁGlExtGetRenderbuffersQCOM
	ixǁShaderIdᵖ
	ixǁGlExtGetShadersQCOM
	ixǁGlExtGetTexLevelParameterivQCOM
	ixǁGlExtGetTexSubImageQCOM
	ixǁTextureIdᵖ
	ixǁGlExtGetTexturesQCOM
	ixǁGlExtIsProgramBinaryQCOM
	ixǁGlExtTexObjectStateOverrideiQCOM
	ixǁGlFenceSync
	ixǁGlFenceSyncAPPLE
	ixǁGlFinish
	ixǁGlFinishFenceNV
	ixǁGlFlush
	ixǁGlFlushMappedBufferRange
	ixǁGlFlushMappedBufferRangeEXT
	ixǁGlFogf
	ixǁGlFogfv
	ixǁGlFogx
	ixǁGlFogxOES
	ixǁGlFogxv
	ixǁGlFogxvOES
	ixǁGlFragmentCoverageColorNV
	ixǁGlFramebufferParameteri
	ixǁGlFramebufferRenderbuffer
	ixǁGlFramebufferRenderbufferOES
	ixǁGlFramebufferSampleLocationsfvNV
	ixǁGlFramebufferTexture
	ixǁGlFramebufferTexture2D
	ixǁGlFramebufferTexture2DMultisampleEXT
	ixǁGlFramebufferTexture2DMultisampleIMG
	ixǁGlFramebufferTexture2DOES
	ixǁGlFramebufferTexture3DOES
	ixǁGlFramebufferTextureEXT
	ixǁGlFramebufferTextureLayer
	ixǁGlFramebufferTextureMultiviewOVR
	ixǁGlFramebufferTextureOES
	ixǁGlFrontFace
	ixǁGlFrustumf
	ixǁGlFrustumfOES
	ixǁGlFrustumx
	ixǁGlFrustumxOES
	ixǁGlGenBuffers
	ixǁGlGenFencesNV
	ixǁGlGenFramebuffers
	ixǁGlGenFramebuffersOES
	ixǁGlGenPathsNV
	ixǁGlGenPerfMonitorsAMD
	ixǁPipelineIdᵖ
	ixǁGlGenProgramPipelines
	ixǁGlGenProgramPipelinesEXT
	ixǁQueryIdᵖ
	ixǁGlGenQueries
	ixǁGlGenQueriesEXT
	ixǁGlGenRenderbuffers
	ixǁGlGenRenderbuffersOES
	ixǁSamplerIdᵖ
	ixǁGlGenSamplers
	ixǁGlGenTextures
	ixǁTransformFeedbackIdᵖ
	ixǁGlGenTransformFeedbacks
	ixǁVertexArrayIdᵖ
	ixǁGlGenVertexArrays
	ixǁGlGenVertexArraysOES
	ixǁGlGenerateMipmap
	ixǁGlGenerateMipmapOES
	ixǁGlGetActiveAttrib
	ixǁGlGetActiveUniform
	ixǁGlGetActiveUniformBlockName
	ixǁGlGetActiveUniformBlockiv
	ixǁUniformIndexᶜᵖ
	ixǁGlGetActiveUniformsiv
	ixǁGlGetAttachedShaders
	ixǁGlGetAttribLocation
	ixǁGlGetBooleani_v
	ixǁGlGetBooleanv
	ixǁGlGetBufferParameteri64v
	ixǁGlGetBufferParameteriv
	ixǁGlGetBufferPointerv
	ixǁGlGetBufferPointervOES
	ixǁGlGetClipPlanef
	ixǁGlGetClipPlanefOES
	ixǁGlGetClipPlanex
	ixǁGlGetClipPlanexOES
	ixǁGlGetCoverageModulationTableNV
	ixǁGlGetDebugMessageLog
	ixǁGlGetDebugMessageLogKHR
	ixǁGlGetDriverControlStringQCOM
	ixǁGlGetDriverControlsQCOM
	ixǁGlGetError
	ixǁGlGetFenceivNV
	ixǁGlGetFirstPerfQueryIdINTEL
	ixǁGlGetFixedv
	ixǁGlGetFixedvOES
	ixǁGlGetFloati_vNV
	ixǁGlGetFloatv
	ixǁGlGetFragDataIndexEXT
	ixǁGlGetFragDataLocation
	ixǁGlGetFramebufferAttachmentParameteriv
	ixǁGlGetFramebufferAttachmentParameterivOES
	ixǁGlGetFramebufferParameteriv
	ixǁGlGetGraphicsResetStatus
	ixǁGlGetGraphicsResetStatusEXT
	ixǁGlGetGraphicsResetStatusKHR
	ixǁGlGetImageHandleNV
	ixǁGlGetInteger64i_v
	ixǁGlGetInteger64v
	ixǁGlGetInteger64vAPPLE
	ixǁGlGetIntegeri_v
	ixǁGlGetIntegeri_vEXT
	ixǁGlGetIntegerv
	ixǁGlGetInternalformatSampleivNV
	ixǁGlGetInternalformativ
	ixǁGlGetLightfv
	ixǁGlGetLightxv
	ixǁGlGetLightxvOES
	ixǁGlGetMaterialfv
	ixǁGlGetMaterialxv
	ixǁGlGetMaterialxvOES
	ixǁGlGetMultisamplefv
	ixǁGlGetNextPerfQueryIdINTEL
	ixǁGlGetObjectLabel
	ixǁGlGetObjectLabelEXT
	ixǁGlGetObjectLabelKHR
	ixǁGlGetObjectPtrLabel
	ixǁGlGetObjectPtrLabelKHR
	ixǁGlGetPathCommandsNV
	ixǁGlGetPathCoordsNV
	ixǁGlGetPathDashArrayNV
	ixǁGlGetPathLengthNV
	ixǁGlGetPathMetricRangeNV
	ixǁGlGetPathMetricsNV
	ixǁGlGetPathParameterfvNV
	ixǁGlGetPathParameterivNV
	ixǁGlGetPathSpacingNV
	ixǁGlGetPerfCounterInfoINTEL
	ixǁGlGetPerfMonitorCounterDataAMD
	ixǁGlGetPerfMonitorCounterInfoAMD
	ixǁGlGetPerfMonitorCounterStringAMD
	ixǁGlGetPerfMonitorCountersAMD
	ixǁGlGetPerfMonitorGroupStringAMD
	ixǁGlGetPerfMonitorGroupsAMD
	ixǁGlGetPerfQueryDataINTEL
	ixǁGlGetPerfQueryIdByNameINTEL
	ixǁGlGetPerfQueryInfoINTEL
	ixǁGlGetPointerv
	ixǁGlGetPointervKHR
	ixǁGlGetProgramBinary
	ixǁGlGetProgramBinaryOES
	ixǁGlGetProgramInfoLog
	ixǁGlGetProgramInterfaceiv
	ixǁGlGetProgramPipelineInfoLog
	ixǁGlGetProgramPipelineInfoLogEXT
	ixǁGlGetProgramPipelineiv
	ixǁGlGetProgramPipelineivEXT
	ixǁGlGetProgramResourceIndex
	ixǁGlGetProgramResourceLocation
	ixǁGlGetProgramResourceLocationIndexEXT
	ixǁGlGetProgramResourceName
	ixǁGlGetProgramResourcefvNV
	ixǁGlGetProgramResourceiv
	ixǁGlGetProgramiv
	ixǁS64ᵖ
	ixǁGlGetQueryObjecti64v
	ixǁGlGetQueryObjecti64vEXT
	ixǁGlGetQueryObjectivEXT
	ixǁU64ᵖ
	ixǁGlGetQueryObjectui64v
	ixǁGlGetQueryObjectui64vEXT
	ixǁGlGetQueryObjectuiv
	ixǁGlGetQueryObjectuivEXT
	ixǁGlGetQueryiv
	ixǁGlGetQueryivEXT
	ixǁGlGetRenderbufferParameteriv
	ixǁGlGetRenderbufferParameterivOES
	ixǁGlGetSamplerParameterIiv
	ixǁGlGetSamplerParameterIivEXT
	ixǁGlGetSamplerParameterIivOES
	ixǁGlGetSamplerParameterIuiv
	ixǁGlGetSamplerParameterIuivEXT
	ixǁGlGetSamplerParameterIuivOES
	ixǁGlGetSamplerParameterfv
	ixǁGlGetSamplerParameteriv
	ixǁGlGetShaderInfoLog
	ixǁGlGetShaderPrecisionFormat
	ixǁGlGetShaderSource
	ixǁGlGetShaderiv
	ixǁGlGetString
	ixǁGlGetStringi
	ixǁGlGetSynciv
	ixǁGlGetSyncivAPPLE
	ixǁGlGetTexEnvfv
	ixǁGlGetTexEnviv
	ixǁGlGetTexEnvxv
	ixǁGlGetTexEnvxvOES
	ixǁGlGetTexGenfvOES
	ixǁGlGetTexGenivOES
	ixǁGlGetTexGenxvOES
	ixǁGlGetTexLevelParameterfv
	ixǁGlGetTexLevelParameteriv
	ixǁGlGetTexParameterIiv
	ixǁGlGetTexParameterIivEXT
	ixǁGlGetTexParameterIivOES
	ixǁGlGetTexParameterIuiv
	ixǁGlGetTexParameterIuivEXT
	ixǁGlGetTexParameterIuivOES
	ixǁGlGetTexParameterfv
	ixǁGlGetTexParameteriv
	ixǁGlGetTexParameterxv
	ixǁGlGetTexParameterxvOES
	ixǁGlGetTextureHandleNV
	ixǁGlGetTextureSamplerHandleNV
	ixǁGlGetTransformFeedbackVarying
	ixǁGlGetTranslatedShaderSourceANGLE
	ixǁGlGetUniformBlockIndex
	ixǁUniformIndexᵖ
	ixǁGlGetUniformIndices
	ixǁGlGetUniformLocation
	ixǁGlGetUniformfv
	ixǁGlGetUniformiv
	ixǁGlGetUniformuiv
	ixǁGlGetVertexAttribIiv
	ixǁGlGetVertexAttribIuiv
	ixǁGlGetVertexAttribPointerv
	ixǁGlGetVertexAttribfv
	ixǁGlGetVertexAttribiv
	ixǁGlGetnUniformfv
	ixǁGlGetnUniformfvEXT
	ixǁGlGetnUniformfvKHR
	ixǁGlGetnUniformiv
	ixǁGlGetnUniformivEXT
	ixǁGlGetnUniformivKHR
	ixǁGlGetnUniformuiv
	ixǁGlGetnUniformuivKHR
	ixǁGlHint
	ixǁGlInsertEventMarkerEXT
	ixǁGlInterpolatePathsNV
	ixǁGlInvalidateFramebuffer
	ixǁGlInvalidateSubFramebuffer
	ixǁGlIsBuffer
	ixǁGlIsEnabled
	ixǁGlIsEnabledi
	ixǁGlIsEnablediEXT
	ixǁGlIsEnablediNV
	ixǁGlIsEnablediOES
	ixǁGlIsFenceNV
	ixǁGlIsFramebuffer
	ixǁGlIsFramebufferOES
	ixǁGlIsImageHandleResidentNV
	ixǁGlIsPathNV
	ixǁGlIsPointInFillPathNV
	ixǁGlIsPointInStrokePathNV
	ixǁGlIsProgram
	ixǁGlIsProgramPipeline
	ixǁGlIsProgramPipelineEXT
	ixǁGlIsQuery
	ixǁGlIsQueryEXT
	ixǁGlIsRenderbuffer
	ixǁGlIsRenderbufferOES
	ixǁGlIsSampler
	ixǁGlIsShader
	ixǁGlIsSync
	ixǁGlIsSyncAPPLE
	ixǁGlIsTexture
	ixǁGlIsTextureHandleResidentNV
	ixǁGlIsTransformFeedback
	ixǁGlIsVertexArray
	ixǁGlIsVertexArrayOES
	ixǁGlLabelObjectEXT
	ixǁGlLightModelf
	ixǁGlLightModelfv
	ixǁGlLightModelx
	ixǁGlLightModelxOES
	ixǁGlLightModelxv
	ixǁGlLightModelxvOES
	ixǁGlLightf
	ixǁGlLightfv
	ixǁGlLightx
	ixǁGlLightxOES
	ixǁGlLightxv
	ixǁGlLightxvOES
	ixǁGlLineWidth
	ixǁGlLineWidthx
	ixǁGlLineWidthxOES
	ixǁGlLinkProgram
	ixǁGlLoadIdentity
	ixǁGlLoadMatrixf
	ixǁGlLoadMatrixx
	ixǁGlLoadMatrixxOES
	ixǁGlLoadPaletteFromModelViewMatrixOES
	ixǁGlLogicOp
	ixǁGlMakeImageHandleNonResidentNV
	ixǁGlMakeImageHandleResidentNV
	ixǁGlMakeTextureHandleNonResidentNV
	ixǁGlMakeTextureHandleResidentNV
	ixǁGlMapBuffer
	ixǁGlMapBufferOES
	ixǁGlMapBufferRange
	ixǁGlMapBufferRangeEXT
	ixǁGlMaterialf
	ixǁGlMaterialfv
	ixǁGlMaterialx
	ixǁGlMaterialxOES
	ixǁGlMaterialxv
	ixǁGlMaterialxvOES
	ixǁGlMatrixIndexPointerOES
	ixǁGlMatrixIndexPointerOESBounds
	ixǁGlMatrixLoad3x2fNV
	ixǁGlMatrixLoad3x3fNV
	ixǁGlMatrixLoadTranspose3x3fNV
	ixǁGlMatrixMode
	ixǁGlMatrixMult3x2fNV
	ixǁGlMatrixMult3x3fNV
	ixǁGlMatrixMultTranspose3x3fNV
	ixǁGlMemoryBarrier
	ixǁGlMemoryBarrierByRegion
	ixǁGlMinSampleShading
	ixǁGlMinSampleShadingOES
	ixǁGlMultMatrixf
	ixǁGlMultMatrixx
	ixǁGlMultMatrixxOES
	ixǁGlMultiDrawArraysEXT
	ixǁGlMultiDrawArraysIndirectEXT
	ixǁVoidᶜᵖᶜᵖ
	ixǁGlMultiDrawElementsBaseVertexEXT
	ixǁGlMultiDrawElementsBaseVertexOES
	ixǁGlMultiDrawElementsEXT
	ixǁGlMultiDrawElementsIndirectEXT
	ixǁGlMultiTexCoord4f
	ixǁGlMultiTexCoord4x
	ixǁGlMultiTexCoord4xOES
	ixǁGlNamedFramebufferSampleLocationsfvNV
	ixǁGlNormal3f
	ixǁGlNormal3x
	ixǁGlNormal3xOES
	ixǁGlNormalPointer
	ixǁGlNormalPointerBounds
	ixǁGlObjectLabel
	ixǁGlObjectLabelKHR
	ixǁGlObjectPtrLabel
	ixǁGlObjectPtrLabelKHR
	ixǁGlOrthof
	ixǁGlOrthofOES
	ixǁGlOrthox
	ixǁGlOrthoxOES
	ixǁGlPatchParameteri
	ixǁGlPatchParameteriEXT
	ixǁGlPatchParameteriOES
	ixǁGlPathCommandsNV
	ixǁGlPathCoordsNV
	ixǁGlPathCoverDepthFuncNV
	ixǁGlPathDashArrayNV
	ixǁGlPathGlyphIndexArrayNV
	ixǁGlPathGlyphIndexRangeNV
	ixǁGlPathGlyphRangeNV
	ixǁGlPathGlyphsNV
	ixǁGlPathMemoryGlyphIndexArrayNV
	ixǁGlPathParameterfNV
	ixǁGlPathParameterfvNV
	ixǁGlPathParameteriNV
	ixǁGlPathParameterivNV
	ixǁGlPathStencilDepthOffsetNV
	ixǁGlPathStencilFuncNV
	ixǁGlPathStringNV
	ixǁGlPathSubCommandsNV
	ixǁGlPathSubCoordsNV
	ixǁGlPauseTransformFeedback
	ixǁGlPixelStorei
	ixǁGlPointAlongPathNV
	ixǁGlPointParameterf
	ixǁGlPointParameterfv
	ixǁGlPointParameterx
	ixǁGlPointParameterxOES
	ixǁGlPointParameterxv
	ixǁGlPointParameterxvOES
	ixǁGlPointSize
	ixǁGlPointSizePointerOES
	ixǁGlPointSizePointerOESBounds
	ixǁGlPointSizex
	ixǁGlPointSizexOES
	ixǁGlPolygonModeNV
	ixǁGlPolygonOffset
	ixǁGlPolygonOffsetx
	ixǁGlPolygonOffsetxOES
	ixǁGlPopDebugGroup
	ixǁGlPopDebugGroupKHR
	ixǁGlPopGroupMarkerEXT
	ixǁGlPopMatrix
	ixǁGlPrimitiveBoundingBox
	ixǁGlPrimitiveBoundingBoxEXT
	ixǁGlPrimitiveBoundingBoxOES
	ixǁGlProgramBinary
	ixǁGlProgramBinaryOES
	ixǁGlProgramParameteri
	ixǁGlProgramParameteriEXT
	ixǁGlProgramPathFragmentInputGenNV
	ixǁGlProgramUniform1f
	ixǁGlProgramUniform1fEXT
	ixǁGlProgramUniform1fv
	ixǁGlProgramUniform1fvEXT
	ixǁGlProgramUniform1i
	ixǁGlProgramUniform1iEXT
	ixǁGlProgramUniform1iv
	ixǁGlProgramUniform1ivEXT
	ixǁGlProgramUniform1ui
	ixǁGlProgramUniform1uiEXT
	ixǁGlProgramUniform1uiv
	ixǁGlProgramUniform1uivEXT
	ixǁGlProgramUniform2f
	ixǁGlProgramUniform2fEXT
	ixǁGlProgramUniform2fv
	ixǁGlProgramUniform2fvEXT
	ixǁGlProgramUniform2i
	ixǁGlProgramUniform2iEXT
	ixǁGlProgramUniform2iv
	ixǁGlProgramUniform2ivEXT
	ixǁGlProgramUniform2ui
	ixǁGlProgramUniform2uiEXT
	ixǁGlProgramUniform2uiv
	ixǁGlProgramUniform2uivEXT
	ixǁGlProgramUniform3f
	ixǁGlProgramUniform3fEXT
	ixǁGlProgramUniform3fv
	ixǁGlProgramUniform3fvEXT
	ixǁGlProgramUniform3i
	ixǁGlProgramUniform3iEXT
	ixǁGlProgramUniform3iv
	ixǁGlProgramUniform3ivEXT
	ixǁGlProgramUniform3ui
	ixǁGlProgramUniform3uiEXT
	ixǁGlProgramUniform3uiv
	ixǁGlProgramUniform3uivEXT
	ixǁGlProgramUniform4f
	ixǁGlProgramUniform4fEXT
	ixǁGlProgramUniform4fv
	ixǁGlProgramUniform4fvEXT
	ixǁGlProgramUniform4i
	ixǁGlProgramUniform4iEXT
	ixǁGlProgramUniform4iv
	ixǁGlProgramUniform4ivEXT
	ixǁGlProgramUniform4ui
	ixǁGlProgramUniform4uiEXT
	ixǁGlProgramUniform4uiv
	ixǁGlProgramUniform4uivEXT
	ixǁGlProgramUniformHandleui64NV
	ixǁGlProgramUniformHandleui64vNV
	ixǁGlProgramUniformMatrix2fv
	ixǁGlProgramUniformMatrix2fvEXT
	ixǁGlProgramUniformMatrix2x3fv
	ixǁGlProgramUniformMatrix2x3fvEXT
	ixǁGlProgramUniformMatrix2x4fv
	ixǁGlProgramUniformMatrix2x4fvEXT
	ixǁGlProgramUniformMatrix3fv
	ixǁGlProgramUniformMatrix3fvEXT
	ixǁGlProgramUniformMatrix3x2fv
	ixǁGlProgramUniformMatrix3x2fvEXT
	ixǁGlProgramUniformMatrix3x4fv
	ixǁGlProgramUniformMatrix3x4fvEXT
	ixǁGlProgramUniformMatrix4fv
	ixǁGlProgramUniformMatrix4fvEXT
	ixǁGlProgramUniformMatrix4x2fv
	ixǁGlProgramUniformMatrix4x2fvEXT
	ixǁGlProgramUniformMatrix4x3fv
	ixǁGlProgramUniformMatrix4x3fvEXT
	ixǁGlPushDebugGroup
	ixǁGlPushDebugGroupKHR
	ixǁGlPushGroupMarkerEXT
	ixǁGlPushMatrix
	ixǁGlQueryCounterEXT
	ixǁGlQueryMatrixxOES
	ixǁGlRasterSamplesEXT
	ixǁGlReadBuffer
	ixǁGlReadBufferIndexedEXT
	ixǁGlReadBufferNV
	ixǁGlReadPixels
	ixǁGlReadnPixels
	ixǁGlReadnPixelsEXT
	ixǁGlReadnPixelsKHR
	ixǁGlReleaseShaderCompiler
	ixǁGlRenderbufferStorage
	ixǁGlRenderbufferStorageMultisample
	ixǁGlRenderbufferStorageMultisampleANGLE
	ixǁGlRenderbufferStorageMultisampleAPPLE
	ixǁGlRenderbufferStorageMultisampleEXT
	ixǁGlRenderbufferStorageMultisampleIMG
	ixǁGlRenderbufferStorageMultisampleNV
	ixǁGlRenderbufferStorageOES
	ixǁGlResolveDepthValuesNV
	ixǁGlResolveMultisampleFramebufferAPPLE
	ixǁGlResumeTransformFeedback
	ixǁGlRotatef
	ixǁGlRotatex
	ixǁGlRotatexOES
	ixǁGlSampleCoverage
	ixǁGlSampleCoveragex
	ixǁGlSampleCoveragexOES
	ixǁGlSampleMaski
	ixǁGlSamplerParameterIiv
	ixǁGlSamplerParameterIivEXT
	ixǁGlSamplerParameterIivOES
	ixǁGlSamplerParameterIuiv
	ixǁGlSamplerParameterIuivEXT
	ixǁGlSamplerParameterIuivOES
	ixǁGlSamplerParameterf
	ixǁGlSamplerParameterfv
	ixǁGlSamplerParameteri
	ixǁGlSamplerParameteriv
	ixǁGlScalef
	ixǁGlScalex
	ixǁGlScalexOES
	ixǁGlScissor
	ixǁGlScissorArrayvNV
	ixǁGlScissorIndexedNV
	ixǁGlScissorIndexedvNV
	ixǁGlSelectPerfMonitorCountersAMD
	ixǁGlSetFenceNV
	ixǁGlShadeModel
	ixǁShaderIdᶜᵖ
	ixǁGlShaderBinary
	ixǁGlShaderSource
	ixǁGlStartTilingQCOM
	ixǁGlStencilFillPathInstancedNV
	ixǁGlStencilFillPathNV
	ixǁGlStencilFunc
	ixǁGlStencilFuncSeparate
	ixǁGlStencilMask
	ixǁGlStencilMaskSeparate
	ixǁGlStencilOp
	ixǁGlStencilOpSeparate
	ixǁGlStencilStrokePathInstancedNV
	ixǁGlStencilStrokePathNV
	ixǁGlStencilThenCoverFillPathInstancedNV
	ixǁGlStencilThenCoverFillPathNV
	ixǁGlStencilThenCoverStrokePathInstancedNV
	ixǁGlStencilThenCoverStrokePathNV
	ixǁGlSubpixelPrecisionBiasNV
	ixǁGlTestFenceNV
	ixǁGlTexBuffer
	ixǁGlTexBufferEXT
	ixǁGlTexBufferOES
	ixǁGlTexBufferRange
	ixǁGlTexBufferRangeEXT
	ixǁGlTexBufferRangeOES
	ixǁGlTexCoordPointer
	ixǁGlTexCoordPointerBounds
	ixǁGlTexEnvf
	ixǁGlTexEnvfv
	ixǁGlTexEnvi
	ixǁGlTexEnviv
	ixǁGlTexEnvx
	ixǁGlTexEnvxOES
	ixǁGlTexEnvxv
	ixǁGlTexEnvxvOES
	ixǁGlTexGenfOES
	ixǁGlTexGenfvOES
	ixǁGlTexGeniOES
	ixǁGlTexGenivOES
	ixǁGlTexGenxOES
	ixǁGlTexGenxvOES
	ixǁGlTexImage2D
	ixǁGlTexImage3D
	ixǁGlTexImage3DOES
	ixǁGlTexPageCommitmentEXT
	ixǁGlTexParameterIiv
	ixǁGlTexParameterIivEXT
	ixǁGlTexParameterIivOES
	ixǁGlTexParameterIuiv
	ixǁGlTexParameterIuivEXT
	ixǁGlTexParameterIuivOES
	ixǁGlTexParameterf
	ixǁGlTexParameterfv
	ixǁGlTexParameteri
	ixǁGlTexParameteriv
	ixǁGlTexParameterx
	ixǁGlTexParameterxOES
	ixǁGlTexParameterxv
	ixǁGlTexParameterxvOES
	ixǁGlTexStorage1D
	ixǁGlTexStorage1DEXT
	ixǁGlTexStorage2D
	ixǁGlTexStorage2DEXT
	ixǁGlTexStorage2DMultisample
	ixǁGlTexStorage3D
	ixǁGlTexStorage3DEXT
	ixǁGlTexStorage3DMultisample
	ixǁGlTexStorage3DMultisampleOES
	ixǁGlTexSubImage2D
	ixǁGlTexSubImage3D
	ixǁGlTexSubImage3DOES
	ixǁGlTextureStorage1DEXT
	ixǁGlTextureStorage2DEXT
	ixǁGlTextureStorage3DEXT
	ixǁGlTextureViewEXT
	ixǁGlTextureViewOES
	ixǁGlTransformFeedbackVaryings
	ixǁGlTransformPathNV
	ixǁGlTranslatef
	ixǁGlTranslatex
	ixǁGlTranslatexOES
	ixǁGlUniform1f
	ixǁGlUniform1fv
	ixǁGlUniform1i
	ixǁGlUniform1iv
	ixǁGlUniform1ui
	ixǁGlUniform1uiv
	ixǁGlUniform2f
	ixǁGlUniform2fv
	ixǁGlUniform2i
	ixǁGlUniform2iv
	ixǁGlUniform2ui
	ixǁGlUniform2uiv
	ixǁGlUniform3f
	ixǁGlUniform3fv
	ixǁGlUniform3i
	ixǁGlUniform3iv
	ixǁGlUniform3ui
	ixǁGlUniform3uiv
	ixǁGlUniform4f
	ixǁGlUniform4fv
	ixǁGlUniform4i
	ixǁGlUniform4iv
	ixǁGlUniform4ui
	ixǁGlUniform4uiv
	ixǁGlUniformBlockBinding
	ixǁGlUniformHandleui64NV
	ixǁGlUniformHandleui64vNV
	ixǁGlUniformMatrix2fv
	ixǁGlUniformMatrix2x3fv
	ixǁGlUniformMatrix2x3fvNV
	ixǁGlUniformMatrix2x4fv
	ixǁGlUniformMatrix2x4fvNV
	ixǁGlUniformMatrix3fv
	ixǁGlUniformMatrix3x2fv
	ixǁGlUniformMatrix3x2fvNV
	ixǁGlUniformMatrix3x4fv
	ixǁGlUniformMatrix3x4fvNV
	ixǁGlUniformMatrix4fv
	ixǁGlUniformMatrix4x2fv
	ixǁGlUniformMatrix4x2fvNV
	ixǁGlUniformMatrix4x3fv
	ixǁGlUniformMatrix4x3fvNV
	ixǁGlUnmapBuffer
	ixǁGlUnmapBufferOES
	ixǁGlUseProgram
	ixǁGlUseProgramStages
	ixǁGlUseProgramStagesEXT
	ixǁGlValidateProgram
	ixǁGlValidateProgramPipeline
	ixǁGlValidateProgramPipelineEXT
	ixǁGlVertexAttrib1f
	ixǁGlVertexAttrib1fv
	ixǁGlVertexAttrib2f
	ixǁGlVertexAttrib2fv
	ixǁGlVertexAttrib3f
	ixǁGlVertexAttrib3fv
	ixǁGlVertexAttrib4f
	ixǁGlVertexAttrib4fv
	ixǁGlVertexAttribBinding
	ixǁGlVertexAttribDivisor
	ixǁGlVertexAttribDivisorANGLE
	ixǁGlVertexAttribDivisorEXT
	ixǁGlVertexAttribDivisorNV
	ixǁGlVertexAttribFormat
	ixǁGlVertexAttribI4i
	ixǁGlVertexAttribI4iv
	ixǁGlVertexAttribI4ui
	ixǁGlVertexAttribI4uiv
	ixǁGlVertexAttribIFormat
	ixǁGlVertexAttribIPointer
	ixǁGlVertexAttribPointer
	ixǁGlVertexBindingDivisor
	ixǁGlVertexPointer
	ixǁGlVertexPointerBounds
	ixǁGlViewport
	ixǁGlViewportArrayvNV
	ixǁGlViewportIndexedfNV
	ixǁGlViewportIndexedfvNV
	ixǁGlWaitSync
	ixǁGlWaitSyncAPPLE
	ixǁGlWeightPathsNV
	ixǁGlWeightPointerOES
	ixǁGlWeightPointerOESBounds
	ixǁGlXCreateContext
	ixǁGlXCreateNewContext
	ixǁGlXMakeContextCurrent
	ixǁGlXMakeCurrent
	ixǁIntᵖ
	ixǁGlXQueryDrawable
	ixǁGlXSwapBuffers
	ixǁHDC
	ixǁHGLRC
	ixǁIntˢ
	ixǁLazyGLSLParseResult
	ixǁMat2f
	ixǁMat2fˢ
	ixǁMat2fᵖ
	ixǁVec3f
	ixǁMat2x3f
	ixǁMat2x3fˢ
	ixǁMat2x3fᵖ
	ixǁMat2x4f
	ixǁMat2x4fˢ
	ixǁMat2x4fᵖ
	ixǁMat3f
	ixǁMat3fˢ
	ixǁMat3fᵖ
	ixǁMat3x2f
	ixǁMat3x2fˢ
	ixǁMat3x2fᵖ
	ixǁMat3x4f
	ixǁMat3x4fˢ
	ixǁMat3x4fᵖ
	ixǁMat4f
	ixǁMat4fˢ
	ixǁMat4fᵖ
	ixǁMat4x2f
	ixǁMat4x2fˢ
	ixǁMat4x2fᵖ
	ixǁMat4x3f
	ixǁMat4x3fˢ
	ixǁMat4x3fᵖ
	ixǁPipelineIdˢ
	ixǁProgramIdˢ
	ixǁProgramInfo
	ixǁQueryIdˢ
	ixǁRenderbufferIdˢ
	ixǁReplayBindRenderer
	ixǁReplayChangeBackbuffer
	ixǁReplayCreateRenderer
	ixǁS64ˢ
	ixǁSamplerIdˢ
	ixǁShaderIdˢ
	ixǁStartTimer
	ixǁState
	ixǁStaticContextState
	ixǁStopTimer
	ixǁTAG_ATOM_NAME
	ixǁTextureIdˢ
	ixǁTransformFeedbackIdˢ
	ixǁU32ˢ
	ixǁU64ˢ
	ixǁUniformIndexˢ
	ixǁVec1f
	ixǁVec1i
	ixǁVec2fː2ᵃ
	ixǁVec2fː3ᵃ
	ixǁVec2fː4ᵃ
	ixǁVec2fˢ
	ixǁVec2fᵖ
	ixǁVec2i
	ixǁVec2iˢ
	ixǁVec2iᵖ
	ixǁVec2u
	ixǁVec2uˢ
	ixǁVec2uᵖ
	ixǁVec3fː2ᵃ
	ixǁVec3fː3ᵃ
	ixǁVec3fː4ᵃ
	ixǁVec3fˢ
	ixǁVec3fᵖ
	ixǁVec3i
	ixǁVec3iˢ
	ixǁVec3iᵖ
	ixǁVec3u
	ixǁVec3uˢ
	ixǁVec3uᵖ
	ixǁVec4fː2ᵃ
	ixǁVec4fː3ᵃ
	ixǁVec4fː4ᵃ
	ixǁVec4fˢ
	ixǁVec4fᵖ
	ixǁVec4i
	ixǁVec4iˢ
	ixǁVec4iᵖ
	ixǁVec4u
	ixǁVec4uˢ
	ixǁVec4uᵖ
	ixǁVertexArrayIdˢ
	ixǁVoidˢ
	ixǁVoidᵖˢ
	ixǁVoidᶜᵖˢ
	ixǁVoidᶜᵖᵖ
	ixǁWARN_UNKNOWN_CONTEXT
	ixǁWglCreateContext
	ixǁWglCreateContextAttribsARB
	ixǁWglMakeCurrent
	ixǁWglSwapBuffers
	ixǁu32Limits
)

var entities [1264]binary.Entity

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.AddClassOf((*ActiveAttribute)(nil))
	Namespace.AddClassOf((*ActiveUniform)(nil))
	Namespace.AddClassOf((*BlendState)(nil))
	Namespace.AddClassOf((*Vec4f)(nil))
	Namespace.AddClassOf((*BoundingBox)(nil))
	Namespace.AddClassOf((*U8ˢ)(nil))
	Namespace.AddClassOf((*U8ᵖ)(nil))
	Namespace.AddClassOf((*Buffer)(nil))
	Namespace.AddClassOf((*BufferBinding)(nil))
	Namespace.AddClassOf((*BufferBindings)(nil))
	Namespace.AddClassOf((*BufferDataPointer)(nil))
	Namespace.AddClassOf((*BufferIdˢ)(nil))
	Namespace.AddClassOf((*BufferIdᵖ)(nil))
	Namespace.AddClassOf((*BufferIdᶜᵖ)(nil))
	Namespace.AddClassOf((*CGLContextObj)(nil))
	Namespace.AddClassOf((*CGLContextObjˢ)(nil))
	Namespace.AddClassOf((*CGLContextObjᵖ)(nil))
	Namespace.AddClassOf((*CGLTexelFormatObj)(nil))
	Namespace.AddClassOf((*CGLCreateContext)(nil))
	Namespace.AddClassOf((*CGLFlushDrawable)(nil))
	Namespace.AddClassOf((*CGSConnectionIDᵖ)(nil))
	Namespace.AddClassOf((*CGSWindowIDᵖ)(nil))
	Namespace.AddClassOf((*CGSSurfaceIDᵖ)(nil))
	Namespace.AddClassOf((*CGLGetSurface)(nil))
	Namespace.AddClassOf((*CGLSetCurrentContext)(nil))
	Namespace.AddClassOf((*CGSConnectionID)(nil))
	Namespace.AddClassOf((*CGSConnectionIDˢ)(nil))
	Namespace.AddClassOf((*F64ᵖ)(nil))
	Namespace.AddClassOf((*CGSGetSurfaceBounds)(nil))
	Namespace.AddClassOf((*CGSSurfaceIDˢ)(nil))
	Namespace.AddClassOf((*CGSWindowIDˢ)(nil))
	Namespace.AddClassOf((*Charˢ)(nil))
	Namespace.AddClassOf((*Charᵖ)(nil))
	Namespace.AddClassOf((*Charᶜᵖ)(nil))
	Namespace.AddClassOf((*Color)(nil))
	Namespace.AddClassOf((*GLfloatː2ᵃ)(nil))
	Namespace.AddClassOf((*GLintː2ᵃ)(nil))
	Namespace.AddClassOf((*PrecisionFormat)(nil))
	Namespace.AddClassOf((*ShaderPrecisionFormat)(nil))
	Namespace.AddClassOf((*GLintː3ᵃ)(nil))
	Namespace.AddClassOf((*Constants)(nil))
	Namespace.AddClassOf((*ContextCreationInfo)(nil))
	Namespace.AddClassOf((*GLDEBUGPROC)(nil))
	Namespace.AddClassOf((*Voidᶜᵖ)(nil))
	Namespace.AddClassOf((*DebugState)(nil))
	Namespace.AddClassOf((*Rect)(nil))
	Namespace.AddClassOf((*Vec2f)(nil))
	Namespace.AddClassOf((*RasterizationState)(nil))
	Namespace.AddClassOf((*ScissorState)(nil))
	Namespace.AddClassOf((*StencilState)(nil))
	Namespace.AddClassOf((*DepthState)(nil))
	Namespace.AddClassOf((*FragmentOperationsState)(nil))
	Namespace.AddClassOf((*Vec4b)(nil))
	Namespace.AddClassOf((*FramebufferState)(nil))
	Namespace.AddClassOf((*VertexAttributeValue)(nil))
	Namespace.AddClassOf((*TextureUnit)(nil))
	Namespace.AddClassOf((*ImageUnit)(nil))
	Namespace.AddClassOf((*PixelStorageState)(nil))
	Namespace.AddClassOf((*MiscellaneousState)(nil))
	Namespace.AddClassOf((*Renderbuffer)(nil))
	Namespace.AddClassOf((*Image)(nil))
	Namespace.AddClassOf((*CubemapLevel)(nil))
	Namespace.AddClassOf((*Texture)(nil))
	Namespace.AddClassOf((*DefaultTextureObjects)(nil))
	Namespace.AddClassOf((*FramebufferAttachment)(nil))
	Namespace.AddClassOf((*Framebuffer)(nil))
	Namespace.AddClassOf((*Sampler)(nil))
	Namespace.AddClassOf((*GLcharˢ)(nil))
	Namespace.AddClassOf((*Shader)(nil))
	Namespace.AddClassOf((*Uniform)(nil))
	Namespace.AddClassOf((*Program)(nil))
	Namespace.AddClassOf((*Pipeline)(nil))
	Namespace.AddClassOf((*VertexBufferBinding)(nil))
	Namespace.AddClassOf((*VertexPointer)(nil))
	Namespace.AddClassOf((*VertexAttributeArray)(nil))
	Namespace.AddClassOf((*VertexArray)(nil))
	Namespace.AddClassOf((*Query)(nil))
	Namespace.AddClassOf((*TransformFeedback)(nil))
	Namespace.AddClassOf((*GLsync)(nil))
	Namespace.AddClassOf((*SyncObject)(nil))
	Namespace.AddClassOf((*Objects)(nil))
	Namespace.AddClassOf((*Context)(nil))
	Namespace.AddClassOf((*GLenumᵖ)(nil))
	Namespace.AddClassOf((*U32ᵖ)(nil))
	Namespace.AddClassOf((*ContextInfo)(nil))
	Namespace.AddClassOf((*DeviceInfo)(nil))
	Namespace.AddClassOf((*DynamicContextState)(nil))
	Namespace.AddClassOf((*EGLClientBuffer)(nil))
	Namespace.AddClassOf((*EGLConfig)(nil))
	Namespace.AddClassOf((*EGLConfigˢ)(nil))
	Namespace.AddClassOf((*EGLConfigᵖ)(nil))
	Namespace.AddClassOf((*EGLContext)(nil))
	Namespace.AddClassOf((*EGLDisplay)(nil))
	Namespace.AddClassOf((*EGLImageKHR)(nil))
	Namespace.AddClassOf((*EGLNativePixmapType)(nil))
	Namespace.AddClassOf((*EGLNativeWindowType)(nil))
	Namespace.AddClassOf((*EGLSurface)(nil))
	Namespace.AddClassOf((*EGLSyncKHR)(nil))
	Namespace.AddClassOf((*EGLintˢ)(nil))
	Namespace.AddClassOf((*EGLintᵖ)(nil))
	Namespace.AddClassOf((*EGLintᶜᵖ)(nil))
	Namespace.AddClassOf((*ERR_CONTEXT_DOES_NOT_EXIST)(nil))
	Namespace.AddClassOf((*ERR_CRITICAL)(nil))
	Namespace.AddClassOf((*ERR_FIELD_DOES_NOT_EXIST)(nil))
	Namespace.AddClassOf((*ERR_FRAMEBUFFER_UNAVAILABLE)(nil))
	Namespace.AddClassOf((*ERR_INCORRECT_MAP_KEY_TYPE)(nil))
	Namespace.AddClassOf((*ERR_INVALID_ENUM_VALUE)(nil))
	Namespace.AddClassOf((*ERR_INVALID_OPERATION)(nil))
	Namespace.AddClassOf((*ERR_INVALID_VALUE)(nil))
	Namespace.AddClassOf((*ERR_MAP_KEY_DOES_NOT_EXIST)(nil))
	Namespace.AddClassOf((*ERR_MESH_NOT_AVAILABLE)(nil))
	Namespace.AddClassOf((*ERR_MESSAGE)(nil))
	Namespace.AddClassOf((*ERR_NIL_POINTER_DEREFERENCE)(nil))
	Namespace.AddClassOf((*ERR_NO_CONTEXT_BOUND)(nil))
	Namespace.AddClassOf((*ERR_NO_TEXTURE_DATA)(nil))
	Namespace.AddClassOf((*ERR_REPLAY_DRIVER)(nil))
	Namespace.AddClassOf((*ERR_SLICE_OUT_OF_BOUNDS)(nil))
	Namespace.AddClassOf((*ERR_STATE_UNAVAILABLE)(nil))
	Namespace.AddClassOf((*ERR_TRACE_ASSERT)(nil))
	Namespace.AddClassOf((*ERR_TYPE_NOT_ARRAY_INDEXABLE)(nil))
	Namespace.AddClassOf((*ERR_TYPE_NOT_MAP_INDEXABLE)(nil))
	Namespace.AddClassOf((*ERR_TYPE_NOT_SLICEABLE)(nil))
	Namespace.AddClassOf((*ERR_UNKNOWN_DEVICE)(nil))
	Namespace.AddClassOf((*ERR_UNSUPPORTED_CONVERSION)(nil))
	Namespace.AddClassOf((*ERR_VALUE_GE_LIMIT)(nil))
	Namespace.AddClassOf((*ERR_VALUE_NEG)(nil))
	Namespace.AddClassOf((*ERR_VALUE_OUT_OF_BOUNDS)(nil))
	Namespace.AddClassOf((*ERR_WRONG_CONTEXT_VERSION)(nil))
	Namespace.AddClassOf((*EglBindAPI)(nil))
	Namespace.AddClassOf((*EglBindTexImage)(nil))
	Namespace.AddClassOf((*EglChooseConfig)(nil))
	Namespace.AddClassOf((*EglClientWaitSyncKHR)(nil))
	Namespace.AddClassOf((*EglCopyBuffers)(nil))
	Namespace.AddClassOf((*EglCreateContext)(nil))
	Namespace.AddClassOf((*EglCreateImageKHR)(nil))
	Namespace.AddClassOf((*EglCreatePbufferFromClientBuffer)(nil))
	Namespace.AddClassOf((*EglCreatePbufferSurface)(nil))
	Namespace.AddClassOf((*EglCreatePixmapSurface)(nil))
	Namespace.AddClassOf((*EglCreateSyncKHR)(nil))
	Namespace.AddClassOf((*EglCreateWindowSurface)(nil))
	Namespace.AddClassOf((*EglDestroyContext)(nil))
	Namespace.AddClassOf((*EglDestroyImageKHR)(nil))
	Namespace.AddClassOf((*EglDestroySurface)(nil))
	Namespace.AddClassOf((*EglDestroySyncKHR)(nil))
	Namespace.AddClassOf((*EglGetConfigAttrib)(nil))
	Namespace.AddClassOf((*EglGetConfigs)(nil))
	Namespace.AddClassOf((*EglGetCurrentContext)(nil))
	Namespace.AddClassOf((*EglGetCurrentDisplay)(nil))
	Namespace.AddClassOf((*EglGetCurrentSurface)(nil))
	Namespace.AddClassOf((*EglGetDisplay)(nil))
	Namespace.AddClassOf((*EglGetError)(nil))
	Namespace.AddClassOf((*EglGetSyncAttribKHR)(nil))
	Namespace.AddClassOf((*EglInitialize)(nil))
	Namespace.AddClassOf((*EglMakeCurrent)(nil))
	Namespace.AddClassOf((*EglQueryAPI)(nil))
	Namespace.AddClassOf((*EglQueryContext)(nil))
	Namespace.AddClassOf((*EglQueryString)(nil))
	Namespace.AddClassOf((*EglQuerySurface)(nil))
	Namespace.AddClassOf((*EglReleaseTexImage)(nil))
	Namespace.AddClassOf((*EglReleaseThread)(nil))
	Namespace.AddClassOf((*EglSignalSyncKHR)(nil))
	Namespace.AddClassOf((*EglSurfaceAttrib)(nil))
	Namespace.AddClassOf((*Voidᵖ)(nil))
	Namespace.AddClassOf((*EglSwapBuffers)(nil))
	Namespace.AddClassOf((*EglSwapBuffersWithDamageKHR)(nil))
	Namespace.AddClassOf((*EglSwapInterval)(nil))
	Namespace.AddClassOf((*EglTerminate)(nil))
	Namespace.AddClassOf((*EglWaitClient)(nil))
	Namespace.AddClassOf((*EglWaitGL)(nil))
	Namespace.AddClassOf((*EglWaitNative)(nil))
	Namespace.AddClassOf((*ErrorState)(nil))
	Namespace.AddClassOf((*F64ˢ)(nil))
	Namespace.AddClassOf((*FlushPostBuffer)(nil))
	Namespace.AddClassOf((*FramebufferIdˢ)(nil))
	Namespace.AddClassOf((*FramebufferIdᵖ)(nil))
	Namespace.AddClassOf((*FramebufferIdᶜᵖ)(nil))
	Namespace.AddClassOf((*GLXContext)(nil))
	Namespace.AddClassOf((*GLXDrawable)(nil))
	Namespace.AddClassOf((*GLbooleanː4ᵃ)(nil))
	Namespace.AddClassOf((*GLbooleanˢ)(nil))
	Namespace.AddClassOf((*GLbooleanᵖ)(nil))
	Namespace.AddClassOf((*GLcharᵖ)(nil))
	Namespace.AddClassOf((*GLcharᶜᵖ)(nil))
	Namespace.AddClassOf((*GLcharᶜᵖˢ)(nil))
	Namespace.AddClassOf((*GLcharᶜᵖᵖ)(nil))
	Namespace.AddClassOf((*GLcharᶜᵖᶜᵖ)(nil))
	Namespace.AddClassOf((*GLeglImageOES)(nil))
	Namespace.AddClassOf((*GLenumˢ)(nil))
	Namespace.AddClassOf((*GLenumᶜᵖ)(nil))
	Namespace.AddClassOf((*GLfixedˢ)(nil))
	Namespace.AddClassOf((*GLfixedᵖ)(nil))
	Namespace.AddClassOf((*GLfixedᶜᵖ)(nil))
	Namespace.AddClassOf((*GLfloatː1ᵃ)(nil))
	Namespace.AddClassOf((*GLfloatː3ᵃ)(nil))
	Namespace.AddClassOf((*GLfloatː4ᵃ)(nil))
	Namespace.AddClassOf((*GLfloatˢ)(nil))
	Namespace.AddClassOf((*GLfloatᵖ)(nil))
	Namespace.AddClassOf((*GLfloatᶜᵖ)(nil))
	Namespace.AddClassOf((*GLint64ˢ)(nil))
	Namespace.AddClassOf((*GLint64ᵖ)(nil))
	Namespace.AddClassOf((*GLintː1ᵃ)(nil))
	Namespace.AddClassOf((*GLintː4ᵃ)(nil))
	Namespace.AddClassOf((*GLintˢ)(nil))
	Namespace.AddClassOf((*GLintᵖ)(nil))
	Namespace.AddClassOf((*GLintᶜᵖ)(nil))
	Namespace.AddClassOf((*GLshortˢ)(nil))
	Namespace.AddClassOf((*GLshortᵖ)(nil))
	Namespace.AddClassOf((*GLshortᶜᵖ)(nil))
	Namespace.AddClassOf((*GLsizeiˢ)(nil))
	Namespace.AddClassOf((*GLsizeiᵖ)(nil))
	Namespace.AddClassOf((*GLsizeiᶜᵖ)(nil))
	Namespace.AddClassOf((*GLubyteˢ)(nil))
	Namespace.AddClassOf((*GLubyteᵖ)(nil))
	Namespace.AddClassOf((*GLubyteᶜᵖ)(nil))
	Namespace.AddClassOf((*GLuint64ˢ)(nil))
	Namespace.AddClassOf((*GLuint64ᵖ)(nil))
	Namespace.AddClassOf((*GLuint64ᶜᵖ)(nil))
	Namespace.AddClassOf((*GLuintː2ᵃ)(nil))
	Namespace.AddClassOf((*GLuintː3ᵃ)(nil))
	Namespace.AddClassOf((*GLuintː4ᵃ)(nil))
	Namespace.AddClassOf((*GLuintˢ)(nil))
	Namespace.AddClassOf((*GLuintᵖ)(nil))
	Namespace.AddClassOf((*GLuintᶜᵖ)(nil))
	Namespace.AddClassOf((*GLvoidˢ)(nil))
	Namespace.AddClassOf((*GLvoidᵖ)(nil))
	Namespace.AddClassOf((*GlActiveShaderProgram)(nil))
	Namespace.AddClassOf((*GlActiveShaderProgramEXT)(nil))
	Namespace.AddClassOf((*GlActiveTexture)(nil))
	Namespace.AddClassOf((*GlAlphaFunc)(nil))
	Namespace.AddClassOf((*GlAlphaFuncQCOM)(nil))
	Namespace.AddClassOf((*GlAlphaFuncx)(nil))
	Namespace.AddClassOf((*GlAlphaFuncxOES)(nil))
	Namespace.AddClassOf((*GlApplyFramebufferAttachmentCMAAINTEL)(nil))
	Namespace.AddClassOf((*GlAttachShader)(nil))
	Namespace.AddClassOf((*GlBeginConditionalRenderNV)(nil))
	Namespace.AddClassOf((*GlBeginPerfMonitorAMD)(nil))
	Namespace.AddClassOf((*GlBeginPerfQueryINTEL)(nil))
	Namespace.AddClassOf((*GlBeginQuery)(nil))
	Namespace.AddClassOf((*GlBeginQueryEXT)(nil))
	Namespace.AddClassOf((*GlBeginTransformFeedback)(nil))
	Namespace.AddClassOf((*GlBindAttribLocation)(nil))
	Namespace.AddClassOf((*GlBindBuffer)(nil))
	Namespace.AddClassOf((*GlBindBufferBase)(nil))
	Namespace.AddClassOf((*GlBindBufferRange)(nil))
	Namespace.AddClassOf((*GlBindFragDataLocation)(nil))
	Namespace.AddClassOf((*GlBindFragDataLocationEXT)(nil))
	Namespace.AddClassOf((*GlBindFragDataLocationIndexedEXT)(nil))
	Namespace.AddClassOf((*GlBindFramebuffer)(nil))
	Namespace.AddClassOf((*GlBindFramebufferOES)(nil))
	Namespace.AddClassOf((*GlBindImageTexture)(nil))
	Namespace.AddClassOf((*GlBindProgramPipeline)(nil))
	Namespace.AddClassOf((*GlBindProgramPipelineEXT)(nil))
	Namespace.AddClassOf((*GlBindRenderbuffer)(nil))
	Namespace.AddClassOf((*GlBindRenderbufferOES)(nil))
	Namespace.AddClassOf((*GlBindSampler)(nil))
	Namespace.AddClassOf((*GlBindTexture)(nil))
	Namespace.AddClassOf((*GlBindTransformFeedback)(nil))
	Namespace.AddClassOf((*GlBindVertexArray)(nil))
	Namespace.AddClassOf((*GlBindVertexArrayOES)(nil))
	Namespace.AddClassOf((*GlBindVertexBuffer)(nil))
	Namespace.AddClassOf((*GlBlendBarrier)(nil))
	Namespace.AddClassOf((*GlBlendBarrierKHR)(nil))
	Namespace.AddClassOf((*GlBlendBarrierNV)(nil))
	Namespace.AddClassOf((*GlBlendColor)(nil))
	Namespace.AddClassOf((*GlBlendEquation)(nil))
	Namespace.AddClassOf((*GlBlendEquationOES)(nil))
	Namespace.AddClassOf((*GlBlendEquationSeparate)(nil))
	Namespace.AddClassOf((*GlBlendEquationSeparateOES)(nil))
	Namespace.AddClassOf((*GlBlendEquationSeparatei)(nil))
	Namespace.AddClassOf((*GlBlendEquationSeparateiEXT)(nil))
	Namespace.AddClassOf((*GlBlendEquationSeparateiOES)(nil))
	Namespace.AddClassOf((*GlBlendEquationi)(nil))
	Namespace.AddClassOf((*GlBlendEquationiEXT)(nil))
	Namespace.AddClassOf((*GlBlendEquationiOES)(nil))
	Namespace.AddClassOf((*GlBlendFunc)(nil))
	Namespace.AddClassOf((*GlBlendFuncSeparate)(nil))
	Namespace.AddClassOf((*GlBlendFuncSeparateOES)(nil))
	Namespace.AddClassOf((*GlBlendFuncSeparatei)(nil))
	Namespace.AddClassOf((*GlBlendFuncSeparateiEXT)(nil))
	Namespace.AddClassOf((*GlBlendFuncSeparateiOES)(nil))
	Namespace.AddClassOf((*GlBlendFunci)(nil))
	Namespace.AddClassOf((*GlBlendFunciEXT)(nil))
	Namespace.AddClassOf((*GlBlendFunciOES)(nil))
	Namespace.AddClassOf((*GlBlendParameteriNV)(nil))
	Namespace.AddClassOf((*GlBlitFramebuffer)(nil))
	Namespace.AddClassOf((*GlBlitFramebufferANGLE)(nil))
	Namespace.AddClassOf((*GlBlitFramebufferNV)(nil))
	Namespace.AddClassOf((*GlBufferData)(nil))
	Namespace.AddClassOf((*GlBufferStorageEXT)(nil))
	Namespace.AddClassOf((*GlBufferSubData)(nil))
	Namespace.AddClassOf((*GlCheckFramebufferStatus)(nil))
	Namespace.AddClassOf((*GlCheckFramebufferStatusOES)(nil))
	Namespace.AddClassOf((*GlClear)(nil))
	Namespace.AddClassOf((*GlClearBufferfi)(nil))
	Namespace.AddClassOf((*GlClearBufferfv)(nil))
	Namespace.AddClassOf((*GlClearBufferiv)(nil))
	Namespace.AddClassOf((*GlClearBufferuiv)(nil))
	Namespace.AddClassOf((*GlClearColor)(nil))
	Namespace.AddClassOf((*GlClearColorx)(nil))
	Namespace.AddClassOf((*GlClearColorxOES)(nil))
	Namespace.AddClassOf((*GlClearDepthf)(nil))
	Namespace.AddClassOf((*GlClearDepthfOES)(nil))
	Namespace.AddClassOf((*GlClearDepthx)(nil))
	Namespace.AddClassOf((*GlClearDepthxOES)(nil))
	Namespace.AddClassOf((*GlClearStencil)(nil))
	Namespace.AddClassOf((*GlClientActiveTexture)(nil))
	Namespace.AddClassOf((*GlClientWaitSync)(nil))
	Namespace.AddClassOf((*GlClientWaitSyncAPPLE)(nil))
	Namespace.AddClassOf((*GlClipPlanef)(nil))
	Namespace.AddClassOf((*GlClipPlanefIMG)(nil))
	Namespace.AddClassOf((*GlClipPlanefOES)(nil))
	Namespace.AddClassOf((*GlClipPlanex)(nil))
	Namespace.AddClassOf((*GlClipPlanexIMG)(nil))
	Namespace.AddClassOf((*GlClipPlanexOES)(nil))
	Namespace.AddClassOf((*GlColor4f)(nil))
	Namespace.AddClassOf((*GlColor4ub)(nil))
	Namespace.AddClassOf((*GlColor4x)(nil))
	Namespace.AddClassOf((*GlColor4xOES)(nil))
	Namespace.AddClassOf((*GlColorMask)(nil))
	Namespace.AddClassOf((*GlColorMaski)(nil))
	Namespace.AddClassOf((*GlColorMaskiEXT)(nil))
	Namespace.AddClassOf((*GlColorMaskiOES)(nil))
	Namespace.AddClassOf((*GlColorPointer)(nil))
	Namespace.AddClassOf((*GlColorPointerBounds)(nil))
	Namespace.AddClassOf((*GlCompileShader)(nil))
	Namespace.AddClassOf((*TexturePointer)(nil))
	Namespace.AddClassOf((*GlCompressedTexImage2D)(nil))
	Namespace.AddClassOf((*GlCompressedTexImage3D)(nil))
	Namespace.AddClassOf((*GlCompressedTexImage3DOES)(nil))
	Namespace.AddClassOf((*GlCompressedTexSubImage2D)(nil))
	Namespace.AddClassOf((*GlCompressedTexSubImage3D)(nil))
	Namespace.AddClassOf((*GlCompressedTexSubImage3DOES)(nil))
	Namespace.AddClassOf((*GlCopyBufferSubData)(nil))
	Namespace.AddClassOf((*GlCopyBufferSubDataNV)(nil))
	Namespace.AddClassOf((*GlCopyImageSubData)(nil))
	Namespace.AddClassOf((*GlCopyImageSubDataEXT)(nil))
	Namespace.AddClassOf((*GlCopyImageSubDataOES)(nil))
	Namespace.AddClassOf((*GlCopyPathNV)(nil))
	Namespace.AddClassOf((*GlCopyTexImage2D)(nil))
	Namespace.AddClassOf((*GlCopyTexSubImage2D)(nil))
	Namespace.AddClassOf((*GlCopyTexSubImage3D)(nil))
	Namespace.AddClassOf((*GlCopyTexSubImage3DOES)(nil))
	Namespace.AddClassOf((*GlCopyTextureLevelsAPPLE)(nil))
	Namespace.AddClassOf((*GlCoverFillPathInstancedNV)(nil))
	Namespace.AddClassOf((*GlCoverFillPathNV)(nil))
	Namespace.AddClassOf((*GlCoverStrokePathInstancedNV)(nil))
	Namespace.AddClassOf((*GlCoverStrokePathNV)(nil))
	Namespace.AddClassOf((*GlCoverageMaskNV)(nil))
	Namespace.AddClassOf((*GlCoverageModulationNV)(nil))
	Namespace.AddClassOf((*GlCoverageModulationTableNV)(nil))
	Namespace.AddClassOf((*GlCoverageOperationNV)(nil))
	Namespace.AddClassOf((*GlCreatePerfQueryINTEL)(nil))
	Namespace.AddClassOf((*GlCreateProgram)(nil))
	Namespace.AddClassOf((*GlCreateShader)(nil))
	Namespace.AddClassOf((*GlCreateShaderProgramv)(nil))
	Namespace.AddClassOf((*GlCreateShaderProgramvEXT)(nil))
	Namespace.AddClassOf((*GlCullFace)(nil))
	Namespace.AddClassOf((*GlCurrentPaletteMatrixOES)(nil))
	Namespace.AddClassOf((*GlDebugMessageCallback)(nil))
	Namespace.AddClassOf((*GlDebugMessageCallbackKHR)(nil))
	Namespace.AddClassOf((*GlDebugMessageControl)(nil))
	Namespace.AddClassOf((*GlDebugMessageControlKHR)(nil))
	Namespace.AddClassOf((*GlDebugMessageInsert)(nil))
	Namespace.AddClassOf((*GlDebugMessageInsertKHR)(nil))
	Namespace.AddClassOf((*GlDeleteBuffers)(nil))
	Namespace.AddClassOf((*GlDeleteFencesNV)(nil))
	Namespace.AddClassOf((*GlDeleteFramebuffers)(nil))
	Namespace.AddClassOf((*GlDeleteFramebuffersOES)(nil))
	Namespace.AddClassOf((*GlDeletePathsNV)(nil))
	Namespace.AddClassOf((*GlDeletePerfMonitorsAMD)(nil))
	Namespace.AddClassOf((*GlDeletePerfQueryINTEL)(nil))
	Namespace.AddClassOf((*GlDeleteProgram)(nil))
	Namespace.AddClassOf((*PipelineIdᶜᵖ)(nil))
	Namespace.AddClassOf((*GlDeleteProgramPipelines)(nil))
	Namespace.AddClassOf((*GlDeleteProgramPipelinesEXT)(nil))
	Namespace.AddClassOf((*QueryIdᶜᵖ)(nil))
	Namespace.AddClassOf((*GlDeleteQueries)(nil))
	Namespace.AddClassOf((*GlDeleteQueriesEXT)(nil))
	Namespace.AddClassOf((*RenderbufferIdᶜᵖ)(nil))
	Namespace.AddClassOf((*GlDeleteRenderbuffers)(nil))
	Namespace.AddClassOf((*GlDeleteRenderbuffersOES)(nil))
	Namespace.AddClassOf((*SamplerIdᶜᵖ)(nil))
	Namespace.AddClassOf((*GlDeleteSamplers)(nil))
	Namespace.AddClassOf((*GlDeleteShader)(nil))
	Namespace.AddClassOf((*GlDeleteSync)(nil))
	Namespace.AddClassOf((*GlDeleteSyncAPPLE)(nil))
	Namespace.AddClassOf((*TextureIdᶜᵖ)(nil))
	Namespace.AddClassOf((*GlDeleteTextures)(nil))
	Namespace.AddClassOf((*TransformFeedbackIdᶜᵖ)(nil))
	Namespace.AddClassOf((*GlDeleteTransformFeedbacks)(nil))
	Namespace.AddClassOf((*VertexArrayIdᶜᵖ)(nil))
	Namespace.AddClassOf((*GlDeleteVertexArrays)(nil))
	Namespace.AddClassOf((*GlDeleteVertexArraysOES)(nil))
	Namespace.AddClassOf((*GlDepthFunc)(nil))
	Namespace.AddClassOf((*GlDepthMask)(nil))
	Namespace.AddClassOf((*GlDepthRangeArrayfvNV)(nil))
	Namespace.AddClassOf((*GlDepthRangeIndexedfNV)(nil))
	Namespace.AddClassOf((*GlDepthRangef)(nil))
	Namespace.AddClassOf((*GlDepthRangefOES)(nil))
	Namespace.AddClassOf((*GlDepthRangex)(nil))
	Namespace.AddClassOf((*GlDepthRangexOES)(nil))
	Namespace.AddClassOf((*GlDetachShader)(nil))
	Namespace.AddClassOf((*GlDisable)(nil))
	Namespace.AddClassOf((*GlDisableClientState)(nil))
	Namespace.AddClassOf((*GlDisableDriverControlQCOM)(nil))
	Namespace.AddClassOf((*GlDisableVertexAttribArray)(nil))
	Namespace.AddClassOf((*GlDisablei)(nil))
	Namespace.AddClassOf((*GlDisableiEXT)(nil))
	Namespace.AddClassOf((*GlDisableiNV)(nil))
	Namespace.AddClassOf((*GlDisableiOES)(nil))
	Namespace.AddClassOf((*GlDiscardFramebufferEXT)(nil))
	Namespace.AddClassOf((*GlDispatchCompute)(nil))
	Namespace.AddClassOf((*GlDispatchComputeIndirect)(nil))
	Namespace.AddClassOf((*GlDrawArrays)(nil))
	Namespace.AddClassOf((*GlDrawArraysIndirect)(nil))
	Namespace.AddClassOf((*GlDrawArraysInstanced)(nil))
	Namespace.AddClassOf((*GlDrawArraysInstancedANGLE)(nil))
	Namespace.AddClassOf((*GlDrawArraysInstancedBaseInstanceEXT)(nil))
	Namespace.AddClassOf((*GlDrawArraysInstancedEXT)(nil))
	Namespace.AddClassOf((*GlDrawArraysInstancedNV)(nil))
	Namespace.AddClassOf((*GlDrawBuffers)(nil))
	Namespace.AddClassOf((*GlDrawBuffersEXT)(nil))
	Namespace.AddClassOf((*GlDrawBuffersIndexedEXT)(nil))
	Namespace.AddClassOf((*GlDrawBuffersNV)(nil))
	Namespace.AddClassOf((*IndicesPointer)(nil))
	Namespace.AddClassOf((*GlDrawElements)(nil))
	Namespace.AddClassOf((*GlDrawElementsBaseVertex)(nil))
	Namespace.AddClassOf((*GlDrawElementsBaseVertexEXT)(nil))
	Namespace.AddClassOf((*GlDrawElementsBaseVertexOES)(nil))
	Namespace.AddClassOf((*GlDrawElementsIndirect)(nil))
	Namespace.AddClassOf((*GlDrawElementsInstanced)(nil))
	Namespace.AddClassOf((*GlDrawElementsInstancedANGLE)(nil))
	Namespace.AddClassOf((*GlDrawElementsInstancedBaseInstanceEXT)(nil))
	Namespace.AddClassOf((*GlDrawElementsInstancedBaseVertex)(nil))
	Namespace.AddClassOf((*GlDrawElementsInstancedBaseVertexBaseInstanceEXT)(nil))
	Namespace.AddClassOf((*GlDrawElementsInstancedBaseVertexEXT)(nil))
	Namespace.AddClassOf((*GlDrawElementsInstancedBaseVertexOES)(nil))
	Namespace.AddClassOf((*GlDrawElementsInstancedEXT)(nil))
	Namespace.AddClassOf((*GlDrawElementsInstancedNV)(nil))
	Namespace.AddClassOf((*GlDrawRangeElements)(nil))
	Namespace.AddClassOf((*GlDrawRangeElementsBaseVertex)(nil))
	Namespace.AddClassOf((*GlDrawRangeElementsBaseVertexEXT)(nil))
	Namespace.AddClassOf((*GlDrawRangeElementsBaseVertexOES)(nil))
	Namespace.AddClassOf((*GlDrawTexfOES)(nil))
	Namespace.AddClassOf((*GlDrawTexfvOES)(nil))
	Namespace.AddClassOf((*GlDrawTexiOES)(nil))
	Namespace.AddClassOf((*GlDrawTexivOES)(nil))
	Namespace.AddClassOf((*GlDrawTexsOES)(nil))
	Namespace.AddClassOf((*GlDrawTexsvOES)(nil))
	Namespace.AddClassOf((*GlDrawTexxOES)(nil))
	Namespace.AddClassOf((*GlDrawTexxvOES)(nil))
	Namespace.AddClassOf((*GlEGLImageTargetRenderbufferStorageOES)(nil))
	Namespace.AddClassOf((*GlEGLImageTargetTexture2DOES)(nil))
	Namespace.AddClassOf((*GlEnable)(nil))
	Namespace.AddClassOf((*GlEnableClientState)(nil))
	Namespace.AddClassOf((*GlEnableDriverControlQCOM)(nil))
	Namespace.AddClassOf((*GlEnableVertexAttribArray)(nil))
	Namespace.AddClassOf((*GlEnablei)(nil))
	Namespace.AddClassOf((*GlEnableiEXT)(nil))
	Namespace.AddClassOf((*GlEnableiNV)(nil))
	Namespace.AddClassOf((*GlEnableiOES)(nil))
	Namespace.AddClassOf((*GlEndConditionalRenderNV)(nil))
	Namespace.AddClassOf((*GlEndPerfMonitorAMD)(nil))
	Namespace.AddClassOf((*GlEndPerfQueryINTEL)(nil))
	Namespace.AddClassOf((*GlEndQuery)(nil))
	Namespace.AddClassOf((*GlEndQueryEXT)(nil))
	Namespace.AddClassOf((*GlEndTilingQCOM)(nil))
	Namespace.AddClassOf((*GlEndTransformFeedback)(nil))
	Namespace.AddClassOf((*Voidᵖᵖ)(nil))
	Namespace.AddClassOf((*GlExtGetBufferPointervQCOM)(nil))
	Namespace.AddClassOf((*GlExtGetBuffersQCOM)(nil))
	Namespace.AddClassOf((*GlExtGetFramebuffersQCOM)(nil))
	Namespace.AddClassOf((*GlExtGetProgramBinarySourceQCOM)(nil))
	Namespace.AddClassOf((*ProgramIdᵖ)(nil))
	Namespace.AddClassOf((*GlExtGetProgramsQCOM)(nil))
	Namespace.AddClassOf((*RenderbufferIdᵖ)(nil))
	Namespace.AddClassOf((*GlExtGetRenderbuffersQCOM)(nil))
	Namespace.AddClassOf((*ShaderIdᵖ)(nil))
	Namespace.AddClassOf((*GlExtGetShadersQCOM)(nil))
	Namespace.AddClassOf((*GlExtGetTexLevelParameterivQCOM)(nil))
	Namespace.AddClassOf((*GlExtGetTexSubImageQCOM)(nil))
	Namespace.AddClassOf((*TextureIdᵖ)(nil))
	Namespace.AddClassOf((*GlExtGetTexturesQCOM)(nil))
	Namespace.AddClassOf((*GlExtIsProgramBinaryQCOM)(nil))
	Namespace.AddClassOf((*GlExtTexObjectStateOverrideiQCOM)(nil))
	Namespace.AddClassOf((*GlFenceSync)(nil))
	Namespace.AddClassOf((*GlFenceSyncAPPLE)(nil))
	Namespace.AddClassOf((*GlFinish)(nil))
	Namespace.AddClassOf((*GlFinishFenceNV)(nil))
	Namespace.AddClassOf((*GlFlush)(nil))
	Namespace.AddClassOf((*GlFlushMappedBufferRange)(nil))
	Namespace.AddClassOf((*GlFlushMappedBufferRangeEXT)(nil))
	Namespace.AddClassOf((*GlFogf)(nil))
	Namespace.AddClassOf((*GlFogfv)(nil))
	Namespace.AddClassOf((*GlFogx)(nil))
	Namespace.AddClassOf((*GlFogxOES)(nil))
	Namespace.AddClassOf((*GlFogxv)(nil))
	Namespace.AddClassOf((*GlFogxvOES)(nil))
	Namespace.AddClassOf((*GlFragmentCoverageColorNV)(nil))
	Namespace.AddClassOf((*GlFramebufferParameteri)(nil))
	Namespace.AddClassOf((*GlFramebufferRenderbuffer)(nil))
	Namespace.AddClassOf((*GlFramebufferRenderbufferOES)(nil))
	Namespace.AddClassOf((*GlFramebufferSampleLocationsfvNV)(nil))
	Namespace.AddClassOf((*GlFramebufferTexture)(nil))
	Namespace.AddClassOf((*GlFramebufferTexture2D)(nil))
	Namespace.AddClassOf((*GlFramebufferTexture2DMultisampleEXT)(nil))
	Namespace.AddClassOf((*GlFramebufferTexture2DMultisampleIMG)(nil))
	Namespace.AddClassOf((*GlFramebufferTexture2DOES)(nil))
	Namespace.AddClassOf((*GlFramebufferTexture3DOES)(nil))
	Namespace.AddClassOf((*GlFramebufferTextureEXT)(nil))
	Namespace.AddClassOf((*GlFramebufferTextureLayer)(nil))
	Namespace.AddClassOf((*GlFramebufferTextureMultiviewOVR)(nil))
	Namespace.AddClassOf((*GlFramebufferTextureOES)(nil))
	Namespace.AddClassOf((*GlFrontFace)(nil))
	Namespace.AddClassOf((*GlFrustumf)(nil))
	Namespace.AddClassOf((*GlFrustumfOES)(nil))
	Namespace.AddClassOf((*GlFrustumx)(nil))
	Namespace.AddClassOf((*GlFrustumxOES)(nil))
	Namespace.AddClassOf((*GlGenBuffers)(nil))
	Namespace.AddClassOf((*GlGenFencesNV)(nil))
	Namespace.AddClassOf((*GlGenFramebuffers)(nil))
	Namespace.AddClassOf((*GlGenFramebuffersOES)(nil))
	Namespace.AddClassOf((*GlGenPathsNV)(nil))
	Namespace.AddClassOf((*GlGenPerfMonitorsAMD)(nil))
	Namespace.AddClassOf((*PipelineIdᵖ)(nil))
	Namespace.AddClassOf((*GlGenProgramPipelines)(nil))
	Namespace.AddClassOf((*GlGenProgramPipelinesEXT)(nil))
	Namespace.AddClassOf((*QueryIdᵖ)(nil))
	Namespace.AddClassOf((*GlGenQueries)(nil))
	Namespace.AddClassOf((*GlGenQueriesEXT)(nil))
	Namespace.AddClassOf((*GlGenRenderbuffers)(nil))
	Namespace.AddClassOf((*GlGenRenderbuffersOES)(nil))
	Namespace.AddClassOf((*SamplerIdᵖ)(nil))
	Namespace.AddClassOf((*GlGenSamplers)(nil))
	Namespace.AddClassOf((*GlGenTextures)(nil))
	Namespace.AddClassOf((*TransformFeedbackIdᵖ)(nil))
	Namespace.AddClassOf((*GlGenTransformFeedbacks)(nil))
	Namespace.AddClassOf((*VertexArrayIdᵖ)(nil))
	Namespace.AddClassOf((*GlGenVertexArrays)(nil))
	Namespace.AddClassOf((*GlGenVertexArraysOES)(nil))
	Namespace.AddClassOf((*GlGenerateMipmap)(nil))
	Namespace.AddClassOf((*GlGenerateMipmapOES)(nil))
	Namespace.AddClassOf((*GlGetActiveAttrib)(nil))
	Namespace.AddClassOf((*GlGetActiveUniform)(nil))
	Namespace.AddClassOf((*GlGetActiveUniformBlockName)(nil))
	Namespace.AddClassOf((*GlGetActiveUniformBlockiv)(nil))
	Namespace.AddClassOf((*UniformIndexᶜᵖ)(nil))
	Namespace.AddClassOf((*GlGetActiveUniformsiv)(nil))
	Namespace.AddClassOf((*GlGetAttachedShaders)(nil))
	Namespace.AddClassOf((*GlGetAttribLocation)(nil))
	Namespace.AddClassOf((*GlGetBooleani_v)(nil))
	Namespace.AddClassOf((*GlGetBooleanv)(nil))
	Namespace.AddClassOf((*GlGetBufferParameteri64v)(nil))
	Namespace.AddClassOf((*GlGetBufferParameteriv)(nil))
	Namespace.AddClassOf((*GlGetBufferPointerv)(nil))
	Namespace.AddClassOf((*GlGetBufferPointervOES)(nil))
	Namespace.AddClassOf((*GlGetClipPlanef)(nil))
	Namespace.AddClassOf((*GlGetClipPlanefOES)(nil))
	Namespace.AddClassOf((*GlGetClipPlanex)(nil))
	Namespace.AddClassOf((*GlGetClipPlanexOES)(nil))
	Namespace.AddClassOf((*GlGetCoverageModulationTableNV)(nil))
	Namespace.AddClassOf((*GlGetDebugMessageLog)(nil))
	Namespace.AddClassOf((*GlGetDebugMessageLogKHR)(nil))
	Namespace.AddClassOf((*GlGetDriverControlStringQCOM)(nil))
	Namespace.AddClassOf((*GlGetDriverControlsQCOM)(nil))
	Namespace.AddClassOf((*GlGetError)(nil))
	Namespace.AddClassOf((*GlGetFenceivNV)(nil))
	Namespace.AddClassOf((*GlGetFirstPerfQueryIdINTEL)(nil))
	Namespace.AddClassOf((*GlGetFixedv)(nil))
	Namespace.AddClassOf((*GlGetFixedvOES)(nil))
	Namespace.AddClassOf((*GlGetFloati_vNV)(nil))
	Namespace.AddClassOf((*GlGetFloatv)(nil))
	Namespace.AddClassOf((*GlGetFragDataIndexEXT)(nil))
	Namespace.AddClassOf((*GlGetFragDataLocation)(nil))
	Namespace.AddClassOf((*GlGetFramebufferAttachmentParameteriv)(nil))
	Namespace.AddClassOf((*GlGetFramebufferAttachmentParameterivOES)(nil))
	Namespace.AddClassOf((*GlGetFramebufferParameteriv)(nil))
	Namespace.AddClassOf((*GlGetGraphicsResetStatus)(nil))
	Namespace.AddClassOf((*GlGetGraphicsResetStatusEXT)(nil))
	Namespace.AddClassOf((*GlGetGraphicsResetStatusKHR)(nil))
	Namespace.AddClassOf((*GlGetImageHandleNV)(nil))
	Namespace.AddClassOf((*GlGetInteger64i_v)(nil))
	Namespace.AddClassOf((*GlGetInteger64v)(nil))
	Namespace.AddClassOf((*GlGetInteger64vAPPLE)(nil))
	Namespace.AddClassOf((*GlGetIntegeri_v)(nil))
	Namespace.AddClassOf((*GlGetIntegeri_vEXT)(nil))
	Namespace.AddClassOf((*GlGetIntegerv)(nil))
	Namespace.AddClassOf((*GlGetInternalformatSampleivNV)(nil))
	Namespace.AddClassOf((*GlGetInternalformativ)(nil))
	Namespace.AddClassOf((*GlGetLightfv)(nil))
	Namespace.AddClassOf((*GlGetLightxv)(nil))
	Namespace.AddClassOf((*GlGetLightxvOES)(nil))
	Namespace.AddClassOf((*GlGetMaterialfv)(nil))
	Namespace.AddClassOf((*GlGetMaterialxv)(nil))
	Namespace.AddClassOf((*GlGetMaterialxvOES)(nil))
	Namespace.AddClassOf((*GlGetMultisamplefv)(nil))
	Namespace.AddClassOf((*GlGetNextPerfQueryIdINTEL)(nil))
	Namespace.AddClassOf((*GlGetObjectLabel)(nil))
	Namespace.AddClassOf((*GlGetObjectLabelEXT)(nil))
	Namespace.AddClassOf((*GlGetObjectLabelKHR)(nil))
	Namespace.AddClassOf((*GlGetObjectPtrLabel)(nil))
	Namespace.AddClassOf((*GlGetObjectPtrLabelKHR)(nil))
	Namespace.AddClassOf((*GlGetPathCommandsNV)(nil))
	Namespace.AddClassOf((*GlGetPathCoordsNV)(nil))
	Namespace.AddClassOf((*GlGetPathDashArrayNV)(nil))
	Namespace.AddClassOf((*GlGetPathLengthNV)(nil))
	Namespace.AddClassOf((*GlGetPathMetricRangeNV)(nil))
	Namespace.AddClassOf((*GlGetPathMetricsNV)(nil))
	Namespace.AddClassOf((*GlGetPathParameterfvNV)(nil))
	Namespace.AddClassOf((*GlGetPathParameterivNV)(nil))
	Namespace.AddClassOf((*GlGetPathSpacingNV)(nil))
	Namespace.AddClassOf((*GlGetPerfCounterInfoINTEL)(nil))
	Namespace.AddClassOf((*GlGetPerfMonitorCounterDataAMD)(nil))
	Namespace.AddClassOf((*GlGetPerfMonitorCounterInfoAMD)(nil))
	Namespace.AddClassOf((*GlGetPerfMonitorCounterStringAMD)(nil))
	Namespace.AddClassOf((*GlGetPerfMonitorCountersAMD)(nil))
	Namespace.AddClassOf((*GlGetPerfMonitorGroupStringAMD)(nil))
	Namespace.AddClassOf((*GlGetPerfMonitorGroupsAMD)(nil))
	Namespace.AddClassOf((*GlGetPerfQueryDataINTEL)(nil))
	Namespace.AddClassOf((*GlGetPerfQueryIdByNameINTEL)(nil))
	Namespace.AddClassOf((*GlGetPerfQueryInfoINTEL)(nil))
	Namespace.AddClassOf((*GlGetPointerv)(nil))
	Namespace.AddClassOf((*GlGetPointervKHR)(nil))
	Namespace.AddClassOf((*GlGetProgramBinary)(nil))
	Namespace.AddClassOf((*GlGetProgramBinaryOES)(nil))
	Namespace.AddClassOf((*GlGetProgramInfoLog)(nil))
	Namespace.AddClassOf((*GlGetProgramInterfaceiv)(nil))
	Namespace.AddClassOf((*GlGetProgramPipelineInfoLog)(nil))
	Namespace.AddClassOf((*GlGetProgramPipelineInfoLogEXT)(nil))
	Namespace.AddClassOf((*GlGetProgramPipelineiv)(nil))
	Namespace.AddClassOf((*GlGetProgramPipelineivEXT)(nil))
	Namespace.AddClassOf((*GlGetProgramResourceIndex)(nil))
	Namespace.AddClassOf((*GlGetProgramResourceLocation)(nil))
	Namespace.AddClassOf((*GlGetProgramResourceLocationIndexEXT)(nil))
	Namespace.AddClassOf((*GlGetProgramResourceName)(nil))
	Namespace.AddClassOf((*GlGetProgramResourcefvNV)(nil))
	Namespace.AddClassOf((*GlGetProgramResourceiv)(nil))
	Namespace.AddClassOf((*GlGetProgramiv)(nil))
	Namespace.AddClassOf((*S64ᵖ)(nil))
	Namespace.AddClassOf((*GlGetQueryObjecti64v)(nil))
	Namespace.AddClassOf((*GlGetQueryObjecti64vEXT)(nil))
	Namespace.AddClassOf((*GlGetQueryObjectivEXT)(nil))
	Namespace.AddClassOf((*U64ᵖ)(nil))
	Namespace.AddClassOf((*GlGetQueryObjectui64v)(nil))
	Namespace.AddClassOf((*GlGetQueryObjectui64vEXT)(nil))
	Namespace.AddClassOf((*GlGetQueryObjectuiv)(nil))
	Namespace.AddClassOf((*GlGetQueryObjectuivEXT)(nil))
	Namespace.AddClassOf((*GlGetQueryiv)(nil))
	Namespace.AddClassOf((*GlGetQueryivEXT)(nil))
	Namespace.AddClassOf((*GlGetRenderbufferParameteriv)(nil))
	Namespace.AddClassOf((*GlGetRenderbufferParameterivOES)(nil))
	Namespace.AddClassOf((*GlGetSamplerParameterIiv)(nil))
	Namespace.AddClassOf((*GlGetSamplerParameterIivEXT)(nil))
	Namespace.AddClassOf((*GlGetSamplerParameterIivOES)(nil))
	Namespace.AddClassOf((*GlGetSamplerParameterIuiv)(nil))
	Namespace.AddClassOf((*GlGetSamplerParameterIuivEXT)(nil))
	Namespace.AddClassOf((*GlGetSamplerParameterIuivOES)(nil))
	Namespace.AddClassOf((*GlGetSamplerParameterfv)(nil))
	Namespace.AddClassOf((*GlGetSamplerParameteriv)(nil))
	Namespace.AddClassOf((*GlGetShaderInfoLog)(nil))
	Namespace.AddClassOf((*GlGetShaderPrecisionFormat)(nil))
	Namespace.AddClassOf((*GlGetShaderSource)(nil))
	Namespace.AddClassOf((*GlGetShaderiv)(nil))
	Namespace.AddClassOf((*GlGetString)(nil))
	Namespace.AddClassOf((*GlGetStringi)(nil))
	Namespace.AddClassOf((*GlGetSynciv)(nil))
	Namespace.AddClassOf((*GlGetSyncivAPPLE)(nil))
	Namespace.AddClassOf((*GlGetTexEnvfv)(nil))
	Namespace.AddClassOf((*GlGetTexEnviv)(nil))
	Namespace.AddClassOf((*GlGetTexEnvxv)(nil))
	Namespace.AddClassOf((*GlGetTexEnvxvOES)(nil))
	Namespace.AddClassOf((*GlGetTexGenfvOES)(nil))
	Namespace.AddClassOf((*GlGetTexGenivOES)(nil))
	Namespace.AddClassOf((*GlGetTexGenxvOES)(nil))
	Namespace.AddClassOf((*GlGetTexLevelParameterfv)(nil))
	Namespace.AddClassOf((*GlGetTexLevelParameteriv)(nil))
	Namespace.AddClassOf((*GlGetTexParameterIiv)(nil))
	Namespace.AddClassOf((*GlGetTexParameterIivEXT)(nil))
	Namespace.AddClassOf((*GlGetTexParameterIivOES)(nil))
	Namespace.AddClassOf((*GlGetTexParameterIuiv)(nil))
	Namespace.AddClassOf((*GlGetTexParameterIuivEXT)(nil))
	Namespace.AddClassOf((*GlGetTexParameterIuivOES)(nil))
	Namespace.AddClassOf((*GlGetTexParameterfv)(nil))
	Namespace.AddClassOf((*GlGetTexParameteriv)(nil))
	Namespace.AddClassOf((*GlGetTexParameterxv)(nil))
	Namespace.AddClassOf((*GlGetTexParameterxvOES)(nil))
	Namespace.AddClassOf((*GlGetTextureHandleNV)(nil))
	Namespace.AddClassOf((*GlGetTextureSamplerHandleNV)(nil))
	Namespace.AddClassOf((*GlGetTransformFeedbackVarying)(nil))
	Namespace.AddClassOf((*GlGetTranslatedShaderSourceANGLE)(nil))
	Namespace.AddClassOf((*GlGetUniformBlockIndex)(nil))
	Namespace.AddClassOf((*UniformIndexᵖ)(nil))
	Namespace.AddClassOf((*GlGetUniformIndices)(nil))
	Namespace.AddClassOf((*GlGetUniformLocation)(nil))
	Namespace.AddClassOf((*GlGetUniformfv)(nil))
	Namespace.AddClassOf((*GlGetUniformiv)(nil))
	Namespace.AddClassOf((*GlGetUniformuiv)(nil))
	Namespace.AddClassOf((*GlGetVertexAttribIiv)(nil))
	Namespace.AddClassOf((*GlGetVertexAttribIuiv)(nil))
	Namespace.AddClassOf((*GlGetVertexAttribPointerv)(nil))
	Namespace.AddClassOf((*GlGetVertexAttribfv)(nil))
	Namespace.AddClassOf((*GlGetVertexAttribiv)(nil))
	Namespace.AddClassOf((*GlGetnUniformfv)(nil))
	Namespace.AddClassOf((*GlGetnUniformfvEXT)(nil))
	Namespace.AddClassOf((*GlGetnUniformfvKHR)(nil))
	Namespace.AddClassOf((*GlGetnUniformiv)(nil))
	Namespace.AddClassOf((*GlGetnUniformivEXT)(nil))
	Namespace.AddClassOf((*GlGetnUniformivKHR)(nil))
	Namespace.AddClassOf((*GlGetnUniformuiv)(nil))
	Namespace.AddClassOf((*GlGetnUniformuivKHR)(nil))
	Namespace.AddClassOf((*GlHint)(nil))
	Namespace.AddClassOf((*GlInsertEventMarkerEXT)(nil))
	Namespace.AddClassOf((*GlInterpolatePathsNV)(nil))
	Namespace.AddClassOf((*GlInvalidateFramebuffer)(nil))
	Namespace.AddClassOf((*GlInvalidateSubFramebuffer)(nil))
	Namespace.AddClassOf((*GlIsBuffer)(nil))
	Namespace.AddClassOf((*GlIsEnabled)(nil))
	Namespace.AddClassOf((*GlIsEnabledi)(nil))
	Namespace.AddClassOf((*GlIsEnablediEXT)(nil))
	Namespace.AddClassOf((*GlIsEnablediNV)(nil))
	Namespace.AddClassOf((*GlIsEnablediOES)(nil))
	Namespace.AddClassOf((*GlIsFenceNV)(nil))
	Namespace.AddClassOf((*GlIsFramebuffer)(nil))
	Namespace.AddClassOf((*GlIsFramebufferOES)(nil))
	Namespace.AddClassOf((*GlIsImageHandleResidentNV)(nil))
	Namespace.AddClassOf((*GlIsPathNV)(nil))
	Namespace.AddClassOf((*GlIsPointInFillPathNV)(nil))
	Namespace.AddClassOf((*GlIsPointInStrokePathNV)(nil))
	Namespace.AddClassOf((*GlIsProgram)(nil))
	Namespace.AddClassOf((*GlIsProgramPipeline)(nil))
	Namespace.AddClassOf((*GlIsProgramPipelineEXT)(nil))
	Namespace.AddClassOf((*GlIsQuery)(nil))
	Namespace.AddClassOf((*GlIsQueryEXT)(nil))
	Namespace.AddClassOf((*GlIsRenderbuffer)(nil))
	Namespace.AddClassOf((*GlIsRenderbufferOES)(nil))
	Namespace.AddClassOf((*GlIsSampler)(nil))
	Namespace.AddClassOf((*GlIsShader)(nil))
	Namespace.AddClassOf((*GlIsSync)(nil))
	Namespace.AddClassOf((*GlIsSyncAPPLE)(nil))
	Namespace.AddClassOf((*GlIsTexture)(nil))
	Namespace.AddClassOf((*GlIsTextureHandleResidentNV)(nil))
	Namespace.AddClassOf((*GlIsTransformFeedback)(nil))
	Namespace.AddClassOf((*GlIsVertexArray)(nil))
	Namespace.AddClassOf((*GlIsVertexArrayOES)(nil))
	Namespace.AddClassOf((*GlLabelObjectEXT)(nil))
	Namespace.AddClassOf((*GlLightModelf)(nil))
	Namespace.AddClassOf((*GlLightModelfv)(nil))
	Namespace.AddClassOf((*GlLightModelx)(nil))
	Namespace.AddClassOf((*GlLightModelxOES)(nil))
	Namespace.AddClassOf((*GlLightModelxv)(nil))
	Namespace.AddClassOf((*GlLightModelxvOES)(nil))
	Namespace.AddClassOf((*GlLightf)(nil))
	Namespace.AddClassOf((*GlLightfv)(nil))
	Namespace.AddClassOf((*GlLightx)(nil))
	Namespace.AddClassOf((*GlLightxOES)(nil))
	Namespace.AddClassOf((*GlLightxv)(nil))
	Namespace.AddClassOf((*GlLightxvOES)(nil))
	Namespace.AddClassOf((*GlLineWidth)(nil))
	Namespace.AddClassOf((*GlLineWidthx)(nil))
	Namespace.AddClassOf((*GlLineWidthxOES)(nil))
	Namespace.AddClassOf((*GlLinkProgram)(nil))
	Namespace.AddClassOf((*GlLoadIdentity)(nil))
	Namespace.AddClassOf((*GlLoadMatrixf)(nil))
	Namespace.AddClassOf((*GlLoadMatrixx)(nil))
	Namespace.AddClassOf((*GlLoadMatrixxOES)(nil))
	Namespace.AddClassOf((*GlLoadPaletteFromModelViewMatrixOES)(nil))
	Namespace.AddClassOf((*GlLogicOp)(nil))
	Namespace.AddClassOf((*GlMakeImageHandleNonResidentNV)(nil))
	Namespace.AddClassOf((*GlMakeImageHandleResidentNV)(nil))
	Namespace.AddClassOf((*GlMakeTextureHandleNonResidentNV)(nil))
	Namespace.AddClassOf((*GlMakeTextureHandleResidentNV)(nil))
	Namespace.AddClassOf((*GlMapBuffer)(nil))
	Namespace.AddClassOf((*GlMapBufferOES)(nil))
	Namespace.AddClassOf((*GlMapBufferRange)(nil))
	Namespace.AddClassOf((*GlMapBufferRangeEXT)(nil))
	Namespace.AddClassOf((*GlMaterialf)(nil))
	Namespace.AddClassOf((*GlMaterialfv)(nil))
	Namespace.AddClassOf((*GlMaterialx)(nil))
	Namespace.AddClassOf((*GlMaterialxOES)(nil))
	Namespace.AddClassOf((*GlMaterialxv)(nil))
	Namespace.AddClassOf((*GlMaterialxvOES)(nil))
	Namespace.AddClassOf((*GlMatrixIndexPointerOES)(nil))
	Namespace.AddClassOf((*GlMatrixIndexPointerOESBounds)(nil))
	Namespace.AddClassOf((*GlMatrixLoad3x2fNV)(nil))
	Namespace.AddClassOf((*GlMatrixLoad3x3fNV)(nil))
	Namespace.AddClassOf((*GlMatrixLoadTranspose3x3fNV)(nil))
	Namespace.AddClassOf((*GlMatrixMode)(nil))
	Namespace.AddClassOf((*GlMatrixMult3x2fNV)(nil))
	Namespace.AddClassOf((*GlMatrixMult3x3fNV)(nil))
	Namespace.AddClassOf((*GlMatrixMultTranspose3x3fNV)(nil))
	Namespace.AddClassOf((*GlMemoryBarrier)(nil))
	Namespace.AddClassOf((*GlMemoryBarrierByRegion)(nil))
	Namespace.AddClassOf((*GlMinSampleShading)(nil))
	Namespace.AddClassOf((*GlMinSampleShadingOES)(nil))
	Namespace.AddClassOf((*GlMultMatrixf)(nil))
	Namespace.AddClassOf((*GlMultMatrixx)(nil))
	Namespace.AddClassOf((*GlMultMatrixxOES)(nil))
	Namespace.AddClassOf((*GlMultiDrawArraysEXT)(nil))
	Namespace.AddClassOf((*GlMultiDrawArraysIndirectEXT)(nil))
	Namespace.AddClassOf((*Voidᶜᵖᶜᵖ)(nil))
	Namespace.AddClassOf((*GlMultiDrawElementsBaseVertexEXT)(nil))
	Namespace.AddClassOf((*GlMultiDrawElementsBaseVertexOES)(nil))
	Namespace.AddClassOf((*GlMultiDrawElementsEXT)(nil))
	Namespace.AddClassOf((*GlMultiDrawElementsIndirectEXT)(nil))
	Namespace.AddClassOf((*GlMultiTexCoord4f)(nil))
	Namespace.AddClassOf((*GlMultiTexCoord4x)(nil))
	Namespace.AddClassOf((*GlMultiTexCoord4xOES)(nil))
	Namespace.AddClassOf((*GlNamedFramebufferSampleLocationsfvNV)(nil))
	Namespace.AddClassOf((*GlNormal3f)(nil))
	Namespace.AddClassOf((*GlNormal3x)(nil))
	Namespace.AddClassOf((*GlNormal3xOES)(nil))
	Namespace.AddClassOf((*GlNormalPointer)(nil))
	Namespace.AddClassOf((*GlNormalPointerBounds)(nil))
	Namespace.AddClassOf((*GlObjectLabel)(nil))
	Namespace.AddClassOf((*GlObjectLabelKHR)(nil))
	Namespace.AddClassOf((*GlObjectPtrLabel)(nil))
	Namespace.AddClassOf((*GlObjectPtrLabelKHR)(nil))
	Namespace.AddClassOf((*GlOrthof)(nil))
	Namespace.AddClassOf((*GlOrthofOES)(nil))
	Namespace.AddClassOf((*GlOrthox)(nil))
	Namespace.AddClassOf((*GlOrthoxOES)(nil))
	Namespace.AddClassOf((*GlPatchParameteri)(nil))
	Namespace.AddClassOf((*GlPatchParameteriEXT)(nil))
	Namespace.AddClassOf((*GlPatchParameteriOES)(nil))
	Namespace.AddClassOf((*GlPathCommandsNV)(nil))
	Namespace.AddClassOf((*GlPathCoordsNV)(nil))
	Namespace.AddClassOf((*GlPathCoverDepthFuncNV)(nil))
	Namespace.AddClassOf((*GlPathDashArrayNV)(nil))
	Namespace.AddClassOf((*GlPathGlyphIndexArrayNV)(nil))
	Namespace.AddClassOf((*GlPathGlyphIndexRangeNV)(nil))
	Namespace.AddClassOf((*GlPathGlyphRangeNV)(nil))
	Namespace.AddClassOf((*GlPathGlyphsNV)(nil))
	Namespace.AddClassOf((*GlPathMemoryGlyphIndexArrayNV)(nil))
	Namespace.AddClassOf((*GlPathParameterfNV)(nil))
	Namespace.AddClassOf((*GlPathParameterfvNV)(nil))
	Namespace.AddClassOf((*GlPathParameteriNV)(nil))
	Namespace.AddClassOf((*GlPathParameterivNV)(nil))
	Namespace.AddClassOf((*GlPathStencilDepthOffsetNV)(nil))
	Namespace.AddClassOf((*GlPathStencilFuncNV)(nil))
	Namespace.AddClassOf((*GlPathStringNV)(nil))
	Namespace.AddClassOf((*GlPathSubCommandsNV)(nil))
	Namespace.AddClassOf((*GlPathSubCoordsNV)(nil))
	Namespace.AddClassOf((*GlPauseTransformFeedback)(nil))
	Namespace.AddClassOf((*GlPixelStorei)(nil))
	Namespace.AddClassOf((*GlPointAlongPathNV)(nil))
	Namespace.AddClassOf((*GlPointParameterf)(nil))
	Namespace.AddClassOf((*GlPointParameterfv)(nil))
	Namespace.AddClassOf((*GlPointParameterx)(nil))
	Namespace.AddClassOf((*GlPointParameterxOES)(nil))
	Namespace.AddClassOf((*GlPointParameterxv)(nil))
	Namespace.AddClassOf((*GlPointParameterxvOES)(nil))
	Namespace.AddClassOf((*GlPointSize)(nil))
	Namespace.AddClassOf((*GlPointSizePointerOES)(nil))
	Namespace.AddClassOf((*GlPointSizePointerOESBounds)(nil))
	Namespace.AddClassOf((*GlPointSizex)(nil))
	Namespace.AddClassOf((*GlPointSizexOES)(nil))
	Namespace.AddClassOf((*GlPolygonModeNV)(nil))
	Namespace.AddClassOf((*GlPolygonOffset)(nil))
	Namespace.AddClassOf((*GlPolygonOffsetx)(nil))
	Namespace.AddClassOf((*GlPolygonOffsetxOES)(nil))
	Namespace.AddClassOf((*GlPopDebugGroup)(nil))
	Namespace.AddClassOf((*GlPopDebugGroupKHR)(nil))
	Namespace.AddClassOf((*GlPopGroupMarkerEXT)(nil))
	Namespace.AddClassOf((*GlPopMatrix)(nil))
	Namespace.AddClassOf((*GlPrimitiveBoundingBox)(nil))
	Namespace.AddClassOf((*GlPrimitiveBoundingBoxEXT)(nil))
	Namespace.AddClassOf((*GlPrimitiveBoundingBoxOES)(nil))
	Namespace.AddClassOf((*GlProgramBinary)(nil))
	Namespace.AddClassOf((*GlProgramBinaryOES)(nil))
	Namespace.AddClassOf((*GlProgramParameteri)(nil))
	Namespace.AddClassOf((*GlProgramParameteriEXT)(nil))
	Namespace.AddClassOf((*GlProgramPathFragmentInputGenNV)(nil))
	Namespace.AddClassOf((*GlProgramUniform1f)(nil))
	Namespace.AddClassOf((*GlProgramUniform1fEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform1fv)(nil))
	Namespace.AddClassOf((*GlProgramUniform1fvEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform1i)(nil))
	Namespace.AddClassOf((*GlProgramUniform1iEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform1iv)(nil))
	Namespace.AddClassOf((*GlProgramUniform1ivEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform1ui)(nil))
	Namespace.AddClassOf((*GlProgramUniform1uiEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform1uiv)(nil))
	Namespace.AddClassOf((*GlProgramUniform1uivEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform2f)(nil))
	Namespace.AddClassOf((*GlProgramUniform2fEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform2fv)(nil))
	Namespace.AddClassOf((*GlProgramUniform2fvEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform2i)(nil))
	Namespace.AddClassOf((*GlProgramUniform2iEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform2iv)(nil))
	Namespace.AddClassOf((*GlProgramUniform2ivEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform2ui)(nil))
	Namespace.AddClassOf((*GlProgramUniform2uiEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform2uiv)(nil))
	Namespace.AddClassOf((*GlProgramUniform2uivEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform3f)(nil))
	Namespace.AddClassOf((*GlProgramUniform3fEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform3fv)(nil))
	Namespace.AddClassOf((*GlProgramUniform3fvEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform3i)(nil))
	Namespace.AddClassOf((*GlProgramUniform3iEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform3iv)(nil))
	Namespace.AddClassOf((*GlProgramUniform3ivEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform3ui)(nil))
	Namespace.AddClassOf((*GlProgramUniform3uiEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform3uiv)(nil))
	Namespace.AddClassOf((*GlProgramUniform3uivEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform4f)(nil))
	Namespace.AddClassOf((*GlProgramUniform4fEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform4fv)(nil))
	Namespace.AddClassOf((*GlProgramUniform4fvEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform4i)(nil))
	Namespace.AddClassOf((*GlProgramUniform4iEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform4iv)(nil))
	Namespace.AddClassOf((*GlProgramUniform4ivEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform4ui)(nil))
	Namespace.AddClassOf((*GlProgramUniform4uiEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniform4uiv)(nil))
	Namespace.AddClassOf((*GlProgramUniform4uivEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniformHandleui64NV)(nil))
	Namespace.AddClassOf((*GlProgramUniformHandleui64vNV)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix2fv)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix2fvEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix2x3fv)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix2x3fvEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix2x4fv)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix2x4fvEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix3fv)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix3fvEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix3x2fv)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix3x2fvEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix3x4fv)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix3x4fvEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix4fv)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix4fvEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix4x2fv)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix4x2fvEXT)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix4x3fv)(nil))
	Namespace.AddClassOf((*GlProgramUniformMatrix4x3fvEXT)(nil))
	Namespace.AddClassOf((*GlPushDebugGroup)(nil))
	Namespace.AddClassOf((*GlPushDebugGroupKHR)(nil))
	Namespace.AddClassOf((*GlPushGroupMarkerEXT)(nil))
	Namespace.AddClassOf((*GlPushMatrix)(nil))
	Namespace.AddClassOf((*GlQueryCounterEXT)(nil))
	Namespace.AddClassOf((*GlQueryMatrixxOES)(nil))
	Namespace.AddClassOf((*GlRasterSamplesEXT)(nil))
	Namespace.AddClassOf((*GlReadBuffer)(nil))
	Namespace.AddClassOf((*GlReadBufferIndexedEXT)(nil))
	Namespace.AddClassOf((*GlReadBufferNV)(nil))
	Namespace.AddClassOf((*GlReadPixels)(nil))
	Namespace.AddClassOf((*GlReadnPixels)(nil))
	Namespace.AddClassOf((*GlReadnPixelsEXT)(nil))
	Namespace.AddClassOf((*GlReadnPixelsKHR)(nil))
	Namespace.AddClassOf((*GlReleaseShaderCompiler)(nil))
	Namespace.AddClassOf((*GlRenderbufferStorage)(nil))
	Namespace.AddClassOf((*GlRenderbufferStorageMultisample)(nil))
	Namespace.AddClassOf((*GlRenderbufferStorageMultisampleANGLE)(nil))
	Namespace.AddClassOf((*GlRenderbufferStorageMultisampleAPPLE)(nil))
	Namespace.AddClassOf((*GlRenderbufferStorageMultisampleEXT)(nil))
	Namespace.AddClassOf((*GlRenderbufferStorageMultisampleIMG)(nil))
	Namespace.AddClassOf((*GlRenderbufferStorageMultisampleNV)(nil))
	Namespace.AddClassOf((*GlRenderbufferStorageOES)(nil))
	Namespace.AddClassOf((*GlResolveDepthValuesNV)(nil))
	Namespace.AddClassOf((*GlResolveMultisampleFramebufferAPPLE)(nil))
	Namespace.AddClassOf((*GlResumeTransformFeedback)(nil))
	Namespace.AddClassOf((*GlRotatef)(nil))
	Namespace.AddClassOf((*GlRotatex)(nil))
	Namespace.AddClassOf((*GlRotatexOES)(nil))
	Namespace.AddClassOf((*GlSampleCoverage)(nil))
	Namespace.AddClassOf((*GlSampleCoveragex)(nil))
	Namespace.AddClassOf((*GlSampleCoveragexOES)(nil))
	Namespace.AddClassOf((*GlSampleMaski)(nil))
	Namespace.AddClassOf((*GlSamplerParameterIiv)(nil))
	Namespace.AddClassOf((*GlSamplerParameterIivEXT)(nil))
	Namespace.AddClassOf((*GlSamplerParameterIivOES)(nil))
	Namespace.AddClassOf((*GlSamplerParameterIuiv)(nil))
	Namespace.AddClassOf((*GlSamplerParameterIuivEXT)(nil))
	Namespace.AddClassOf((*GlSamplerParameterIuivOES)(nil))
	Namespace.AddClassOf((*GlSamplerParameterf)(nil))
	Namespace.AddClassOf((*GlSamplerParameterfv)(nil))
	Namespace.AddClassOf((*GlSamplerParameteri)(nil))
	Namespace.AddClassOf((*GlSamplerParameteriv)(nil))
	Namespace.AddClassOf((*GlScalef)(nil))
	Namespace.AddClassOf((*GlScalex)(nil))
	Namespace.AddClassOf((*GlScalexOES)(nil))
	Namespace.AddClassOf((*GlScissor)(nil))
	Namespace.AddClassOf((*GlScissorArrayvNV)(nil))
	Namespace.AddClassOf((*GlScissorIndexedNV)(nil))
	Namespace.AddClassOf((*GlScissorIndexedvNV)(nil))
	Namespace.AddClassOf((*GlSelectPerfMonitorCountersAMD)(nil))
	Namespace.AddClassOf((*GlSetFenceNV)(nil))
	Namespace.AddClassOf((*GlShadeModel)(nil))
	Namespace.AddClassOf((*ShaderIdᶜᵖ)(nil))
	Namespace.AddClassOf((*GlShaderBinary)(nil))
	Namespace.AddClassOf((*GlShaderSource)(nil))
	Namespace.AddClassOf((*GlStartTilingQCOM)(nil))
	Namespace.AddClassOf((*GlStencilFillPathInstancedNV)(nil))
	Namespace.AddClassOf((*GlStencilFillPathNV)(nil))
	Namespace.AddClassOf((*GlStencilFunc)(nil))
	Namespace.AddClassOf((*GlStencilFuncSeparate)(nil))
	Namespace.AddClassOf((*GlStencilMask)(nil))
	Namespace.AddClassOf((*GlStencilMaskSeparate)(nil))
	Namespace.AddClassOf((*GlStencilOp)(nil))
	Namespace.AddClassOf((*GlStencilOpSeparate)(nil))
	Namespace.AddClassOf((*GlStencilStrokePathInstancedNV)(nil))
	Namespace.AddClassOf((*GlStencilStrokePathNV)(nil))
	Namespace.AddClassOf((*GlStencilThenCoverFillPathInstancedNV)(nil))
	Namespace.AddClassOf((*GlStencilThenCoverFillPathNV)(nil))
	Namespace.AddClassOf((*GlStencilThenCoverStrokePathInstancedNV)(nil))
	Namespace.AddClassOf((*GlStencilThenCoverStrokePathNV)(nil))
	Namespace.AddClassOf((*GlSubpixelPrecisionBiasNV)(nil))
	Namespace.AddClassOf((*GlTestFenceNV)(nil))
	Namespace.AddClassOf((*GlTexBuffer)(nil))
	Namespace.AddClassOf((*GlTexBufferEXT)(nil))
	Namespace.AddClassOf((*GlTexBufferOES)(nil))
	Namespace.AddClassOf((*GlTexBufferRange)(nil))
	Namespace.AddClassOf((*GlTexBufferRangeEXT)(nil))
	Namespace.AddClassOf((*GlTexBufferRangeOES)(nil))
	Namespace.AddClassOf((*GlTexCoordPointer)(nil))
	Namespace.AddClassOf((*GlTexCoordPointerBounds)(nil))
	Namespace.AddClassOf((*GlTexEnvf)(nil))
	Namespace.AddClassOf((*GlTexEnvfv)(nil))
	Namespace.AddClassOf((*GlTexEnvi)(nil))
	Namespace.AddClassOf((*GlTexEnviv)(nil))
	Namespace.AddClassOf((*GlTexEnvx)(nil))
	Namespace.AddClassOf((*GlTexEnvxOES)(nil))
	Namespace.AddClassOf((*GlTexEnvxv)(nil))
	Namespace.AddClassOf((*GlTexEnvxvOES)(nil))
	Namespace.AddClassOf((*GlTexGenfOES)(nil))
	Namespace.AddClassOf((*GlTexGenfvOES)(nil))
	Namespace.AddClassOf((*GlTexGeniOES)(nil))
	Namespace.AddClassOf((*GlTexGenivOES)(nil))
	Namespace.AddClassOf((*GlTexGenxOES)(nil))
	Namespace.AddClassOf((*GlTexGenxvOES)(nil))
	Namespace.AddClassOf((*GlTexImage2D)(nil))
	Namespace.AddClassOf((*GlTexImage3D)(nil))
	Namespace.AddClassOf((*GlTexImage3DOES)(nil))
	Namespace.AddClassOf((*GlTexPageCommitmentEXT)(nil))
	Namespace.AddClassOf((*GlTexParameterIiv)(nil))
	Namespace.AddClassOf((*GlTexParameterIivEXT)(nil))
	Namespace.AddClassOf((*GlTexParameterIivOES)(nil))
	Namespace.AddClassOf((*GlTexParameterIuiv)(nil))
	Namespace.AddClassOf((*GlTexParameterIuivEXT)(nil))
	Namespace.AddClassOf((*GlTexParameterIuivOES)(nil))
	Namespace.AddClassOf((*GlTexParameterf)(nil))
	Namespace.AddClassOf((*GlTexParameterfv)(nil))
	Namespace.AddClassOf((*GlTexParameteri)(nil))
	Namespace.AddClassOf((*GlTexParameteriv)(nil))
	Namespace.AddClassOf((*GlTexParameterx)(nil))
	Namespace.AddClassOf((*GlTexParameterxOES)(nil))
	Namespace.AddClassOf((*GlTexParameterxv)(nil))
	Namespace.AddClassOf((*GlTexParameterxvOES)(nil))
	Namespace.AddClassOf((*GlTexStorage1D)(nil))
	Namespace.AddClassOf((*GlTexStorage1DEXT)(nil))
	Namespace.AddClassOf((*GlTexStorage2D)(nil))
	Namespace.AddClassOf((*GlTexStorage2DEXT)(nil))
	Namespace.AddClassOf((*GlTexStorage2DMultisample)(nil))
	Namespace.AddClassOf((*GlTexStorage3D)(nil))
	Namespace.AddClassOf((*GlTexStorage3DEXT)(nil))
	Namespace.AddClassOf((*GlTexStorage3DMultisample)(nil))
	Namespace.AddClassOf((*GlTexStorage3DMultisampleOES)(nil))
	Namespace.AddClassOf((*GlTexSubImage2D)(nil))
	Namespace.AddClassOf((*GlTexSubImage3D)(nil))
	Namespace.AddClassOf((*GlTexSubImage3DOES)(nil))
	Namespace.AddClassOf((*GlTextureStorage1DEXT)(nil))
	Namespace.AddClassOf((*GlTextureStorage2DEXT)(nil))
	Namespace.AddClassOf((*GlTextureStorage3DEXT)(nil))
	Namespace.AddClassOf((*GlTextureViewEXT)(nil))
	Namespace.AddClassOf((*GlTextureViewOES)(nil))
	Namespace.AddClassOf((*GlTransformFeedbackVaryings)(nil))
	Namespace.AddClassOf((*GlTransformPathNV)(nil))
	Namespace.AddClassOf((*GlTranslatef)(nil))
	Namespace.AddClassOf((*GlTranslatex)(nil))
	Namespace.AddClassOf((*GlTranslatexOES)(nil))
	Namespace.AddClassOf((*GlUniform1f)(nil))
	Namespace.AddClassOf((*GlUniform1fv)(nil))
	Namespace.AddClassOf((*GlUniform1i)(nil))
	Namespace.AddClassOf((*GlUniform1iv)(nil))
	Namespace.AddClassOf((*GlUniform1ui)(nil))
	Namespace.AddClassOf((*GlUniform1uiv)(nil))
	Namespace.AddClassOf((*GlUniform2f)(nil))
	Namespace.AddClassOf((*GlUniform2fv)(nil))
	Namespace.AddClassOf((*GlUniform2i)(nil))
	Namespace.AddClassOf((*GlUniform2iv)(nil))
	Namespace.AddClassOf((*GlUniform2ui)(nil))
	Namespace.AddClassOf((*GlUniform2uiv)(nil))
	Namespace.AddClassOf((*GlUniform3f)(nil))
	Namespace.AddClassOf((*GlUniform3fv)(nil))
	Namespace.AddClassOf((*GlUniform3i)(nil))
	Namespace.AddClassOf((*GlUniform3iv)(nil))
	Namespace.AddClassOf((*GlUniform3ui)(nil))
	Namespace.AddClassOf((*GlUniform3uiv)(nil))
	Namespace.AddClassOf((*GlUniform4f)(nil))
	Namespace.AddClassOf((*GlUniform4fv)(nil))
	Namespace.AddClassOf((*GlUniform4i)(nil))
	Namespace.AddClassOf((*GlUniform4iv)(nil))
	Namespace.AddClassOf((*GlUniform4ui)(nil))
	Namespace.AddClassOf((*GlUniform4uiv)(nil))
	Namespace.AddClassOf((*GlUniformBlockBinding)(nil))
	Namespace.AddClassOf((*GlUniformHandleui64NV)(nil))
	Namespace.AddClassOf((*GlUniformHandleui64vNV)(nil))
	Namespace.AddClassOf((*GlUniformMatrix2fv)(nil))
	Namespace.AddClassOf((*GlUniformMatrix2x3fv)(nil))
	Namespace.AddClassOf((*GlUniformMatrix2x3fvNV)(nil))
	Namespace.AddClassOf((*GlUniformMatrix2x4fv)(nil))
	Namespace.AddClassOf((*GlUniformMatrix2x4fvNV)(nil))
	Namespace.AddClassOf((*GlUniformMatrix3fv)(nil))
	Namespace.AddClassOf((*GlUniformMatrix3x2fv)(nil))
	Namespace.AddClassOf((*GlUniformMatrix3x2fvNV)(nil))
	Namespace.AddClassOf((*GlUniformMatrix3x4fv)(nil))
	Namespace.AddClassOf((*GlUniformMatrix3x4fvNV)(nil))
	Namespace.AddClassOf((*GlUniformMatrix4fv)(nil))
	Namespace.AddClassOf((*GlUniformMatrix4x2fv)(nil))
	Namespace.AddClassOf((*GlUniformMatrix4x2fvNV)(nil))
	Namespace.AddClassOf((*GlUniformMatrix4x3fv)(nil))
	Namespace.AddClassOf((*GlUniformMatrix4x3fvNV)(nil))
	Namespace.AddClassOf((*GlUnmapBuffer)(nil))
	Namespace.AddClassOf((*GlUnmapBufferOES)(nil))
	Namespace.AddClassOf((*GlUseProgram)(nil))
	Namespace.AddClassOf((*GlUseProgramStages)(nil))
	Namespace.AddClassOf((*GlUseProgramStagesEXT)(nil))
	Namespace.AddClassOf((*GlValidateProgram)(nil))
	Namespace.AddClassOf((*GlValidateProgramPipeline)(nil))
	Namespace.AddClassOf((*GlValidateProgramPipelineEXT)(nil))
	Namespace.AddClassOf((*GlVertexAttrib1f)(nil))
	Namespace.AddClassOf((*GlVertexAttrib1fv)(nil))
	Namespace.AddClassOf((*GlVertexAttrib2f)(nil))
	Namespace.AddClassOf((*GlVertexAttrib2fv)(nil))
	Namespace.AddClassOf((*GlVertexAttrib3f)(nil))
	Namespace.AddClassOf((*GlVertexAttrib3fv)(nil))
	Namespace.AddClassOf((*GlVertexAttrib4f)(nil))
	Namespace.AddClassOf((*GlVertexAttrib4fv)(nil))
	Namespace.AddClassOf((*GlVertexAttribBinding)(nil))
	Namespace.AddClassOf((*GlVertexAttribDivisor)(nil))
	Namespace.AddClassOf((*GlVertexAttribDivisorANGLE)(nil))
	Namespace.AddClassOf((*GlVertexAttribDivisorEXT)(nil))
	Namespace.AddClassOf((*GlVertexAttribDivisorNV)(nil))
	Namespace.AddClassOf((*GlVertexAttribFormat)(nil))
	Namespace.AddClassOf((*GlVertexAttribI4i)(nil))
	Namespace.AddClassOf((*GlVertexAttribI4iv)(nil))
	Namespace.AddClassOf((*GlVertexAttribI4ui)(nil))
	Namespace.AddClassOf((*GlVertexAttribI4uiv)(nil))
	Namespace.AddClassOf((*GlVertexAttribIFormat)(nil))
	Namespace.AddClassOf((*GlVertexAttribIPointer)(nil))
	Namespace.AddClassOf((*GlVertexAttribPointer)(nil))
	Namespace.AddClassOf((*GlVertexBindingDivisor)(nil))
	Namespace.AddClassOf((*GlVertexPointer)(nil))
	Namespace.AddClassOf((*GlVertexPointerBounds)(nil))
	Namespace.AddClassOf((*GlViewport)(nil))
	Namespace.AddClassOf((*GlViewportArrayvNV)(nil))
	Namespace.AddClassOf((*GlViewportIndexedfNV)(nil))
	Namespace.AddClassOf((*GlViewportIndexedfvNV)(nil))
	Namespace.AddClassOf((*GlWaitSync)(nil))
	Namespace.AddClassOf((*GlWaitSyncAPPLE)(nil))
	Namespace.AddClassOf((*GlWeightPathsNV)(nil))
	Namespace.AddClassOf((*GlWeightPointerOES)(nil))
	Namespace.AddClassOf((*GlWeightPointerOESBounds)(nil))
	Namespace.AddClassOf((*GlXCreateContext)(nil))
	Namespace.AddClassOf((*GlXCreateNewContext)(nil))
	Namespace.AddClassOf((*GlXMakeContextCurrent)(nil))
	Namespace.AddClassOf((*GlXMakeCurrent)(nil))
	Namespace.AddClassOf((*Intᵖ)(nil))
	Namespace.AddClassOf((*GlXQueryDrawable)(nil))
	Namespace.AddClassOf((*GlXSwapBuffers)(nil))
	Namespace.AddClassOf((*HDC)(nil))
	Namespace.AddClassOf((*HGLRC)(nil))
	Namespace.AddClassOf((*Intˢ)(nil))
	Namespace.AddClassOf((*LazyGLSLParseResult)(nil))
	Namespace.AddClassOf((*Mat2f)(nil))
	Namespace.AddClassOf((*Mat2fˢ)(nil))
	Namespace.AddClassOf((*Mat2fᵖ)(nil))
	Namespace.AddClassOf((*Vec3f)(nil))
	Namespace.AddClassOf((*Mat2x3f)(nil))
	Namespace.AddClassOf((*Mat2x3fˢ)(nil))
	Namespace.AddClassOf((*Mat2x3fᵖ)(nil))
	Namespace.AddClassOf((*Mat2x4f)(nil))
	Namespace.AddClassOf((*Mat2x4fˢ)(nil))
	Namespace.AddClassOf((*Mat2x4fᵖ)(nil))
	Namespace.AddClassOf((*Mat3f)(nil))
	Namespace.AddClassOf((*Mat3fˢ)(nil))
	Namespace.AddClassOf((*Mat3fᵖ)(nil))
	Namespace.AddClassOf((*Mat3x2f)(nil))
	Namespace.AddClassOf((*Mat3x2fˢ)(nil))
	Namespace.AddClassOf((*Mat3x2fᵖ)(nil))
	Namespace.AddClassOf((*Mat3x4f)(nil))
	Namespace.AddClassOf((*Mat3x4fˢ)(nil))
	Namespace.AddClassOf((*Mat3x4fᵖ)(nil))
	Namespace.AddClassOf((*Mat4f)(nil))
	Namespace.AddClassOf((*Mat4fˢ)(nil))
	Namespace.AddClassOf((*Mat4fᵖ)(nil))
	Namespace.AddClassOf((*Mat4x2f)(nil))
	Namespace.AddClassOf((*Mat4x2fˢ)(nil))
	Namespace.AddClassOf((*Mat4x2fᵖ)(nil))
	Namespace.AddClassOf((*Mat4x3f)(nil))
	Namespace.AddClassOf((*Mat4x3fˢ)(nil))
	Namespace.AddClassOf((*Mat4x3fᵖ)(nil))
	Namespace.AddClassOf((*PipelineIdˢ)(nil))
	Namespace.AddClassOf((*ProgramIdˢ)(nil))
	Namespace.AddClassOf((*ProgramInfo)(nil))
	Namespace.AddClassOf((*QueryIdˢ)(nil))
	Namespace.AddClassOf((*RenderbufferIdˢ)(nil))
	Namespace.AddClassOf((*ReplayBindRenderer)(nil))
	Namespace.AddClassOf((*ReplayChangeBackbuffer)(nil))
	Namespace.AddClassOf((*ReplayCreateRenderer)(nil))
	Namespace.AddClassOf((*S64ˢ)(nil))
	Namespace.AddClassOf((*SamplerIdˢ)(nil))
	Namespace.AddClassOf((*ShaderIdˢ)(nil))
	Namespace.AddClassOf((*StartTimer)(nil))
	Namespace.AddClassOf((*State)(nil))
	Namespace.AddClassOf((*StaticContextState)(nil))
	Namespace.AddClassOf((*StopTimer)(nil))
	Namespace.AddClassOf((*TAG_ATOM_NAME)(nil))
	Namespace.AddClassOf((*TextureIdˢ)(nil))
	Namespace.AddClassOf((*TransformFeedbackIdˢ)(nil))
	Namespace.AddClassOf((*U32ˢ)(nil))
	Namespace.AddClassOf((*U64ˢ)(nil))
	Namespace.AddClassOf((*UniformIndexˢ)(nil))
	Namespace.AddClassOf((*Vec1f)(nil))
	Namespace.AddClassOf((*Vec1i)(nil))
	Namespace.AddClassOf((*Vec2fː2ᵃ)(nil))
	Namespace.AddClassOf((*Vec2fː3ᵃ)(nil))
	Namespace.AddClassOf((*Vec2fː4ᵃ)(nil))
	Namespace.AddClassOf((*Vec2fˢ)(nil))
	Namespace.AddClassOf((*Vec2fᵖ)(nil))
	Namespace.AddClassOf((*Vec2i)(nil))
	Namespace.AddClassOf((*Vec2iˢ)(nil))
	Namespace.AddClassOf((*Vec2iᵖ)(nil))
	Namespace.AddClassOf((*Vec2u)(nil))
	Namespace.AddClassOf((*Vec2uˢ)(nil))
	Namespace.AddClassOf((*Vec2uᵖ)(nil))
	Namespace.AddClassOf((*Vec3fː2ᵃ)(nil))
	Namespace.AddClassOf((*Vec3fː3ᵃ)(nil))
	Namespace.AddClassOf((*Vec3fː4ᵃ)(nil))
	Namespace.AddClassOf((*Vec3fˢ)(nil))
	Namespace.AddClassOf((*Vec3fᵖ)(nil))
	Namespace.AddClassOf((*Vec3i)(nil))
	Namespace.AddClassOf((*Vec3iˢ)(nil))
	Namespace.AddClassOf((*Vec3iᵖ)(nil))
	Namespace.AddClassOf((*Vec3u)(nil))
	Namespace.AddClassOf((*Vec3uˢ)(nil))
	Namespace.AddClassOf((*Vec3uᵖ)(nil))
	Namespace.AddClassOf((*Vec4fː2ᵃ)(nil))
	Namespace.AddClassOf((*Vec4fː3ᵃ)(nil))
	Namespace.AddClassOf((*Vec4fː4ᵃ)(nil))
	Namespace.AddClassOf((*Vec4fˢ)(nil))
	Namespace.AddClassOf((*Vec4fᵖ)(nil))
	Namespace.AddClassOf((*Vec4i)(nil))
	Namespace.AddClassOf((*Vec4iˢ)(nil))
	Namespace.AddClassOf((*Vec4iᵖ)(nil))
	Namespace.AddClassOf((*Vec4u)(nil))
	Namespace.AddClassOf((*Vec4uˢ)(nil))
	Namespace.AddClassOf((*Vec4uᵖ)(nil))
	Namespace.AddClassOf((*VertexArrayIdˢ)(nil))
	Namespace.AddClassOf((*Voidˢ)(nil))
	Namespace.AddClassOf((*Voidᵖˢ)(nil))
	Namespace.AddClassOf((*Voidᶜᵖˢ)(nil))
	Namespace.AddClassOf((*Voidᶜᵖᵖ)(nil))
	Namespace.AddClassOf((*WARN_UNKNOWN_CONTEXT)(nil))
	Namespace.AddClassOf((*WglCreateContext)(nil))
	Namespace.AddClassOf((*WglCreateContextAttribsARB)(nil))
	Namespace.AddClassOf((*WglMakeCurrent)(nil))
	Namespace.AddClassOf((*WglSwapBuffers)(nil))
	Namespace.AddClassOf((*u32Limits)(nil))
}

type binaryClassActiveAttribute struct{}

func (*ActiveAttribute) Class() binary.Class {
	return (*binaryClassActiveAttribute)(nil)
}
func doEncodeActiveAttribute(e binary.Writer, o *ActiveAttribute) {
	e.String(o.Name)
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.ArraySize))
	e.Uint32(uint32(o.Location))
}
func doDecodeActiveAttribute(d binary.Reader, o *ActiveAttribute) {
	o.Name = string(d.String())
	o.Type = GLenum(d.Uint32())
	o.ArraySize = GLint(d.Int32())
	o.Location = AttributeLocation(d.Uint32())
}
func doDecodeRawActiveAttribute(d binary.Reader, o *ActiveAttribute) {
	o.Name = string(d.String())
	o.Type = GLenum(d.Uint32())
	o.ArraySize = GLint(d.Int32())
	o.Location = AttributeLocation(d.Uint32())
}
func (*binaryClassActiveAttribute) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeActiveAttribute(e, obj.(*ActiveAttribute))
}
func (*binaryClassActiveAttribute) New() binary.Object {
	return &ActiveAttribute{}
}
func (*binaryClassActiveAttribute) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeActiveAttribute(d, obj.(*ActiveAttribute))
}
func (o *ActiveAttribute) WriteSimple(w binary.Writer) {
	doEncodeActiveAttribute(w, o)
}
func (o *ActiveAttribute) ReadSimple(r binary.Reader) {
	doDecodeActiveAttribute(r, o)
}
func (c *binaryClassActiveAttribute) Schema() *binary.Entity {
	return &entities[ixǁActiveAttribute]
}

type binaryClassActiveUniform struct{}

func (*ActiveUniform) Class() binary.Class {
	return (*binaryClassActiveUniform)(nil)
}
func doEncodeActiveUniform(e binary.Writer, o *ActiveUniform) {
	e.String(o.Name)
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.ArraySize))
	e.Int32(int32(o.Location))
}
func doDecodeActiveUniform(d binary.Reader, o *ActiveUniform) {
	o.Name = string(d.String())
	o.Type = GLenum(d.Uint32())
	o.ArraySize = GLint(d.Int32())
	o.Location = UniformLocation(d.Int32())
}
func doDecodeRawActiveUniform(d binary.Reader, o *ActiveUniform) {
	o.Name = string(d.String())
	o.Type = GLenum(d.Uint32())
	o.ArraySize = GLint(d.Int32())
	o.Location = UniformLocation(d.Int32())
}
func (*binaryClassActiveUniform) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeActiveUniform(e, obj.(*ActiveUniform))
}
func (*binaryClassActiveUniform) New() binary.Object {
	return &ActiveUniform{}
}
func (*binaryClassActiveUniform) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeActiveUniform(d, obj.(*ActiveUniform))
}
func (o *ActiveUniform) WriteSimple(w binary.Writer) {
	doEncodeActiveUniform(w, o)
}
func (o *ActiveUniform) ReadSimple(r binary.Reader) {
	doDecodeActiveUniform(r, o)
}
func (c *binaryClassActiveUniform) Schema() *binary.Entity {
	return &entities[ixǁActiveUniform]
}

type binaryClassBlendState struct{}

func (*BlendState) Class() binary.Class {
	return (*binaryClassBlendState)(nil)
}
func doEncodeBlendState(e binary.Writer, o *BlendState) {
	e.Uint8(uint8(o.Enabled))
	e.Uint32(uint32(o.SrcRgb))
	e.Uint32(uint32(o.SrcAlpha))
	e.Uint32(uint32(o.DstRgb))
	e.Uint32(uint32(o.DstAlpha))
	e.Uint32(uint32(o.EquationRgb))
	e.Uint32(uint32(o.EquationAlpha))
}
func doDecodeBlendState(d binary.Reader, o *BlendState) {
	o.Enabled = GLboolean(d.Uint8())
	o.SrcRgb = GLenum(d.Uint32())
	o.SrcAlpha = GLenum(d.Uint32())
	o.DstRgb = GLenum(d.Uint32())
	o.DstAlpha = GLenum(d.Uint32())
	o.EquationRgb = GLenum(d.Uint32())
	o.EquationAlpha = GLenum(d.Uint32())
}
func doDecodeRawBlendState(d binary.Reader, o *BlendState) {
	o.Enabled = GLboolean(d.Uint8())
	o.SrcRgb = GLenum(d.Uint32())
	o.SrcAlpha = GLenum(d.Uint32())
	o.DstRgb = GLenum(d.Uint32())
	o.DstAlpha = GLenum(d.Uint32())
	o.EquationRgb = GLenum(d.Uint32())
	o.EquationAlpha = GLenum(d.Uint32())
}
func (*binaryClassBlendState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeBlendState(e, obj.(*BlendState))
}
func (*binaryClassBlendState) New() binary.Object {
	return &BlendState{}
}
func (*binaryClassBlendState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeBlendState(d, obj.(*BlendState))
}
func (o *BlendState) WriteSimple(w binary.Writer) {
	doEncodeBlendState(w, o)
}
func (o *BlendState) ReadSimple(r binary.Reader) {
	doDecodeBlendState(r, o)
}
func (c *binaryClassBlendState) Schema() *binary.Entity {
	return &entities[ixǁBlendState]
}

type binaryClassVec4f struct{}

func (*Vec4f) Class() binary.Class {
	return (*binaryClassVec4f)(nil)
}
func doEncodeVec4f(e binary.Writer, o *Vec4f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Float32(float32(*curr))
	}
}
func doDecodeVec4f(d binary.Reader, o *Vec4f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func doDecodeRawVec4f(d binary.Reader, o *Vec4f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func (*binaryClassVec4f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4f(e, obj.(*Vec4f))
}
func (*binaryClassVec4f) New() binary.Object {
	return &Vec4f{}
}
func (*binaryClassVec4f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4f(d, obj.(*Vec4f))
}
func (o *Vec4f) WriteSimple(w binary.Writer) {
	doEncodeVec4f(w, o)
}
func (o *Vec4f) ReadSimple(r binary.Reader) {
	doDecodeVec4f(r, o)
}
func (c *binaryClassVec4f) Schema() *binary.Entity {
	return &entities[ixǁVec4f]
}

type binaryClassBoundingBox struct{}

func (*BoundingBox) Class() binary.Class {
	return (*binaryClassBoundingBox)(nil)
}
func doEncodeBoundingBox(e binary.Writer, o *BoundingBox) {
	e.Simple(&o.Min)
	e.Simple(&o.Max)
}
func doDecodeBoundingBox(d binary.Reader, o *BoundingBox) {
	d.Simple(&o.Min)
	d.Simple(&o.Max)
}
func doDecodeRawBoundingBox(d binary.Reader, o *BoundingBox) {
	d.Simple(&o.Min)
	d.Simple(&o.Max)
}
func (*binaryClassBoundingBox) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeBoundingBox(e, obj.(*BoundingBox))
}
func (*binaryClassBoundingBox) New() binary.Object {
	return &BoundingBox{}
}
func (*binaryClassBoundingBox) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeBoundingBox(d, obj.(*BoundingBox))
}
func (o *BoundingBox) WriteSimple(w binary.Writer) {
	doEncodeBoundingBox(w, o)
}
func (o *BoundingBox) ReadSimple(r binary.Reader) {
	doDecodeBoundingBox(r, o)
}
func (c *binaryClassBoundingBox) Schema() *binary.Entity {
	return &entities[ixǁBoundingBox]
}

type binaryClassU8ˢ struct{}

func (*U8ˢ) Class() binary.Class {
	return (*binaryClassU8ˢ)(nil)
}
func doEncodeU8ˢ(e binary.Writer, o *U8ˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeU8ˢ(d binary.Reader, o *U8ˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawU8ˢ(d binary.Reader, o *U8ˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassU8ˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeU8ˢ(e, obj.(*U8ˢ))
}
func (*binaryClassU8ˢ) New() binary.Object {
	return &U8ˢ{}
}
func (*binaryClassU8ˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeU8ˢ(d, obj.(*U8ˢ))
}
func (o *U8ˢ) WriteSimple(w binary.Writer) {
	doEncodeU8ˢ(w, o)
}
func (o *U8ˢ) ReadSimple(r binary.Reader) {
	doDecodeU8ˢ(r, o)
}
func (c *binaryClassU8ˢ) Schema() *binary.Entity {
	return &entities[ixǁU8ˢ]
}

type binaryClassU8ᵖ struct{}

func (*U8ᵖ) Class() binary.Class {
	return (*binaryClassU8ᵖ)(nil)
}
func doEncodeU8ᵖ(e binary.Writer, o *U8ᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeU8ᵖ(d binary.Reader, o *U8ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawU8ᵖ(d binary.Reader, o *U8ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassU8ᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeU8ᵖ(e, obj.(*U8ᵖ))
}
func (*binaryClassU8ᵖ) New() binary.Object {
	return &U8ᵖ{}
}
func (*binaryClassU8ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeU8ᵖ(d, obj.(*U8ᵖ))
}
func (o *U8ᵖ) WriteSimple(w binary.Writer) {
	doEncodeU8ᵖ(w, o)
}
func (o *U8ᵖ) ReadSimple(r binary.Reader) {
	doDecodeU8ᵖ(r, o)
}
func (c *binaryClassU8ᵖ) Schema() *binary.Entity {
	return &entities[ixǁU8ᵖ]
}

type binaryClassBuffer struct{}

func (*Buffer) Class() binary.Class {
	return (*binaryClassBuffer)(nil)
}
func doEncodeBuffer(e binary.Writer, o *Buffer) {
	e.Simple(&o.Data)
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Usage))
	e.Uint32(uint32(o.AccessFlags))
	e.Uint8(uint8(o.Mapped))
	e.Simple(&o.MapPointer)
	e.Int32(int32(o.MapOffset))
	e.Int32(int32(o.MapLength))
	e.String(o.Label)
}
func doDecodeBuffer(d binary.Reader, o *Buffer) {
	d.Simple(&o.Data)
	o.Size = GLsizeiptr(d.Int32())
	o.Usage = GLenum(d.Uint32())
	o.AccessFlags = GLbitfield(d.Uint32())
	o.Mapped = GLboolean(d.Uint8())
	d.Simple(&o.MapPointer)
	o.MapOffset = GLintptr(d.Int32())
	o.MapLength = GLsizeiptr(d.Int32())
	o.Label = string(d.String())
}
func doDecodeRawBuffer(d binary.Reader, o *Buffer) {
	d.Simple(&o.Data)
	o.Size = GLsizeiptr(d.Int32())
	o.Usage = GLenum(d.Uint32())
	o.AccessFlags = GLbitfield(d.Uint32())
	o.Mapped = GLboolean(d.Uint8())
	d.Simple(&o.MapPointer)
	o.MapOffset = GLintptr(d.Int32())
	o.MapLength = GLsizeiptr(d.Int32())
	o.Label = string(d.String())
}
func (*binaryClassBuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeBuffer(e, obj.(*Buffer))
}
func (*binaryClassBuffer) New() binary.Object {
	return &Buffer{}
}
func (*binaryClassBuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeBuffer(d, obj.(*Buffer))
}
func (o *Buffer) WriteSimple(w binary.Writer) {
	doEncodeBuffer(w, o)
}
func (o *Buffer) ReadSimple(r binary.Reader) {
	doDecodeBuffer(r, o)
}
func (c *binaryClassBuffer) Schema() *binary.Entity {
	return &entities[ixǁBuffer]
}

type binaryClassBufferBinding struct{}

func (*BufferBinding) Class() binary.Class {
	return (*binaryClassBufferBinding)(nil)
}
func doEncodeBufferBinding(e binary.Writer, o *BufferBinding) {
	e.Uint32(uint32(o.Binding))
	e.Int32(int32(o.Start))
	e.Int32(int32(o.Size))
}
func doDecodeBufferBinding(d binary.Reader, o *BufferBinding) {
	o.Binding = BufferId(d.Uint32())
	o.Start = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func doDecodeRawBufferBinding(d binary.Reader, o *BufferBinding) {
	o.Binding = BufferId(d.Uint32())
	o.Start = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func (*binaryClassBufferBinding) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeBufferBinding(e, obj.(*BufferBinding))
}
func (*binaryClassBufferBinding) New() binary.Object {
	return &BufferBinding{}
}
func (*binaryClassBufferBinding) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeBufferBinding(d, obj.(*BufferBinding))
}
func (o *BufferBinding) WriteSimple(w binary.Writer) {
	doEncodeBufferBinding(w, o)
}
func (o *BufferBinding) ReadSimple(r binary.Reader) {
	doDecodeBufferBinding(r, o)
}
func (c *binaryClassBufferBinding) Schema() *binary.Entity {
	return &entities[ixǁBufferBinding]
}

type binaryClassBufferBindings struct{}

func (*BufferBindings) Class() binary.Class {
	return (*binaryClassBufferBindings)(nil)
}
func doEncodeBufferBindings(e binary.Writer, o *BufferBindings) {
	e.Uint32(uint32(o.ArrayBuffer))
	e.Uint32(uint32(o.AtomicCounterBuffer))
	e.Uint32(uint32(len(o.AtomicCounterBuffers)))
	for _, k := range (o.AtomicCounterBuffers).KeysSorted() {
		v := (o.AtomicCounterBuffers)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
	e.Uint32(uint32(o.CopyReadBuffer))
	e.Uint32(uint32(o.CopyWriteBuffer))
	e.Uint32(uint32(o.DispatchIndirectBuffer))
	e.Uint32(uint32(o.DrawIndirectBuffer))
	e.Uint32(uint32(o.PixelPackBuffer))
	e.Uint32(uint32(o.PixelUnpackBuffer))
	e.Uint32(uint32(o.ShaderStorageBuffer))
	e.Uint32(uint32(len(o.ShaderStorageBuffers)))
	for _, k := range (o.ShaderStorageBuffers).KeysSorted() {
		v := (o.ShaderStorageBuffers)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
	e.Uint32(uint32(o.TextureBuffer))
	e.Uint32(uint32(o.TransformFeedbackBuffer))
	e.Uint32(uint32(o.UniformBuffer))
	e.Uint32(uint32(len(o.UniformBuffers)))
	for _, k := range (o.UniformBuffers).KeysSorted() {
		v := (o.UniformBuffers)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
}
func doDecodeBufferBindings(d binary.Reader, o *BufferBindings) {
	o.ArrayBuffer = BufferId(d.Uint32())
	o.AtomicCounterBuffer = BufferId(d.Uint32())
	if count := d.Count(); count > 0 {
		o.AtomicCounterBuffers = make(GLuintːBufferBindingᵐ, count)
		m := o.AtomicCounterBuffers
		for i := uint32(0); i < count; i++ {
			var k GLuint
			var v BufferBinding
			k = GLuint(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.CopyReadBuffer = BufferId(d.Uint32())
	o.CopyWriteBuffer = BufferId(d.Uint32())
	o.DispatchIndirectBuffer = BufferId(d.Uint32())
	o.DrawIndirectBuffer = BufferId(d.Uint32())
	o.PixelPackBuffer = BufferId(d.Uint32())
	o.PixelUnpackBuffer = BufferId(d.Uint32())
	o.ShaderStorageBuffer = BufferId(d.Uint32())
	if count := d.Count(); count > 0 {
		o.ShaderStorageBuffers = make(GLuintːBufferBindingᵐ, count)
		m := o.ShaderStorageBuffers
		for i := uint32(0); i < count; i++ {
			var k GLuint
			var v BufferBinding
			k = GLuint(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.TextureBuffer = BufferId(d.Uint32())
	o.TransformFeedbackBuffer = BufferId(d.Uint32())
	o.UniformBuffer = BufferId(d.Uint32())
	if count := d.Count(); count > 0 {
		o.UniformBuffers = make(GLuintːBufferBindingᵐ, count)
		m := o.UniformBuffers
		for i := uint32(0); i < count; i++ {
			var k GLuint
			var v BufferBinding
			k = GLuint(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
}
func doDecodeRawBufferBindings(d binary.Reader, o *BufferBindings) {
	o.ArrayBuffer = BufferId(d.Uint32())
	o.AtomicCounterBuffer = BufferId(d.Uint32())
	if count := d.Count(); count > 0 {
		o.AtomicCounterBuffers = make(GLuintːBufferBindingᵐ, count)
		m := o.AtomicCounterBuffers
		for i := uint32(0); i < count; i++ {
			var k GLuint
			var v BufferBinding
			k = GLuint(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.CopyReadBuffer = BufferId(d.Uint32())
	o.CopyWriteBuffer = BufferId(d.Uint32())
	o.DispatchIndirectBuffer = BufferId(d.Uint32())
	o.DrawIndirectBuffer = BufferId(d.Uint32())
	o.PixelPackBuffer = BufferId(d.Uint32())
	o.PixelUnpackBuffer = BufferId(d.Uint32())
	o.ShaderStorageBuffer = BufferId(d.Uint32())
	if count := d.Count(); count > 0 {
		o.ShaderStorageBuffers = make(GLuintːBufferBindingᵐ, count)
		m := o.ShaderStorageBuffers
		for i := uint32(0); i < count; i++ {
			var k GLuint
			var v BufferBinding
			k = GLuint(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.TextureBuffer = BufferId(d.Uint32())
	o.TransformFeedbackBuffer = BufferId(d.Uint32())
	o.UniformBuffer = BufferId(d.Uint32())
	if count := d.Count(); count > 0 {
		o.UniformBuffers = make(GLuintːBufferBindingᵐ, count)
		m := o.UniformBuffers
		for i := uint32(0); i < count; i++ {
			var k GLuint
			var v BufferBinding
			k = GLuint(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
}
func (*binaryClassBufferBindings) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeBufferBindings(e, obj.(*BufferBindings))
}
func (*binaryClassBufferBindings) New() binary.Object {
	return &BufferBindings{}
}
func (*binaryClassBufferBindings) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeBufferBindings(d, obj.(*BufferBindings))
}
func (o *BufferBindings) WriteSimple(w binary.Writer) {
	doEncodeBufferBindings(w, o)
}
func (o *BufferBindings) ReadSimple(r binary.Reader) {
	doDecodeBufferBindings(r, o)
}
func (c *binaryClassBufferBindings) Schema() *binary.Entity {
	return &entities[ixǁBufferBindings]
}

type binaryClassBufferDataPointer struct{}

func (*BufferDataPointer) Class() binary.Class {
	return (*binaryClassBufferDataPointer)(nil)
}
func doEncodeBufferDataPointer(e binary.Writer, o *BufferDataPointer) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeBufferDataPointer(d binary.Reader, o *BufferDataPointer) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawBufferDataPointer(d binary.Reader, o *BufferDataPointer) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassBufferDataPointer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeBufferDataPointer(e, obj.(*BufferDataPointer))
}
func (*binaryClassBufferDataPointer) New() binary.Object {
	return &BufferDataPointer{}
}
func (*binaryClassBufferDataPointer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeBufferDataPointer(d, obj.(*BufferDataPointer))
}
func (o *BufferDataPointer) WriteSimple(w binary.Writer) {
	doEncodeBufferDataPointer(w, o)
}
func (o *BufferDataPointer) ReadSimple(r binary.Reader) {
	doDecodeBufferDataPointer(r, o)
}
func (c *binaryClassBufferDataPointer) Schema() *binary.Entity {
	return &entities[ixǁBufferDataPointer]
}

type binaryClassBufferIdˢ struct{}

func (*BufferIdˢ) Class() binary.Class {
	return (*binaryClassBufferIdˢ)(nil)
}
func doEncodeBufferIdˢ(e binary.Writer, o *BufferIdˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeBufferIdˢ(d binary.Reader, o *BufferIdˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawBufferIdˢ(d binary.Reader, o *BufferIdˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassBufferIdˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeBufferIdˢ(e, obj.(*BufferIdˢ))
}
func (*binaryClassBufferIdˢ) New() binary.Object {
	return &BufferIdˢ{}
}
func (*binaryClassBufferIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeBufferIdˢ(d, obj.(*BufferIdˢ))
}
func (o *BufferIdˢ) WriteSimple(w binary.Writer) {
	doEncodeBufferIdˢ(w, o)
}
func (o *BufferIdˢ) ReadSimple(r binary.Reader) {
	doDecodeBufferIdˢ(r, o)
}
func (c *binaryClassBufferIdˢ) Schema() *binary.Entity {
	return &entities[ixǁBufferIdˢ]
}

type binaryClassBufferIdᵖ struct{}

func (*BufferIdᵖ) Class() binary.Class {
	return (*binaryClassBufferIdᵖ)(nil)
}
func doEncodeBufferIdᵖ(e binary.Writer, o *BufferIdᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeBufferIdᵖ(d binary.Reader, o *BufferIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawBufferIdᵖ(d binary.Reader, o *BufferIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassBufferIdᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeBufferIdᵖ(e, obj.(*BufferIdᵖ))
}
func (*binaryClassBufferIdᵖ) New() binary.Object {
	return &BufferIdᵖ{}
}
func (*binaryClassBufferIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeBufferIdᵖ(d, obj.(*BufferIdᵖ))
}
func (o *BufferIdᵖ) WriteSimple(w binary.Writer) {
	doEncodeBufferIdᵖ(w, o)
}
func (o *BufferIdᵖ) ReadSimple(r binary.Reader) {
	doDecodeBufferIdᵖ(r, o)
}
func (c *binaryClassBufferIdᵖ) Schema() *binary.Entity {
	return &entities[ixǁBufferIdᵖ]
}

type binaryClassBufferIdᶜᵖ struct{}

func (*BufferIdᶜᵖ) Class() binary.Class {
	return (*binaryClassBufferIdᶜᵖ)(nil)
}
func doEncodeBufferIdᶜᵖ(e binary.Writer, o *BufferIdᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeBufferIdᶜᵖ(d binary.Reader, o *BufferIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawBufferIdᶜᵖ(d binary.Reader, o *BufferIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassBufferIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeBufferIdᶜᵖ(e, obj.(*BufferIdᶜᵖ))
}
func (*binaryClassBufferIdᶜᵖ) New() binary.Object {
	return &BufferIdᶜᵖ{}
}
func (*binaryClassBufferIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeBufferIdᶜᵖ(d, obj.(*BufferIdᶜᵖ))
}
func (o *BufferIdᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeBufferIdᶜᵖ(w, o)
}
func (o *BufferIdᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeBufferIdᶜᵖ(r, o)
}
func (c *binaryClassBufferIdᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁBufferIdᶜᵖ]
}

type binaryClassCGLContextObj struct{}

func (*CGLContextObj) Class() binary.Class {
	return (*binaryClassCGLContextObj)(nil)
}
func doEncodeCGLContextObj(e binary.Writer, o *CGLContextObj) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeCGLContextObj(d binary.Reader, o *CGLContextObj) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawCGLContextObj(d binary.Reader, o *CGLContextObj) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassCGLContextObj) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGLContextObj(e, obj.(*CGLContextObj))
}
func (*binaryClassCGLContextObj) New() binary.Object {
	return &CGLContextObj{}
}
func (*binaryClassCGLContextObj) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGLContextObj(d, obj.(*CGLContextObj))
}
func (o *CGLContextObj) WriteSimple(w binary.Writer) {
	doEncodeCGLContextObj(w, o)
}
func (o *CGLContextObj) ReadSimple(r binary.Reader) {
	doDecodeCGLContextObj(r, o)
}
func (c *binaryClassCGLContextObj) Schema() *binary.Entity {
	return &entities[ixǁCGLContextObj]
}

type binaryClassCGLContextObjˢ struct{}

func (*CGLContextObjˢ) Class() binary.Class {
	return (*binaryClassCGLContextObjˢ)(nil)
}
func doEncodeCGLContextObjˢ(e binary.Writer, o *CGLContextObjˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeCGLContextObjˢ(d binary.Reader, o *CGLContextObjˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawCGLContextObjˢ(d binary.Reader, o *CGLContextObjˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassCGLContextObjˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGLContextObjˢ(e, obj.(*CGLContextObjˢ))
}
func (*binaryClassCGLContextObjˢ) New() binary.Object {
	return &CGLContextObjˢ{}
}
func (*binaryClassCGLContextObjˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGLContextObjˢ(d, obj.(*CGLContextObjˢ))
}
func (o *CGLContextObjˢ) WriteSimple(w binary.Writer) {
	doEncodeCGLContextObjˢ(w, o)
}
func (o *CGLContextObjˢ) ReadSimple(r binary.Reader) {
	doDecodeCGLContextObjˢ(r, o)
}
func (c *binaryClassCGLContextObjˢ) Schema() *binary.Entity {
	return &entities[ixǁCGLContextObjˢ]
}

type binaryClassCGLContextObjᵖ struct{}

func (*CGLContextObjᵖ) Class() binary.Class {
	return (*binaryClassCGLContextObjᵖ)(nil)
}
func doEncodeCGLContextObjᵖ(e binary.Writer, o *CGLContextObjᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeCGLContextObjᵖ(d binary.Reader, o *CGLContextObjᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawCGLContextObjᵖ(d binary.Reader, o *CGLContextObjᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassCGLContextObjᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGLContextObjᵖ(e, obj.(*CGLContextObjᵖ))
}
func (*binaryClassCGLContextObjᵖ) New() binary.Object {
	return &CGLContextObjᵖ{}
}
func (*binaryClassCGLContextObjᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGLContextObjᵖ(d, obj.(*CGLContextObjᵖ))
}
func (o *CGLContextObjᵖ) WriteSimple(w binary.Writer) {
	doEncodeCGLContextObjᵖ(w, o)
}
func (o *CGLContextObjᵖ) ReadSimple(r binary.Reader) {
	doDecodeCGLContextObjᵖ(r, o)
}
func (c *binaryClassCGLContextObjᵖ) Schema() *binary.Entity {
	return &entities[ixǁCGLContextObjᵖ]
}

type binaryClassCGLTexelFormatObj struct{}

func (*CGLTexelFormatObj) Class() binary.Class {
	return (*binaryClassCGLTexelFormatObj)(nil)
}
func doEncodeCGLTexelFormatObj(e binary.Writer, o *CGLTexelFormatObj) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeCGLTexelFormatObj(d binary.Reader, o *CGLTexelFormatObj) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawCGLTexelFormatObj(d binary.Reader, o *CGLTexelFormatObj) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassCGLTexelFormatObj) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGLTexelFormatObj(e, obj.(*CGLTexelFormatObj))
}
func (*binaryClassCGLTexelFormatObj) New() binary.Object {
	return &CGLTexelFormatObj{}
}
func (*binaryClassCGLTexelFormatObj) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGLTexelFormatObj(d, obj.(*CGLTexelFormatObj))
}
func (o *CGLTexelFormatObj) WriteSimple(w binary.Writer) {
	doEncodeCGLTexelFormatObj(w, o)
}
func (o *CGLTexelFormatObj) ReadSimple(r binary.Reader) {
	doDecodeCGLTexelFormatObj(r, o)
}
func (c *binaryClassCGLTexelFormatObj) Schema() *binary.Entity {
	return &entities[ixǁCGLTexelFormatObj]
}

type binaryClassCGLCreateContext struct{}

func (*CGLCreateContext) Class() binary.Class {
	return (*binaryClassCGLCreateContext)(nil)
}
func doEncodeCGLCreateContext(e binary.Encoder, o *CGLCreateContext) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Pix)
	e.Simple(&o.Share)
	e.Simple(&o.Ctx)
	e.Int64(int64(o.Result))
}
func doDecodeCGLCreateContext(d binary.Decoder, o *CGLCreateContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Pix)
	d.Simple(&o.Share)
	d.Simple(&o.Ctx)
	o.Result = CGLError(d.Int64())
}
func doDecodeRawCGLCreateContext(d binary.Decoder, o *CGLCreateContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Pix)
	d.Simple(&o.Share)
	d.Simple(&o.Ctx)
	o.Result = CGLError(d.Int64())
}
func (*binaryClassCGLCreateContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGLCreateContext(e, obj.(*CGLCreateContext))
}
func (*binaryClassCGLCreateContext) New() binary.Object {
	return &CGLCreateContext{}
}
func (*binaryClassCGLCreateContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGLCreateContext(d, obj.(*CGLCreateContext))
}
func (c *binaryClassCGLCreateContext) Schema() *binary.Entity {
	return &entities[ixǁCGLCreateContext]
}

type binaryClassCGLFlushDrawable struct{}

func (*CGLFlushDrawable) Class() binary.Class {
	return (*binaryClassCGLFlushDrawable)(nil)
}
func doEncodeCGLFlushDrawable(e binary.Encoder, o *CGLFlushDrawable) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Ctx)
	e.Int64(int64(o.Result))
}
func doDecodeCGLFlushDrawable(d binary.Decoder, o *CGLFlushDrawable) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ctx)
	o.Result = CGLError(d.Int64())
}
func doDecodeRawCGLFlushDrawable(d binary.Decoder, o *CGLFlushDrawable) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ctx)
	o.Result = CGLError(d.Int64())
}
func (*binaryClassCGLFlushDrawable) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGLFlushDrawable(e, obj.(*CGLFlushDrawable))
}
func (*binaryClassCGLFlushDrawable) New() binary.Object {
	return &CGLFlushDrawable{}
}
func (*binaryClassCGLFlushDrawable) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGLFlushDrawable(d, obj.(*CGLFlushDrawable))
}
func (c *binaryClassCGLFlushDrawable) Schema() *binary.Entity {
	return &entities[ixǁCGLFlushDrawable]
}

type binaryClassCGSConnectionIDᵖ struct{}

func (*CGSConnectionIDᵖ) Class() binary.Class {
	return (*binaryClassCGSConnectionIDᵖ)(nil)
}
func doEncodeCGSConnectionIDᵖ(e binary.Writer, o *CGSConnectionIDᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeCGSConnectionIDᵖ(d binary.Reader, o *CGSConnectionIDᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawCGSConnectionIDᵖ(d binary.Reader, o *CGSConnectionIDᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassCGSConnectionIDᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGSConnectionIDᵖ(e, obj.(*CGSConnectionIDᵖ))
}
func (*binaryClassCGSConnectionIDᵖ) New() binary.Object {
	return &CGSConnectionIDᵖ{}
}
func (*binaryClassCGSConnectionIDᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGSConnectionIDᵖ(d, obj.(*CGSConnectionIDᵖ))
}
func (o *CGSConnectionIDᵖ) WriteSimple(w binary.Writer) {
	doEncodeCGSConnectionIDᵖ(w, o)
}
func (o *CGSConnectionIDᵖ) ReadSimple(r binary.Reader) {
	doDecodeCGSConnectionIDᵖ(r, o)
}
func (c *binaryClassCGSConnectionIDᵖ) Schema() *binary.Entity {
	return &entities[ixǁCGSConnectionIDᵖ]
}

type binaryClassCGSWindowIDᵖ struct{}

func (*CGSWindowIDᵖ) Class() binary.Class {
	return (*binaryClassCGSWindowIDᵖ)(nil)
}
func doEncodeCGSWindowIDᵖ(e binary.Writer, o *CGSWindowIDᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeCGSWindowIDᵖ(d binary.Reader, o *CGSWindowIDᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawCGSWindowIDᵖ(d binary.Reader, o *CGSWindowIDᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassCGSWindowIDᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGSWindowIDᵖ(e, obj.(*CGSWindowIDᵖ))
}
func (*binaryClassCGSWindowIDᵖ) New() binary.Object {
	return &CGSWindowIDᵖ{}
}
func (*binaryClassCGSWindowIDᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGSWindowIDᵖ(d, obj.(*CGSWindowIDᵖ))
}
func (o *CGSWindowIDᵖ) WriteSimple(w binary.Writer) {
	doEncodeCGSWindowIDᵖ(w, o)
}
func (o *CGSWindowIDᵖ) ReadSimple(r binary.Reader) {
	doDecodeCGSWindowIDᵖ(r, o)
}
func (c *binaryClassCGSWindowIDᵖ) Schema() *binary.Entity {
	return &entities[ixǁCGSWindowIDᵖ]
}

type binaryClassCGSSurfaceIDᵖ struct{}

func (*CGSSurfaceIDᵖ) Class() binary.Class {
	return (*binaryClassCGSSurfaceIDᵖ)(nil)
}
func doEncodeCGSSurfaceIDᵖ(e binary.Writer, o *CGSSurfaceIDᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeCGSSurfaceIDᵖ(d binary.Reader, o *CGSSurfaceIDᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawCGSSurfaceIDᵖ(d binary.Reader, o *CGSSurfaceIDᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassCGSSurfaceIDᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGSSurfaceIDᵖ(e, obj.(*CGSSurfaceIDᵖ))
}
func (*binaryClassCGSSurfaceIDᵖ) New() binary.Object {
	return &CGSSurfaceIDᵖ{}
}
func (*binaryClassCGSSurfaceIDᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGSSurfaceIDᵖ(d, obj.(*CGSSurfaceIDᵖ))
}
func (o *CGSSurfaceIDᵖ) WriteSimple(w binary.Writer) {
	doEncodeCGSSurfaceIDᵖ(w, o)
}
func (o *CGSSurfaceIDᵖ) ReadSimple(r binary.Reader) {
	doDecodeCGSSurfaceIDᵖ(r, o)
}
func (c *binaryClassCGSSurfaceIDᵖ) Schema() *binary.Entity {
	return &entities[ixǁCGSSurfaceIDᵖ]
}

type binaryClassCGLGetSurface struct{}

func (*CGLGetSurface) Class() binary.Class {
	return (*binaryClassCGLGetSurface)(nil)
}
func doEncodeCGLGetSurface(e binary.Encoder, o *CGLGetSurface) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Ctx)
	e.Simple(&o.Cid)
	e.Simple(&o.Wid)
	e.Simple(&o.Sid)
	e.Int64(o.Result)
}
func doDecodeCGLGetSurface(d binary.Decoder, o *CGLGetSurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ctx)
	d.Simple(&o.Cid)
	d.Simple(&o.Wid)
	d.Simple(&o.Sid)
	o.Result = int64(d.Int64())
}
func doDecodeRawCGLGetSurface(d binary.Decoder, o *CGLGetSurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ctx)
	d.Simple(&o.Cid)
	d.Simple(&o.Wid)
	d.Simple(&o.Sid)
	o.Result = int64(d.Int64())
}
func (*binaryClassCGLGetSurface) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGLGetSurface(e, obj.(*CGLGetSurface))
}
func (*binaryClassCGLGetSurface) New() binary.Object {
	return &CGLGetSurface{}
}
func (*binaryClassCGLGetSurface) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGLGetSurface(d, obj.(*CGLGetSurface))
}
func (c *binaryClassCGLGetSurface) Schema() *binary.Entity {
	return &entities[ixǁCGLGetSurface]
}

type binaryClassCGLSetCurrentContext struct{}

func (*CGLSetCurrentContext) Class() binary.Class {
	return (*binaryClassCGLSetCurrentContext)(nil)
}
func doEncodeCGLSetCurrentContext(e binary.Encoder, o *CGLSetCurrentContext) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Ctx)
	e.Int64(int64(o.Result))
}
func doDecodeCGLSetCurrentContext(d binary.Decoder, o *CGLSetCurrentContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ctx)
	o.Result = CGLError(d.Int64())
}
func doDecodeRawCGLSetCurrentContext(d binary.Decoder, o *CGLSetCurrentContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ctx)
	o.Result = CGLError(d.Int64())
}
func (*binaryClassCGLSetCurrentContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGLSetCurrentContext(e, obj.(*CGLSetCurrentContext))
}
func (*binaryClassCGLSetCurrentContext) New() binary.Object {
	return &CGLSetCurrentContext{}
}
func (*binaryClassCGLSetCurrentContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGLSetCurrentContext(d, obj.(*CGLSetCurrentContext))
}
func (c *binaryClassCGLSetCurrentContext) Schema() *binary.Entity {
	return &entities[ixǁCGLSetCurrentContext]
}

type binaryClassCGSConnectionID struct{}

func (*CGSConnectionID) Class() binary.Class {
	return (*binaryClassCGSConnectionID)(nil)
}
func doEncodeCGSConnectionID(e binary.Writer, o *CGSConnectionID) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeCGSConnectionID(d binary.Reader, o *CGSConnectionID) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawCGSConnectionID(d binary.Reader, o *CGSConnectionID) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassCGSConnectionID) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGSConnectionID(e, obj.(*CGSConnectionID))
}
func (*binaryClassCGSConnectionID) New() binary.Object {
	return &CGSConnectionID{}
}
func (*binaryClassCGSConnectionID) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGSConnectionID(d, obj.(*CGSConnectionID))
}
func (o *CGSConnectionID) WriteSimple(w binary.Writer) {
	doEncodeCGSConnectionID(w, o)
}
func (o *CGSConnectionID) ReadSimple(r binary.Reader) {
	doDecodeCGSConnectionID(r, o)
}
func (c *binaryClassCGSConnectionID) Schema() *binary.Entity {
	return &entities[ixǁCGSConnectionID]
}

type binaryClassCGSConnectionIDˢ struct{}

func (*CGSConnectionIDˢ) Class() binary.Class {
	return (*binaryClassCGSConnectionIDˢ)(nil)
}
func doEncodeCGSConnectionIDˢ(e binary.Writer, o *CGSConnectionIDˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeCGSConnectionIDˢ(d binary.Reader, o *CGSConnectionIDˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawCGSConnectionIDˢ(d binary.Reader, o *CGSConnectionIDˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassCGSConnectionIDˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGSConnectionIDˢ(e, obj.(*CGSConnectionIDˢ))
}
func (*binaryClassCGSConnectionIDˢ) New() binary.Object {
	return &CGSConnectionIDˢ{}
}
func (*binaryClassCGSConnectionIDˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGSConnectionIDˢ(d, obj.(*CGSConnectionIDˢ))
}
func (o *CGSConnectionIDˢ) WriteSimple(w binary.Writer) {
	doEncodeCGSConnectionIDˢ(w, o)
}
func (o *CGSConnectionIDˢ) ReadSimple(r binary.Reader) {
	doDecodeCGSConnectionIDˢ(r, o)
}
func (c *binaryClassCGSConnectionIDˢ) Schema() *binary.Entity {
	return &entities[ixǁCGSConnectionIDˢ]
}

type binaryClassF64ᵖ struct{}

func (*F64ᵖ) Class() binary.Class {
	return (*binaryClassF64ᵖ)(nil)
}
func doEncodeF64ᵖ(e binary.Writer, o *F64ᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeF64ᵖ(d binary.Reader, o *F64ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawF64ᵖ(d binary.Reader, o *F64ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassF64ᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeF64ᵖ(e, obj.(*F64ᵖ))
}
func (*binaryClassF64ᵖ) New() binary.Object {
	return &F64ᵖ{}
}
func (*binaryClassF64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeF64ᵖ(d, obj.(*F64ᵖ))
}
func (o *F64ᵖ) WriteSimple(w binary.Writer) {
	doEncodeF64ᵖ(w, o)
}
func (o *F64ᵖ) ReadSimple(r binary.Reader) {
	doDecodeF64ᵖ(r, o)
}
func (c *binaryClassF64ᵖ) Schema() *binary.Entity {
	return &entities[ixǁF64ᵖ]
}

type binaryClassCGSGetSurfaceBounds struct{}

func (*CGSGetSurfaceBounds) Class() binary.Class {
	return (*binaryClassCGSGetSurfaceBounds)(nil)
}
func doEncodeCGSGetSurfaceBounds(e binary.Encoder, o *CGSGetSurfaceBounds) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Cid)
	e.Int32(int32(o.Wid))
	e.Int32(int32(o.Sid))
	e.Simple(&o.Bounds)
	e.Int64(o.Result)
}
func doDecodeCGSGetSurfaceBounds(d binary.Decoder, o *CGSGetSurfaceBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Cid)
	o.Wid = CGSWindowID(d.Int32())
	o.Sid = CGSSurfaceID(d.Int32())
	d.Simple(&o.Bounds)
	o.Result = int64(d.Int64())
}
func doDecodeRawCGSGetSurfaceBounds(d binary.Decoder, o *CGSGetSurfaceBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Cid)
	o.Wid = CGSWindowID(d.Int32())
	o.Sid = CGSSurfaceID(d.Int32())
	d.Simple(&o.Bounds)
	o.Result = int64(d.Int64())
}
func (*binaryClassCGSGetSurfaceBounds) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGSGetSurfaceBounds(e, obj.(*CGSGetSurfaceBounds))
}
func (*binaryClassCGSGetSurfaceBounds) New() binary.Object {
	return &CGSGetSurfaceBounds{}
}
func (*binaryClassCGSGetSurfaceBounds) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGSGetSurfaceBounds(d, obj.(*CGSGetSurfaceBounds))
}
func (c *binaryClassCGSGetSurfaceBounds) Schema() *binary.Entity {
	return &entities[ixǁCGSGetSurfaceBounds]
}

type binaryClassCGSSurfaceIDˢ struct{}

func (*CGSSurfaceIDˢ) Class() binary.Class {
	return (*binaryClassCGSSurfaceIDˢ)(nil)
}
func doEncodeCGSSurfaceIDˢ(e binary.Writer, o *CGSSurfaceIDˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeCGSSurfaceIDˢ(d binary.Reader, o *CGSSurfaceIDˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawCGSSurfaceIDˢ(d binary.Reader, o *CGSSurfaceIDˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassCGSSurfaceIDˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGSSurfaceIDˢ(e, obj.(*CGSSurfaceIDˢ))
}
func (*binaryClassCGSSurfaceIDˢ) New() binary.Object {
	return &CGSSurfaceIDˢ{}
}
func (*binaryClassCGSSurfaceIDˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGSSurfaceIDˢ(d, obj.(*CGSSurfaceIDˢ))
}
func (o *CGSSurfaceIDˢ) WriteSimple(w binary.Writer) {
	doEncodeCGSSurfaceIDˢ(w, o)
}
func (o *CGSSurfaceIDˢ) ReadSimple(r binary.Reader) {
	doDecodeCGSSurfaceIDˢ(r, o)
}
func (c *binaryClassCGSSurfaceIDˢ) Schema() *binary.Entity {
	return &entities[ixǁCGSSurfaceIDˢ]
}

type binaryClassCGSWindowIDˢ struct{}

func (*CGSWindowIDˢ) Class() binary.Class {
	return (*binaryClassCGSWindowIDˢ)(nil)
}
func doEncodeCGSWindowIDˢ(e binary.Writer, o *CGSWindowIDˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeCGSWindowIDˢ(d binary.Reader, o *CGSWindowIDˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawCGSWindowIDˢ(d binary.Reader, o *CGSWindowIDˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassCGSWindowIDˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCGSWindowIDˢ(e, obj.(*CGSWindowIDˢ))
}
func (*binaryClassCGSWindowIDˢ) New() binary.Object {
	return &CGSWindowIDˢ{}
}
func (*binaryClassCGSWindowIDˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCGSWindowIDˢ(d, obj.(*CGSWindowIDˢ))
}
func (o *CGSWindowIDˢ) WriteSimple(w binary.Writer) {
	doEncodeCGSWindowIDˢ(w, o)
}
func (o *CGSWindowIDˢ) ReadSimple(r binary.Reader) {
	doDecodeCGSWindowIDˢ(r, o)
}
func (c *binaryClassCGSWindowIDˢ) Schema() *binary.Entity {
	return &entities[ixǁCGSWindowIDˢ]
}

type binaryClassCharˢ struct{}

func (*Charˢ) Class() binary.Class {
	return (*binaryClassCharˢ)(nil)
}
func doEncodeCharˢ(e binary.Writer, o *Charˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeCharˢ(d binary.Reader, o *Charˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawCharˢ(d binary.Reader, o *Charˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassCharˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCharˢ(e, obj.(*Charˢ))
}
func (*binaryClassCharˢ) New() binary.Object {
	return &Charˢ{}
}
func (*binaryClassCharˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCharˢ(d, obj.(*Charˢ))
}
func (o *Charˢ) WriteSimple(w binary.Writer) {
	doEncodeCharˢ(w, o)
}
func (o *Charˢ) ReadSimple(r binary.Reader) {
	doDecodeCharˢ(r, o)
}
func (c *binaryClassCharˢ) Schema() *binary.Entity {
	return &entities[ixǁCharˢ]
}

type binaryClassCharᵖ struct{}

func (*Charᵖ) Class() binary.Class {
	return (*binaryClassCharᵖ)(nil)
}
func doEncodeCharᵖ(e binary.Writer, o *Charᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeCharᵖ(d binary.Reader, o *Charᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawCharᵖ(d binary.Reader, o *Charᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassCharᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCharᵖ(e, obj.(*Charᵖ))
}
func (*binaryClassCharᵖ) New() binary.Object {
	return &Charᵖ{}
}
func (*binaryClassCharᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCharᵖ(d, obj.(*Charᵖ))
}
func (o *Charᵖ) WriteSimple(w binary.Writer) {
	doEncodeCharᵖ(w, o)
}
func (o *Charᵖ) ReadSimple(r binary.Reader) {
	doDecodeCharᵖ(r, o)
}
func (c *binaryClassCharᵖ) Schema() *binary.Entity {
	return &entities[ixǁCharᵖ]
}

type binaryClassCharᶜᵖ struct{}

func (*Charᶜᵖ) Class() binary.Class {
	return (*binaryClassCharᶜᵖ)(nil)
}
func doEncodeCharᶜᵖ(e binary.Writer, o *Charᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeCharᶜᵖ(d binary.Reader, o *Charᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawCharᶜᵖ(d binary.Reader, o *Charᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassCharᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCharᶜᵖ(e, obj.(*Charᶜᵖ))
}
func (*binaryClassCharᶜᵖ) New() binary.Object {
	return &Charᶜᵖ{}
}
func (*binaryClassCharᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCharᶜᵖ(d, obj.(*Charᶜᵖ))
}
func (o *Charᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeCharᶜᵖ(w, o)
}
func (o *Charᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeCharᶜᵖ(r, o)
}
func (c *binaryClassCharᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁCharᶜᵖ]
}

type binaryClassColor struct{}

func (*Color) Class() binary.Class {
	return (*binaryClassColor)(nil)
}
func doEncodeColor(e binary.Writer, o *Color) {
	e.Float32(float32(o.Red))
	e.Float32(float32(o.Green))
	e.Float32(float32(o.Blue))
	e.Float32(float32(o.Alpha))
}
func doDecodeColor(d binary.Reader, o *Color) {
	o.Red = GLfloat(d.Float32())
	o.Green = GLfloat(d.Float32())
	o.Blue = GLfloat(d.Float32())
	o.Alpha = GLfloat(d.Float32())
}
func doDecodeRawColor(d binary.Reader, o *Color) {
	o.Red = GLfloat(d.Float32())
	o.Green = GLfloat(d.Float32())
	o.Blue = GLfloat(d.Float32())
	o.Alpha = GLfloat(d.Float32())
}
func (*binaryClassColor) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeColor(e, obj.(*Color))
}
func (*binaryClassColor) New() binary.Object {
	return &Color{}
}
func (*binaryClassColor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeColor(d, obj.(*Color))
}
func (o *Color) WriteSimple(w binary.Writer) {
	doEncodeColor(w, o)
}
func (o *Color) ReadSimple(r binary.Reader) {
	doDecodeColor(r, o)
}
func (c *binaryClassColor) Schema() *binary.Entity {
	return &entities[ixǁColor]
}

type binaryClassGLfloatː2ᵃ struct{}

func (*GLfloatː2ᵃ) Class() binary.Class {
	return (*binaryClassGLfloatː2ᵃ)(nil)
}
func doEncodeGLfloatː2ᵃ(e binary.Writer, o *GLfloatː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Float32(float32(*curr))
	}
}
func doDecodeGLfloatː2ᵃ(d binary.Reader, o *GLfloatː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func doDecodeRawGLfloatː2ᵃ(d binary.Reader, o *GLfloatː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func (*binaryClassGLfloatː2ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLfloatː2ᵃ(e, obj.(*GLfloatː2ᵃ))
}
func (*binaryClassGLfloatː2ᵃ) New() binary.Object {
	return &GLfloatː2ᵃ{}
}
func (*binaryClassGLfloatː2ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLfloatː2ᵃ(d, obj.(*GLfloatː2ᵃ))
}
func (o *GLfloatː2ᵃ) WriteSimple(w binary.Writer) {
	doEncodeGLfloatː2ᵃ(w, o)
}
func (o *GLfloatː2ᵃ) ReadSimple(r binary.Reader) {
	doDecodeGLfloatː2ᵃ(r, o)
}
func (c *binaryClassGLfloatː2ᵃ) Schema() *binary.Entity {
	return &entities[ixǁGLfloatː2ᵃ]
}

type binaryClassGLintː2ᵃ struct{}

func (*GLintː2ᵃ) Class() binary.Class {
	return (*binaryClassGLintː2ᵃ)(nil)
}
func doEncodeGLintː2ᵃ(e binary.Writer, o *GLintː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Int32(int32(*curr))
	}
}
func doDecodeGLintː2ᵃ(d binary.Reader, o *GLintː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func doDecodeRawGLintː2ᵃ(d binary.Reader, o *GLintː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func (*binaryClassGLintː2ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLintː2ᵃ(e, obj.(*GLintː2ᵃ))
}
func (*binaryClassGLintː2ᵃ) New() binary.Object {
	return &GLintː2ᵃ{}
}
func (*binaryClassGLintː2ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLintː2ᵃ(d, obj.(*GLintː2ᵃ))
}
func (o *GLintː2ᵃ) WriteSimple(w binary.Writer) {
	doEncodeGLintː2ᵃ(w, o)
}
func (o *GLintː2ᵃ) ReadSimple(r binary.Reader) {
	doDecodeGLintː2ᵃ(r, o)
}
func (c *binaryClassGLintː2ᵃ) Schema() *binary.Entity {
	return &entities[ixǁGLintː2ᵃ]
}

type binaryClassPrecisionFormat struct{}

func (*PrecisionFormat) Class() binary.Class {
	return (*binaryClassPrecisionFormat)(nil)
}
func doEncodePrecisionFormat(e binary.Writer, o *PrecisionFormat) {
	e.Int32(int32(o.MinRange))
	e.Int32(int32(o.MaxRange))
	e.Int32(int32(o.Precision))
}
func doDecodePrecisionFormat(d binary.Reader, o *PrecisionFormat) {
	o.MinRange = GLint(d.Int32())
	o.MaxRange = GLint(d.Int32())
	o.Precision = GLint(d.Int32())
}
func doDecodeRawPrecisionFormat(d binary.Reader, o *PrecisionFormat) {
	o.MinRange = GLint(d.Int32())
	o.MaxRange = GLint(d.Int32())
	o.Precision = GLint(d.Int32())
}
func (*binaryClassPrecisionFormat) Encode(e binary.Encoder, obj binary.Object) {
	doEncodePrecisionFormat(e, obj.(*PrecisionFormat))
}
func (*binaryClassPrecisionFormat) New() binary.Object {
	return &PrecisionFormat{}
}
func (*binaryClassPrecisionFormat) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodePrecisionFormat(d, obj.(*PrecisionFormat))
}
func (o *PrecisionFormat) WriteSimple(w binary.Writer) {
	doEncodePrecisionFormat(w, o)
}
func (o *PrecisionFormat) ReadSimple(r binary.Reader) {
	doDecodePrecisionFormat(r, o)
}
func (c *binaryClassPrecisionFormat) Schema() *binary.Entity {
	return &entities[ixǁPrecisionFormat]
}

type binaryClassShaderPrecisionFormat struct{}

func (*ShaderPrecisionFormat) Class() binary.Class {
	return (*binaryClassShaderPrecisionFormat)(nil)
}
func doEncodeShaderPrecisionFormat(e binary.Writer, o *ShaderPrecisionFormat) {
	e.Simple(&o.LowFloat)
	e.Simple(&o.MediumFloat)
	e.Simple(&o.HighFloat)
	e.Simple(&o.LowInt)
	e.Simple(&o.MediumInt)
	e.Simple(&o.HighInt)
}
func doDecodeShaderPrecisionFormat(d binary.Reader, o *ShaderPrecisionFormat) {
	d.Simple(&o.LowFloat)
	d.Simple(&o.MediumFloat)
	d.Simple(&o.HighFloat)
	d.Simple(&o.LowInt)
	d.Simple(&o.MediumInt)
	d.Simple(&o.HighInt)
}
func doDecodeRawShaderPrecisionFormat(d binary.Reader, o *ShaderPrecisionFormat) {
	d.Simple(&o.LowFloat)
	d.Simple(&o.MediumFloat)
	d.Simple(&o.HighFloat)
	d.Simple(&o.LowInt)
	d.Simple(&o.MediumInt)
	d.Simple(&o.HighInt)
}
func (*binaryClassShaderPrecisionFormat) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeShaderPrecisionFormat(e, obj.(*ShaderPrecisionFormat))
}
func (*binaryClassShaderPrecisionFormat) New() binary.Object {
	return &ShaderPrecisionFormat{}
}
func (*binaryClassShaderPrecisionFormat) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeShaderPrecisionFormat(d, obj.(*ShaderPrecisionFormat))
}
func (o *ShaderPrecisionFormat) WriteSimple(w binary.Writer) {
	doEncodeShaderPrecisionFormat(w, o)
}
func (o *ShaderPrecisionFormat) ReadSimple(r binary.Reader) {
	doDecodeShaderPrecisionFormat(r, o)
}
func (c *binaryClassShaderPrecisionFormat) Schema() *binary.Entity {
	return &entities[ixǁShaderPrecisionFormat]
}

type binaryClassGLintː3ᵃ struct{}

func (*GLintː3ᵃ) Class() binary.Class {
	return (*binaryClassGLintː3ᵃ)(nil)
}
func doEncodeGLintː3ᵃ(e binary.Writer, o *GLintː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Int32(int32(*curr))
	}
}
func doDecodeGLintː3ᵃ(d binary.Reader, o *GLintː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func doDecodeRawGLintː3ᵃ(d binary.Reader, o *GLintː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func (*binaryClassGLintː3ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLintː3ᵃ(e, obj.(*GLintː3ᵃ))
}
func (*binaryClassGLintː3ᵃ) New() binary.Object {
	return &GLintː3ᵃ{}
}
func (*binaryClassGLintː3ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLintː3ᵃ(d, obj.(*GLintː3ᵃ))
}
func (o *GLintː3ᵃ) WriteSimple(w binary.Writer) {
	doEncodeGLintː3ᵃ(w, o)
}
func (o *GLintː3ᵃ) ReadSimple(r binary.Reader) {
	doDecodeGLintː3ᵃ(r, o)
}
func (c *binaryClassGLintː3ᵃ) Schema() *binary.Entity {
	return &entities[ixǁGLintː3ᵃ]
}

type binaryClassConstants struct{}

func (*Constants) Class() binary.Class {
	return (*binaryClassConstants)(nil)
}
func doEncodeConstants(e binary.Writer, o *Constants) {
	e.Simple(&o.AliasedLineWidthRange)
	e.Simple(&o.AliasedPointSizeRange)
	e.Uint32(uint32(len(o.CompressedTextureFormats)))
	for _, k := range (o.CompressedTextureFormats).KeysSorted() {
		v := (o.CompressedTextureFormats)[k]
		e.Uint32(k)
		e.Uint32(uint32(v))
	}
	e.Uint32(uint32(len(o.Extensions)))
	for _, k := range (o.Extensions).KeysSorted() {
		v := (o.Extensions)[k]
		e.Uint32(k)
		e.String(v)
	}
	e.Int32(int32(o.MaxCombinedTextureImageUnits))
	e.Int32(int32(o.MaxCubeMapTextureSize))
	e.Int32(int32(o.MaxFragmentUniformVectors))
	e.Int32(int32(o.MaxRenderbufferSize))
	e.Int32(int32(o.MaxTextureImageUnits))
	e.Int32(int32(o.MaxTextureSize))
	e.Int32(int32(o.MaxVaryingVectors))
	e.Int32(int32(o.MaxVertexAttribs))
	e.Int32(int32(o.MaxVertexTextureImageUnits))
	e.Int32(int32(o.MaxVertexUniformVectors))
	e.Simple(&o.MaxViewportDims)
	e.String(o.Renderer)
	e.Uint32(uint32(len(o.ShaderBinaryFormats)))
	for _, k := range (o.ShaderBinaryFormats).KeysSorted() {
		v := (o.ShaderBinaryFormats)[k]
		e.Uint32(k)
		e.Uint32(uint32(v))
	}
	e.Uint8(uint8(o.ShaderCompiler))
	e.String(o.ShadingLanguageVersion)
	e.Int32(int32(o.SubpixelBits))
	e.String(o.Vendor)
	e.String(o.Version)
	e.Simple(&o.VertexShaderPrecisionFormat)
	e.Simple(&o.FragmentShaderPrecisionFormat)
	e.Int32(int32(o.MajorVersion))
	e.Int32(int32(o.Max3dTextureSize))
	e.Int32(int32(o.MaxArrayTextureLayers))
	e.Int32(int32(o.MaxColorAttachments))
	e.Int64(int64(o.MaxCombinedFragmentUniformComponents))
	e.Int32(int32(o.MaxCombinedUniformBlocks))
	e.Int64(int64(o.MaxCombinedVertexUniformComponents))
	e.Int32(int32(o.MaxDrawBuffers))
	e.Int32(int32(o.MaxElementsIndices))
	e.Int32(int32(o.MaxElementsVertices))
	e.Int64(int64(o.MaxElementIndex))
	e.Int32(int32(o.MaxFragmentInputComponents))
	e.Int32(int32(o.MaxFragmentUniformBlocks))
	e.Int32(int32(o.MaxFragmentUniformComponents))
	e.Int32(int32(o.MaxProgramTexelOffset))
	e.Int64(int64(o.MaxServerWaitTimeout))
	e.Float32(float32(o.MaxTextureLodBias))
	e.Int32(int32(o.MaxTransformFeedbackInterleavedComponents))
	e.Int32(int32(o.MaxTransformFeedbackSeparateAttribs))
	e.Int32(int32(o.MaxTransformFeedbackSeparateComponents))
	e.Int64(int64(o.MaxUniformBlockSize))
	e.Int32(int32(o.MaxUniformBufferBindings))
	e.Int32(int32(o.MaxVaryingComponents))
	e.Int32(int32(o.MaxVertexOutputComponents))
	e.Int32(int32(o.MaxVertexUniformBlocks))
	e.Int32(int32(o.MaxVertexUniformComponents))
	e.Int32(int32(o.MinorVersion))
	e.Int32(int32(o.MinProgramTexelOffset))
	e.Uint32(uint32(len(o.ProgramBinaryFormats)))
	for _, k := range (o.ProgramBinaryFormats).KeysSorted() {
		v := (o.ProgramBinaryFormats)[k]
		e.Uint32(k)
		e.Uint32(uint32(v))
	}
	e.Int32(int32(o.UniformBufferOffsetAlignment))
	e.Int32(int32(o.MaxAtomicCounterBufferBindings))
	e.Int32(int32(o.MaxAtomicCounterBufferSize))
	e.Int32(int32(o.MaxColorTextureSamples))
	e.Int32(int32(o.MaxCombinedAtomicCounters))
	e.Int32(int32(o.MaxCombinedAtomicCounterBuffers))
	e.Int32(int32(o.MaxCombinedComputeUniformComponents))
	e.Int32(int32(o.MaxCombinedImageUniforms))
	e.Int32(int32(o.MaxCombinedShaderOutputResources))
	e.Int32(int32(o.MaxCombinedShaderStorageBlocks))
	e.Int32(int32(o.MaxComputeAtomicCounters))
	e.Int32(int32(o.MaxComputeAtomicCounterBuffers))
	e.Int32(int32(o.MaxComputeImageUniforms))
	e.Int32(int32(o.MaxComputeShaderStorageBlocks))
	e.Int32(int32(o.MaxComputeSharedMemorySize))
	e.Int32(int32(o.MaxComputeTextureImageUnits))
	e.Int32(int32(o.MaxComputeUniformBlocks))
	e.Int32(int32(o.MaxComputeUniformComponents))
	e.Simple(&o.MaxComputeWorkGroupCount)
	e.Int32(int32(o.MaxComputeWorkGroupInvocations))
	e.Simple(&o.MaxComputeWorkGroupSize)
	e.Int32(int32(o.MaxDepthTextureSamples))
	e.Int32(int32(o.MaxFragmentAtomicCounters))
	e.Int32(int32(o.MaxFragmentAtomicCounterBuffers))
	e.Int32(int32(o.MaxFragmentImageUniforms))
	e.Int32(int32(o.MaxFragmentShaderStorageBlocks))
	e.Int32(int32(o.MaxFramebufferHeight))
	e.Int32(int32(o.MaxFramebufferSamples))
	e.Int32(int32(o.MaxFramebufferWidth))
	e.Int32(int32(o.MaxImageUnits))
	e.Int32(int32(o.MaxIntegerSamples))
	e.Int32(int32(o.MaxProgramTextureGatherOffset))
	e.Int32(int32(o.MaxSampleMaskWords))
	e.Int64(int64(o.MaxShaderStorageBlockSize))
	e.Int32(int32(o.MaxShaderStorageBufferBindings))
	e.Int32(int32(o.MaxUniformLocations))
	e.Int32(int32(o.MaxVertexAtomicCounters))
	e.Int32(int32(o.MaxVertexAtomicCounterBuffers))
	e.Int32(int32(o.MaxVertexAttribBindings))
	e.Int32(int32(o.MaxVertexAttribRelativeOffset))
	e.Int32(int32(o.MaxVertexAttribStride))
	e.Int32(int32(o.MaxVertexImageUniforms))
	e.Int32(int32(o.MaxVertexShaderStorageBlocks))
	e.Int32(int32(o.MinProgramTextureGatherOffset))
	e.Int32(int32(o.ShaderStorageBufferOffsetAlignment))
	e.Int32(int32(o.ContextFlags))
	e.Int32(int32(o.FragmentInterpolationOffsetBits))
	e.Uint32(uint32(o.LayerProvokingVertex))
	e.Int32(int32(o.MaxCombinedGeometryUniformComponents))
	e.Int32(int32(o.MaxCombinedTessControlUniformComponents))
	e.Int32(int32(o.MaxCombinedTessEvaluationUniformComponents))
	e.Int32(int32(o.MaxDebugGroupStackDepth))
	e.Int32(int32(o.MaxDebugLoggedMessages))
	e.Int32(int32(o.MaxDebugMessageLength))
	e.Float32(float32(o.MaxFragmentInterpolationOffset))
	e.Int32(int32(o.MaxFramebufferLayers))
	e.Int32(int32(o.MaxGeometryAtomicCounters))
	e.Int32(int32(o.MaxGeometryAtomicCounterBuffers))
	e.Int32(int32(o.MaxGeometryImageUniforms))
	e.Int32(int32(o.MaxGeometryInputComponents))
	e.Int32(int32(o.MaxGeometryOutputComponents))
	e.Int32(int32(o.MaxGeometryOutputVertices))
	e.Int32(int32(o.MaxGeometryShaderInvocations))
	e.Int32(int32(o.MaxGeometryShaderStorageBlocks))
	e.Int32(int32(o.MaxGeometryTextureImageUnits))
	e.Int32(int32(o.MaxGeometryTotalOutputComponents))
	e.Int32(int32(o.MaxGeometryUniformBlocks))
	e.Int32(int32(o.MaxGeometryUniformComponents))
	e.Int32(int32(o.MaxLabelLength))
	e.Int32(int32(o.MaxPatchVertices))
	e.Int32(int32(o.MaxTessControlAtomicCounters))
	e.Int32(int32(o.MaxTessControlAtomicCounterBuffers))
	e.Int32(int32(o.MaxTessControlImageUniforms))
	e.Int32(int32(o.MaxTessControlInputComponents))
	e.Int32(int32(o.MaxTessControlOutputComponents))
	e.Int32(int32(o.MaxTessControlShaderStorageBlocks))
	e.Int32(int32(o.MaxTessControlTextureImageUnits))
	e.Int32(int32(o.MaxTessControlTotalOutputComponents))
	e.Int32(int32(o.MaxTessControlUniformBlocks))
	e.Int32(int32(o.MaxTessControlUniformComponents))
	e.Int32(int32(o.MaxTessEvaluationAtomicCounters))
	e.Int32(int32(o.MaxTessEvaluationAtomicCounterBuffers))
	e.Int32(int32(o.MaxTessEvaluationImageUniforms))
	e.Int32(int32(o.MaxTessEvaluationInputComponents))
	e.Int32(int32(o.MaxTessEvaluationOutputComponents))
	e.Int32(int32(o.MaxTessEvaluationShaderStorageBlocks))
	e.Int32(int32(o.MaxTessEvaluationTextureImageUnits))
	e.Int32(int32(o.MaxTessEvaluationUniformBlocks))
	e.Int32(int32(o.MaxTessEvaluationUniformComponents))
	e.Int32(int32(o.MaxTessGenLevel))
	e.Int32(int32(o.MaxTessPatchComponents))
	e.Int32(int32(o.MaxTextureBufferSize))
	e.Float32(float32(o.MinFragmentInterpolationOffset))
	e.Float32(float32(o.MultisampleLineWidthGranularity))
	e.Simple(&o.MultisampleLineWidthRange)
	e.Uint8(uint8(o.PrimitiveRestartForPatchesSupported))
	e.Int32(int32(o.TextureBufferOffsetAlignment))
	e.Float32(float32(o.MaxTextureMaxAnisotropyExt))
}
func doDecodeConstants(d binary.Reader, o *Constants) {
	d.Simple(&o.AliasedLineWidthRange)
	d.Simple(&o.AliasedPointSizeRange)
	if count := d.Count(); count > 0 {
		o.CompressedTextureFormats = make(U32ːGLenumᵐ, count)
		m := o.CompressedTextureFormats
		for i := uint32(0); i < count; i++ {
			var k uint32
			var v GLenum
			k = uint32(d.Uint32())
			v = GLenum(d.Uint32())
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Extensions = make(U32ːstringᵐ, count)
		m := o.Extensions
		for i := uint32(0); i < count; i++ {
			var k uint32
			var v string
			k = uint32(d.Uint32())
			v = string(d.String())
			m[k] = v
		}
	}
	o.MaxCombinedTextureImageUnits = GLint(d.Int32())
	o.MaxCubeMapTextureSize = GLint(d.Int32())
	o.MaxFragmentUniformVectors = GLint(d.Int32())
	o.MaxRenderbufferSize = GLint(d.Int32())
	o.MaxTextureImageUnits = GLint(d.Int32())
	o.MaxTextureSize = GLint(d.Int32())
	o.MaxVaryingVectors = GLint(d.Int32())
	o.MaxVertexAttribs = GLint(d.Int32())
	o.MaxVertexTextureImageUnits = GLint(d.Int32())
	o.MaxVertexUniformVectors = GLint(d.Int32())
	d.Simple(&o.MaxViewportDims)
	o.Renderer = string(d.String())
	if count := d.Count(); count > 0 {
		o.ShaderBinaryFormats = make(U32ːGLenumᵐ, count)
		m := o.ShaderBinaryFormats
		for i := uint32(0); i < count; i++ {
			var k uint32
			var v GLenum
			k = uint32(d.Uint32())
			v = GLenum(d.Uint32())
			m[k] = v
		}
	}
	o.ShaderCompiler = GLboolean(d.Uint8())
	o.ShadingLanguageVersion = string(d.String())
	o.SubpixelBits = GLint(d.Int32())
	o.Vendor = string(d.String())
	o.Version = string(d.String())
	d.Simple(&o.VertexShaderPrecisionFormat)
	d.Simple(&o.FragmentShaderPrecisionFormat)
	o.MajorVersion = GLint(d.Int32())
	o.Max3dTextureSize = GLint(d.Int32())
	o.MaxArrayTextureLayers = GLint(d.Int32())
	o.MaxColorAttachments = GLint(d.Int32())
	o.MaxCombinedFragmentUniformComponents = GLint64(d.Int64())
	o.MaxCombinedUniformBlocks = GLint(d.Int32())
	o.MaxCombinedVertexUniformComponents = GLint64(d.Int64())
	o.MaxDrawBuffers = GLint(d.Int32())
	o.MaxElementsIndices = GLint(d.Int32())
	o.MaxElementsVertices = GLint(d.Int32())
	o.MaxElementIndex = GLint64(d.Int64())
	o.MaxFragmentInputComponents = GLint(d.Int32())
	o.MaxFragmentUniformBlocks = GLint(d.Int32())
	o.MaxFragmentUniformComponents = GLint(d.Int32())
	o.MaxProgramTexelOffset = GLint(d.Int32())
	o.MaxServerWaitTimeout = GLint64(d.Int64())
	o.MaxTextureLodBias = GLfloat(d.Float32())
	o.MaxTransformFeedbackInterleavedComponents = GLint(d.Int32())
	o.MaxTransformFeedbackSeparateAttribs = GLint(d.Int32())
	o.MaxTransformFeedbackSeparateComponents = GLint(d.Int32())
	o.MaxUniformBlockSize = GLint64(d.Int64())
	o.MaxUniformBufferBindings = GLint(d.Int32())
	o.MaxVaryingComponents = GLint(d.Int32())
	o.MaxVertexOutputComponents = GLint(d.Int32())
	o.MaxVertexUniformBlocks = GLint(d.Int32())
	o.MaxVertexUniformComponents = GLint(d.Int32())
	o.MinorVersion = GLint(d.Int32())
	o.MinProgramTexelOffset = GLint(d.Int32())
	if count := d.Count(); count > 0 {
		o.ProgramBinaryFormats = make(U32ːGLenumᵐ, count)
		m := o.ProgramBinaryFormats
		for i := uint32(0); i < count; i++ {
			var k uint32
			var v GLenum
			k = uint32(d.Uint32())
			v = GLenum(d.Uint32())
			m[k] = v
		}
	}
	o.UniformBufferOffsetAlignment = GLint(d.Int32())
	o.MaxAtomicCounterBufferBindings = GLint(d.Int32())
	o.MaxAtomicCounterBufferSize = GLint(d.Int32())
	o.MaxColorTextureSamples = GLint(d.Int32())
	o.MaxCombinedAtomicCounters = GLint(d.Int32())
	o.MaxCombinedAtomicCounterBuffers = GLint(d.Int32())
	o.MaxCombinedComputeUniformComponents = GLint(d.Int32())
	o.MaxCombinedImageUniforms = GLint(d.Int32())
	o.MaxCombinedShaderOutputResources = GLint(d.Int32())
	o.MaxCombinedShaderStorageBlocks = GLint(d.Int32())
	o.MaxComputeAtomicCounters = GLint(d.Int32())
	o.MaxComputeAtomicCounterBuffers = GLint(d.Int32())
	o.MaxComputeImageUniforms = GLint(d.Int32())
	o.MaxComputeShaderStorageBlocks = GLint(d.Int32())
	o.MaxComputeSharedMemorySize = GLint(d.Int32())
	o.MaxComputeTextureImageUnits = GLint(d.Int32())
	o.MaxComputeUniformBlocks = GLint(d.Int32())
	o.MaxComputeUniformComponents = GLint(d.Int32())
	d.Simple(&o.MaxComputeWorkGroupCount)
	o.MaxComputeWorkGroupInvocations = GLint(d.Int32())
	d.Simple(&o.MaxComputeWorkGroupSize)
	o.MaxDepthTextureSamples = GLint(d.Int32())
	o.MaxFragmentAtomicCounters = GLint(d.Int32())
	o.MaxFragmentAtomicCounterBuffers = GLint(d.Int32())
	o.MaxFragmentImageUniforms = GLint(d.Int32())
	o.MaxFragmentShaderStorageBlocks = GLint(d.Int32())
	o.MaxFramebufferHeight = GLint(d.Int32())
	o.MaxFramebufferSamples = GLint(d.Int32())
	o.MaxFramebufferWidth = GLint(d.Int32())
	o.MaxImageUnits = GLint(d.Int32())
	o.MaxIntegerSamples = GLint(d.Int32())
	o.MaxProgramTextureGatherOffset = GLint(d.Int32())
	o.MaxSampleMaskWords = GLint(d.Int32())
	o.MaxShaderStorageBlockSize = GLint64(d.Int64())
	o.MaxShaderStorageBufferBindings = GLint(d.Int32())
	o.MaxUniformLocations = GLint(d.Int32())
	o.MaxVertexAtomicCounters = GLint(d.Int32())
	o.MaxVertexAtomicCounterBuffers = GLint(d.Int32())
	o.MaxVertexAttribBindings = GLint(d.Int32())
	o.MaxVertexAttribRelativeOffset = GLint(d.Int32())
	o.MaxVertexAttribStride = GLint(d.Int32())
	o.MaxVertexImageUniforms = GLint(d.Int32())
	o.MaxVertexShaderStorageBlocks = GLint(d.Int32())
	o.MinProgramTextureGatherOffset = GLint(d.Int32())
	o.ShaderStorageBufferOffsetAlignment = GLint(d.Int32())
	o.ContextFlags = GLint(d.Int32())
	o.FragmentInterpolationOffsetBits = GLint(d.Int32())
	o.LayerProvokingVertex = GLenum(d.Uint32())
	o.MaxCombinedGeometryUniformComponents = GLint(d.Int32())
	o.MaxCombinedTessControlUniformComponents = GLint(d.Int32())
	o.MaxCombinedTessEvaluationUniformComponents = GLint(d.Int32())
	o.MaxDebugGroupStackDepth = GLint(d.Int32())
	o.MaxDebugLoggedMessages = GLint(d.Int32())
	o.MaxDebugMessageLength = GLint(d.Int32())
	o.MaxFragmentInterpolationOffset = GLfloat(d.Float32())
	o.MaxFramebufferLayers = GLint(d.Int32())
	o.MaxGeometryAtomicCounters = GLint(d.Int32())
	o.MaxGeometryAtomicCounterBuffers = GLint(d.Int32())
	o.MaxGeometryImageUniforms = GLint(d.Int32())
	o.MaxGeometryInputComponents = GLint(d.Int32())
	o.MaxGeometryOutputComponents = GLint(d.Int32())
	o.MaxGeometryOutputVertices = GLint(d.Int32())
	o.MaxGeometryShaderInvocations = GLint(d.Int32())
	o.MaxGeometryShaderStorageBlocks = GLint(d.Int32())
	o.MaxGeometryTextureImageUnits = GLint(d.Int32())
	o.MaxGeometryTotalOutputComponents = GLint(d.Int32())
	o.MaxGeometryUniformBlocks = GLint(d.Int32())
	o.MaxGeometryUniformComponents = GLint(d.Int32())
	o.MaxLabelLength = GLint(d.Int32())
	o.MaxPatchVertices = GLint(d.Int32())
	o.MaxTessControlAtomicCounters = GLint(d.Int32())
	o.MaxTessControlAtomicCounterBuffers = GLint(d.Int32())
	o.MaxTessControlImageUniforms = GLint(d.Int32())
	o.MaxTessControlInputComponents = GLint(d.Int32())
	o.MaxTessControlOutputComponents = GLint(d.Int32())
	o.MaxTessControlShaderStorageBlocks = GLint(d.Int32())
	o.MaxTessControlTextureImageUnits = GLint(d.Int32())
	o.MaxTessControlTotalOutputComponents = GLint(d.Int32())
	o.MaxTessControlUniformBlocks = GLint(d.Int32())
	o.MaxTessControlUniformComponents = GLint(d.Int32())
	o.MaxTessEvaluationAtomicCounters = GLint(d.Int32())
	o.MaxTessEvaluationAtomicCounterBuffers = GLint(d.Int32())
	o.MaxTessEvaluationImageUniforms = GLint(d.Int32())
	o.MaxTessEvaluationInputComponents = GLint(d.Int32())
	o.MaxTessEvaluationOutputComponents = GLint(d.Int32())
	o.MaxTessEvaluationShaderStorageBlocks = GLint(d.Int32())
	o.MaxTessEvaluationTextureImageUnits = GLint(d.Int32())
	o.MaxTessEvaluationUniformBlocks = GLint(d.Int32())
	o.MaxTessEvaluationUniformComponents = GLint(d.Int32())
	o.MaxTessGenLevel = GLint(d.Int32())
	o.MaxTessPatchComponents = GLint(d.Int32())
	o.MaxTextureBufferSize = GLint(d.Int32())
	o.MinFragmentInterpolationOffset = GLfloat(d.Float32())
	o.MultisampleLineWidthGranularity = GLfloat(d.Float32())
	d.Simple(&o.MultisampleLineWidthRange)
	o.PrimitiveRestartForPatchesSupported = GLboolean(d.Uint8())
	o.TextureBufferOffsetAlignment = GLint(d.Int32())
	o.MaxTextureMaxAnisotropyExt = GLfloat(d.Float32())
}
func doDecodeRawConstants(d binary.Reader, o *Constants) {
	d.Simple(&o.AliasedLineWidthRange)
	d.Simple(&o.AliasedPointSizeRange)
	if count := d.Count(); count > 0 {
		o.CompressedTextureFormats = make(U32ːGLenumᵐ, count)
		m := o.CompressedTextureFormats
		for i := uint32(0); i < count; i++ {
			var k uint32
			var v GLenum
			k = uint32(d.Uint32())
			v = GLenum(d.Uint32())
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Extensions = make(U32ːstringᵐ, count)
		m := o.Extensions
		for i := uint32(0); i < count; i++ {
			var k uint32
			var v string
			k = uint32(d.Uint32())
			v = string(d.String())
			m[k] = v
		}
	}
	o.MaxCombinedTextureImageUnits = GLint(d.Int32())
	o.MaxCubeMapTextureSize = GLint(d.Int32())
	o.MaxFragmentUniformVectors = GLint(d.Int32())
	o.MaxRenderbufferSize = GLint(d.Int32())
	o.MaxTextureImageUnits = GLint(d.Int32())
	o.MaxTextureSize = GLint(d.Int32())
	o.MaxVaryingVectors = GLint(d.Int32())
	o.MaxVertexAttribs = GLint(d.Int32())
	o.MaxVertexTextureImageUnits = GLint(d.Int32())
	o.MaxVertexUniformVectors = GLint(d.Int32())
	d.Simple(&o.MaxViewportDims)
	o.Renderer = string(d.String())
	if count := d.Count(); count > 0 {
		o.ShaderBinaryFormats = make(U32ːGLenumᵐ, count)
		m := o.ShaderBinaryFormats
		for i := uint32(0); i < count; i++ {
			var k uint32
			var v GLenum
			k = uint32(d.Uint32())
			v = GLenum(d.Uint32())
			m[k] = v
		}
	}
	o.ShaderCompiler = GLboolean(d.Uint8())
	o.ShadingLanguageVersion = string(d.String())
	o.SubpixelBits = GLint(d.Int32())
	o.Vendor = string(d.String())
	o.Version = string(d.String())
	d.Simple(&o.VertexShaderPrecisionFormat)
	d.Simple(&o.FragmentShaderPrecisionFormat)
	o.MajorVersion = GLint(d.Int32())
	o.Max3dTextureSize = GLint(d.Int32())
	o.MaxArrayTextureLayers = GLint(d.Int32())
	o.MaxColorAttachments = GLint(d.Int32())
	o.MaxCombinedFragmentUniformComponents = GLint64(d.Int64())
	o.MaxCombinedUniformBlocks = GLint(d.Int32())
	o.MaxCombinedVertexUniformComponents = GLint64(d.Int64())
	o.MaxDrawBuffers = GLint(d.Int32())
	o.MaxElementsIndices = GLint(d.Int32())
	o.MaxElementsVertices = GLint(d.Int32())
	o.MaxElementIndex = GLint64(d.Int64())
	o.MaxFragmentInputComponents = GLint(d.Int32())
	o.MaxFragmentUniformBlocks = GLint(d.Int32())
	o.MaxFragmentUniformComponents = GLint(d.Int32())
	o.MaxProgramTexelOffset = GLint(d.Int32())
	o.MaxServerWaitTimeout = GLint64(d.Int64())
	o.MaxTextureLodBias = GLfloat(d.Float32())
	o.MaxTransformFeedbackInterleavedComponents = GLint(d.Int32())
	o.MaxTransformFeedbackSeparateAttribs = GLint(d.Int32())
	o.MaxTransformFeedbackSeparateComponents = GLint(d.Int32())
	o.MaxUniformBlockSize = GLint64(d.Int64())
	o.MaxUniformBufferBindings = GLint(d.Int32())
	o.MaxVaryingComponents = GLint(d.Int32())
	o.MaxVertexOutputComponents = GLint(d.Int32())
	o.MaxVertexUniformBlocks = GLint(d.Int32())
	o.MaxVertexUniformComponents = GLint(d.Int32())
	o.MinorVersion = GLint(d.Int32())
	o.MinProgramTexelOffset = GLint(d.Int32())
	if count := d.Count(); count > 0 {
		o.ProgramBinaryFormats = make(U32ːGLenumᵐ, count)
		m := o.ProgramBinaryFormats
		for i := uint32(0); i < count; i++ {
			var k uint32
			var v GLenum
			k = uint32(d.Uint32())
			v = GLenum(d.Uint32())
			m[k] = v
		}
	}
	o.UniformBufferOffsetAlignment = GLint(d.Int32())
	o.MaxAtomicCounterBufferBindings = GLint(d.Int32())
	o.MaxAtomicCounterBufferSize = GLint(d.Int32())
	o.MaxColorTextureSamples = GLint(d.Int32())
	o.MaxCombinedAtomicCounters = GLint(d.Int32())
	o.MaxCombinedAtomicCounterBuffers = GLint(d.Int32())
	o.MaxCombinedComputeUniformComponents = GLint(d.Int32())
	o.MaxCombinedImageUniforms = GLint(d.Int32())
	o.MaxCombinedShaderOutputResources = GLint(d.Int32())
	o.MaxCombinedShaderStorageBlocks = GLint(d.Int32())
	o.MaxComputeAtomicCounters = GLint(d.Int32())
	o.MaxComputeAtomicCounterBuffers = GLint(d.Int32())
	o.MaxComputeImageUniforms = GLint(d.Int32())
	o.MaxComputeShaderStorageBlocks = GLint(d.Int32())
	o.MaxComputeSharedMemorySize = GLint(d.Int32())
	o.MaxComputeTextureImageUnits = GLint(d.Int32())
	o.MaxComputeUniformBlocks = GLint(d.Int32())
	o.MaxComputeUniformComponents = GLint(d.Int32())
	d.Simple(&o.MaxComputeWorkGroupCount)
	o.MaxComputeWorkGroupInvocations = GLint(d.Int32())
	d.Simple(&o.MaxComputeWorkGroupSize)
	o.MaxDepthTextureSamples = GLint(d.Int32())
	o.MaxFragmentAtomicCounters = GLint(d.Int32())
	o.MaxFragmentAtomicCounterBuffers = GLint(d.Int32())
	o.MaxFragmentImageUniforms = GLint(d.Int32())
	o.MaxFragmentShaderStorageBlocks = GLint(d.Int32())
	o.MaxFramebufferHeight = GLint(d.Int32())
	o.MaxFramebufferSamples = GLint(d.Int32())
	o.MaxFramebufferWidth = GLint(d.Int32())
	o.MaxImageUnits = GLint(d.Int32())
	o.MaxIntegerSamples = GLint(d.Int32())
	o.MaxProgramTextureGatherOffset = GLint(d.Int32())
	o.MaxSampleMaskWords = GLint(d.Int32())
	o.MaxShaderStorageBlockSize = GLint64(d.Int64())
	o.MaxShaderStorageBufferBindings = GLint(d.Int32())
	o.MaxUniformLocations = GLint(d.Int32())
	o.MaxVertexAtomicCounters = GLint(d.Int32())
	o.MaxVertexAtomicCounterBuffers = GLint(d.Int32())
	o.MaxVertexAttribBindings = GLint(d.Int32())
	o.MaxVertexAttribRelativeOffset = GLint(d.Int32())
	o.MaxVertexAttribStride = GLint(d.Int32())
	o.MaxVertexImageUniforms = GLint(d.Int32())
	o.MaxVertexShaderStorageBlocks = GLint(d.Int32())
	o.MinProgramTextureGatherOffset = GLint(d.Int32())
	o.ShaderStorageBufferOffsetAlignment = GLint(d.Int32())
	o.ContextFlags = GLint(d.Int32())
	o.FragmentInterpolationOffsetBits = GLint(d.Int32())
	o.LayerProvokingVertex = GLenum(d.Uint32())
	o.MaxCombinedGeometryUniformComponents = GLint(d.Int32())
	o.MaxCombinedTessControlUniformComponents = GLint(d.Int32())
	o.MaxCombinedTessEvaluationUniformComponents = GLint(d.Int32())
	o.MaxDebugGroupStackDepth = GLint(d.Int32())
	o.MaxDebugLoggedMessages = GLint(d.Int32())
	o.MaxDebugMessageLength = GLint(d.Int32())
	o.MaxFragmentInterpolationOffset = GLfloat(d.Float32())
	o.MaxFramebufferLayers = GLint(d.Int32())
	o.MaxGeometryAtomicCounters = GLint(d.Int32())
	o.MaxGeometryAtomicCounterBuffers = GLint(d.Int32())
	o.MaxGeometryImageUniforms = GLint(d.Int32())
	o.MaxGeometryInputComponents = GLint(d.Int32())
	o.MaxGeometryOutputComponents = GLint(d.Int32())
	o.MaxGeometryOutputVertices = GLint(d.Int32())
	o.MaxGeometryShaderInvocations = GLint(d.Int32())
	o.MaxGeometryShaderStorageBlocks = GLint(d.Int32())
	o.MaxGeometryTextureImageUnits = GLint(d.Int32())
	o.MaxGeometryTotalOutputComponents = GLint(d.Int32())
	o.MaxGeometryUniformBlocks = GLint(d.Int32())
	o.MaxGeometryUniformComponents = GLint(d.Int32())
	o.MaxLabelLength = GLint(d.Int32())
	o.MaxPatchVertices = GLint(d.Int32())
	o.MaxTessControlAtomicCounters = GLint(d.Int32())
	o.MaxTessControlAtomicCounterBuffers = GLint(d.Int32())
	o.MaxTessControlImageUniforms = GLint(d.Int32())
	o.MaxTessControlInputComponents = GLint(d.Int32())
	o.MaxTessControlOutputComponents = GLint(d.Int32())
	o.MaxTessControlShaderStorageBlocks = GLint(d.Int32())
	o.MaxTessControlTextureImageUnits = GLint(d.Int32())
	o.MaxTessControlTotalOutputComponents = GLint(d.Int32())
	o.MaxTessControlUniformBlocks = GLint(d.Int32())
	o.MaxTessControlUniformComponents = GLint(d.Int32())
	o.MaxTessEvaluationAtomicCounters = GLint(d.Int32())
	o.MaxTessEvaluationAtomicCounterBuffers = GLint(d.Int32())
	o.MaxTessEvaluationImageUniforms = GLint(d.Int32())
	o.MaxTessEvaluationInputComponents = GLint(d.Int32())
	o.MaxTessEvaluationOutputComponents = GLint(d.Int32())
	o.MaxTessEvaluationShaderStorageBlocks = GLint(d.Int32())
	o.MaxTessEvaluationTextureImageUnits = GLint(d.Int32())
	o.MaxTessEvaluationUniformBlocks = GLint(d.Int32())
	o.MaxTessEvaluationUniformComponents = GLint(d.Int32())
	o.MaxTessGenLevel = GLint(d.Int32())
	o.MaxTessPatchComponents = GLint(d.Int32())
	o.MaxTextureBufferSize = GLint(d.Int32())
	o.MinFragmentInterpolationOffset = GLfloat(d.Float32())
	o.MultisampleLineWidthGranularity = GLfloat(d.Float32())
	d.Simple(&o.MultisampleLineWidthRange)
	o.PrimitiveRestartForPatchesSupported = GLboolean(d.Uint8())
	o.TextureBufferOffsetAlignment = GLint(d.Int32())
	o.MaxTextureMaxAnisotropyExt = GLfloat(d.Float32())
}
func (*binaryClassConstants) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeConstants(e, obj.(*Constants))
}
func (*binaryClassConstants) New() binary.Object {
	return &Constants{}
}
func (*binaryClassConstants) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeConstants(d, obj.(*Constants))
}
func (o *Constants) WriteSimple(w binary.Writer) {
	doEncodeConstants(w, o)
}
func (o *Constants) ReadSimple(r binary.Reader) {
	doDecodeConstants(r, o)
}
func (c *binaryClassConstants) Schema() *binary.Entity {
	return &entities[ixǁConstants]
}

type binaryClassContextCreationInfo struct{}

func (*ContextCreationInfo) Class() binary.Class {
	return (*binaryClassContextCreationInfo)(nil)
}
func doEncodeContextCreationInfo(e binary.Writer, o *ContextCreationInfo) {
	e.Bool(o.Initialized)
	e.Bool(o.PreserveBuffersOnSwap)
}
func doDecodeContextCreationInfo(d binary.Reader, o *ContextCreationInfo) {
	o.Initialized = bool(d.Bool())
	o.PreserveBuffersOnSwap = bool(d.Bool())
}
func doDecodeRawContextCreationInfo(d binary.Reader, o *ContextCreationInfo) {
	o.Initialized = bool(d.Bool())
	o.PreserveBuffersOnSwap = bool(d.Bool())
}
func (*binaryClassContextCreationInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeContextCreationInfo(e, obj.(*ContextCreationInfo))
}
func (*binaryClassContextCreationInfo) New() binary.Object {
	return &ContextCreationInfo{}
}
func (*binaryClassContextCreationInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeContextCreationInfo(d, obj.(*ContextCreationInfo))
}
func (o *ContextCreationInfo) WriteSimple(w binary.Writer) {
	doEncodeContextCreationInfo(w, o)
}
func (o *ContextCreationInfo) ReadSimple(r binary.Reader) {
	doDecodeContextCreationInfo(r, o)
}
func (c *binaryClassContextCreationInfo) Schema() *binary.Entity {
	return &entities[ixǁContextCreationInfo]
}

type binaryClassGLDEBUGPROC struct{}

func (*GLDEBUGPROC) Class() binary.Class {
	return (*binaryClassGLDEBUGPROC)(nil)
}
func doEncodeGLDEBUGPROC(e binary.Writer, o *GLDEBUGPROC) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLDEBUGPROC(d binary.Reader, o *GLDEBUGPROC) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLDEBUGPROC(d binary.Reader, o *GLDEBUGPROC) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLDEBUGPROC) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLDEBUGPROC(e, obj.(*GLDEBUGPROC))
}
func (*binaryClassGLDEBUGPROC) New() binary.Object {
	return &GLDEBUGPROC{}
}
func (*binaryClassGLDEBUGPROC) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLDEBUGPROC(d, obj.(*GLDEBUGPROC))
}
func (o *GLDEBUGPROC) WriteSimple(w binary.Writer) {
	doEncodeGLDEBUGPROC(w, o)
}
func (o *GLDEBUGPROC) ReadSimple(r binary.Reader) {
	doDecodeGLDEBUGPROC(r, o)
}
func (c *binaryClassGLDEBUGPROC) Schema() *binary.Entity {
	return &entities[ixǁGLDEBUGPROC]
}

type binaryClassVoidᶜᵖ struct{}

func (*Voidᶜᵖ) Class() binary.Class {
	return (*binaryClassVoidᶜᵖ)(nil)
}
func doEncodeVoidᶜᵖ(e binary.Writer, o *Voidᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVoidᶜᵖ(d binary.Reader, o *Voidᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVoidᶜᵖ(d binary.Reader, o *Voidᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVoidᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVoidᶜᵖ(e, obj.(*Voidᶜᵖ))
}
func (*binaryClassVoidᶜᵖ) New() binary.Object {
	return &Voidᶜᵖ{}
}
func (*binaryClassVoidᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVoidᶜᵖ(d, obj.(*Voidᶜᵖ))
}
func (o *Voidᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeVoidᶜᵖ(w, o)
}
func (o *Voidᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeVoidᶜᵖ(r, o)
}
func (c *binaryClassVoidᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁVoidᶜᵖ]
}

type binaryClassDebugState struct{}

func (*DebugState) Class() binary.Class {
	return (*binaryClassDebugState)(nil)
}
func doEncodeDebugState(e binary.Writer, o *DebugState) {
	e.Simple(&o.CallbackFunction)
	e.Simple(&o.CallbackUserParam)
	e.Uint8(uint8(o.OutputSynchronous))
	e.Uint8(uint8(o.Output))
}
func doDecodeDebugState(d binary.Reader, o *DebugState) {
	d.Simple(&o.CallbackFunction)
	d.Simple(&o.CallbackUserParam)
	o.OutputSynchronous = GLboolean(d.Uint8())
	o.Output = GLboolean(d.Uint8())
}
func doDecodeRawDebugState(d binary.Reader, o *DebugState) {
	d.Simple(&o.CallbackFunction)
	d.Simple(&o.CallbackUserParam)
	o.OutputSynchronous = GLboolean(d.Uint8())
	o.Output = GLboolean(d.Uint8())
}
func (*binaryClassDebugState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeDebugState(e, obj.(*DebugState))
}
func (*binaryClassDebugState) New() binary.Object {
	return &DebugState{}
}
func (*binaryClassDebugState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeDebugState(d, obj.(*DebugState))
}
func (o *DebugState) WriteSimple(w binary.Writer) {
	doEncodeDebugState(w, o)
}
func (o *DebugState) ReadSimple(r binary.Reader) {
	doDecodeDebugState(r, o)
}
func (c *binaryClassDebugState) Schema() *binary.Entity {
	return &entities[ixǁDebugState]
}

type binaryClassRect struct{}

func (*Rect) Class() binary.Class {
	return (*binaryClassRect)(nil)
}
func doEncodeRect(e binary.Writer, o *Rect) {
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeRect(d binary.Reader, o *Rect) {
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawRect(d binary.Reader, o *Rect) {
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassRect) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeRect(e, obj.(*Rect))
}
func (*binaryClassRect) New() binary.Object {
	return &Rect{}
}
func (*binaryClassRect) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeRect(d, obj.(*Rect))
}
func (o *Rect) WriteSimple(w binary.Writer) {
	doEncodeRect(w, o)
}
func (o *Rect) ReadSimple(r binary.Reader) {
	doDecodeRect(r, o)
}
func (c *binaryClassRect) Schema() *binary.Entity {
	return &entities[ixǁRect]
}

type binaryClassVec2f struct{}

func (*Vec2f) Class() binary.Class {
	return (*binaryClassVec2f)(nil)
}
func doEncodeVec2f(e binary.Writer, o *Vec2f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Float32(float32(*curr))
	}
}
func doDecodeVec2f(d binary.Reader, o *Vec2f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func doDecodeRawVec2f(d binary.Reader, o *Vec2f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func (*binaryClassVec2f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec2f(e, obj.(*Vec2f))
}
func (*binaryClassVec2f) New() binary.Object {
	return &Vec2f{}
}
func (*binaryClassVec2f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec2f(d, obj.(*Vec2f))
}
func (o *Vec2f) WriteSimple(w binary.Writer) {
	doEncodeVec2f(w, o)
}
func (o *Vec2f) ReadSimple(r binary.Reader) {
	doDecodeVec2f(r, o)
}
func (c *binaryClassVec2f) Schema() *binary.Entity {
	return &entities[ixǁVec2f]
}

type binaryClassRasterizationState struct{}

func (*RasterizationState) Class() binary.Class {
	return (*binaryClassRasterizationState)(nil)
}
func doEncodeRasterizationState(e binary.Writer, o *RasterizationState) {
	e.Simple(&o.Viewport)
	e.Simple(&o.DepthRange)
	e.Simple(&o.PrimitiveBoundingBox)
	e.Uint8(uint8(o.RasterizerDiscard))
	e.Float32(float32(o.LineWidth))
	e.Uint8(uint8(o.CullFace))
	e.Uint32(uint32(o.CullFaceMode))
	e.Uint32(uint32(o.FrontFace))
	e.Float32(float32(o.PolygonOffsetFactor))
	e.Float32(float32(o.PolygonOffsetUnits))
	e.Uint8(uint8(o.PolygonOffsetFill))
	e.Uint8(uint8(o.SampleAlphaToCoverage))
	e.Uint8(uint8(o.SampleCoverage))
	e.Float32(float32(o.SampleCoverageValue))
	e.Uint8(uint8(o.SampleCoverageInvert))
	e.Uint8(uint8(o.SampleShading))
	e.Float32(float32(o.MinSampleShadingValue))
	e.Uint8(uint8(o.SampleMask))
	e.Uint32(uint32(len(o.SampleMaskValue)))
	for _, k := range (o.SampleMaskValue).KeysSorted() {
		v := (o.SampleMaskValue)[k]
		e.Uint32(uint32(k))
		e.Uint32(uint32(v))
	}
}
func doDecodeRasterizationState(d binary.Reader, o *RasterizationState) {
	d.Simple(&o.Viewport)
	d.Simple(&o.DepthRange)
	d.Simple(&o.PrimitiveBoundingBox)
	o.RasterizerDiscard = GLboolean(d.Uint8())
	o.LineWidth = GLfloat(d.Float32())
	o.CullFace = GLboolean(d.Uint8())
	o.CullFaceMode = GLenum(d.Uint32())
	o.FrontFace = GLenum(d.Uint32())
	o.PolygonOffsetFactor = GLfloat(d.Float32())
	o.PolygonOffsetUnits = GLfloat(d.Float32())
	o.PolygonOffsetFill = GLboolean(d.Uint8())
	o.SampleAlphaToCoverage = GLboolean(d.Uint8())
	o.SampleCoverage = GLboolean(d.Uint8())
	o.SampleCoverageValue = GLfloat(d.Float32())
	o.SampleCoverageInvert = GLboolean(d.Uint8())
	o.SampleShading = GLboolean(d.Uint8())
	o.MinSampleShadingValue = GLfloat(d.Float32())
	o.SampleMask = GLboolean(d.Uint8())
	if count := d.Count(); count > 0 {
		o.SampleMaskValue = make(GLuintːGLbitfieldᵐ, count)
		m := o.SampleMaskValue
		for i := uint32(0); i < count; i++ {
			var k GLuint
			var v GLbitfield
			k = GLuint(d.Uint32())
			v = GLbitfield(d.Uint32())
			m[k] = v
		}
	}
}
func doDecodeRawRasterizationState(d binary.Reader, o *RasterizationState) {
	d.Simple(&o.Viewport)
	d.Simple(&o.DepthRange)
	d.Simple(&o.PrimitiveBoundingBox)
	o.RasterizerDiscard = GLboolean(d.Uint8())
	o.LineWidth = GLfloat(d.Float32())
	o.CullFace = GLboolean(d.Uint8())
	o.CullFaceMode = GLenum(d.Uint32())
	o.FrontFace = GLenum(d.Uint32())
	o.PolygonOffsetFactor = GLfloat(d.Float32())
	o.PolygonOffsetUnits = GLfloat(d.Float32())
	o.PolygonOffsetFill = GLboolean(d.Uint8())
	o.SampleAlphaToCoverage = GLboolean(d.Uint8())
	o.SampleCoverage = GLboolean(d.Uint8())
	o.SampleCoverageValue = GLfloat(d.Float32())
	o.SampleCoverageInvert = GLboolean(d.Uint8())
	o.SampleShading = GLboolean(d.Uint8())
	o.MinSampleShadingValue = GLfloat(d.Float32())
	o.SampleMask = GLboolean(d.Uint8())
	if count := d.Count(); count > 0 {
		o.SampleMaskValue = make(GLuintːGLbitfieldᵐ, count)
		m := o.SampleMaskValue
		for i := uint32(0); i < count; i++ {
			var k GLuint
			var v GLbitfield
			k = GLuint(d.Uint32())
			v = GLbitfield(d.Uint32())
			m[k] = v
		}
	}
}
func (*binaryClassRasterizationState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeRasterizationState(e, obj.(*RasterizationState))
}
func (*binaryClassRasterizationState) New() binary.Object {
	return &RasterizationState{}
}
func (*binaryClassRasterizationState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeRasterizationState(d, obj.(*RasterizationState))
}
func (o *RasterizationState) WriteSimple(w binary.Writer) {
	doEncodeRasterizationState(w, o)
}
func (o *RasterizationState) ReadSimple(r binary.Reader) {
	doDecodeRasterizationState(r, o)
}
func (c *binaryClassRasterizationState) Schema() *binary.Entity {
	return &entities[ixǁRasterizationState]
}

type binaryClassScissorState struct{}

func (*ScissorState) Class() binary.Class {
	return (*binaryClassScissorState)(nil)
}
func doEncodeScissorState(e binary.Writer, o *ScissorState) {
	e.Uint8(uint8(o.Test))
	e.Simple(&o.Box)
}
func doDecodeScissorState(d binary.Reader, o *ScissorState) {
	o.Test = GLboolean(d.Uint8())
	d.Simple(&o.Box)
}
func doDecodeRawScissorState(d binary.Reader, o *ScissorState) {
	o.Test = GLboolean(d.Uint8())
	d.Simple(&o.Box)
}
func (*binaryClassScissorState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeScissorState(e, obj.(*ScissorState))
}
func (*binaryClassScissorState) New() binary.Object {
	return &ScissorState{}
}
func (*binaryClassScissorState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeScissorState(d, obj.(*ScissorState))
}
func (o *ScissorState) WriteSimple(w binary.Writer) {
	doEncodeScissorState(w, o)
}
func (o *ScissorState) ReadSimple(r binary.Reader) {
	doDecodeScissorState(r, o)
}
func (c *binaryClassScissorState) Schema() *binary.Entity {
	return &entities[ixǁScissorState]
}

type binaryClassStencilState struct{}

func (*StencilState) Class() binary.Class {
	return (*binaryClassStencilState)(nil)
}
func doEncodeStencilState(e binary.Writer, o *StencilState) {
	e.Uint8(uint8(o.Test))
	e.Uint32(uint32(o.Func))
	e.Uint32(uint32(o.ValueMask))
	e.Int32(int32(o.Ref))
	e.Uint32(uint32(o.Fail))
	e.Uint32(uint32(o.PassDepthFail))
	e.Uint32(uint32(o.PassDepthPass))
	e.Uint32(uint32(o.BackFunc))
	e.Uint32(uint32(o.BackValueMask))
	e.Int32(int32(o.BackRef))
	e.Uint32(uint32(o.BackFail))
	e.Uint32(uint32(o.BackPassDepthFail))
	e.Uint32(uint32(o.BackPassDepthPass))
}
func doDecodeStencilState(d binary.Reader, o *StencilState) {
	o.Test = GLboolean(d.Uint8())
	o.Func = GLenum(d.Uint32())
	o.ValueMask = GLuint(d.Uint32())
	o.Ref = GLint(d.Int32())
	o.Fail = GLenum(d.Uint32())
	o.PassDepthFail = GLenum(d.Uint32())
	o.PassDepthPass = GLenum(d.Uint32())
	o.BackFunc = GLenum(d.Uint32())
	o.BackValueMask = GLuint(d.Uint32())
	o.BackRef = GLint(d.Int32())
	o.BackFail = GLenum(d.Uint32())
	o.BackPassDepthFail = GLenum(d.Uint32())
	o.BackPassDepthPass = GLenum(d.Uint32())
}
func doDecodeRawStencilState(d binary.Reader, o *StencilState) {
	o.Test = GLboolean(d.Uint8())
	o.Func = GLenum(d.Uint32())
	o.ValueMask = GLuint(d.Uint32())
	o.Ref = GLint(d.Int32())
	o.Fail = GLenum(d.Uint32())
	o.PassDepthFail = GLenum(d.Uint32())
	o.PassDepthPass = GLenum(d.Uint32())
	o.BackFunc = GLenum(d.Uint32())
	o.BackValueMask = GLuint(d.Uint32())
	o.BackRef = GLint(d.Int32())
	o.BackFail = GLenum(d.Uint32())
	o.BackPassDepthFail = GLenum(d.Uint32())
	o.BackPassDepthPass = GLenum(d.Uint32())
}
func (*binaryClassStencilState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeStencilState(e, obj.(*StencilState))
}
func (*binaryClassStencilState) New() binary.Object {
	return &StencilState{}
}
func (*binaryClassStencilState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeStencilState(d, obj.(*StencilState))
}
func (o *StencilState) WriteSimple(w binary.Writer) {
	doEncodeStencilState(w, o)
}
func (o *StencilState) ReadSimple(r binary.Reader) {
	doDecodeStencilState(r, o)
}
func (c *binaryClassStencilState) Schema() *binary.Entity {
	return &entities[ixǁStencilState]
}

type binaryClassDepthState struct{}

func (*DepthState) Class() binary.Class {
	return (*binaryClassDepthState)(nil)
}
func doEncodeDepthState(e binary.Writer, o *DepthState) {
	e.Uint8(uint8(o.Test))
	e.Uint32(uint32(o.Func))
}
func doDecodeDepthState(d binary.Reader, o *DepthState) {
	o.Test = GLboolean(d.Uint8())
	o.Func = GLenum(d.Uint32())
}
func doDecodeRawDepthState(d binary.Reader, o *DepthState) {
	o.Test = GLboolean(d.Uint8())
	o.Func = GLenum(d.Uint32())
}
func (*binaryClassDepthState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeDepthState(e, obj.(*DepthState))
}
func (*binaryClassDepthState) New() binary.Object {
	return &DepthState{}
}
func (*binaryClassDepthState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeDepthState(d, obj.(*DepthState))
}
func (o *DepthState) WriteSimple(w binary.Writer) {
	doEncodeDepthState(w, o)
}
func (o *DepthState) ReadSimple(r binary.Reader) {
	doDecodeDepthState(r, o)
}
func (c *binaryClassDepthState) Schema() *binary.Entity {
	return &entities[ixǁDepthState]
}

type binaryClassFragmentOperationsState struct{}

func (*FragmentOperationsState) Class() binary.Class {
	return (*binaryClassFragmentOperationsState)(nil)
}
func doEncodeFragmentOperationsState(e binary.Writer, o *FragmentOperationsState) {
	e.Simple(&o.Scissor)
	e.Simple(&o.Stencil)
	e.Simple(&o.Depth)
	e.Uint32(uint32(len(o.Blend)))
	for _, k := range (o.Blend).KeysSorted() {
		v := (o.Blend)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
	e.Simple(&o.BlendColor)
	e.Uint8(uint8(o.Dither))
	e.Uint8(uint8(o.FramebufferSrgb))
}
func doDecodeFragmentOperationsState(d binary.Reader, o *FragmentOperationsState) {
	d.Simple(&o.Scissor)
	d.Simple(&o.Stencil)
	d.Simple(&o.Depth)
	if count := d.Count(); count > 0 {
		o.Blend = make(DrawBufferIndexːBlendStateᵐ, count)
		m := o.Blend
		for i := uint32(0); i < count; i++ {
			var k DrawBufferIndex
			var v BlendState
			k = DrawBufferIndex(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	d.Simple(&o.BlendColor)
	o.Dither = GLboolean(d.Uint8())
	o.FramebufferSrgb = GLboolean(d.Uint8())
}
func doDecodeRawFragmentOperationsState(d binary.Reader, o *FragmentOperationsState) {
	d.Simple(&o.Scissor)
	d.Simple(&o.Stencil)
	d.Simple(&o.Depth)
	if count := d.Count(); count > 0 {
		o.Blend = make(DrawBufferIndexːBlendStateᵐ, count)
		m := o.Blend
		for i := uint32(0); i < count; i++ {
			var k DrawBufferIndex
			var v BlendState
			k = DrawBufferIndex(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	d.Simple(&o.BlendColor)
	o.Dither = GLboolean(d.Uint8())
	o.FramebufferSrgb = GLboolean(d.Uint8())
}
func (*binaryClassFragmentOperationsState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeFragmentOperationsState(e, obj.(*FragmentOperationsState))
}
func (*binaryClassFragmentOperationsState) New() binary.Object {
	return &FragmentOperationsState{}
}
func (*binaryClassFragmentOperationsState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeFragmentOperationsState(d, obj.(*FragmentOperationsState))
}
func (o *FragmentOperationsState) WriteSimple(w binary.Writer) {
	doEncodeFragmentOperationsState(w, o)
}
func (o *FragmentOperationsState) ReadSimple(r binary.Reader) {
	doDecodeFragmentOperationsState(r, o)
}
func (c *binaryClassFragmentOperationsState) Schema() *binary.Entity {
	return &entities[ixǁFragmentOperationsState]
}

type binaryClassVec4b struct{}

func (*Vec4b) Class() binary.Class {
	return (*binaryClassVec4b)(nil)
}
func doEncodeVec4b(e binary.Writer, o *Vec4b) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Uint8(uint8(*curr))
	}
}
func doDecodeVec4b(d binary.Reader, o *Vec4b) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLboolean(d.Uint8())
	}
}
func doDecodeRawVec4b(d binary.Reader, o *Vec4b) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLboolean(d.Uint8())
	}
}
func (*binaryClassVec4b) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4b(e, obj.(*Vec4b))
}
func (*binaryClassVec4b) New() binary.Object {
	return &Vec4b{}
}
func (*binaryClassVec4b) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4b(d, obj.(*Vec4b))
}
func (o *Vec4b) WriteSimple(w binary.Writer) {
	doEncodeVec4b(w, o)
}
func (o *Vec4b) ReadSimple(r binary.Reader) {
	doDecodeVec4b(r, o)
}
func (c *binaryClassVec4b) Schema() *binary.Entity {
	return &entities[ixǁVec4b]
}

type binaryClassFramebufferState struct{}

func (*FramebufferState) Class() binary.Class {
	return (*binaryClassFramebufferState)(nil)
}
func doEncodeFramebufferState(e binary.Writer, o *FramebufferState) {
	e.Uint32(uint32(len(o.ColorWritemask)))
	for _, k := range (o.ColorWritemask).KeysSorted() {
		v := (o.ColorWritemask)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
	e.Uint8(uint8(o.DepthWritemask))
	e.Uint32(uint32(o.StencilWritemask))
	e.Uint32(uint32(o.StencilBackWritemask))
	e.Simple(&o.ColorClearValue)
	e.Float32(float32(o.DepthClearValue))
	e.Int32(int32(o.StencilClearValue))
}
func doDecodeFramebufferState(d binary.Reader, o *FramebufferState) {
	if count := d.Count(); count > 0 {
		o.ColorWritemask = make(DrawBufferIndexːVec4bᵐ, count)
		m := o.ColorWritemask
		for i := uint32(0); i < count; i++ {
			var k DrawBufferIndex
			var v Vec4b
			k = DrawBufferIndex(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.DepthWritemask = GLboolean(d.Uint8())
	o.StencilWritemask = GLuint(d.Uint32())
	o.StencilBackWritemask = GLuint(d.Uint32())
	d.Simple(&o.ColorClearValue)
	o.DepthClearValue = GLfloat(d.Float32())
	o.StencilClearValue = GLint(d.Int32())
}
func doDecodeRawFramebufferState(d binary.Reader, o *FramebufferState) {
	if count := d.Count(); count > 0 {
		o.ColorWritemask = make(DrawBufferIndexːVec4bᵐ, count)
		m := o.ColorWritemask
		for i := uint32(0); i < count; i++ {
			var k DrawBufferIndex
			var v Vec4b
			k = DrawBufferIndex(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.DepthWritemask = GLboolean(d.Uint8())
	o.StencilWritemask = GLuint(d.Uint32())
	o.StencilBackWritemask = GLuint(d.Uint32())
	d.Simple(&o.ColorClearValue)
	o.DepthClearValue = GLfloat(d.Float32())
	o.StencilClearValue = GLint(d.Int32())
}
func (*binaryClassFramebufferState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeFramebufferState(e, obj.(*FramebufferState))
}
func (*binaryClassFramebufferState) New() binary.Object {
	return &FramebufferState{}
}
func (*binaryClassFramebufferState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeFramebufferState(d, obj.(*FramebufferState))
}
func (o *FramebufferState) WriteSimple(w binary.Writer) {
	doEncodeFramebufferState(w, o)
}
func (o *FramebufferState) ReadSimple(r binary.Reader) {
	doDecodeFramebufferState(r, o)
}
func (c *binaryClassFramebufferState) Schema() *binary.Entity {
	return &entities[ixǁFramebufferState]
}

type binaryClassVertexAttributeValue struct{}

func (*VertexAttributeValue) Class() binary.Class {
	return (*binaryClassVertexAttributeValue)(nil)
}
func doEncodeVertexAttributeValue(e binary.Writer, o *VertexAttributeValue) {
	e.Simple(&o.Value)
}
func doDecodeVertexAttributeValue(d binary.Reader, o *VertexAttributeValue) {
	d.Simple(&o.Value)
}
func doDecodeRawVertexAttributeValue(d binary.Reader, o *VertexAttributeValue) {
	d.Simple(&o.Value)
}
func (*binaryClassVertexAttributeValue) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVertexAttributeValue(e, obj.(*VertexAttributeValue))
}
func (*binaryClassVertexAttributeValue) New() binary.Object {
	return &VertexAttributeValue{}
}
func (*binaryClassVertexAttributeValue) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVertexAttributeValue(d, obj.(*VertexAttributeValue))
}
func (o *VertexAttributeValue) WriteSimple(w binary.Writer) {
	doEncodeVertexAttributeValue(w, o)
}
func (o *VertexAttributeValue) ReadSimple(r binary.Reader) {
	doDecodeVertexAttributeValue(r, o)
}
func (c *binaryClassVertexAttributeValue) Schema() *binary.Entity {
	return &entities[ixǁVertexAttributeValue]
}

type binaryClassTextureUnit struct{}

func (*TextureUnit) Class() binary.Class {
	return (*binaryClassTextureUnit)(nil)
}
func doEncodeTextureUnit(e binary.Writer, o *TextureUnit) {
	e.Uint32(uint32(o.Binding2d))
	e.Uint32(uint32(o.Binding3d))
	e.Uint32(uint32(o.Binding2dArray))
	e.Uint32(uint32(o.BindingBuffer))
	e.Uint32(uint32(o.BindingCubeMap))
	e.Uint32(uint32(o.BindingCubeMapArray))
	e.Uint32(uint32(o.Binding2dMultisample))
	e.Uint32(uint32(o.Binding2dMultisampleArray))
	e.Uint32(uint32(o.BindingExternalOes))
	e.Uint32(uint32(o.SamplerBinding))
}
func doDecodeTextureUnit(d binary.Reader, o *TextureUnit) {
	o.Binding2d = TextureId(d.Uint32())
	o.Binding3d = TextureId(d.Uint32())
	o.Binding2dArray = TextureId(d.Uint32())
	o.BindingBuffer = TextureId(d.Uint32())
	o.BindingCubeMap = TextureId(d.Uint32())
	o.BindingCubeMapArray = TextureId(d.Uint32())
	o.Binding2dMultisample = TextureId(d.Uint32())
	o.Binding2dMultisampleArray = TextureId(d.Uint32())
	o.BindingExternalOes = TextureId(d.Uint32())
	o.SamplerBinding = SamplerId(d.Uint32())
}
func doDecodeRawTextureUnit(d binary.Reader, o *TextureUnit) {
	o.Binding2d = TextureId(d.Uint32())
	o.Binding3d = TextureId(d.Uint32())
	o.Binding2dArray = TextureId(d.Uint32())
	o.BindingBuffer = TextureId(d.Uint32())
	o.BindingCubeMap = TextureId(d.Uint32())
	o.BindingCubeMapArray = TextureId(d.Uint32())
	o.Binding2dMultisample = TextureId(d.Uint32())
	o.Binding2dMultisampleArray = TextureId(d.Uint32())
	o.BindingExternalOes = TextureId(d.Uint32())
	o.SamplerBinding = SamplerId(d.Uint32())
}
func (*binaryClassTextureUnit) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTextureUnit(e, obj.(*TextureUnit))
}
func (*binaryClassTextureUnit) New() binary.Object {
	return &TextureUnit{}
}
func (*binaryClassTextureUnit) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTextureUnit(d, obj.(*TextureUnit))
}
func (o *TextureUnit) WriteSimple(w binary.Writer) {
	doEncodeTextureUnit(w, o)
}
func (o *TextureUnit) ReadSimple(r binary.Reader) {
	doDecodeTextureUnit(r, o)
}
func (c *binaryClassTextureUnit) Schema() *binary.Entity {
	return &entities[ixǁTextureUnit]
}

type binaryClassImageUnit struct{}

func (*ImageUnit) Class() binary.Class {
	return (*binaryClassImageUnit)(nil)
}
func doEncodeImageUnit(e binary.Writer, o *ImageUnit) {
	e.Uint32(uint32(o.Name))
	e.Int32(int32(o.Level))
	e.Uint8(uint8(o.Layered))
	e.Int32(int32(o.Layer))
	e.Uint32(uint32(o.Access))
	e.Uint32(uint32(o.Format))
}
func doDecodeImageUnit(d binary.Reader, o *ImageUnit) {
	o.Name = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Layered = GLboolean(d.Uint8())
	o.Layer = GLint(d.Int32())
	o.Access = GLenum(d.Uint32())
	o.Format = GLenum(d.Uint32())
}
func doDecodeRawImageUnit(d binary.Reader, o *ImageUnit) {
	o.Name = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Layered = GLboolean(d.Uint8())
	o.Layer = GLint(d.Int32())
	o.Access = GLenum(d.Uint32())
	o.Format = GLenum(d.Uint32())
}
func (*binaryClassImageUnit) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeImageUnit(e, obj.(*ImageUnit))
}
func (*binaryClassImageUnit) New() binary.Object {
	return &ImageUnit{}
}
func (*binaryClassImageUnit) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeImageUnit(d, obj.(*ImageUnit))
}
func (o *ImageUnit) WriteSimple(w binary.Writer) {
	doEncodeImageUnit(w, o)
}
func (o *ImageUnit) ReadSimple(r binary.Reader) {
	doDecodeImageUnit(r, o)
}
func (c *binaryClassImageUnit) Schema() *binary.Entity {
	return &entities[ixǁImageUnit]
}

type binaryClassPixelStorageState struct{}

func (*PixelStorageState) Class() binary.Class {
	return (*binaryClassPixelStorageState)(nil)
}
func doEncodePixelStorageState(e binary.Writer, o *PixelStorageState) {
	e.Int32(int32(o.UnpackImageHeight))
	e.Int32(int32(o.UnpackSkipImages))
	e.Int32(int32(o.UnpackRowLength))
	e.Int32(int32(o.UnpackSkipRows))
	e.Int32(int32(o.UnpackSkipPixels))
	e.Int32(int32(o.UnpackAlignment))
	e.Int32(int32(o.PackImageHeight))
	e.Int32(int32(o.PackSkipImages))
	e.Int32(int32(o.PackRowLength))
	e.Int32(int32(o.PackSkipRows))
	e.Int32(int32(o.PackSkipPixels))
	e.Int32(int32(o.PackAlignment))
}
func doDecodePixelStorageState(d binary.Reader, o *PixelStorageState) {
	o.UnpackImageHeight = GLint(d.Int32())
	o.UnpackSkipImages = GLint(d.Int32())
	o.UnpackRowLength = GLint(d.Int32())
	o.UnpackSkipRows = GLint(d.Int32())
	o.UnpackSkipPixels = GLint(d.Int32())
	o.UnpackAlignment = GLint(d.Int32())
	o.PackImageHeight = GLint(d.Int32())
	o.PackSkipImages = GLint(d.Int32())
	o.PackRowLength = GLint(d.Int32())
	o.PackSkipRows = GLint(d.Int32())
	o.PackSkipPixels = GLint(d.Int32())
	o.PackAlignment = GLint(d.Int32())
}
func doDecodeRawPixelStorageState(d binary.Reader, o *PixelStorageState) {
	o.UnpackImageHeight = GLint(d.Int32())
	o.UnpackSkipImages = GLint(d.Int32())
	o.UnpackRowLength = GLint(d.Int32())
	o.UnpackSkipRows = GLint(d.Int32())
	o.UnpackSkipPixels = GLint(d.Int32())
	o.UnpackAlignment = GLint(d.Int32())
	o.PackImageHeight = GLint(d.Int32())
	o.PackSkipImages = GLint(d.Int32())
	o.PackRowLength = GLint(d.Int32())
	o.PackSkipRows = GLint(d.Int32())
	o.PackSkipPixels = GLint(d.Int32())
	o.PackAlignment = GLint(d.Int32())
}
func (*binaryClassPixelStorageState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodePixelStorageState(e, obj.(*PixelStorageState))
}
func (*binaryClassPixelStorageState) New() binary.Object {
	return &PixelStorageState{}
}
func (*binaryClassPixelStorageState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodePixelStorageState(d, obj.(*PixelStorageState))
}
func (o *PixelStorageState) WriteSimple(w binary.Writer) {
	doEncodePixelStorageState(w, o)
}
func (o *PixelStorageState) ReadSimple(r binary.Reader) {
	doDecodePixelStorageState(r, o)
}
func (c *binaryClassPixelStorageState) Schema() *binary.Entity {
	return &entities[ixǁPixelStorageState]
}

type binaryClassMiscellaneousState struct{}

func (*MiscellaneousState) Class() binary.Class {
	return (*binaryClassMiscellaneousState)(nil)
}
func doEncodeMiscellaneousState(e binary.Writer, o *MiscellaneousState) {
	e.Int32(int32(o.PatchVertices))
	e.Uint8(uint8(o.PrimitiveRestartFixedIndex))
	e.Uint32(uint32(o.GenerateMipmapHint))
	e.Uint32(uint32(o.FragmentShaderDerivativeHint))
}
func doDecodeMiscellaneousState(d binary.Reader, o *MiscellaneousState) {
	o.PatchVertices = GLint(d.Int32())
	o.PrimitiveRestartFixedIndex = GLboolean(d.Uint8())
	o.GenerateMipmapHint = GLenum(d.Uint32())
	o.FragmentShaderDerivativeHint = GLenum(d.Uint32())
}
func doDecodeRawMiscellaneousState(d binary.Reader, o *MiscellaneousState) {
	o.PatchVertices = GLint(d.Int32())
	o.PrimitiveRestartFixedIndex = GLboolean(d.Uint8())
	o.GenerateMipmapHint = GLenum(d.Uint32())
	o.FragmentShaderDerivativeHint = GLenum(d.Uint32())
}
func (*binaryClassMiscellaneousState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMiscellaneousState(e, obj.(*MiscellaneousState))
}
func (*binaryClassMiscellaneousState) New() binary.Object {
	return &MiscellaneousState{}
}
func (*binaryClassMiscellaneousState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMiscellaneousState(d, obj.(*MiscellaneousState))
}
func (o *MiscellaneousState) WriteSimple(w binary.Writer) {
	doEncodeMiscellaneousState(w, o)
}
func (o *MiscellaneousState) ReadSimple(r binary.Reader) {
	doDecodeMiscellaneousState(r, o)
}
func (c *binaryClassMiscellaneousState) Schema() *binary.Entity {
	return &entities[ixǁMiscellaneousState]
}

type binaryClassRenderbuffer struct{}

func (*Renderbuffer) Class() binary.Class {
	return (*binaryClassRenderbuffer)(nil)
}
func doEncodeRenderbuffer(e binary.Writer, o *Renderbuffer) {
	e.Simple(&o.Data)
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Uint32(uint32(o.InternalFormat))
	e.String(o.Label)
}
func doDecodeRenderbuffer(d binary.Reader, o *Renderbuffer) {
	d.Simple(&o.Data)
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.InternalFormat = GLenum(d.Uint32())
	o.Label = string(d.String())
}
func doDecodeRawRenderbuffer(d binary.Reader, o *Renderbuffer) {
	d.Simple(&o.Data)
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.InternalFormat = GLenum(d.Uint32())
	o.Label = string(d.String())
}
func (*binaryClassRenderbuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeRenderbuffer(e, obj.(*Renderbuffer))
}
func (*binaryClassRenderbuffer) New() binary.Object {
	return &Renderbuffer{}
}
func (*binaryClassRenderbuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeRenderbuffer(d, obj.(*Renderbuffer))
}
func (o *Renderbuffer) WriteSimple(w binary.Writer) {
	doEncodeRenderbuffer(w, o)
}
func (o *Renderbuffer) ReadSimple(r binary.Reader) {
	doDecodeRenderbuffer(r, o)
}
func (c *binaryClassRenderbuffer) Schema() *binary.Entity {
	return &entities[ixǁRenderbuffer]
}

type binaryClassImage struct{}

func (*Image) Class() binary.Class {
	return (*binaryClassImage)(nil)
}
func doEncodeImage(e binary.Writer, o *Image) {
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Simple(&o.Data)
	e.Uint32(o.Size)
	e.Uint32(uint32(o.TexelFormat))
	e.Uint32(uint32(o.TexelType))
}
func doDecodeImage(d binary.Reader, o *Image) {
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	d.Simple(&o.Data)
	o.Size = uint32(d.Uint32())
	o.TexelFormat = GLenum(d.Uint32())
	o.TexelType = GLenum(d.Uint32())
}
func doDecodeRawImage(d binary.Reader, o *Image) {
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	d.Simple(&o.Data)
	o.Size = uint32(d.Uint32())
	o.TexelFormat = GLenum(d.Uint32())
	o.TexelType = GLenum(d.Uint32())
}
func (*binaryClassImage) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeImage(e, obj.(*Image))
}
func (*binaryClassImage) New() binary.Object {
	return &Image{}
}
func (*binaryClassImage) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeImage(d, obj.(*Image))
}
func (o *Image) WriteSimple(w binary.Writer) {
	doEncodeImage(w, o)
}
func (o *Image) ReadSimple(r binary.Reader) {
	doDecodeImage(r, o)
}
func (c *binaryClassImage) Schema() *binary.Entity {
	return &entities[ixǁImage]
}

type binaryClassCubemapLevel struct{}

func (*CubemapLevel) Class() binary.Class {
	return (*binaryClassCubemapLevel)(nil)
}
func doEncodeCubemapLevel(e binary.Writer, o *CubemapLevel) {
	e.Uint32(uint32(len(o.Faces)))
	for _, k := range (o.Faces).KeysSorted() {
		v := (o.Faces)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
}
func doDecodeCubemapLevel(d binary.Reader, o *CubemapLevel) {
	if count := d.Count(); count > 0 {
		o.Faces = make(GLenumːImageᵐ, count)
		m := o.Faces
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v Image
			k = GLenum(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
}
func doDecodeRawCubemapLevel(d binary.Reader, o *CubemapLevel) {
	if count := d.Count(); count > 0 {
		o.Faces = make(GLenumːImageᵐ, count)
		m := o.Faces
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v Image
			k = GLenum(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
}
func (*binaryClassCubemapLevel) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCubemapLevel(e, obj.(*CubemapLevel))
}
func (*binaryClassCubemapLevel) New() binary.Object {
	return &CubemapLevel{}
}
func (*binaryClassCubemapLevel) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCubemapLevel(d, obj.(*CubemapLevel))
}
func (o *CubemapLevel) WriteSimple(w binary.Writer) {
	doEncodeCubemapLevel(w, o)
}
func (o *CubemapLevel) ReadSimple(r binary.Reader) {
	doDecodeCubemapLevel(r, o)
}
func (c *binaryClassCubemapLevel) Schema() *binary.Entity {
	return &entities[ixǁCubemapLevel]
}

type binaryClassTexture struct{}

func (*Texture) Class() binary.Class {
	return (*binaryClassTexture)(nil)
}
func doEncodeTexture(e binary.Encoder, o *Texture) {
	e.Uint32(uint32(o.ID))
	e.Uint32(uint32(o.Kind))
	e.Uint32(uint32(o.TexelFormat))
	e.Uint32(uint32(o.TexelType))
	e.Uint32(uint32(len(o.Texture2D)))
	for _, k := range (o.Texture2D).KeysSorted() {
		v := (o.Texture2D)[k]
		e.Int32(int32(k))
		e.Simple(&v)
	}
	e.Uint32(uint32(len(o.Cubemap)))
	for _, k := range (o.Cubemap).KeysSorted() {
		v := (o.Cubemap)[k]
		e.Int32(int32(k))
		e.Simple(&v)
	}
	e.Uint32(uint32(o.SwizzleR))
	e.Uint32(uint32(o.SwizzleG))
	e.Uint32(uint32(o.SwizzleB))
	e.Uint32(uint32(o.SwizzleA))
	e.Simple(&o.BorderColor)
	e.Uint32(uint32(o.MinFilter))
	e.Uint32(uint32(o.MagFilter))
	e.Uint32(uint32(o.WrapS))
	e.Uint32(uint32(o.WrapT))
	e.Uint32(uint32(o.WrapR))
	e.Float32(float32(o.MinLod))
	e.Float32(float32(o.MaxLod))
	e.Int32(int32(o.BaseLevel))
	e.Int32(int32(o.MaxLevel))
	e.Uint32(uint32(o.DepthStencilTextureMode))
	e.Uint32(uint32(o.CompareMode))
	e.Uint32(uint32(o.CompareFunc))
	e.Uint8(uint8(o.ImmutableFormat))
	e.Uint32(uint32(o.ImmutableLevels))
	e.String(o.Label)
	e.Float32(float32(o.MaxAnisotropy))
}
func doDecodeTexture(d binary.Decoder, o *Texture) {
	o.ID = TextureId(d.Uint32())
	o.Kind = GLenum(d.Uint32())
	o.TexelFormat = GLenum(d.Uint32())
	o.TexelType = GLenum(d.Uint32())
	if count := d.Count(); count > 0 {
		o.Texture2D = make(GLintːImageᵐ, count)
		m := o.Texture2D
		for i := uint32(0); i < count; i++ {
			var k GLint
			var v Image
			k = GLint(d.Int32())
			d.Simple(&v)
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Cubemap = make(GLintːCubemapLevelᵐ, count)
		m := o.Cubemap
		for i := uint32(0); i < count; i++ {
			var k GLint
			var v CubemapLevel
			k = GLint(d.Int32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.SwizzleR = GLenum(d.Uint32())
	o.SwizzleG = GLenum(d.Uint32())
	o.SwizzleB = GLenum(d.Uint32())
	o.SwizzleA = GLenum(d.Uint32())
	d.Simple(&o.BorderColor)
	o.MinFilter = GLenum(d.Uint32())
	o.MagFilter = GLenum(d.Uint32())
	o.WrapS = GLenum(d.Uint32())
	o.WrapT = GLenum(d.Uint32())
	o.WrapR = GLenum(d.Uint32())
	o.MinLod = GLfloat(d.Float32())
	o.MaxLod = GLfloat(d.Float32())
	o.BaseLevel = GLint(d.Int32())
	o.MaxLevel = GLint(d.Int32())
	o.DepthStencilTextureMode = GLenum(d.Uint32())
	o.CompareMode = GLenum(d.Uint32())
	o.CompareFunc = GLenum(d.Uint32())
	o.ImmutableFormat = GLboolean(d.Uint8())
	o.ImmutableLevels = GLuint(d.Uint32())
	o.Label = string(d.String())
	o.MaxAnisotropy = GLfloat(d.Float32())
}
func doDecodeRawTexture(d binary.Decoder, o *Texture) {
	o.ID = TextureId(d.Uint32())
	o.Kind = GLenum(d.Uint32())
	o.TexelFormat = GLenum(d.Uint32())
	o.TexelType = GLenum(d.Uint32())
	if count := d.Count(); count > 0 {
		o.Texture2D = make(GLintːImageᵐ, count)
		m := o.Texture2D
		for i := uint32(0); i < count; i++ {
			var k GLint
			var v Image
			k = GLint(d.Int32())
			d.Simple(&v)
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Cubemap = make(GLintːCubemapLevelᵐ, count)
		m := o.Cubemap
		for i := uint32(0); i < count; i++ {
			var k GLint
			var v CubemapLevel
			k = GLint(d.Int32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.SwizzleR = GLenum(d.Uint32())
	o.SwizzleG = GLenum(d.Uint32())
	o.SwizzleB = GLenum(d.Uint32())
	o.SwizzleA = GLenum(d.Uint32())
	d.Simple(&o.BorderColor)
	o.MinFilter = GLenum(d.Uint32())
	o.MagFilter = GLenum(d.Uint32())
	o.WrapS = GLenum(d.Uint32())
	o.WrapT = GLenum(d.Uint32())
	o.WrapR = GLenum(d.Uint32())
	o.MinLod = GLfloat(d.Float32())
	o.MaxLod = GLfloat(d.Float32())
	o.BaseLevel = GLint(d.Int32())
	o.MaxLevel = GLint(d.Int32())
	o.DepthStencilTextureMode = GLenum(d.Uint32())
	o.CompareMode = GLenum(d.Uint32())
	o.CompareFunc = GLenum(d.Uint32())
	o.ImmutableFormat = GLboolean(d.Uint8())
	o.ImmutableLevels = GLuint(d.Uint32())
	o.Label = string(d.String())
	o.MaxAnisotropy = GLfloat(d.Float32())
}
func (*binaryClassTexture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTexture(e, obj.(*Texture))
}
func (*binaryClassTexture) New() binary.Object {
	return &Texture{}
}
func (*binaryClassTexture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTexture(d, obj.(*Texture))
}
func (c *binaryClassTexture) Schema() *binary.Entity {
	return &entities[ixǁTexture]
}

type binaryClassDefaultTextureObjects struct{}

func (*DefaultTextureObjects) Class() binary.Class {
	return (*binaryClassDefaultTextureObjects)(nil)
}
func doEncodeDefaultTextureObjects(e binary.Encoder, o *DefaultTextureObjects) {
	if o.Texture2d != nil {
		e.Object(o.Texture2d)
	} else {
		e.Object(nil)
	}
	if o.Texture2dArray != nil {
		e.Object(o.Texture2dArray)
	} else {
		e.Object(nil)
	}
	if o.Texture2dMultisample != nil {
		e.Object(o.Texture2dMultisample)
	} else {
		e.Object(nil)
	}
	if o.Texture2dMultisampleArray != nil {
		e.Object(o.Texture2dMultisampleArray)
	} else {
		e.Object(nil)
	}
	if o.Texture3d != nil {
		e.Object(o.Texture3d)
	} else {
		e.Object(nil)
	}
	if o.TextureBuffer != nil {
		e.Object(o.TextureBuffer)
	} else {
		e.Object(nil)
	}
	if o.TextureCubeMap != nil {
		e.Object(o.TextureCubeMap)
	} else {
		e.Object(nil)
	}
	if o.TextureCubeMapArray != nil {
		e.Object(o.TextureCubeMapArray)
	} else {
		e.Object(nil)
	}
	if o.TextureExternalOes != nil {
		e.Object(o.TextureExternalOes)
	} else {
		e.Object(nil)
	}
}
func doDecodeDefaultTextureObjects(d binary.Decoder, o *DefaultTextureObjects) {
	if obj := d.Object(); obj != nil {
		o.Texture2d = obj.(*Texture)
	} else {
		o.Texture2d = nil
	}
	if obj := d.Object(); obj != nil {
		o.Texture2dArray = obj.(*Texture)
	} else {
		o.Texture2dArray = nil
	}
	if obj := d.Object(); obj != nil {
		o.Texture2dMultisample = obj.(*Texture)
	} else {
		o.Texture2dMultisample = nil
	}
	if obj := d.Object(); obj != nil {
		o.Texture2dMultisampleArray = obj.(*Texture)
	} else {
		o.Texture2dMultisampleArray = nil
	}
	if obj := d.Object(); obj != nil {
		o.Texture3d = obj.(*Texture)
	} else {
		o.Texture3d = nil
	}
	if obj := d.Object(); obj != nil {
		o.TextureBuffer = obj.(*Texture)
	} else {
		o.TextureBuffer = nil
	}
	if obj := d.Object(); obj != nil {
		o.TextureCubeMap = obj.(*Texture)
	} else {
		o.TextureCubeMap = nil
	}
	if obj := d.Object(); obj != nil {
		o.TextureCubeMapArray = obj.(*Texture)
	} else {
		o.TextureCubeMapArray = nil
	}
	if obj := d.Object(); obj != nil {
		o.TextureExternalOes = obj.(*Texture)
	} else {
		o.TextureExternalOes = nil
	}
}
func doDecodeRawDefaultTextureObjects(d binary.Decoder, o *DefaultTextureObjects) {
	if obj := d.Object(); obj != nil {
		o.Texture2d = obj.(*Texture)
	} else {
		o.Texture2d = nil
	}
	if obj := d.Object(); obj != nil {
		o.Texture2dArray = obj.(*Texture)
	} else {
		o.Texture2dArray = nil
	}
	if obj := d.Object(); obj != nil {
		o.Texture2dMultisample = obj.(*Texture)
	} else {
		o.Texture2dMultisample = nil
	}
	if obj := d.Object(); obj != nil {
		o.Texture2dMultisampleArray = obj.(*Texture)
	} else {
		o.Texture2dMultisampleArray = nil
	}
	if obj := d.Object(); obj != nil {
		o.Texture3d = obj.(*Texture)
	} else {
		o.Texture3d = nil
	}
	if obj := d.Object(); obj != nil {
		o.TextureBuffer = obj.(*Texture)
	} else {
		o.TextureBuffer = nil
	}
	if obj := d.Object(); obj != nil {
		o.TextureCubeMap = obj.(*Texture)
	} else {
		o.TextureCubeMap = nil
	}
	if obj := d.Object(); obj != nil {
		o.TextureCubeMapArray = obj.(*Texture)
	} else {
		o.TextureCubeMapArray = nil
	}
	if obj := d.Object(); obj != nil {
		o.TextureExternalOes = obj.(*Texture)
	} else {
		o.TextureExternalOes = nil
	}
}
func (*binaryClassDefaultTextureObjects) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeDefaultTextureObjects(e, obj.(*DefaultTextureObjects))
}
func (*binaryClassDefaultTextureObjects) New() binary.Object {
	return &DefaultTextureObjects{}
}
func (*binaryClassDefaultTextureObjects) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeDefaultTextureObjects(d, obj.(*DefaultTextureObjects))
}
func (c *binaryClassDefaultTextureObjects) Schema() *binary.Entity {
	return &entities[ixǁDefaultTextureObjects]
}

type binaryClassFramebufferAttachment struct{}

func (*FramebufferAttachment) Class() binary.Class {
	return (*binaryClassFramebufferAttachment)(nil)
}
func doEncodeFramebufferAttachment(e binary.Writer, o *FramebufferAttachment) {
	e.Uint32(uint32(o.ObjectType))
	e.Uint32(uint32(o.ObjectName))
	e.Int32(int32(o.TextureLevel))
	e.Uint32(uint32(o.TextureCubeMapFace))
	e.Int32(int32(o.TextureLayer))
	e.Uint8(uint8(o.Layered))
}
func doDecodeFramebufferAttachment(d binary.Reader, o *FramebufferAttachment) {
	o.ObjectType = GLenum(d.Uint32())
	o.ObjectName = GLuint(d.Uint32())
	o.TextureLevel = GLint(d.Int32())
	o.TextureCubeMapFace = GLenum(d.Uint32())
	o.TextureLayer = GLint(d.Int32())
	o.Layered = GLboolean(d.Uint8())
}
func doDecodeRawFramebufferAttachment(d binary.Reader, o *FramebufferAttachment) {
	o.ObjectType = GLenum(d.Uint32())
	o.ObjectName = GLuint(d.Uint32())
	o.TextureLevel = GLint(d.Int32())
	o.TextureCubeMapFace = GLenum(d.Uint32())
	o.TextureLayer = GLint(d.Int32())
	o.Layered = GLboolean(d.Uint8())
}
func (*binaryClassFramebufferAttachment) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeFramebufferAttachment(e, obj.(*FramebufferAttachment))
}
func (*binaryClassFramebufferAttachment) New() binary.Object {
	return &FramebufferAttachment{}
}
func (*binaryClassFramebufferAttachment) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeFramebufferAttachment(d, obj.(*FramebufferAttachment))
}
func (o *FramebufferAttachment) WriteSimple(w binary.Writer) {
	doEncodeFramebufferAttachment(w, o)
}
func (o *FramebufferAttachment) ReadSimple(r binary.Reader) {
	doDecodeFramebufferAttachment(r, o)
}
func (c *binaryClassFramebufferAttachment) Schema() *binary.Entity {
	return &entities[ixǁFramebufferAttachment]
}

type binaryClassFramebuffer struct{}

func (*Framebuffer) Class() binary.Class {
	return (*binaryClassFramebuffer)(nil)
}
func doEncodeFramebuffer(e binary.Writer, o *Framebuffer) {
	e.Uint32(uint32(len(o.Attachments)))
	for _, k := range (o.Attachments).KeysSorted() {
		v := (o.Attachments)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
	e.Uint32(uint32(len(o.DrawBuffer)))
	for _, k := range (o.DrawBuffer).KeysSorted() {
		v := (o.DrawBuffer)[k]
		e.Int32(int32(k))
		e.Uint32(uint32(v))
	}
	e.Uint32(uint32(o.ReadBuffer))
	e.Int32(int32(o.DefaultWidth))
	e.Int32(int32(o.DefaultHeight))
	e.Int32(int32(o.DefaultLayers))
	e.Int32(int32(o.DefaultSamples))
	e.Uint8(uint8(o.DefaultFixedSampleLocations))
	e.String(o.Label)
}
func doDecodeFramebuffer(d binary.Reader, o *Framebuffer) {
	if count := d.Count(); count > 0 {
		o.Attachments = make(GLenumːFramebufferAttachmentᵐ, count)
		m := o.Attachments
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v FramebufferAttachment
			k = GLenum(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.DrawBuffer = make(GLintːGLenumᵐ, count)
		m := o.DrawBuffer
		for i := uint32(0); i < count; i++ {
			var k GLint
			var v GLenum
			k = GLint(d.Int32())
			v = GLenum(d.Uint32())
			m[k] = v
		}
	}
	o.ReadBuffer = GLenum(d.Uint32())
	o.DefaultWidth = GLint(d.Int32())
	o.DefaultHeight = GLint(d.Int32())
	o.DefaultLayers = GLint(d.Int32())
	o.DefaultSamples = GLint(d.Int32())
	o.DefaultFixedSampleLocations = GLboolean(d.Uint8())
	o.Label = string(d.String())
}
func doDecodeRawFramebuffer(d binary.Reader, o *Framebuffer) {
	if count := d.Count(); count > 0 {
		o.Attachments = make(GLenumːFramebufferAttachmentᵐ, count)
		m := o.Attachments
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v FramebufferAttachment
			k = GLenum(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.DrawBuffer = make(GLintːGLenumᵐ, count)
		m := o.DrawBuffer
		for i := uint32(0); i < count; i++ {
			var k GLint
			var v GLenum
			k = GLint(d.Int32())
			v = GLenum(d.Uint32())
			m[k] = v
		}
	}
	o.ReadBuffer = GLenum(d.Uint32())
	o.DefaultWidth = GLint(d.Int32())
	o.DefaultHeight = GLint(d.Int32())
	o.DefaultLayers = GLint(d.Int32())
	o.DefaultSamples = GLint(d.Int32())
	o.DefaultFixedSampleLocations = GLboolean(d.Uint8())
	o.Label = string(d.String())
}
func (*binaryClassFramebuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeFramebuffer(e, obj.(*Framebuffer))
}
func (*binaryClassFramebuffer) New() binary.Object {
	return &Framebuffer{}
}
func (*binaryClassFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeFramebuffer(d, obj.(*Framebuffer))
}
func (o *Framebuffer) WriteSimple(w binary.Writer) {
	doEncodeFramebuffer(w, o)
}
func (o *Framebuffer) ReadSimple(r binary.Reader) {
	doDecodeFramebuffer(r, o)
}
func (c *binaryClassFramebuffer) Schema() *binary.Entity {
	return &entities[ixǁFramebuffer]
}

type binaryClassSampler struct{}

func (*Sampler) Class() binary.Class {
	return (*binaryClassSampler)(nil)
}
func doEncodeSampler(e binary.Writer, o *Sampler) {
	e.Simple(&o.BorderColor)
	e.Uint32(uint32(o.MinFilter))
	e.Uint32(uint32(o.MagFilter))
	e.Uint32(uint32(o.WrapS))
	e.Uint32(uint32(o.WrapT))
	e.Uint32(uint32(o.WrapR))
	e.Float32(float32(o.MinLod))
	e.Float32(float32(o.MaxLod))
	e.Uint32(uint32(o.CompareMode))
	e.Uint32(uint32(o.CompareFunc))
	e.String(o.Label)
}
func doDecodeSampler(d binary.Reader, o *Sampler) {
	d.Simple(&o.BorderColor)
	o.MinFilter = GLenum(d.Uint32())
	o.MagFilter = GLenum(d.Uint32())
	o.WrapS = GLenum(d.Uint32())
	o.WrapT = GLenum(d.Uint32())
	o.WrapR = GLenum(d.Uint32())
	o.MinLod = GLfloat(d.Float32())
	o.MaxLod = GLfloat(d.Float32())
	o.CompareMode = GLenum(d.Uint32())
	o.CompareFunc = GLenum(d.Uint32())
	o.Label = string(d.String())
}
func doDecodeRawSampler(d binary.Reader, o *Sampler) {
	d.Simple(&o.BorderColor)
	o.MinFilter = GLenum(d.Uint32())
	o.MagFilter = GLenum(d.Uint32())
	o.WrapS = GLenum(d.Uint32())
	o.WrapT = GLenum(d.Uint32())
	o.WrapR = GLenum(d.Uint32())
	o.MinLod = GLfloat(d.Float32())
	o.MaxLod = GLfloat(d.Float32())
	o.CompareMode = GLenum(d.Uint32())
	o.CompareFunc = GLenum(d.Uint32())
	o.Label = string(d.String())
}
func (*binaryClassSampler) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeSampler(e, obj.(*Sampler))
}
func (*binaryClassSampler) New() binary.Object {
	return &Sampler{}
}
func (*binaryClassSampler) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeSampler(d, obj.(*Sampler))
}
func (o *Sampler) WriteSimple(w binary.Writer) {
	doEncodeSampler(w, o)
}
func (o *Sampler) ReadSimple(r binary.Reader) {
	doDecodeSampler(r, o)
}
func (c *binaryClassSampler) Schema() *binary.Entity {
	return &entities[ixǁSampler]
}

type binaryClassGLcharˢ struct{}

func (*GLcharˢ) Class() binary.Class {
	return (*binaryClassGLcharˢ)(nil)
}
func doEncodeGLcharˢ(e binary.Writer, o *GLcharˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLcharˢ(d binary.Reader, o *GLcharˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLcharˢ(d binary.Reader, o *GLcharˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLcharˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLcharˢ(e, obj.(*GLcharˢ))
}
func (*binaryClassGLcharˢ) New() binary.Object {
	return &GLcharˢ{}
}
func (*binaryClassGLcharˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLcharˢ(d, obj.(*GLcharˢ))
}
func (o *GLcharˢ) WriteSimple(w binary.Writer) {
	doEncodeGLcharˢ(w, o)
}
func (o *GLcharˢ) ReadSimple(r binary.Reader) {
	doDecodeGLcharˢ(r, o)
}
func (c *binaryClassGLcharˢ) Schema() *binary.Entity {
	return &entities[ixǁGLcharˢ]
}

type binaryClassShader struct{}

func (*Shader) Class() binary.Class {
	return (*binaryClassShader)(nil)
}
func doEncodeShader(e binary.Writer, o *Shader) {
	e.Uint32(uint32(o.ID))
	e.Uint32(uint32(o.ShaderType))
	e.Simple(&o.Binary)
	e.Bool(o.Compiled)
	e.Bool(o.DeleteStatus)
	e.Simple(&o.InfoLog)
	e.String(o.Source)
	e.Uint32(uint32(o.Type))
	e.String(o.Label)
	e.Uint32(uint32(o.RefCount))
}
func doDecodeShader(d binary.Reader, o *Shader) {
	o.ID = ShaderId(d.Uint32())
	o.ShaderType = GLenum(d.Uint32())
	d.Simple(&o.Binary)
	o.Compiled = bool(d.Bool())
	o.DeleteStatus = bool(d.Bool())
	d.Simple(&o.InfoLog)
	o.Source = string(d.String())
	o.Type = GLenum(d.Uint32())
	o.Label = string(d.String())
	o.RefCount = GLuint(d.Uint32())
}
func doDecodeRawShader(d binary.Reader, o *Shader) {
	o.ID = ShaderId(d.Uint32())
	o.ShaderType = GLenum(d.Uint32())
	d.Simple(&o.Binary)
	o.Compiled = bool(d.Bool())
	o.DeleteStatus = bool(d.Bool())
	d.Simple(&o.InfoLog)
	o.Source = string(d.String())
	o.Type = GLenum(d.Uint32())
	o.Label = string(d.String())
	o.RefCount = GLuint(d.Uint32())
}
func (*binaryClassShader) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeShader(e, obj.(*Shader))
}
func (*binaryClassShader) New() binary.Object {
	return &Shader{}
}
func (*binaryClassShader) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeShader(d, obj.(*Shader))
}
func (o *Shader) WriteSimple(w binary.Writer) {
	doEncodeShader(w, o)
}
func (o *Shader) ReadSimple(r binary.Reader) {
	doDecodeShader(r, o)
}
func (c *binaryClassShader) Schema() *binary.Entity {
	return &entities[ixǁShader]
}

type binaryClassUniform struct{}

func (*Uniform) Class() binary.Class {
	return (*binaryClassUniform)(nil)
}
func doEncodeUniform(e binary.Writer, o *Uniform) {
	e.Simple(&o.Value)
	e.Uint32(uint32(o.Type))
}
func doDecodeUniform(d binary.Reader, o *Uniform) {
	d.Simple(&o.Value)
	o.Type = GLenum(d.Uint32())
}
func doDecodeRawUniform(d binary.Reader, o *Uniform) {
	d.Simple(&o.Value)
	o.Type = GLenum(d.Uint32())
}
func (*binaryClassUniform) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeUniform(e, obj.(*Uniform))
}
func (*binaryClassUniform) New() binary.Object {
	return &Uniform{}
}
func (*binaryClassUniform) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeUniform(d, obj.(*Uniform))
}
func (o *Uniform) WriteSimple(w binary.Writer) {
	doEncodeUniform(w, o)
}
func (o *Uniform) ReadSimple(r binary.Reader) {
	doDecodeUniform(r, o)
}
func (c *binaryClassUniform) Schema() *binary.Entity {
	return &entities[ixǁUniform]
}

type binaryClassProgram struct{}

func (*Program) Class() binary.Class {
	return (*binaryClassProgram)(nil)
}
func doEncodeProgram(e binary.Writer, o *Program) {
	e.Uint32(uint32(o.ID))
	e.Uint32(uint32(len(o.Shaders)))
	for _, k := range (o.Shaders).KeysSorted() {
		v := (o.Shaders)[k]
		e.Uint32(uint32(k))
		e.Uint32(uint32(v))
	}
	e.Uint8(uint8(o.LinkStatus))
	e.String(o.InfoLog)
	e.Bool(o.Precompiled)
	e.Bool(o.DeleteStatus)
	e.Simple(&o.Binary)
	e.Uint32(uint32(len(o.AttributeBindings)))
	for _, k := range (o.AttributeBindings).KeysSorted() {
		v := (o.AttributeBindings)[k]
		e.String(k)
		e.Uint32(uint32(v))
	}
	e.Uint32(uint32(len(o.ActiveAttributes)))
	for _, k := range (o.ActiveAttributes).KeysSorted() {
		v := (o.ActiveAttributes)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
	e.Uint32(uint32(len(o.ActiveUniforms)))
	for _, k := range (o.ActiveUniforms).KeysSorted() {
		v := (o.ActiveUniforms)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
	e.Uint32(uint32(len(o.Uniforms)))
	for _, k := range (o.Uniforms).KeysSorted() {
		v := (o.Uniforms)[k]
		e.Int32(int32(k))
		e.Simple(&v)
	}
	e.String(o.Label)
}
func doDecodeProgram(d binary.Reader, o *Program) {
	o.ID = ProgramId(d.Uint32())
	if count := d.Count(); count > 0 {
		o.Shaders = make(GLenumːShaderIdᵐ, count)
		m := o.Shaders
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v ShaderId
			k = GLenum(d.Uint32())
			v = ShaderId(d.Uint32())
			m[k] = v
		}
	}
	o.LinkStatus = GLboolean(d.Uint8())
	o.InfoLog = string(d.String())
	o.Precompiled = bool(d.Bool())
	o.DeleteStatus = bool(d.Bool())
	d.Simple(&o.Binary)
	if count := d.Count(); count > 0 {
		o.AttributeBindings = make(StringːAttributeLocationᵐ, count)
		m := o.AttributeBindings
		for i := uint32(0); i < count; i++ {
			var k string
			var v AttributeLocation
			k = string(d.String())
			v = AttributeLocation(d.Uint32())
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.ActiveAttributes = make(AttributeIndexːActiveAttributeᵐ, count)
		m := o.ActiveAttributes
		for i := uint32(0); i < count; i++ {
			var k AttributeIndex
			var v ActiveAttribute
			k = AttributeIndex(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.ActiveUniforms = make(UniformIndexːActiveUniformᵐ, count)
		m := o.ActiveUniforms
		for i := uint32(0); i < count; i++ {
			var k UniformIndex
			var v ActiveUniform
			k = UniformIndex(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Uniforms = make(UniformLocationːUniformᵐ, count)
		m := o.Uniforms
		for i := uint32(0); i < count; i++ {
			var k UniformLocation
			var v Uniform
			k = UniformLocation(d.Int32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.Label = string(d.String())
}
func doDecodeRawProgram(d binary.Reader, o *Program) {
	o.ID = ProgramId(d.Uint32())
	if count := d.Count(); count > 0 {
		o.Shaders = make(GLenumːShaderIdᵐ, count)
		m := o.Shaders
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v ShaderId
			k = GLenum(d.Uint32())
			v = ShaderId(d.Uint32())
			m[k] = v
		}
	}
	o.LinkStatus = GLboolean(d.Uint8())
	o.InfoLog = string(d.String())
	o.Precompiled = bool(d.Bool())
	o.DeleteStatus = bool(d.Bool())
	d.Simple(&o.Binary)
	if count := d.Count(); count > 0 {
		o.AttributeBindings = make(StringːAttributeLocationᵐ, count)
		m := o.AttributeBindings
		for i := uint32(0); i < count; i++ {
			var k string
			var v AttributeLocation
			k = string(d.String())
			v = AttributeLocation(d.Uint32())
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.ActiveAttributes = make(AttributeIndexːActiveAttributeᵐ, count)
		m := o.ActiveAttributes
		for i := uint32(0); i < count; i++ {
			var k AttributeIndex
			var v ActiveAttribute
			k = AttributeIndex(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.ActiveUniforms = make(UniformIndexːActiveUniformᵐ, count)
		m := o.ActiveUniforms
		for i := uint32(0); i < count; i++ {
			var k UniformIndex
			var v ActiveUniform
			k = UniformIndex(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Uniforms = make(UniformLocationːUniformᵐ, count)
		m := o.Uniforms
		for i := uint32(0); i < count; i++ {
			var k UniformLocation
			var v Uniform
			k = UniformLocation(d.Int32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.Label = string(d.String())
}
func (*binaryClassProgram) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeProgram(e, obj.(*Program))
}
func (*binaryClassProgram) New() binary.Object {
	return &Program{}
}
func (*binaryClassProgram) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeProgram(d, obj.(*Program))
}
func (o *Program) WriteSimple(w binary.Writer) {
	doEncodeProgram(w, o)
}
func (o *Program) ReadSimple(r binary.Reader) {
	doDecodeProgram(r, o)
}
func (c *binaryClassProgram) Schema() *binary.Entity {
	return &entities[ixǁProgram]
}

type binaryClassPipeline struct{}

func (*Pipeline) Class() binary.Class {
	return (*binaryClassPipeline)(nil)
}
func doEncodePipeline(e binary.Writer, o *Pipeline) {
	e.String(o.Label)
}
func doDecodePipeline(d binary.Reader, o *Pipeline) {
	o.Label = string(d.String())
}
func doDecodeRawPipeline(d binary.Reader, o *Pipeline) {
	o.Label = string(d.String())
}
func (*binaryClassPipeline) Encode(e binary.Encoder, obj binary.Object) {
	doEncodePipeline(e, obj.(*Pipeline))
}
func (*binaryClassPipeline) New() binary.Object {
	return &Pipeline{}
}
func (*binaryClassPipeline) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodePipeline(d, obj.(*Pipeline))
}
func (o *Pipeline) WriteSimple(w binary.Writer) {
	doEncodePipeline(w, o)
}
func (o *Pipeline) ReadSimple(r binary.Reader) {
	doDecodePipeline(r, o)
}
func (c *binaryClassPipeline) Schema() *binary.Entity {
	return &entities[ixǁPipeline]
}

type binaryClassVertexBufferBinding struct{}

func (*VertexBufferBinding) Class() binary.Class {
	return (*binaryClassVertexBufferBinding)(nil)
}
func doEncodeVertexBufferBinding(e binary.Writer, o *VertexBufferBinding) {
	e.Int32(int32(o.Offset))
	e.Int32(int32(o.Stride))
	e.Uint32(uint32(o.Divisor))
	e.Uint32(uint32(o.Buffer))
}
func doDecodeVertexBufferBinding(d binary.Reader, o *VertexBufferBinding) {
	o.Offset = GLintptr(d.Int32())
	o.Stride = GLsizei(d.Int32())
	o.Divisor = GLuint(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
}
func doDecodeRawVertexBufferBinding(d binary.Reader, o *VertexBufferBinding) {
	o.Offset = GLintptr(d.Int32())
	o.Stride = GLsizei(d.Int32())
	o.Divisor = GLuint(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
}
func (*binaryClassVertexBufferBinding) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVertexBufferBinding(e, obj.(*VertexBufferBinding))
}
func (*binaryClassVertexBufferBinding) New() binary.Object {
	return &VertexBufferBinding{}
}
func (*binaryClassVertexBufferBinding) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVertexBufferBinding(d, obj.(*VertexBufferBinding))
}
func (o *VertexBufferBinding) WriteSimple(w binary.Writer) {
	doEncodeVertexBufferBinding(w, o)
}
func (o *VertexBufferBinding) ReadSimple(r binary.Reader) {
	doDecodeVertexBufferBinding(r, o)
}
func (c *binaryClassVertexBufferBinding) Schema() *binary.Entity {
	return &entities[ixǁVertexBufferBinding]
}

type binaryClassVertexPointer struct{}

func (*VertexPointer) Class() binary.Class {
	return (*binaryClassVertexPointer)(nil)
}
func doEncodeVertexPointer(e binary.Writer, o *VertexPointer) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVertexPointer(d binary.Reader, o *VertexPointer) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVertexPointer(d binary.Reader, o *VertexPointer) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVertexPointer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVertexPointer(e, obj.(*VertexPointer))
}
func (*binaryClassVertexPointer) New() binary.Object {
	return &VertexPointer{}
}
func (*binaryClassVertexPointer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVertexPointer(d, obj.(*VertexPointer))
}
func (o *VertexPointer) WriteSimple(w binary.Writer) {
	doEncodeVertexPointer(w, o)
}
func (o *VertexPointer) ReadSimple(r binary.Reader) {
	doDecodeVertexPointer(r, o)
}
func (c *binaryClassVertexPointer) Schema() *binary.Entity {
	return &entities[ixǁVertexPointer]
}

type binaryClassVertexAttributeArray struct{}

func (*VertexAttributeArray) Class() binary.Class {
	return (*binaryClassVertexAttributeArray)(nil)
}
func doEncodeVertexAttributeArray(e binary.Writer, o *VertexAttributeArray) {
	e.Uint8(uint8(o.Enabled))
	e.Int32(int32(o.Size))
	e.Int32(int32(o.Stride))
	e.Uint32(uint32(o.Type))
	e.Uint8(uint8(o.Normalized))
	e.Uint8(uint8(o.Integer))
	e.Uint32(uint32(o.Divisor))
	e.Simple(&o.Pointer)
	e.Uint32(uint32(o.BufferBinding))
	e.Uint32(uint32(o.Binding))
	e.Uint32(uint32(o.RelativeOffset))
}
func doDecodeVertexAttributeArray(d binary.Reader, o *VertexAttributeArray) {
	o.Enabled = GLboolean(d.Uint8())
	o.Size = GLint(d.Int32())
	o.Stride = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Normalized = GLboolean(d.Uint8())
	o.Integer = GLboolean(d.Uint8())
	o.Divisor = GLuint(d.Uint32())
	d.Simple(&o.Pointer)
	o.BufferBinding = GLuint(d.Uint32())
	o.Binding = VertexBufferBindingIndex(d.Uint32())
	o.RelativeOffset = GLuint(d.Uint32())
}
func doDecodeRawVertexAttributeArray(d binary.Reader, o *VertexAttributeArray) {
	o.Enabled = GLboolean(d.Uint8())
	o.Size = GLint(d.Int32())
	o.Stride = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Normalized = GLboolean(d.Uint8())
	o.Integer = GLboolean(d.Uint8())
	o.Divisor = GLuint(d.Uint32())
	d.Simple(&o.Pointer)
	o.BufferBinding = GLuint(d.Uint32())
	o.Binding = VertexBufferBindingIndex(d.Uint32())
	o.RelativeOffset = GLuint(d.Uint32())
}
func (*binaryClassVertexAttributeArray) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVertexAttributeArray(e, obj.(*VertexAttributeArray))
}
func (*binaryClassVertexAttributeArray) New() binary.Object {
	return &VertexAttributeArray{}
}
func (*binaryClassVertexAttributeArray) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVertexAttributeArray(d, obj.(*VertexAttributeArray))
}
func (o *VertexAttributeArray) WriteSimple(w binary.Writer) {
	doEncodeVertexAttributeArray(w, o)
}
func (o *VertexAttributeArray) ReadSimple(r binary.Reader) {
	doDecodeVertexAttributeArray(r, o)
}
func (c *binaryClassVertexAttributeArray) Schema() *binary.Entity {
	return &entities[ixǁVertexAttributeArray]
}

type binaryClassVertexArray struct{}

func (*VertexArray) Class() binary.Class {
	return (*binaryClassVertexArray)(nil)
}
func doEncodeVertexArray(e binary.Encoder, o *VertexArray) {
	e.Uint32(uint32(len(o.VertexBufferBindings)))
	for _, k := range (o.VertexBufferBindings).KeysSorted() {
		v := (o.VertexBufferBindings)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.VertexAttributeArrays)))
	for _, k := range (o.VertexAttributeArrays).KeysSorted() {
		v := (o.VertexAttributeArrays)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(o.ElementArrayBuffer))
	e.String(o.Label)
}
func doDecodeVertexArray(d binary.Decoder, o *VertexArray) {
	if count := d.Count(); count > 0 {
		o.VertexBufferBindings = make(VertexBufferBindingIndexːVertexBufferBindingʳᵐ, count)
		m := o.VertexBufferBindings
		for i := uint32(0); i < count; i++ {
			var k VertexBufferBindingIndex
			var v *VertexBufferBinding
			k = VertexBufferBindingIndex(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*VertexBufferBinding)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.VertexAttributeArrays = make(AttributeLocationːVertexAttributeArrayʳᵐ, count)
		m := o.VertexAttributeArrays
		for i := uint32(0); i < count; i++ {
			var k AttributeLocation
			var v *VertexAttributeArray
			k = AttributeLocation(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*VertexAttributeArray)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	o.ElementArrayBuffer = BufferId(d.Uint32())
	o.Label = string(d.String())
}
func doDecodeRawVertexArray(d binary.Decoder, o *VertexArray) {
	if count := d.Count(); count > 0 {
		o.VertexBufferBindings = make(VertexBufferBindingIndexːVertexBufferBindingʳᵐ, count)
		m := o.VertexBufferBindings
		for i := uint32(0); i < count; i++ {
			var k VertexBufferBindingIndex
			var v *VertexBufferBinding
			k = VertexBufferBindingIndex(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*VertexBufferBinding)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.VertexAttributeArrays = make(AttributeLocationːVertexAttributeArrayʳᵐ, count)
		m := o.VertexAttributeArrays
		for i := uint32(0); i < count; i++ {
			var k AttributeLocation
			var v *VertexAttributeArray
			k = AttributeLocation(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*VertexAttributeArray)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	o.ElementArrayBuffer = BufferId(d.Uint32())
	o.Label = string(d.String())
}
func (*binaryClassVertexArray) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVertexArray(e, obj.(*VertexArray))
}
func (*binaryClassVertexArray) New() binary.Object {
	return &VertexArray{}
}
func (*binaryClassVertexArray) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVertexArray(d, obj.(*VertexArray))
}
func (c *binaryClassVertexArray) Schema() *binary.Entity {
	return &entities[ixǁVertexArray]
}

type binaryClassQuery struct{}

func (*Query) Class() binary.Class {
	return (*binaryClassQuery)(nil)
}
func doEncodeQuery(e binary.Writer, o *Query) {
	e.String(o.Label)
}
func doDecodeQuery(d binary.Reader, o *Query) {
	o.Label = string(d.String())
}
func doDecodeRawQuery(d binary.Reader, o *Query) {
	o.Label = string(d.String())
}
func (*binaryClassQuery) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeQuery(e, obj.(*Query))
}
func (*binaryClassQuery) New() binary.Object {
	return &Query{}
}
func (*binaryClassQuery) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeQuery(d, obj.(*Query))
}
func (o *Query) WriteSimple(w binary.Writer) {
	doEncodeQuery(w, o)
}
func (o *Query) ReadSimple(r binary.Reader) {
	doDecodeQuery(r, o)
}
func (c *binaryClassQuery) Schema() *binary.Entity {
	return &entities[ixǁQuery]
}

type binaryClassTransformFeedback struct{}

func (*TransformFeedback) Class() binary.Class {
	return (*binaryClassTransformFeedback)(nil)
}
func doEncodeTransformFeedback(e binary.Writer, o *TransformFeedback) {
	e.Uint32(uint32(len(o.Buffers)))
	for _, k := range (o.Buffers).KeysSorted() {
		v := (o.Buffers)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
	e.Uint8(uint8(o.Paused))
	e.Uint8(uint8(o.Active))
	e.String(o.Label)
}
func doDecodeTransformFeedback(d binary.Reader, o *TransformFeedback) {
	if count := d.Count(); count > 0 {
		o.Buffers = make(GLuintːBufferBindingᵐ, count)
		m := o.Buffers
		for i := uint32(0); i < count; i++ {
			var k GLuint
			var v BufferBinding
			k = GLuint(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.Paused = GLboolean(d.Uint8())
	o.Active = GLboolean(d.Uint8())
	o.Label = string(d.String())
}
func doDecodeRawTransformFeedback(d binary.Reader, o *TransformFeedback) {
	if count := d.Count(); count > 0 {
		o.Buffers = make(GLuintːBufferBindingᵐ, count)
		m := o.Buffers
		for i := uint32(0); i < count; i++ {
			var k GLuint
			var v BufferBinding
			k = GLuint(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.Paused = GLboolean(d.Uint8())
	o.Active = GLboolean(d.Uint8())
	o.Label = string(d.String())
}
func (*binaryClassTransformFeedback) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTransformFeedback(e, obj.(*TransformFeedback))
}
func (*binaryClassTransformFeedback) New() binary.Object {
	return &TransformFeedback{}
}
func (*binaryClassTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTransformFeedback(d, obj.(*TransformFeedback))
}
func (o *TransformFeedback) WriteSimple(w binary.Writer) {
	doEncodeTransformFeedback(w, o)
}
func (o *TransformFeedback) ReadSimple(r binary.Reader) {
	doDecodeTransformFeedback(r, o)
}
func (c *binaryClassTransformFeedback) Schema() *binary.Entity {
	return &entities[ixǁTransformFeedback]
}

type binaryClassGLsync struct{}

func (*GLsync) Class() binary.Class {
	return (*binaryClassGLsync)(nil)
}
func doEncodeGLsync(e binary.Writer, o *GLsync) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLsync(d binary.Reader, o *GLsync) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLsync(d binary.Reader, o *GLsync) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLsync) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLsync(e, obj.(*GLsync))
}
func (*binaryClassGLsync) New() binary.Object {
	return &GLsync{}
}
func (*binaryClassGLsync) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLsync(d, obj.(*GLsync))
}
func (o *GLsync) WriteSimple(w binary.Writer) {
	doEncodeGLsync(w, o)
}
func (o *GLsync) ReadSimple(r binary.Reader) {
	doDecodeGLsync(r, o)
}
func (c *binaryClassGLsync) Schema() *binary.Entity {
	return &entities[ixǁGLsync]
}

type binaryClassSyncObject struct{}

func (*SyncObject) Class() binary.Class {
	return (*binaryClassSyncObject)(nil)
}
func doEncodeSyncObject(e binary.Writer, o *SyncObject) {
}
func doDecodeSyncObject(d binary.Reader, o *SyncObject) {
}
func doDecodeRawSyncObject(d binary.Reader, o *SyncObject) {
}
func (*binaryClassSyncObject) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeSyncObject(e, obj.(*SyncObject))
}
func (*binaryClassSyncObject) New() binary.Object {
	return &SyncObject{}
}
func (*binaryClassSyncObject) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeSyncObject(d, obj.(*SyncObject))
}
func (o *SyncObject) WriteSimple(w binary.Writer) {
	doEncodeSyncObject(w, o)
}
func (o *SyncObject) ReadSimple(r binary.Reader) {
	doDecodeSyncObject(r, o)
}
func (c *binaryClassSyncObject) Schema() *binary.Entity {
	return &entities[ixǁSyncObject]
}

type binaryClassObjects struct{}

func (*Objects) Class() binary.Class {
	return (*binaryClassObjects)(nil)
}
func doEncodeObjects(e binary.Encoder, o *Objects) {
	e.Uint32(uint32(len(o.Renderbuffers)))
	for _, k := range (o.Renderbuffers).KeysSorted() {
		v := (o.Renderbuffers)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Struct(&o.DefaultTextures)
	e.Uint32(uint32(len(o.Textures)))
	for _, k := range (o.Textures).KeysSorted() {
		v := (o.Textures)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.Framebuffers)))
	for _, k := range (o.Framebuffers).KeysSorted() {
		v := (o.Framebuffers)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.Buffers)))
	for _, k := range (o.Buffers).KeysSorted() {
		v := (o.Buffers)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.Samplers)))
	for _, k := range (o.Samplers).KeysSorted() {
		v := (o.Samplers)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.Shaders)))
	for _, k := range (o.Shaders).KeysSorted() {
		v := (o.Shaders)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.Programs)))
	for _, k := range (o.Programs).KeysSorted() {
		v := (o.Programs)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.Pipelines)))
	for _, k := range (o.Pipelines).KeysSorted() {
		v := (o.Pipelines)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.VertexArrays)))
	for _, k := range (o.VertexArrays).KeysSorted() {
		v := (o.VertexArrays)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.Queries)))
	for _, k := range (o.Queries).KeysSorted() {
		v := (o.Queries)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.TransformFeedbacks)))
	for _, k := range (o.TransformFeedbacks).KeysSorted() {
		v := (o.TransformFeedbacks)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.SyncObjects)))
	for _, k := range (o.SyncObjects).KeysSorted() {
		v := (o.SyncObjects)[k]
		e.Simple(&k)
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
}
func doDecodeObjects(d binary.Decoder, o *Objects) {
	if count := d.Count(); count > 0 {
		o.Renderbuffers = make(RenderbufferIdːRenderbufferʳᵐ, count)
		m := o.Renderbuffers
		for i := uint32(0); i < count; i++ {
			var k RenderbufferId
			var v *Renderbuffer
			k = RenderbufferId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Renderbuffer)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	d.Struct(&o.DefaultTextures)
	if count := d.Count(); count > 0 {
		o.Textures = make(TextureIdːTextureʳᵐ, count)
		m := o.Textures
		for i := uint32(0); i < count; i++ {
			var k TextureId
			var v *Texture
			k = TextureId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Texture)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Framebuffers = make(FramebufferIdːFramebufferʳᵐ, count)
		m := o.Framebuffers
		for i := uint32(0); i < count; i++ {
			var k FramebufferId
			var v *Framebuffer
			k = FramebufferId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Framebuffer)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Buffers = make(BufferIdːBufferʳᵐ, count)
		m := o.Buffers
		for i := uint32(0); i < count; i++ {
			var k BufferId
			var v *Buffer
			k = BufferId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Buffer)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Samplers = make(SamplerIdːSamplerʳᵐ, count)
		m := o.Samplers
		for i := uint32(0); i < count; i++ {
			var k SamplerId
			var v *Sampler
			k = SamplerId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Sampler)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Shaders = make(ShaderIdːShaderʳᵐ, count)
		m := o.Shaders
		for i := uint32(0); i < count; i++ {
			var k ShaderId
			var v *Shader
			k = ShaderId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Shader)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Programs = make(ProgramIdːProgramʳᵐ, count)
		m := o.Programs
		for i := uint32(0); i < count; i++ {
			var k ProgramId
			var v *Program
			k = ProgramId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Program)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Pipelines = make(PipelineIdːPipelineʳᵐ, count)
		m := o.Pipelines
		for i := uint32(0); i < count; i++ {
			var k PipelineId
			var v *Pipeline
			k = PipelineId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Pipeline)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.VertexArrays = make(VertexArrayIdːVertexArrayʳᵐ, count)
		m := o.VertexArrays
		for i := uint32(0); i < count; i++ {
			var k VertexArrayId
			var v *VertexArray
			k = VertexArrayId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*VertexArray)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Queries = make(QueryIdːQueryʳᵐ, count)
		m := o.Queries
		for i := uint32(0); i < count; i++ {
			var k QueryId
			var v *Query
			k = QueryId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Query)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.TransformFeedbacks = make(TransformFeedbackIdːTransformFeedbackʳᵐ, count)
		m := o.TransformFeedbacks
		for i := uint32(0); i < count; i++ {
			var k TransformFeedbackId
			var v *TransformFeedback
			k = TransformFeedbackId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*TransformFeedback)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.SyncObjects = make(GLsyncːSyncObjectʳᵐ, count)
		m := o.SyncObjects
		for i := uint32(0); i < count; i++ {
			var k GLsync
			var v *SyncObject
			d.Simple(&k)
			if obj := d.Object(); obj != nil {
				v = obj.(*SyncObject)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
}
func doDecodeRawObjects(d binary.Decoder, o *Objects) {
	if count := d.Count(); count > 0 {
		o.Renderbuffers = make(RenderbufferIdːRenderbufferʳᵐ, count)
		m := o.Renderbuffers
		for i := uint32(0); i < count; i++ {
			var k RenderbufferId
			var v *Renderbuffer
			k = RenderbufferId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Renderbuffer)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	d.Struct(&o.DefaultTextures)
	if count := d.Count(); count > 0 {
		o.Textures = make(TextureIdːTextureʳᵐ, count)
		m := o.Textures
		for i := uint32(0); i < count; i++ {
			var k TextureId
			var v *Texture
			k = TextureId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Texture)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Framebuffers = make(FramebufferIdːFramebufferʳᵐ, count)
		m := o.Framebuffers
		for i := uint32(0); i < count; i++ {
			var k FramebufferId
			var v *Framebuffer
			k = FramebufferId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Framebuffer)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Buffers = make(BufferIdːBufferʳᵐ, count)
		m := o.Buffers
		for i := uint32(0); i < count; i++ {
			var k BufferId
			var v *Buffer
			k = BufferId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Buffer)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Samplers = make(SamplerIdːSamplerʳᵐ, count)
		m := o.Samplers
		for i := uint32(0); i < count; i++ {
			var k SamplerId
			var v *Sampler
			k = SamplerId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Sampler)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Shaders = make(ShaderIdːShaderʳᵐ, count)
		m := o.Shaders
		for i := uint32(0); i < count; i++ {
			var k ShaderId
			var v *Shader
			k = ShaderId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Shader)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Programs = make(ProgramIdːProgramʳᵐ, count)
		m := o.Programs
		for i := uint32(0); i < count; i++ {
			var k ProgramId
			var v *Program
			k = ProgramId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Program)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Pipelines = make(PipelineIdːPipelineʳᵐ, count)
		m := o.Pipelines
		for i := uint32(0); i < count; i++ {
			var k PipelineId
			var v *Pipeline
			k = PipelineId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Pipeline)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.VertexArrays = make(VertexArrayIdːVertexArrayʳᵐ, count)
		m := o.VertexArrays
		for i := uint32(0); i < count; i++ {
			var k VertexArrayId
			var v *VertexArray
			k = VertexArrayId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*VertexArray)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.Queries = make(QueryIdːQueryʳᵐ, count)
		m := o.Queries
		for i := uint32(0); i < count; i++ {
			var k QueryId
			var v *Query
			k = QueryId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*Query)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.TransformFeedbacks = make(TransformFeedbackIdːTransformFeedbackʳᵐ, count)
		m := o.TransformFeedbacks
		for i := uint32(0); i < count; i++ {
			var k TransformFeedbackId
			var v *TransformFeedback
			k = TransformFeedbackId(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*TransformFeedback)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.SyncObjects = make(GLsyncːSyncObjectʳᵐ, count)
		m := o.SyncObjects
		for i := uint32(0); i < count; i++ {
			var k GLsync
			var v *SyncObject
			d.Simple(&k)
			if obj := d.Object(); obj != nil {
				v = obj.(*SyncObject)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
}
func (*binaryClassObjects) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeObjects(e, obj.(*Objects))
}
func (*binaryClassObjects) New() binary.Object {
	return &Objects{}
}
func (*binaryClassObjects) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeObjects(d, obj.(*Objects))
}
func (c *binaryClassObjects) Schema() *binary.Entity {
	return &entities[ixǁObjects]
}

type binaryClassContext struct{}

func (*Context) Class() binary.Class {
	return (*binaryClassContext)(nil)
}
func doEncodeContext(e binary.Encoder, o *Context) {
	e.Uint32(uint32(o.Identifier))
	e.Simple(&o.Info)
	e.Simple(&o.Debug)
	e.Simple(&o.Rasterization)
	e.Simple(&o.FragmentOperations)
	e.Simple(&o.Framebuffer)
	e.Uint32(uint32(len(o.BoundFramebuffers)))
	for _, k := range (o.BoundFramebuffers).KeysSorted() {
		v := (o.BoundFramebuffers)[k]
		e.Uint32(uint32(k))
		e.Uint32(uint32(v))
	}
	e.Uint32(uint32(len(o.BoundRenderbuffers)))
	for _, k := range (o.BoundRenderbuffers).KeysSorted() {
		v := (o.BoundRenderbuffers)[k]
		e.Uint32(uint32(k))
		e.Uint32(uint32(v))
	}
	e.Simple(&o.BoundBuffers)
	e.Uint32(uint32(o.BoundProgram))
	e.Uint32(uint32(o.BoundTransformFeedback))
	e.Uint32(uint32(o.BoundVertexArray))
	e.Uint32(uint32(len(o.VertexAttributes)))
	for _, k := range (o.VertexAttributes).KeysSorted() {
		v := (o.VertexAttributes)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
	e.Uint32(uint32(len(o.TextureUnits)))
	for _, k := range (o.TextureUnits).KeysSorted() {
		v := (o.TextureUnits)[k]
		e.Uint32(uint32(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.ImageUnits)))
	for _, k := range (o.ImageUnits).KeysSorted() {
		v := (o.ImageUnits)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
	e.Uint32(uint32(o.ActiveTextureUnit))
	e.Simple(&o.PixelStorage)
	e.Simple(&o.Miscellaneous)
	e.Uint32(uint32(len(o.ActiveQueries)))
	for _, k := range (o.ActiveQueries).KeysSorted() {
		v := (o.ActiveQueries)[k]
		e.Uint32(uint32(k))
		e.Uint32(uint32(v))
	}
	e.Struct(&o.Instances)
	e.Simple(&o.Constants)
}
func doDecodeContext(d binary.Decoder, o *Context) {
	o.Identifier = ContextID(d.Uint32())
	d.Simple(&o.Info)
	d.Simple(&o.Debug)
	d.Simple(&o.Rasterization)
	d.Simple(&o.FragmentOperations)
	d.Simple(&o.Framebuffer)
	if count := d.Count(); count > 0 {
		o.BoundFramebuffers = make(GLenumːFramebufferIdᵐ, count)
		m := o.BoundFramebuffers
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v FramebufferId
			k = GLenum(d.Uint32())
			v = FramebufferId(d.Uint32())
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.BoundRenderbuffers = make(GLenumːRenderbufferIdᵐ, count)
		m := o.BoundRenderbuffers
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v RenderbufferId
			k = GLenum(d.Uint32())
			v = RenderbufferId(d.Uint32())
			m[k] = v
		}
	}
	d.Simple(&o.BoundBuffers)
	o.BoundProgram = ProgramId(d.Uint32())
	o.BoundTransformFeedback = TransformFeedbackId(d.Uint32())
	o.BoundVertexArray = VertexArrayId(d.Uint32())
	if count := d.Count(); count > 0 {
		o.VertexAttributes = make(AttributeLocationːVertexAttributeValueᵐ, count)
		m := o.VertexAttributes
		for i := uint32(0); i < count; i++ {
			var k AttributeLocation
			var v VertexAttributeValue
			k = AttributeLocation(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.TextureUnits = make(GLenumːTextureUnitʳᵐ, count)
		m := o.TextureUnits
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v *TextureUnit
			k = GLenum(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*TextureUnit)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.ImageUnits = make(GLuintːImageUnitᵐ, count)
		m := o.ImageUnits
		for i := uint32(0); i < count; i++ {
			var k GLuint
			var v ImageUnit
			k = GLuint(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.ActiveTextureUnit = GLenum(d.Uint32())
	d.Simple(&o.PixelStorage)
	d.Simple(&o.Miscellaneous)
	if count := d.Count(); count > 0 {
		o.ActiveQueries = make(GLenumːQueryIdᵐ, count)
		m := o.ActiveQueries
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v QueryId
			k = GLenum(d.Uint32())
			v = QueryId(d.Uint32())
			m[k] = v
		}
	}
	d.Struct(&o.Instances)
	d.Simple(&o.Constants)
}
func doDecodeRawContext(d binary.Decoder, o *Context) {
	o.Identifier = ContextID(d.Uint32())
	d.Simple(&o.Info)
	d.Simple(&o.Debug)
	d.Simple(&o.Rasterization)
	d.Simple(&o.FragmentOperations)
	d.Simple(&o.Framebuffer)
	if count := d.Count(); count > 0 {
		o.BoundFramebuffers = make(GLenumːFramebufferIdᵐ, count)
		m := o.BoundFramebuffers
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v FramebufferId
			k = GLenum(d.Uint32())
			v = FramebufferId(d.Uint32())
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.BoundRenderbuffers = make(GLenumːRenderbufferIdᵐ, count)
		m := o.BoundRenderbuffers
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v RenderbufferId
			k = GLenum(d.Uint32())
			v = RenderbufferId(d.Uint32())
			m[k] = v
		}
	}
	d.Simple(&o.BoundBuffers)
	o.BoundProgram = ProgramId(d.Uint32())
	o.BoundTransformFeedback = TransformFeedbackId(d.Uint32())
	o.BoundVertexArray = VertexArrayId(d.Uint32())
	if count := d.Count(); count > 0 {
		o.VertexAttributes = make(AttributeLocationːVertexAttributeValueᵐ, count)
		m := o.VertexAttributes
		for i := uint32(0); i < count; i++ {
			var k AttributeLocation
			var v VertexAttributeValue
			k = AttributeLocation(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.TextureUnits = make(GLenumːTextureUnitʳᵐ, count)
		m := o.TextureUnits
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v *TextureUnit
			k = GLenum(d.Uint32())
			if obj := d.Object(); obj != nil {
				v = obj.(*TextureUnit)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.ImageUnits = make(GLuintːImageUnitᵐ, count)
		m := o.ImageUnits
		for i := uint32(0); i < count; i++ {
			var k GLuint
			var v ImageUnit
			k = GLuint(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	o.ActiveTextureUnit = GLenum(d.Uint32())
	d.Simple(&o.PixelStorage)
	d.Simple(&o.Miscellaneous)
	if count := d.Count(); count > 0 {
		o.ActiveQueries = make(GLenumːQueryIdᵐ, count)
		m := o.ActiveQueries
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v QueryId
			k = GLenum(d.Uint32())
			v = QueryId(d.Uint32())
			m[k] = v
		}
	}
	d.Struct(&o.Instances)
	d.Simple(&o.Constants)
}
func (*binaryClassContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeContext(e, obj.(*Context))
}
func (*binaryClassContext) New() binary.Object {
	return &Context{}
}
func (*binaryClassContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeContext(d, obj.(*Context))
}
func (c *binaryClassContext) Schema() *binary.Entity {
	return &entities[ixǁContext]
}

type binaryClassGLenumᵖ struct{}

func (*GLenumᵖ) Class() binary.Class {
	return (*binaryClassGLenumᵖ)(nil)
}
func doEncodeGLenumᵖ(e binary.Writer, o *GLenumᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLenumᵖ(d binary.Reader, o *GLenumᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLenumᵖ(d binary.Reader, o *GLenumᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLenumᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLenumᵖ(e, obj.(*GLenumᵖ))
}
func (*binaryClassGLenumᵖ) New() binary.Object {
	return &GLenumᵖ{}
}
func (*binaryClassGLenumᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLenumᵖ(d, obj.(*GLenumᵖ))
}
func (o *GLenumᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLenumᵖ(w, o)
}
func (o *GLenumᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLenumᵖ(r, o)
}
func (c *binaryClassGLenumᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLenumᵖ]
}

type binaryClassU32ᵖ struct{}

func (*U32ᵖ) Class() binary.Class {
	return (*binaryClassU32ᵖ)(nil)
}
func doEncodeU32ᵖ(e binary.Writer, o *U32ᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeU32ᵖ(d binary.Reader, o *U32ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawU32ᵖ(d binary.Reader, o *U32ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassU32ᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeU32ᵖ(e, obj.(*U32ᵖ))
}
func (*binaryClassU32ᵖ) New() binary.Object {
	return &U32ᵖ{}
}
func (*binaryClassU32ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeU32ᵖ(d, obj.(*U32ᵖ))
}
func (o *U32ᵖ) WriteSimple(w binary.Writer) {
	doEncodeU32ᵖ(w, o)
}
func (o *U32ᵖ) ReadSimple(r binary.Reader) {
	doDecodeU32ᵖ(r, o)
}
func (c *binaryClassU32ᵖ) Schema() *binary.Entity {
	return &entities[ixǁU32ᵖ]
}

type binaryClassContextInfo struct{}

func (*ContextInfo) Class() binary.Class {
	return (*binaryClassContextInfo)(nil)
}
func doEncodeContextInfo(e binary.Encoder, o *ContextInfo) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(o.ConstantCount)
	e.Simple(&o.ConstantNames)
	e.Simple(&o.ConstantOffsets)
	e.Simple(&o.ConstantSizes)
	e.Simple(&o.ConstantData)
	e.Int32(int32(o.BackbufferWidth))
	e.Int32(int32(o.BackbufferHeight))
	e.Uint32(uint32(o.BackbufferColorFmt))
	e.Uint32(uint32(o.BackbufferDepthFmt))
	e.Uint32(uint32(o.BackbufferStencilFmt))
	e.Bool(o.ResetViewportScissor)
	e.Bool(o.PreserveBuffersOnSwap)
}
func doDecodeContextInfo(d binary.Decoder, o *ContextInfo) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ConstantCount = uint32(d.Uint32())
	d.Simple(&o.ConstantNames)
	d.Simple(&o.ConstantOffsets)
	d.Simple(&o.ConstantSizes)
	d.Simple(&o.ConstantData)
	o.BackbufferWidth = GLsizei(d.Int32())
	o.BackbufferHeight = GLsizei(d.Int32())
	o.BackbufferColorFmt = GLenum(d.Uint32())
	o.BackbufferDepthFmt = GLenum(d.Uint32())
	o.BackbufferStencilFmt = GLenum(d.Uint32())
	o.ResetViewportScissor = bool(d.Bool())
	o.PreserveBuffersOnSwap = bool(d.Bool())
}
func doDecodeRawContextInfo(d binary.Decoder, o *ContextInfo) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ConstantCount = uint32(d.Uint32())
	d.Simple(&o.ConstantNames)
	d.Simple(&o.ConstantOffsets)
	d.Simple(&o.ConstantSizes)
	d.Simple(&o.ConstantData)
	o.BackbufferWidth = GLsizei(d.Int32())
	o.BackbufferHeight = GLsizei(d.Int32())
	o.BackbufferColorFmt = GLenum(d.Uint32())
	o.BackbufferDepthFmt = GLenum(d.Uint32())
	o.BackbufferStencilFmt = GLenum(d.Uint32())
	o.ResetViewportScissor = bool(d.Bool())
	o.PreserveBuffersOnSwap = bool(d.Bool())
}
func (*binaryClassContextInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeContextInfo(e, obj.(*ContextInfo))
}
func (*binaryClassContextInfo) New() binary.Object {
	return &ContextInfo{}
}
func (*binaryClassContextInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeContextInfo(d, obj.(*ContextInfo))
}
func (c *binaryClassContextInfo) Schema() *binary.Entity {
	return &entities[ixǁContextInfo]
}

type binaryClassDeviceInfo struct{}

func (*DeviceInfo) Class() binary.Class {
	return (*binaryClassDeviceInfo)(nil)
}
func doEncodeDeviceInfo(e binary.Writer, o *DeviceInfo) {
	e.String(o.ProductManufacturer)
	e.String(o.ProductModel)
	e.String(o.BuildDescription)
	e.String(o.BuildVersionRelease)
	e.String(o.BuildVersionSdk)
	e.String(o.Debuggable)
	e.String(o.AbiList)
}
func doDecodeDeviceInfo(d binary.Reader, o *DeviceInfo) {
	o.ProductManufacturer = string(d.String())
	o.ProductModel = string(d.String())
	o.BuildDescription = string(d.String())
	o.BuildVersionRelease = string(d.String())
	o.BuildVersionSdk = string(d.String())
	o.Debuggable = string(d.String())
	o.AbiList = string(d.String())
}
func doDecodeRawDeviceInfo(d binary.Reader, o *DeviceInfo) {
	o.ProductManufacturer = string(d.String())
	o.ProductModel = string(d.String())
	o.BuildDescription = string(d.String())
	o.BuildVersionRelease = string(d.String())
	o.BuildVersionSdk = string(d.String())
	o.Debuggable = string(d.String())
	o.AbiList = string(d.String())
}
func (*binaryClassDeviceInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeDeviceInfo(e, obj.(*DeviceInfo))
}
func (*binaryClassDeviceInfo) New() binary.Object {
	return &DeviceInfo{}
}
func (*binaryClassDeviceInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeDeviceInfo(d, obj.(*DeviceInfo))
}
func (o *DeviceInfo) WriteSimple(w binary.Writer) {
	doEncodeDeviceInfo(w, o)
}
func (o *DeviceInfo) ReadSimple(r binary.Reader) {
	doDecodeDeviceInfo(r, o)
}
func (c *binaryClassDeviceInfo) Schema() *binary.Entity {
	return &entities[ixǁDeviceInfo]
}

type binaryClassDynamicContextState struct{}

func (*DynamicContextState) Class() binary.Class {
	return (*binaryClassDynamicContextState)(nil)
}
func doEncodeDynamicContextState(e binary.Writer, o *DynamicContextState) {
	e.Int32(int32(o.BackbufferWidth))
	e.Int32(int32(o.BackbufferHeight))
	e.Uint32(uint32(o.BackbufferColorFmt))
	e.Uint32(uint32(o.BackbufferDepthFmt))
	e.Uint32(uint32(o.BackbufferStencilFmt))
	e.Bool(o.ResetViewportScissor)
	e.Bool(o.PreserveBuffersOnSwap)
	e.Uint32(uint32(o.RedSize))
	e.Uint32(uint32(o.GreenSize))
	e.Uint32(uint32(o.BlueSize))
	e.Uint32(uint32(o.AlphaSize))
	e.Uint32(uint32(o.DepthSize))
	e.Uint32(uint32(o.StencilSize))
}
func doDecodeDynamicContextState(d binary.Reader, o *DynamicContextState) {
	o.BackbufferWidth = GLsizei(d.Int32())
	o.BackbufferHeight = GLsizei(d.Int32())
	o.BackbufferColorFmt = GLenum(d.Uint32())
	o.BackbufferDepthFmt = GLenum(d.Uint32())
	o.BackbufferStencilFmt = GLenum(d.Uint32())
	o.ResetViewportScissor = bool(d.Bool())
	o.PreserveBuffersOnSwap = bool(d.Bool())
	o.RedSize = GLuint(d.Uint32())
	o.GreenSize = GLuint(d.Uint32())
	o.BlueSize = GLuint(d.Uint32())
	o.AlphaSize = GLuint(d.Uint32())
	o.DepthSize = GLuint(d.Uint32())
	o.StencilSize = GLuint(d.Uint32())
}
func doDecodeRawDynamicContextState(d binary.Reader, o *DynamicContextState) {
	o.BackbufferWidth = GLsizei(d.Int32())
	o.BackbufferHeight = GLsizei(d.Int32())
	o.BackbufferColorFmt = GLenum(d.Uint32())
	o.BackbufferDepthFmt = GLenum(d.Uint32())
	o.BackbufferStencilFmt = GLenum(d.Uint32())
	o.ResetViewportScissor = bool(d.Bool())
	o.PreserveBuffersOnSwap = bool(d.Bool())
	o.RedSize = GLuint(d.Uint32())
	o.GreenSize = GLuint(d.Uint32())
	o.BlueSize = GLuint(d.Uint32())
	o.AlphaSize = GLuint(d.Uint32())
	o.DepthSize = GLuint(d.Uint32())
	o.StencilSize = GLuint(d.Uint32())
}
func (*binaryClassDynamicContextState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeDynamicContextState(e, obj.(*DynamicContextState))
}
func (*binaryClassDynamicContextState) New() binary.Object {
	return &DynamicContextState{}
}
func (*binaryClassDynamicContextState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeDynamicContextState(d, obj.(*DynamicContextState))
}
func (o *DynamicContextState) WriteSimple(w binary.Writer) {
	doEncodeDynamicContextState(w, o)
}
func (o *DynamicContextState) ReadSimple(r binary.Reader) {
	doDecodeDynamicContextState(r, o)
}
func (c *binaryClassDynamicContextState) Schema() *binary.Entity {
	return &entities[ixǁDynamicContextState]
}

type binaryClassEGLClientBuffer struct{}

func (*EGLClientBuffer) Class() binary.Class {
	return (*binaryClassEGLClientBuffer)(nil)
}
func doEncodeEGLClientBuffer(e binary.Writer, o *EGLClientBuffer) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeEGLClientBuffer(d binary.Reader, o *EGLClientBuffer) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawEGLClientBuffer(d binary.Reader, o *EGLClientBuffer) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassEGLClientBuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLClientBuffer(e, obj.(*EGLClientBuffer))
}
func (*binaryClassEGLClientBuffer) New() binary.Object {
	return &EGLClientBuffer{}
}
func (*binaryClassEGLClientBuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLClientBuffer(d, obj.(*EGLClientBuffer))
}
func (o *EGLClientBuffer) WriteSimple(w binary.Writer) {
	doEncodeEGLClientBuffer(w, o)
}
func (o *EGLClientBuffer) ReadSimple(r binary.Reader) {
	doDecodeEGLClientBuffer(r, o)
}
func (c *binaryClassEGLClientBuffer) Schema() *binary.Entity {
	return &entities[ixǁEGLClientBuffer]
}

type binaryClassEGLConfig struct{}

func (*EGLConfig) Class() binary.Class {
	return (*binaryClassEGLConfig)(nil)
}
func doEncodeEGLConfig(e binary.Writer, o *EGLConfig) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeEGLConfig(d binary.Reader, o *EGLConfig) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawEGLConfig(d binary.Reader, o *EGLConfig) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassEGLConfig) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLConfig(e, obj.(*EGLConfig))
}
func (*binaryClassEGLConfig) New() binary.Object {
	return &EGLConfig{}
}
func (*binaryClassEGLConfig) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLConfig(d, obj.(*EGLConfig))
}
func (o *EGLConfig) WriteSimple(w binary.Writer) {
	doEncodeEGLConfig(w, o)
}
func (o *EGLConfig) ReadSimple(r binary.Reader) {
	doDecodeEGLConfig(r, o)
}
func (c *binaryClassEGLConfig) Schema() *binary.Entity {
	return &entities[ixǁEGLConfig]
}

type binaryClassEGLConfigˢ struct{}

func (*EGLConfigˢ) Class() binary.Class {
	return (*binaryClassEGLConfigˢ)(nil)
}
func doEncodeEGLConfigˢ(e binary.Writer, o *EGLConfigˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeEGLConfigˢ(d binary.Reader, o *EGLConfigˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawEGLConfigˢ(d binary.Reader, o *EGLConfigˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassEGLConfigˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLConfigˢ(e, obj.(*EGLConfigˢ))
}
func (*binaryClassEGLConfigˢ) New() binary.Object {
	return &EGLConfigˢ{}
}
func (*binaryClassEGLConfigˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLConfigˢ(d, obj.(*EGLConfigˢ))
}
func (o *EGLConfigˢ) WriteSimple(w binary.Writer) {
	doEncodeEGLConfigˢ(w, o)
}
func (o *EGLConfigˢ) ReadSimple(r binary.Reader) {
	doDecodeEGLConfigˢ(r, o)
}
func (c *binaryClassEGLConfigˢ) Schema() *binary.Entity {
	return &entities[ixǁEGLConfigˢ]
}

type binaryClassEGLConfigᵖ struct{}

func (*EGLConfigᵖ) Class() binary.Class {
	return (*binaryClassEGLConfigᵖ)(nil)
}
func doEncodeEGLConfigᵖ(e binary.Writer, o *EGLConfigᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeEGLConfigᵖ(d binary.Reader, o *EGLConfigᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawEGLConfigᵖ(d binary.Reader, o *EGLConfigᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassEGLConfigᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLConfigᵖ(e, obj.(*EGLConfigᵖ))
}
func (*binaryClassEGLConfigᵖ) New() binary.Object {
	return &EGLConfigᵖ{}
}
func (*binaryClassEGLConfigᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLConfigᵖ(d, obj.(*EGLConfigᵖ))
}
func (o *EGLConfigᵖ) WriteSimple(w binary.Writer) {
	doEncodeEGLConfigᵖ(w, o)
}
func (o *EGLConfigᵖ) ReadSimple(r binary.Reader) {
	doDecodeEGLConfigᵖ(r, o)
}
func (c *binaryClassEGLConfigᵖ) Schema() *binary.Entity {
	return &entities[ixǁEGLConfigᵖ]
}

type binaryClassEGLContext struct{}

func (*EGLContext) Class() binary.Class {
	return (*binaryClassEGLContext)(nil)
}
func doEncodeEGLContext(e binary.Writer, o *EGLContext) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeEGLContext(d binary.Reader, o *EGLContext) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawEGLContext(d binary.Reader, o *EGLContext) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassEGLContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLContext(e, obj.(*EGLContext))
}
func (*binaryClassEGLContext) New() binary.Object {
	return &EGLContext{}
}
func (*binaryClassEGLContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLContext(d, obj.(*EGLContext))
}
func (o *EGLContext) WriteSimple(w binary.Writer) {
	doEncodeEGLContext(w, o)
}
func (o *EGLContext) ReadSimple(r binary.Reader) {
	doDecodeEGLContext(r, o)
}
func (c *binaryClassEGLContext) Schema() *binary.Entity {
	return &entities[ixǁEGLContext]
}

type binaryClassEGLDisplay struct{}

func (*EGLDisplay) Class() binary.Class {
	return (*binaryClassEGLDisplay)(nil)
}
func doEncodeEGLDisplay(e binary.Writer, o *EGLDisplay) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeEGLDisplay(d binary.Reader, o *EGLDisplay) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawEGLDisplay(d binary.Reader, o *EGLDisplay) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassEGLDisplay) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLDisplay(e, obj.(*EGLDisplay))
}
func (*binaryClassEGLDisplay) New() binary.Object {
	return &EGLDisplay{}
}
func (*binaryClassEGLDisplay) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLDisplay(d, obj.(*EGLDisplay))
}
func (o *EGLDisplay) WriteSimple(w binary.Writer) {
	doEncodeEGLDisplay(w, o)
}
func (o *EGLDisplay) ReadSimple(r binary.Reader) {
	doDecodeEGLDisplay(r, o)
}
func (c *binaryClassEGLDisplay) Schema() *binary.Entity {
	return &entities[ixǁEGLDisplay]
}

type binaryClassEGLImageKHR struct{}

func (*EGLImageKHR) Class() binary.Class {
	return (*binaryClassEGLImageKHR)(nil)
}
func doEncodeEGLImageKHR(e binary.Writer, o *EGLImageKHR) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeEGLImageKHR(d binary.Reader, o *EGLImageKHR) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawEGLImageKHR(d binary.Reader, o *EGLImageKHR) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassEGLImageKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLImageKHR(e, obj.(*EGLImageKHR))
}
func (*binaryClassEGLImageKHR) New() binary.Object {
	return &EGLImageKHR{}
}
func (*binaryClassEGLImageKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLImageKHR(d, obj.(*EGLImageKHR))
}
func (o *EGLImageKHR) WriteSimple(w binary.Writer) {
	doEncodeEGLImageKHR(w, o)
}
func (o *EGLImageKHR) ReadSimple(r binary.Reader) {
	doDecodeEGLImageKHR(r, o)
}
func (c *binaryClassEGLImageKHR) Schema() *binary.Entity {
	return &entities[ixǁEGLImageKHR]
}

type binaryClassEGLNativePixmapType struct{}

func (*EGLNativePixmapType) Class() binary.Class {
	return (*binaryClassEGLNativePixmapType)(nil)
}
func doEncodeEGLNativePixmapType(e binary.Writer, o *EGLNativePixmapType) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeEGLNativePixmapType(d binary.Reader, o *EGLNativePixmapType) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawEGLNativePixmapType(d binary.Reader, o *EGLNativePixmapType) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassEGLNativePixmapType) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLNativePixmapType(e, obj.(*EGLNativePixmapType))
}
func (*binaryClassEGLNativePixmapType) New() binary.Object {
	return &EGLNativePixmapType{}
}
func (*binaryClassEGLNativePixmapType) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLNativePixmapType(d, obj.(*EGLNativePixmapType))
}
func (o *EGLNativePixmapType) WriteSimple(w binary.Writer) {
	doEncodeEGLNativePixmapType(w, o)
}
func (o *EGLNativePixmapType) ReadSimple(r binary.Reader) {
	doDecodeEGLNativePixmapType(r, o)
}
func (c *binaryClassEGLNativePixmapType) Schema() *binary.Entity {
	return &entities[ixǁEGLNativePixmapType]
}

type binaryClassEGLNativeWindowType struct{}

func (*EGLNativeWindowType) Class() binary.Class {
	return (*binaryClassEGLNativeWindowType)(nil)
}
func doEncodeEGLNativeWindowType(e binary.Writer, o *EGLNativeWindowType) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeEGLNativeWindowType(d binary.Reader, o *EGLNativeWindowType) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawEGLNativeWindowType(d binary.Reader, o *EGLNativeWindowType) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassEGLNativeWindowType) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLNativeWindowType(e, obj.(*EGLNativeWindowType))
}
func (*binaryClassEGLNativeWindowType) New() binary.Object {
	return &EGLNativeWindowType{}
}
func (*binaryClassEGLNativeWindowType) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLNativeWindowType(d, obj.(*EGLNativeWindowType))
}
func (o *EGLNativeWindowType) WriteSimple(w binary.Writer) {
	doEncodeEGLNativeWindowType(w, o)
}
func (o *EGLNativeWindowType) ReadSimple(r binary.Reader) {
	doDecodeEGLNativeWindowType(r, o)
}
func (c *binaryClassEGLNativeWindowType) Schema() *binary.Entity {
	return &entities[ixǁEGLNativeWindowType]
}

type binaryClassEGLSurface struct{}

func (*EGLSurface) Class() binary.Class {
	return (*binaryClassEGLSurface)(nil)
}
func doEncodeEGLSurface(e binary.Writer, o *EGLSurface) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeEGLSurface(d binary.Reader, o *EGLSurface) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawEGLSurface(d binary.Reader, o *EGLSurface) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassEGLSurface) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLSurface(e, obj.(*EGLSurface))
}
func (*binaryClassEGLSurface) New() binary.Object {
	return &EGLSurface{}
}
func (*binaryClassEGLSurface) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLSurface(d, obj.(*EGLSurface))
}
func (o *EGLSurface) WriteSimple(w binary.Writer) {
	doEncodeEGLSurface(w, o)
}
func (o *EGLSurface) ReadSimple(r binary.Reader) {
	doDecodeEGLSurface(r, o)
}
func (c *binaryClassEGLSurface) Schema() *binary.Entity {
	return &entities[ixǁEGLSurface]
}

type binaryClassEGLSyncKHR struct{}

func (*EGLSyncKHR) Class() binary.Class {
	return (*binaryClassEGLSyncKHR)(nil)
}
func doEncodeEGLSyncKHR(e binary.Writer, o *EGLSyncKHR) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeEGLSyncKHR(d binary.Reader, o *EGLSyncKHR) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawEGLSyncKHR(d binary.Reader, o *EGLSyncKHR) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassEGLSyncKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLSyncKHR(e, obj.(*EGLSyncKHR))
}
func (*binaryClassEGLSyncKHR) New() binary.Object {
	return &EGLSyncKHR{}
}
func (*binaryClassEGLSyncKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLSyncKHR(d, obj.(*EGLSyncKHR))
}
func (o *EGLSyncKHR) WriteSimple(w binary.Writer) {
	doEncodeEGLSyncKHR(w, o)
}
func (o *EGLSyncKHR) ReadSimple(r binary.Reader) {
	doDecodeEGLSyncKHR(r, o)
}
func (c *binaryClassEGLSyncKHR) Schema() *binary.Entity {
	return &entities[ixǁEGLSyncKHR]
}

type binaryClassEGLintˢ struct{}

func (*EGLintˢ) Class() binary.Class {
	return (*binaryClassEGLintˢ)(nil)
}
func doEncodeEGLintˢ(e binary.Writer, o *EGLintˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeEGLintˢ(d binary.Reader, o *EGLintˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawEGLintˢ(d binary.Reader, o *EGLintˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassEGLintˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLintˢ(e, obj.(*EGLintˢ))
}
func (*binaryClassEGLintˢ) New() binary.Object {
	return &EGLintˢ{}
}
func (*binaryClassEGLintˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLintˢ(d, obj.(*EGLintˢ))
}
func (o *EGLintˢ) WriteSimple(w binary.Writer) {
	doEncodeEGLintˢ(w, o)
}
func (o *EGLintˢ) ReadSimple(r binary.Reader) {
	doDecodeEGLintˢ(r, o)
}
func (c *binaryClassEGLintˢ) Schema() *binary.Entity {
	return &entities[ixǁEGLintˢ]
}

type binaryClassEGLintᵖ struct{}

func (*EGLintᵖ) Class() binary.Class {
	return (*binaryClassEGLintᵖ)(nil)
}
func doEncodeEGLintᵖ(e binary.Writer, o *EGLintᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeEGLintᵖ(d binary.Reader, o *EGLintᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawEGLintᵖ(d binary.Reader, o *EGLintᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassEGLintᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLintᵖ(e, obj.(*EGLintᵖ))
}
func (*binaryClassEGLintᵖ) New() binary.Object {
	return &EGLintᵖ{}
}
func (*binaryClassEGLintᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLintᵖ(d, obj.(*EGLintᵖ))
}
func (o *EGLintᵖ) WriteSimple(w binary.Writer) {
	doEncodeEGLintᵖ(w, o)
}
func (o *EGLintᵖ) ReadSimple(r binary.Reader) {
	doDecodeEGLintᵖ(r, o)
}
func (c *binaryClassEGLintᵖ) Schema() *binary.Entity {
	return &entities[ixǁEGLintᵖ]
}

type binaryClassEGLintᶜᵖ struct{}

func (*EGLintᶜᵖ) Class() binary.Class {
	return (*binaryClassEGLintᶜᵖ)(nil)
}
func doEncodeEGLintᶜᵖ(e binary.Writer, o *EGLintᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeEGLintᶜᵖ(d binary.Reader, o *EGLintᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawEGLintᶜᵖ(d binary.Reader, o *EGLintᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassEGLintᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEGLintᶜᵖ(e, obj.(*EGLintᶜᵖ))
}
func (*binaryClassEGLintᶜᵖ) New() binary.Object {
	return &EGLintᶜᵖ{}
}
func (*binaryClassEGLintᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEGLintᶜᵖ(d, obj.(*EGLintᶜᵖ))
}
func (o *EGLintᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeEGLintᶜᵖ(w, o)
}
func (o *EGLintᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeEGLintᶜᵖ(r, o)
}
func (c *binaryClassEGLintᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁEGLintᶜᵖ]
}

type binaryClassERR_CONTEXT_DOES_NOT_EXIST struct{}

func (*ERR_CONTEXT_DOES_NOT_EXIST) Class() binary.Class {
	return (*binaryClassERR_CONTEXT_DOES_NOT_EXIST)(nil)
}
func doEncodeERR_CONTEXT_DOES_NOT_EXIST(e binary.Writer, o *ERR_CONTEXT_DOES_NOT_EXIST) {
	e.Uint64(o.Id)
}
func doDecodeERR_CONTEXT_DOES_NOT_EXIST(d binary.Reader, o *ERR_CONTEXT_DOES_NOT_EXIST) {
	o.Id = uint64(d.Uint64())
}
func doDecodeRawERR_CONTEXT_DOES_NOT_EXIST(d binary.Reader, o *ERR_CONTEXT_DOES_NOT_EXIST) {
	o.Id = uint64(d.Uint64())
}
func (*binaryClassERR_CONTEXT_DOES_NOT_EXIST) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_CONTEXT_DOES_NOT_EXIST(e, obj.(*ERR_CONTEXT_DOES_NOT_EXIST))
}
func (*binaryClassERR_CONTEXT_DOES_NOT_EXIST) New() binary.Object {
	return &ERR_CONTEXT_DOES_NOT_EXIST{}
}
func (*binaryClassERR_CONTEXT_DOES_NOT_EXIST) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_CONTEXT_DOES_NOT_EXIST(d, obj.(*ERR_CONTEXT_DOES_NOT_EXIST))
}
func (o *ERR_CONTEXT_DOES_NOT_EXIST) WriteSimple(w binary.Writer) {
	doEncodeERR_CONTEXT_DOES_NOT_EXIST(w, o)
}
func (o *ERR_CONTEXT_DOES_NOT_EXIST) ReadSimple(r binary.Reader) {
	doDecodeERR_CONTEXT_DOES_NOT_EXIST(r, o)
}
func (c *binaryClassERR_CONTEXT_DOES_NOT_EXIST) Schema() *binary.Entity {
	return &entities[ixǁERR_CONTEXT_DOES_NOT_EXIST]
}

type binaryClassERR_CRITICAL struct{}

func (*ERR_CRITICAL) Class() binary.Class {
	return (*binaryClassERR_CRITICAL)(nil)
}
func doEncodeERR_CRITICAL(e binary.Writer, o *ERR_CRITICAL) {
	e.String(o.Err)
}
func doDecodeERR_CRITICAL(d binary.Reader, o *ERR_CRITICAL) {
	o.Err = string(d.String())
}
func doDecodeRawERR_CRITICAL(d binary.Reader, o *ERR_CRITICAL) {
	o.Err = string(d.String())
}
func (*binaryClassERR_CRITICAL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_CRITICAL(e, obj.(*ERR_CRITICAL))
}
func (*binaryClassERR_CRITICAL) New() binary.Object {
	return &ERR_CRITICAL{}
}
func (*binaryClassERR_CRITICAL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_CRITICAL(d, obj.(*ERR_CRITICAL))
}
func (o *ERR_CRITICAL) WriteSimple(w binary.Writer) {
	doEncodeERR_CRITICAL(w, o)
}
func (o *ERR_CRITICAL) ReadSimple(r binary.Reader) {
	doDecodeERR_CRITICAL(r, o)
}
func (c *binaryClassERR_CRITICAL) Schema() *binary.Entity {
	return &entities[ixǁERR_CRITICAL]
}

type binaryClassERR_FIELD_DOES_NOT_EXIST struct{}

func (*ERR_FIELD_DOES_NOT_EXIST) Class() binary.Class {
	return (*binaryClassERR_FIELD_DOES_NOT_EXIST)(nil)
}
func doEncodeERR_FIELD_DOES_NOT_EXIST(e binary.Writer, o *ERR_FIELD_DOES_NOT_EXIST) {
	e.String(o.Ty)
	e.String(o.Field)
}
func doDecodeERR_FIELD_DOES_NOT_EXIST(d binary.Reader, o *ERR_FIELD_DOES_NOT_EXIST) {
	o.Ty = string(d.String())
	o.Field = string(d.String())
}
func doDecodeRawERR_FIELD_DOES_NOT_EXIST(d binary.Reader, o *ERR_FIELD_DOES_NOT_EXIST) {
	o.Ty = string(d.String())
	o.Field = string(d.String())
}
func (*binaryClassERR_FIELD_DOES_NOT_EXIST) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_FIELD_DOES_NOT_EXIST(e, obj.(*ERR_FIELD_DOES_NOT_EXIST))
}
func (*binaryClassERR_FIELD_DOES_NOT_EXIST) New() binary.Object {
	return &ERR_FIELD_DOES_NOT_EXIST{}
}
func (*binaryClassERR_FIELD_DOES_NOT_EXIST) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_FIELD_DOES_NOT_EXIST(d, obj.(*ERR_FIELD_DOES_NOT_EXIST))
}
func (o *ERR_FIELD_DOES_NOT_EXIST) WriteSimple(w binary.Writer) {
	doEncodeERR_FIELD_DOES_NOT_EXIST(w, o)
}
func (o *ERR_FIELD_DOES_NOT_EXIST) ReadSimple(r binary.Reader) {
	doDecodeERR_FIELD_DOES_NOT_EXIST(r, o)
}
func (c *binaryClassERR_FIELD_DOES_NOT_EXIST) Schema() *binary.Entity {
	return &entities[ixǁERR_FIELD_DOES_NOT_EXIST]
}

type binaryClassERR_FRAMEBUFFER_UNAVAILABLE struct{}

func (*ERR_FRAMEBUFFER_UNAVAILABLE) Class() binary.Class {
	return (*binaryClassERR_FRAMEBUFFER_UNAVAILABLE)(nil)
}
func doEncodeERR_FRAMEBUFFER_UNAVAILABLE(e binary.Writer, o *ERR_FRAMEBUFFER_UNAVAILABLE) {
}
func doDecodeERR_FRAMEBUFFER_UNAVAILABLE(d binary.Reader, o *ERR_FRAMEBUFFER_UNAVAILABLE) {
}
func doDecodeRawERR_FRAMEBUFFER_UNAVAILABLE(d binary.Reader, o *ERR_FRAMEBUFFER_UNAVAILABLE) {
}
func (*binaryClassERR_FRAMEBUFFER_UNAVAILABLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_FRAMEBUFFER_UNAVAILABLE(e, obj.(*ERR_FRAMEBUFFER_UNAVAILABLE))
}
func (*binaryClassERR_FRAMEBUFFER_UNAVAILABLE) New() binary.Object {
	return &ERR_FRAMEBUFFER_UNAVAILABLE{}
}
func (*binaryClassERR_FRAMEBUFFER_UNAVAILABLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_FRAMEBUFFER_UNAVAILABLE(d, obj.(*ERR_FRAMEBUFFER_UNAVAILABLE))
}
func (o *ERR_FRAMEBUFFER_UNAVAILABLE) WriteSimple(w binary.Writer) {
	doEncodeERR_FRAMEBUFFER_UNAVAILABLE(w, o)
}
func (o *ERR_FRAMEBUFFER_UNAVAILABLE) ReadSimple(r binary.Reader) {
	doDecodeERR_FRAMEBUFFER_UNAVAILABLE(r, o)
}
func (c *binaryClassERR_FRAMEBUFFER_UNAVAILABLE) Schema() *binary.Entity {
	return &entities[ixǁERR_FRAMEBUFFER_UNAVAILABLE]
}

type binaryClassERR_INCORRECT_MAP_KEY_TYPE struct{}

func (*ERR_INCORRECT_MAP_KEY_TYPE) Class() binary.Class {
	return (*binaryClassERR_INCORRECT_MAP_KEY_TYPE)(nil)
}
func doEncodeERR_INCORRECT_MAP_KEY_TYPE(e binary.Writer, o *ERR_INCORRECT_MAP_KEY_TYPE) {
	e.String(o.Got)
	e.String(o.Expected)
}
func doDecodeERR_INCORRECT_MAP_KEY_TYPE(d binary.Reader, o *ERR_INCORRECT_MAP_KEY_TYPE) {
	o.Got = string(d.String())
	o.Expected = string(d.String())
}
func doDecodeRawERR_INCORRECT_MAP_KEY_TYPE(d binary.Reader, o *ERR_INCORRECT_MAP_KEY_TYPE) {
	o.Got = string(d.String())
	o.Expected = string(d.String())
}
func (*binaryClassERR_INCORRECT_MAP_KEY_TYPE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_INCORRECT_MAP_KEY_TYPE(e, obj.(*ERR_INCORRECT_MAP_KEY_TYPE))
}
func (*binaryClassERR_INCORRECT_MAP_KEY_TYPE) New() binary.Object {
	return &ERR_INCORRECT_MAP_KEY_TYPE{}
}
func (*binaryClassERR_INCORRECT_MAP_KEY_TYPE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_INCORRECT_MAP_KEY_TYPE(d, obj.(*ERR_INCORRECT_MAP_KEY_TYPE))
}
func (o *ERR_INCORRECT_MAP_KEY_TYPE) WriteSimple(w binary.Writer) {
	doEncodeERR_INCORRECT_MAP_KEY_TYPE(w, o)
}
func (o *ERR_INCORRECT_MAP_KEY_TYPE) ReadSimple(r binary.Reader) {
	doDecodeERR_INCORRECT_MAP_KEY_TYPE(r, o)
}
func (c *binaryClassERR_INCORRECT_MAP_KEY_TYPE) Schema() *binary.Entity {
	return &entities[ixǁERR_INCORRECT_MAP_KEY_TYPE]
}

type binaryClassERR_INVALID_ENUM_VALUE struct{}

func (*ERR_INVALID_ENUM_VALUE) Class() binary.Class {
	return (*binaryClassERR_INVALID_ENUM_VALUE)(nil)
}
func doEncodeERR_INVALID_ENUM_VALUE(e binary.Writer, o *ERR_INVALID_ENUM_VALUE) {
	e.Uint32(o.Value)
	e.String(o.Variable)
}
func doDecodeERR_INVALID_ENUM_VALUE(d binary.Reader, o *ERR_INVALID_ENUM_VALUE) {
	o.Value = uint32(d.Uint32())
	o.Variable = string(d.String())
}
func doDecodeRawERR_INVALID_ENUM_VALUE(d binary.Reader, o *ERR_INVALID_ENUM_VALUE) {
	o.Value = uint32(d.Uint32())
	o.Variable = string(d.String())
}
func (*binaryClassERR_INVALID_ENUM_VALUE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_INVALID_ENUM_VALUE(e, obj.(*ERR_INVALID_ENUM_VALUE))
}
func (*binaryClassERR_INVALID_ENUM_VALUE) New() binary.Object {
	return &ERR_INVALID_ENUM_VALUE{}
}
func (*binaryClassERR_INVALID_ENUM_VALUE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_INVALID_ENUM_VALUE(d, obj.(*ERR_INVALID_ENUM_VALUE))
}
func (o *ERR_INVALID_ENUM_VALUE) WriteSimple(w binary.Writer) {
	doEncodeERR_INVALID_ENUM_VALUE(w, o)
}
func (o *ERR_INVALID_ENUM_VALUE) ReadSimple(r binary.Reader) {
	doDecodeERR_INVALID_ENUM_VALUE(r, o)
}
func (c *binaryClassERR_INVALID_ENUM_VALUE) Schema() *binary.Entity {
	return &entities[ixǁERR_INVALID_ENUM_VALUE]
}

type binaryClassERR_INVALID_OPERATION struct{}

func (*ERR_INVALID_OPERATION) Class() binary.Class {
	return (*binaryClassERR_INVALID_OPERATION)(nil)
}
func doEncodeERR_INVALID_OPERATION(e binary.Writer, o *ERR_INVALID_OPERATION) {
	e.String(o.Operation)
}
func doDecodeERR_INVALID_OPERATION(d binary.Reader, o *ERR_INVALID_OPERATION) {
	o.Operation = string(d.String())
}
func doDecodeRawERR_INVALID_OPERATION(d binary.Reader, o *ERR_INVALID_OPERATION) {
	o.Operation = string(d.String())
}
func (*binaryClassERR_INVALID_OPERATION) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_INVALID_OPERATION(e, obj.(*ERR_INVALID_OPERATION))
}
func (*binaryClassERR_INVALID_OPERATION) New() binary.Object {
	return &ERR_INVALID_OPERATION{}
}
func (*binaryClassERR_INVALID_OPERATION) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_INVALID_OPERATION(d, obj.(*ERR_INVALID_OPERATION))
}
func (o *ERR_INVALID_OPERATION) WriteSimple(w binary.Writer) {
	doEncodeERR_INVALID_OPERATION(w, o)
}
func (o *ERR_INVALID_OPERATION) ReadSimple(r binary.Reader) {
	doDecodeERR_INVALID_OPERATION(r, o)
}
func (c *binaryClassERR_INVALID_OPERATION) Schema() *binary.Entity {
	return &entities[ixǁERR_INVALID_OPERATION]
}

type binaryClassERR_INVALID_VALUE struct{}

func (*ERR_INVALID_VALUE) Class() binary.Class {
	return (*binaryClassERR_INVALID_VALUE)(nil)
}
func doEncodeERR_INVALID_VALUE(e binary.Writer, o *ERR_INVALID_VALUE) {
	e.String(o.Value)
	e.String(o.Variable)
}
func doDecodeERR_INVALID_VALUE(d binary.Reader, o *ERR_INVALID_VALUE) {
	o.Value = string(d.String())
	o.Variable = string(d.String())
}
func doDecodeRawERR_INVALID_VALUE(d binary.Reader, o *ERR_INVALID_VALUE) {
	o.Value = string(d.String())
	o.Variable = string(d.String())
}
func (*binaryClassERR_INVALID_VALUE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_INVALID_VALUE(e, obj.(*ERR_INVALID_VALUE))
}
func (*binaryClassERR_INVALID_VALUE) New() binary.Object {
	return &ERR_INVALID_VALUE{}
}
func (*binaryClassERR_INVALID_VALUE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_INVALID_VALUE(d, obj.(*ERR_INVALID_VALUE))
}
func (o *ERR_INVALID_VALUE) WriteSimple(w binary.Writer) {
	doEncodeERR_INVALID_VALUE(w, o)
}
func (o *ERR_INVALID_VALUE) ReadSimple(r binary.Reader) {
	doDecodeERR_INVALID_VALUE(r, o)
}
func (c *binaryClassERR_INVALID_VALUE) Schema() *binary.Entity {
	return &entities[ixǁERR_INVALID_VALUE]
}

type binaryClassERR_MAP_KEY_DOES_NOT_EXIST struct{}

func (*ERR_MAP_KEY_DOES_NOT_EXIST) Class() binary.Class {
	return (*binaryClassERR_MAP_KEY_DOES_NOT_EXIST)(nil)
}
func doEncodeERR_MAP_KEY_DOES_NOT_EXIST(e binary.Writer, o *ERR_MAP_KEY_DOES_NOT_EXIST) {
	e.String(o.Key)
}
func doDecodeERR_MAP_KEY_DOES_NOT_EXIST(d binary.Reader, o *ERR_MAP_KEY_DOES_NOT_EXIST) {
	o.Key = string(d.String())
}
func doDecodeRawERR_MAP_KEY_DOES_NOT_EXIST(d binary.Reader, o *ERR_MAP_KEY_DOES_NOT_EXIST) {
	o.Key = string(d.String())
}
func (*binaryClassERR_MAP_KEY_DOES_NOT_EXIST) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_MAP_KEY_DOES_NOT_EXIST(e, obj.(*ERR_MAP_KEY_DOES_NOT_EXIST))
}
func (*binaryClassERR_MAP_KEY_DOES_NOT_EXIST) New() binary.Object {
	return &ERR_MAP_KEY_DOES_NOT_EXIST{}
}
func (*binaryClassERR_MAP_KEY_DOES_NOT_EXIST) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_MAP_KEY_DOES_NOT_EXIST(d, obj.(*ERR_MAP_KEY_DOES_NOT_EXIST))
}
func (o *ERR_MAP_KEY_DOES_NOT_EXIST) WriteSimple(w binary.Writer) {
	doEncodeERR_MAP_KEY_DOES_NOT_EXIST(w, o)
}
func (o *ERR_MAP_KEY_DOES_NOT_EXIST) ReadSimple(r binary.Reader) {
	doDecodeERR_MAP_KEY_DOES_NOT_EXIST(r, o)
}
func (c *binaryClassERR_MAP_KEY_DOES_NOT_EXIST) Schema() *binary.Entity {
	return &entities[ixǁERR_MAP_KEY_DOES_NOT_EXIST]
}

type binaryClassERR_MESH_NOT_AVAILABLE struct{}

func (*ERR_MESH_NOT_AVAILABLE) Class() binary.Class {
	return (*binaryClassERR_MESH_NOT_AVAILABLE)(nil)
}
func doEncodeERR_MESH_NOT_AVAILABLE(e binary.Writer, o *ERR_MESH_NOT_AVAILABLE) {
}
func doDecodeERR_MESH_NOT_AVAILABLE(d binary.Reader, o *ERR_MESH_NOT_AVAILABLE) {
}
func doDecodeRawERR_MESH_NOT_AVAILABLE(d binary.Reader, o *ERR_MESH_NOT_AVAILABLE) {
}
func (*binaryClassERR_MESH_NOT_AVAILABLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_MESH_NOT_AVAILABLE(e, obj.(*ERR_MESH_NOT_AVAILABLE))
}
func (*binaryClassERR_MESH_NOT_AVAILABLE) New() binary.Object {
	return &ERR_MESH_NOT_AVAILABLE{}
}
func (*binaryClassERR_MESH_NOT_AVAILABLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_MESH_NOT_AVAILABLE(d, obj.(*ERR_MESH_NOT_AVAILABLE))
}
func (o *ERR_MESH_NOT_AVAILABLE) WriteSimple(w binary.Writer) {
	doEncodeERR_MESH_NOT_AVAILABLE(w, o)
}
func (o *ERR_MESH_NOT_AVAILABLE) ReadSimple(r binary.Reader) {
	doDecodeERR_MESH_NOT_AVAILABLE(r, o)
}
func (c *binaryClassERR_MESH_NOT_AVAILABLE) Schema() *binary.Entity {
	return &entities[ixǁERR_MESH_NOT_AVAILABLE]
}

type binaryClassERR_MESSAGE struct{}

func (*ERR_MESSAGE) Class() binary.Class {
	return (*binaryClassERR_MESSAGE)(nil)
}
func doEncodeERR_MESSAGE(e binary.Writer, o *ERR_MESSAGE) {
	e.String(o.Error)
}
func doDecodeERR_MESSAGE(d binary.Reader, o *ERR_MESSAGE) {
	o.Error = string(d.String())
}
func doDecodeRawERR_MESSAGE(d binary.Reader, o *ERR_MESSAGE) {
	o.Error = string(d.String())
}
func (*binaryClassERR_MESSAGE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_MESSAGE(e, obj.(*ERR_MESSAGE))
}
func (*binaryClassERR_MESSAGE) New() binary.Object {
	return &ERR_MESSAGE{}
}
func (*binaryClassERR_MESSAGE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_MESSAGE(d, obj.(*ERR_MESSAGE))
}
func (o *ERR_MESSAGE) WriteSimple(w binary.Writer) {
	doEncodeERR_MESSAGE(w, o)
}
func (o *ERR_MESSAGE) ReadSimple(r binary.Reader) {
	doDecodeERR_MESSAGE(r, o)
}
func (c *binaryClassERR_MESSAGE) Schema() *binary.Entity {
	return &entities[ixǁERR_MESSAGE]
}

type binaryClassERR_NIL_POINTER_DEREFERENCE struct{}

func (*ERR_NIL_POINTER_DEREFERENCE) Class() binary.Class {
	return (*binaryClassERR_NIL_POINTER_DEREFERENCE)(nil)
}
func doEncodeERR_NIL_POINTER_DEREFERENCE(e binary.Writer, o *ERR_NIL_POINTER_DEREFERENCE) {
}
func doDecodeERR_NIL_POINTER_DEREFERENCE(d binary.Reader, o *ERR_NIL_POINTER_DEREFERENCE) {
}
func doDecodeRawERR_NIL_POINTER_DEREFERENCE(d binary.Reader, o *ERR_NIL_POINTER_DEREFERENCE) {
}
func (*binaryClassERR_NIL_POINTER_DEREFERENCE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_NIL_POINTER_DEREFERENCE(e, obj.(*ERR_NIL_POINTER_DEREFERENCE))
}
func (*binaryClassERR_NIL_POINTER_DEREFERENCE) New() binary.Object {
	return &ERR_NIL_POINTER_DEREFERENCE{}
}
func (*binaryClassERR_NIL_POINTER_DEREFERENCE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_NIL_POINTER_DEREFERENCE(d, obj.(*ERR_NIL_POINTER_DEREFERENCE))
}
func (o *ERR_NIL_POINTER_DEREFERENCE) WriteSimple(w binary.Writer) {
	doEncodeERR_NIL_POINTER_DEREFERENCE(w, o)
}
func (o *ERR_NIL_POINTER_DEREFERENCE) ReadSimple(r binary.Reader) {
	doDecodeERR_NIL_POINTER_DEREFERENCE(r, o)
}
func (c *binaryClassERR_NIL_POINTER_DEREFERENCE) Schema() *binary.Entity {
	return &entities[ixǁERR_NIL_POINTER_DEREFERENCE]
}

type binaryClassERR_NO_CONTEXT_BOUND struct{}

func (*ERR_NO_CONTEXT_BOUND) Class() binary.Class {
	return (*binaryClassERR_NO_CONTEXT_BOUND)(nil)
}
func doEncodeERR_NO_CONTEXT_BOUND(e binary.Writer, o *ERR_NO_CONTEXT_BOUND) {
	e.Uint64(o.Thread)
}
func doDecodeERR_NO_CONTEXT_BOUND(d binary.Reader, o *ERR_NO_CONTEXT_BOUND) {
	o.Thread = uint64(d.Uint64())
}
func doDecodeRawERR_NO_CONTEXT_BOUND(d binary.Reader, o *ERR_NO_CONTEXT_BOUND) {
	o.Thread = uint64(d.Uint64())
}
func (*binaryClassERR_NO_CONTEXT_BOUND) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_NO_CONTEXT_BOUND(e, obj.(*ERR_NO_CONTEXT_BOUND))
}
func (*binaryClassERR_NO_CONTEXT_BOUND) New() binary.Object {
	return &ERR_NO_CONTEXT_BOUND{}
}
func (*binaryClassERR_NO_CONTEXT_BOUND) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_NO_CONTEXT_BOUND(d, obj.(*ERR_NO_CONTEXT_BOUND))
}
func (o *ERR_NO_CONTEXT_BOUND) WriteSimple(w binary.Writer) {
	doEncodeERR_NO_CONTEXT_BOUND(w, o)
}
func (o *ERR_NO_CONTEXT_BOUND) ReadSimple(r binary.Reader) {
	doDecodeERR_NO_CONTEXT_BOUND(r, o)
}
func (c *binaryClassERR_NO_CONTEXT_BOUND) Schema() *binary.Entity {
	return &entities[ixǁERR_NO_CONTEXT_BOUND]
}

type binaryClassERR_NO_TEXTURE_DATA struct{}

func (*ERR_NO_TEXTURE_DATA) Class() binary.Class {
	return (*binaryClassERR_NO_TEXTURE_DATA)(nil)
}
func doEncodeERR_NO_TEXTURE_DATA(e binary.Writer, o *ERR_NO_TEXTURE_DATA) {
	e.String(o.Texture_name)
}
func doDecodeERR_NO_TEXTURE_DATA(d binary.Reader, o *ERR_NO_TEXTURE_DATA) {
	o.Texture_name = string(d.String())
}
func doDecodeRawERR_NO_TEXTURE_DATA(d binary.Reader, o *ERR_NO_TEXTURE_DATA) {
	o.Texture_name = string(d.String())
}
func (*binaryClassERR_NO_TEXTURE_DATA) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_NO_TEXTURE_DATA(e, obj.(*ERR_NO_TEXTURE_DATA))
}
func (*binaryClassERR_NO_TEXTURE_DATA) New() binary.Object {
	return &ERR_NO_TEXTURE_DATA{}
}
func (*binaryClassERR_NO_TEXTURE_DATA) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_NO_TEXTURE_DATA(d, obj.(*ERR_NO_TEXTURE_DATA))
}
func (o *ERR_NO_TEXTURE_DATA) WriteSimple(w binary.Writer) {
	doEncodeERR_NO_TEXTURE_DATA(w, o)
}
func (o *ERR_NO_TEXTURE_DATA) ReadSimple(r binary.Reader) {
	doDecodeERR_NO_TEXTURE_DATA(r, o)
}
func (c *binaryClassERR_NO_TEXTURE_DATA) Schema() *binary.Entity {
	return &entities[ixǁERR_NO_TEXTURE_DATA]
}

type binaryClassERR_REPLAY_DRIVER struct{}

func (*ERR_REPLAY_DRIVER) Class() binary.Class {
	return (*binaryClassERR_REPLAY_DRIVER)(nil)
}
func doEncodeERR_REPLAY_DRIVER(e binary.Writer, o *ERR_REPLAY_DRIVER) {
	e.String(o.ReplayError)
}
func doDecodeERR_REPLAY_DRIVER(d binary.Reader, o *ERR_REPLAY_DRIVER) {
	o.ReplayError = string(d.String())
}
func doDecodeRawERR_REPLAY_DRIVER(d binary.Reader, o *ERR_REPLAY_DRIVER) {
	o.ReplayError = string(d.String())
}
func (*binaryClassERR_REPLAY_DRIVER) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_REPLAY_DRIVER(e, obj.(*ERR_REPLAY_DRIVER))
}
func (*binaryClassERR_REPLAY_DRIVER) New() binary.Object {
	return &ERR_REPLAY_DRIVER{}
}
func (*binaryClassERR_REPLAY_DRIVER) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_REPLAY_DRIVER(d, obj.(*ERR_REPLAY_DRIVER))
}
func (o *ERR_REPLAY_DRIVER) WriteSimple(w binary.Writer) {
	doEncodeERR_REPLAY_DRIVER(w, o)
}
func (o *ERR_REPLAY_DRIVER) ReadSimple(r binary.Reader) {
	doDecodeERR_REPLAY_DRIVER(r, o)
}
func (c *binaryClassERR_REPLAY_DRIVER) Schema() *binary.Entity {
	return &entities[ixǁERR_REPLAY_DRIVER]
}

type binaryClassERR_SLICE_OUT_OF_BOUNDS struct{}

func (*ERR_SLICE_OUT_OF_BOUNDS) Class() binary.Class {
	return (*binaryClassERR_SLICE_OUT_OF_BOUNDS)(nil)
}
func doEncodeERR_SLICE_OUT_OF_BOUNDS(e binary.Writer, o *ERR_SLICE_OUT_OF_BOUNDS) {
	e.String(o.From_value)
	e.String(o.To_value)
	e.String(o.From_variable)
	e.String(o.To_variable)
	e.String(o.Min)
	e.String(o.Max)
}
func doDecodeERR_SLICE_OUT_OF_BOUNDS(d binary.Reader, o *ERR_SLICE_OUT_OF_BOUNDS) {
	o.From_value = string(d.String())
	o.To_value = string(d.String())
	o.From_variable = string(d.String())
	o.To_variable = string(d.String())
	o.Min = string(d.String())
	o.Max = string(d.String())
}
func doDecodeRawERR_SLICE_OUT_OF_BOUNDS(d binary.Reader, o *ERR_SLICE_OUT_OF_BOUNDS) {
	o.From_value = string(d.String())
	o.To_value = string(d.String())
	o.From_variable = string(d.String())
	o.To_variable = string(d.String())
	o.Min = string(d.String())
	o.Max = string(d.String())
}
func (*binaryClassERR_SLICE_OUT_OF_BOUNDS) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_SLICE_OUT_OF_BOUNDS(e, obj.(*ERR_SLICE_OUT_OF_BOUNDS))
}
func (*binaryClassERR_SLICE_OUT_OF_BOUNDS) New() binary.Object {
	return &ERR_SLICE_OUT_OF_BOUNDS{}
}
func (*binaryClassERR_SLICE_OUT_OF_BOUNDS) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_SLICE_OUT_OF_BOUNDS(d, obj.(*ERR_SLICE_OUT_OF_BOUNDS))
}
func (o *ERR_SLICE_OUT_OF_BOUNDS) WriteSimple(w binary.Writer) {
	doEncodeERR_SLICE_OUT_OF_BOUNDS(w, o)
}
func (o *ERR_SLICE_OUT_OF_BOUNDS) ReadSimple(r binary.Reader) {
	doDecodeERR_SLICE_OUT_OF_BOUNDS(r, o)
}
func (c *binaryClassERR_SLICE_OUT_OF_BOUNDS) Schema() *binary.Entity {
	return &entities[ixǁERR_SLICE_OUT_OF_BOUNDS]
}

type binaryClassERR_STATE_UNAVAILABLE struct{}

func (*ERR_STATE_UNAVAILABLE) Class() binary.Class {
	return (*binaryClassERR_STATE_UNAVAILABLE)(nil)
}
func doEncodeERR_STATE_UNAVAILABLE(e binary.Writer, o *ERR_STATE_UNAVAILABLE) {
}
func doDecodeERR_STATE_UNAVAILABLE(d binary.Reader, o *ERR_STATE_UNAVAILABLE) {
}
func doDecodeRawERR_STATE_UNAVAILABLE(d binary.Reader, o *ERR_STATE_UNAVAILABLE) {
}
func (*binaryClassERR_STATE_UNAVAILABLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_STATE_UNAVAILABLE(e, obj.(*ERR_STATE_UNAVAILABLE))
}
func (*binaryClassERR_STATE_UNAVAILABLE) New() binary.Object {
	return &ERR_STATE_UNAVAILABLE{}
}
func (*binaryClassERR_STATE_UNAVAILABLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_STATE_UNAVAILABLE(d, obj.(*ERR_STATE_UNAVAILABLE))
}
func (o *ERR_STATE_UNAVAILABLE) WriteSimple(w binary.Writer) {
	doEncodeERR_STATE_UNAVAILABLE(w, o)
}
func (o *ERR_STATE_UNAVAILABLE) ReadSimple(r binary.Reader) {
	doDecodeERR_STATE_UNAVAILABLE(r, o)
}
func (c *binaryClassERR_STATE_UNAVAILABLE) Schema() *binary.Entity {
	return &entities[ixǁERR_STATE_UNAVAILABLE]
}

type binaryClassERR_TRACE_ASSERT struct{}

func (*ERR_TRACE_ASSERT) Class() binary.Class {
	return (*binaryClassERR_TRACE_ASSERT)(nil)
}
func doEncodeERR_TRACE_ASSERT(e binary.Writer, o *ERR_TRACE_ASSERT) {
	e.String(o.Reason)
}
func doDecodeERR_TRACE_ASSERT(d binary.Reader, o *ERR_TRACE_ASSERT) {
	o.Reason = string(d.String())
}
func doDecodeRawERR_TRACE_ASSERT(d binary.Reader, o *ERR_TRACE_ASSERT) {
	o.Reason = string(d.String())
}
func (*binaryClassERR_TRACE_ASSERT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_TRACE_ASSERT(e, obj.(*ERR_TRACE_ASSERT))
}
func (*binaryClassERR_TRACE_ASSERT) New() binary.Object {
	return &ERR_TRACE_ASSERT{}
}
func (*binaryClassERR_TRACE_ASSERT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_TRACE_ASSERT(d, obj.(*ERR_TRACE_ASSERT))
}
func (o *ERR_TRACE_ASSERT) WriteSimple(w binary.Writer) {
	doEncodeERR_TRACE_ASSERT(w, o)
}
func (o *ERR_TRACE_ASSERT) ReadSimple(r binary.Reader) {
	doDecodeERR_TRACE_ASSERT(r, o)
}
func (c *binaryClassERR_TRACE_ASSERT) Schema() *binary.Entity {
	return &entities[ixǁERR_TRACE_ASSERT]
}

type binaryClassERR_TYPE_NOT_ARRAY_INDEXABLE struct{}

func (*ERR_TYPE_NOT_ARRAY_INDEXABLE) Class() binary.Class {
	return (*binaryClassERR_TYPE_NOT_ARRAY_INDEXABLE)(nil)
}
func doEncodeERR_TYPE_NOT_ARRAY_INDEXABLE(e binary.Writer, o *ERR_TYPE_NOT_ARRAY_INDEXABLE) {
	e.String(o.Ty)
}
func doDecodeERR_TYPE_NOT_ARRAY_INDEXABLE(d binary.Reader, o *ERR_TYPE_NOT_ARRAY_INDEXABLE) {
	o.Ty = string(d.String())
}
func doDecodeRawERR_TYPE_NOT_ARRAY_INDEXABLE(d binary.Reader, o *ERR_TYPE_NOT_ARRAY_INDEXABLE) {
	o.Ty = string(d.String())
}
func (*binaryClassERR_TYPE_NOT_ARRAY_INDEXABLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_TYPE_NOT_ARRAY_INDEXABLE(e, obj.(*ERR_TYPE_NOT_ARRAY_INDEXABLE))
}
func (*binaryClassERR_TYPE_NOT_ARRAY_INDEXABLE) New() binary.Object {
	return &ERR_TYPE_NOT_ARRAY_INDEXABLE{}
}
func (*binaryClassERR_TYPE_NOT_ARRAY_INDEXABLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_TYPE_NOT_ARRAY_INDEXABLE(d, obj.(*ERR_TYPE_NOT_ARRAY_INDEXABLE))
}
func (o *ERR_TYPE_NOT_ARRAY_INDEXABLE) WriteSimple(w binary.Writer) {
	doEncodeERR_TYPE_NOT_ARRAY_INDEXABLE(w, o)
}
func (o *ERR_TYPE_NOT_ARRAY_INDEXABLE) ReadSimple(r binary.Reader) {
	doDecodeERR_TYPE_NOT_ARRAY_INDEXABLE(r, o)
}
func (c *binaryClassERR_TYPE_NOT_ARRAY_INDEXABLE) Schema() *binary.Entity {
	return &entities[ixǁERR_TYPE_NOT_ARRAY_INDEXABLE]
}

type binaryClassERR_TYPE_NOT_MAP_INDEXABLE struct{}

func (*ERR_TYPE_NOT_MAP_INDEXABLE) Class() binary.Class {
	return (*binaryClassERR_TYPE_NOT_MAP_INDEXABLE)(nil)
}
func doEncodeERR_TYPE_NOT_MAP_INDEXABLE(e binary.Writer, o *ERR_TYPE_NOT_MAP_INDEXABLE) {
	e.String(o.Ty)
}
func doDecodeERR_TYPE_NOT_MAP_INDEXABLE(d binary.Reader, o *ERR_TYPE_NOT_MAP_INDEXABLE) {
	o.Ty = string(d.String())
}
func doDecodeRawERR_TYPE_NOT_MAP_INDEXABLE(d binary.Reader, o *ERR_TYPE_NOT_MAP_INDEXABLE) {
	o.Ty = string(d.String())
}
func (*binaryClassERR_TYPE_NOT_MAP_INDEXABLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_TYPE_NOT_MAP_INDEXABLE(e, obj.(*ERR_TYPE_NOT_MAP_INDEXABLE))
}
func (*binaryClassERR_TYPE_NOT_MAP_INDEXABLE) New() binary.Object {
	return &ERR_TYPE_NOT_MAP_INDEXABLE{}
}
func (*binaryClassERR_TYPE_NOT_MAP_INDEXABLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_TYPE_NOT_MAP_INDEXABLE(d, obj.(*ERR_TYPE_NOT_MAP_INDEXABLE))
}
func (o *ERR_TYPE_NOT_MAP_INDEXABLE) WriteSimple(w binary.Writer) {
	doEncodeERR_TYPE_NOT_MAP_INDEXABLE(w, o)
}
func (o *ERR_TYPE_NOT_MAP_INDEXABLE) ReadSimple(r binary.Reader) {
	doDecodeERR_TYPE_NOT_MAP_INDEXABLE(r, o)
}
func (c *binaryClassERR_TYPE_NOT_MAP_INDEXABLE) Schema() *binary.Entity {
	return &entities[ixǁERR_TYPE_NOT_MAP_INDEXABLE]
}

type binaryClassERR_TYPE_NOT_SLICEABLE struct{}

func (*ERR_TYPE_NOT_SLICEABLE) Class() binary.Class {
	return (*binaryClassERR_TYPE_NOT_SLICEABLE)(nil)
}
func doEncodeERR_TYPE_NOT_SLICEABLE(e binary.Writer, o *ERR_TYPE_NOT_SLICEABLE) {
	e.String(o.Ty)
}
func doDecodeERR_TYPE_NOT_SLICEABLE(d binary.Reader, o *ERR_TYPE_NOT_SLICEABLE) {
	o.Ty = string(d.String())
}
func doDecodeRawERR_TYPE_NOT_SLICEABLE(d binary.Reader, o *ERR_TYPE_NOT_SLICEABLE) {
	o.Ty = string(d.String())
}
func (*binaryClassERR_TYPE_NOT_SLICEABLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_TYPE_NOT_SLICEABLE(e, obj.(*ERR_TYPE_NOT_SLICEABLE))
}
func (*binaryClassERR_TYPE_NOT_SLICEABLE) New() binary.Object {
	return &ERR_TYPE_NOT_SLICEABLE{}
}
func (*binaryClassERR_TYPE_NOT_SLICEABLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_TYPE_NOT_SLICEABLE(d, obj.(*ERR_TYPE_NOT_SLICEABLE))
}
func (o *ERR_TYPE_NOT_SLICEABLE) WriteSimple(w binary.Writer) {
	doEncodeERR_TYPE_NOT_SLICEABLE(w, o)
}
func (o *ERR_TYPE_NOT_SLICEABLE) ReadSimple(r binary.Reader) {
	doDecodeERR_TYPE_NOT_SLICEABLE(r, o)
}
func (c *binaryClassERR_TYPE_NOT_SLICEABLE) Schema() *binary.Entity {
	return &entities[ixǁERR_TYPE_NOT_SLICEABLE]
}

type binaryClassERR_UNKNOWN_DEVICE struct{}

func (*ERR_UNKNOWN_DEVICE) Class() binary.Class {
	return (*binaryClassERR_UNKNOWN_DEVICE)(nil)
}
func doEncodeERR_UNKNOWN_DEVICE(e binary.Writer, o *ERR_UNKNOWN_DEVICE) {
}
func doDecodeERR_UNKNOWN_DEVICE(d binary.Reader, o *ERR_UNKNOWN_DEVICE) {
}
func doDecodeRawERR_UNKNOWN_DEVICE(d binary.Reader, o *ERR_UNKNOWN_DEVICE) {
}
func (*binaryClassERR_UNKNOWN_DEVICE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_UNKNOWN_DEVICE(e, obj.(*ERR_UNKNOWN_DEVICE))
}
func (*binaryClassERR_UNKNOWN_DEVICE) New() binary.Object {
	return &ERR_UNKNOWN_DEVICE{}
}
func (*binaryClassERR_UNKNOWN_DEVICE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_UNKNOWN_DEVICE(d, obj.(*ERR_UNKNOWN_DEVICE))
}
func (o *ERR_UNKNOWN_DEVICE) WriteSimple(w binary.Writer) {
	doEncodeERR_UNKNOWN_DEVICE(w, o)
}
func (o *ERR_UNKNOWN_DEVICE) ReadSimple(r binary.Reader) {
	doDecodeERR_UNKNOWN_DEVICE(r, o)
}
func (c *binaryClassERR_UNKNOWN_DEVICE) Schema() *binary.Entity {
	return &entities[ixǁERR_UNKNOWN_DEVICE]
}

type binaryClassERR_UNSUPPORTED_CONVERSION struct{}

func (*ERR_UNSUPPORTED_CONVERSION) Class() binary.Class {
	return (*binaryClassERR_UNSUPPORTED_CONVERSION)(nil)
}
func doEncodeERR_UNSUPPORTED_CONVERSION(e binary.Writer, o *ERR_UNSUPPORTED_CONVERSION) {
}
func doDecodeERR_UNSUPPORTED_CONVERSION(d binary.Reader, o *ERR_UNSUPPORTED_CONVERSION) {
}
func doDecodeRawERR_UNSUPPORTED_CONVERSION(d binary.Reader, o *ERR_UNSUPPORTED_CONVERSION) {
}
func (*binaryClassERR_UNSUPPORTED_CONVERSION) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_UNSUPPORTED_CONVERSION(e, obj.(*ERR_UNSUPPORTED_CONVERSION))
}
func (*binaryClassERR_UNSUPPORTED_CONVERSION) New() binary.Object {
	return &ERR_UNSUPPORTED_CONVERSION{}
}
func (*binaryClassERR_UNSUPPORTED_CONVERSION) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_UNSUPPORTED_CONVERSION(d, obj.(*ERR_UNSUPPORTED_CONVERSION))
}
func (o *ERR_UNSUPPORTED_CONVERSION) WriteSimple(w binary.Writer) {
	doEncodeERR_UNSUPPORTED_CONVERSION(w, o)
}
func (o *ERR_UNSUPPORTED_CONVERSION) ReadSimple(r binary.Reader) {
	doDecodeERR_UNSUPPORTED_CONVERSION(r, o)
}
func (c *binaryClassERR_UNSUPPORTED_CONVERSION) Schema() *binary.Entity {
	return &entities[ixǁERR_UNSUPPORTED_CONVERSION]
}

type binaryClassERR_VALUE_GE_LIMIT struct{}

func (*ERR_VALUE_GE_LIMIT) Class() binary.Class {
	return (*binaryClassERR_VALUE_GE_LIMIT)(nil)
}
func doEncodeERR_VALUE_GE_LIMIT(e binary.Writer, o *ERR_VALUE_GE_LIMIT) {
	e.String(o.Valname)
	e.String(o.Limitname)
	e.Int64(o.Val)
	e.Int64(o.Limit)
}
func doDecodeERR_VALUE_GE_LIMIT(d binary.Reader, o *ERR_VALUE_GE_LIMIT) {
	o.Valname = string(d.String())
	o.Limitname = string(d.String())
	o.Val = int64(d.Int64())
	o.Limit = int64(d.Int64())
}
func doDecodeRawERR_VALUE_GE_LIMIT(d binary.Reader, o *ERR_VALUE_GE_LIMIT) {
	o.Valname = string(d.String())
	o.Limitname = string(d.String())
	o.Val = int64(d.Int64())
	o.Limit = int64(d.Int64())
}
func (*binaryClassERR_VALUE_GE_LIMIT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_VALUE_GE_LIMIT(e, obj.(*ERR_VALUE_GE_LIMIT))
}
func (*binaryClassERR_VALUE_GE_LIMIT) New() binary.Object {
	return &ERR_VALUE_GE_LIMIT{}
}
func (*binaryClassERR_VALUE_GE_LIMIT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_VALUE_GE_LIMIT(d, obj.(*ERR_VALUE_GE_LIMIT))
}
func (o *ERR_VALUE_GE_LIMIT) WriteSimple(w binary.Writer) {
	doEncodeERR_VALUE_GE_LIMIT(w, o)
}
func (o *ERR_VALUE_GE_LIMIT) ReadSimple(r binary.Reader) {
	doDecodeERR_VALUE_GE_LIMIT(r, o)
}
func (c *binaryClassERR_VALUE_GE_LIMIT) Schema() *binary.Entity {
	return &entities[ixǁERR_VALUE_GE_LIMIT]
}

type binaryClassERR_VALUE_NEG struct{}

func (*ERR_VALUE_NEG) Class() binary.Class {
	return (*binaryClassERR_VALUE_NEG)(nil)
}
func doEncodeERR_VALUE_NEG(e binary.Writer, o *ERR_VALUE_NEG) {
	e.String(o.Valname)
	e.Int64(o.Value)
}
func doDecodeERR_VALUE_NEG(d binary.Reader, o *ERR_VALUE_NEG) {
	o.Valname = string(d.String())
	o.Value = int64(d.Int64())
}
func doDecodeRawERR_VALUE_NEG(d binary.Reader, o *ERR_VALUE_NEG) {
	o.Valname = string(d.String())
	o.Value = int64(d.Int64())
}
func (*binaryClassERR_VALUE_NEG) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_VALUE_NEG(e, obj.(*ERR_VALUE_NEG))
}
func (*binaryClassERR_VALUE_NEG) New() binary.Object {
	return &ERR_VALUE_NEG{}
}
func (*binaryClassERR_VALUE_NEG) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_VALUE_NEG(d, obj.(*ERR_VALUE_NEG))
}
func (o *ERR_VALUE_NEG) WriteSimple(w binary.Writer) {
	doEncodeERR_VALUE_NEG(w, o)
}
func (o *ERR_VALUE_NEG) ReadSimple(r binary.Reader) {
	doDecodeERR_VALUE_NEG(r, o)
}
func (c *binaryClassERR_VALUE_NEG) Schema() *binary.Entity {
	return &entities[ixǁERR_VALUE_NEG]
}

type binaryClassERR_VALUE_OUT_OF_BOUNDS struct{}

func (*ERR_VALUE_OUT_OF_BOUNDS) Class() binary.Class {
	return (*binaryClassERR_VALUE_OUT_OF_BOUNDS)(nil)
}
func doEncodeERR_VALUE_OUT_OF_BOUNDS(e binary.Writer, o *ERR_VALUE_OUT_OF_BOUNDS) {
	e.String(o.Value)
	e.String(o.Variable)
	e.String(o.Min)
	e.String(o.Max)
}
func doDecodeERR_VALUE_OUT_OF_BOUNDS(d binary.Reader, o *ERR_VALUE_OUT_OF_BOUNDS) {
	o.Value = string(d.String())
	o.Variable = string(d.String())
	o.Min = string(d.String())
	o.Max = string(d.String())
}
func doDecodeRawERR_VALUE_OUT_OF_BOUNDS(d binary.Reader, o *ERR_VALUE_OUT_OF_BOUNDS) {
	o.Value = string(d.String())
	o.Variable = string(d.String())
	o.Min = string(d.String())
	o.Max = string(d.String())
}
func (*binaryClassERR_VALUE_OUT_OF_BOUNDS) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_VALUE_OUT_OF_BOUNDS(e, obj.(*ERR_VALUE_OUT_OF_BOUNDS))
}
func (*binaryClassERR_VALUE_OUT_OF_BOUNDS) New() binary.Object {
	return &ERR_VALUE_OUT_OF_BOUNDS{}
}
func (*binaryClassERR_VALUE_OUT_OF_BOUNDS) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_VALUE_OUT_OF_BOUNDS(d, obj.(*ERR_VALUE_OUT_OF_BOUNDS))
}
func (o *ERR_VALUE_OUT_OF_BOUNDS) WriteSimple(w binary.Writer) {
	doEncodeERR_VALUE_OUT_OF_BOUNDS(w, o)
}
func (o *ERR_VALUE_OUT_OF_BOUNDS) ReadSimple(r binary.Reader) {
	doDecodeERR_VALUE_OUT_OF_BOUNDS(r, o)
}
func (c *binaryClassERR_VALUE_OUT_OF_BOUNDS) Schema() *binary.Entity {
	return &entities[ixǁERR_VALUE_OUT_OF_BOUNDS]
}

type binaryClassERR_WRONG_CONTEXT_VERSION struct{}

func (*ERR_WRONG_CONTEXT_VERSION) Class() binary.Class {
	return (*binaryClassERR_WRONG_CONTEXT_VERSION)(nil)
}
func doEncodeERR_WRONG_CONTEXT_VERSION(e binary.Writer, o *ERR_WRONG_CONTEXT_VERSION) {
	e.Uint32(o.Reqmajor)
	e.Uint32(o.Reqminor)
	e.Uint32(o.Major)
	e.Uint32(o.Minor)
}
func doDecodeERR_WRONG_CONTEXT_VERSION(d binary.Reader, o *ERR_WRONG_CONTEXT_VERSION) {
	o.Reqmajor = uint32(d.Uint32())
	o.Reqminor = uint32(d.Uint32())
	o.Major = uint32(d.Uint32())
	o.Minor = uint32(d.Uint32())
}
func doDecodeRawERR_WRONG_CONTEXT_VERSION(d binary.Reader, o *ERR_WRONG_CONTEXT_VERSION) {
	o.Reqmajor = uint32(d.Uint32())
	o.Reqminor = uint32(d.Uint32())
	o.Major = uint32(d.Uint32())
	o.Minor = uint32(d.Uint32())
}
func (*binaryClassERR_WRONG_CONTEXT_VERSION) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeERR_WRONG_CONTEXT_VERSION(e, obj.(*ERR_WRONG_CONTEXT_VERSION))
}
func (*binaryClassERR_WRONG_CONTEXT_VERSION) New() binary.Object {
	return &ERR_WRONG_CONTEXT_VERSION{}
}
func (*binaryClassERR_WRONG_CONTEXT_VERSION) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeERR_WRONG_CONTEXT_VERSION(d, obj.(*ERR_WRONG_CONTEXT_VERSION))
}
func (o *ERR_WRONG_CONTEXT_VERSION) WriteSimple(w binary.Writer) {
	doEncodeERR_WRONG_CONTEXT_VERSION(w, o)
}
func (o *ERR_WRONG_CONTEXT_VERSION) ReadSimple(r binary.Reader) {
	doDecodeERR_WRONG_CONTEXT_VERSION(r, o)
}
func (c *binaryClassERR_WRONG_CONTEXT_VERSION) Schema() *binary.Entity {
	return &entities[ixǁERR_WRONG_CONTEXT_VERSION]
}

type binaryClassEglBindAPI struct{}

func (*EglBindAPI) Class() binary.Class {
	return (*binaryClassEglBindAPI)(nil)
}
func doEncodeEglBindAPI(e binary.Encoder, o *EglBindAPI) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Api))
	e.Int64(int64(o.Result))
}
func doDecodeEglBindAPI(d binary.Decoder, o *EglBindAPI) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Api = EGLenum(d.Uint32())
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglBindAPI(d binary.Decoder, o *EglBindAPI) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Api = EGLenum(d.Uint32())
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglBindAPI) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglBindAPI(e, obj.(*EglBindAPI))
}
func (*binaryClassEglBindAPI) New() binary.Object {
	return &EglBindAPI{}
}
func (*binaryClassEglBindAPI) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglBindAPI(d, obj.(*EglBindAPI))
}
func (c *binaryClassEglBindAPI) Schema() *binary.Entity {
	return &entities[ixǁEglBindAPI]
}

type binaryClassEglBindTexImage struct{}

func (*EglBindTexImage) Class() binary.Class {
	return (*binaryClassEglBindTexImage)(nil)
}
func doEncodeEglBindTexImage(e binary.Encoder, o *EglBindTexImage) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Surface)
	e.Int64(int64(o.Buffer))
	e.Int64(int64(o.Result))
}
func doDecodeEglBindTexImage(d binary.Decoder, o *EglBindTexImage) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	o.Buffer = EGLint(d.Int64())
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglBindTexImage(d binary.Decoder, o *EglBindTexImage) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	o.Buffer = EGLint(d.Int64())
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglBindTexImage) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglBindTexImage(e, obj.(*EglBindTexImage))
}
func (*binaryClassEglBindTexImage) New() binary.Object {
	return &EglBindTexImage{}
}
func (*binaryClassEglBindTexImage) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglBindTexImage(d, obj.(*EglBindTexImage))
}
func (c *binaryClassEglBindTexImage) Schema() *binary.Entity {
	return &entities[ixǁEglBindTexImage]
}

type binaryClassEglChooseConfig struct{}

func (*EglChooseConfig) Class() binary.Class {
	return (*binaryClassEglChooseConfig)(nil)
}
func doEncodeEglChooseConfig(e binary.Encoder, o *EglChooseConfig) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.AttribList)
	e.Simple(&o.Configs)
	e.Int64(int64(o.ConfigSize))
	e.Simple(&o.NumConfig)
	e.Int64(int64(o.Result))
}
func doDecodeEglChooseConfig(d binary.Decoder, o *EglChooseConfig) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.AttribList)
	d.Simple(&o.Configs)
	o.ConfigSize = EGLint(d.Int64())
	d.Simple(&o.NumConfig)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglChooseConfig(d binary.Decoder, o *EglChooseConfig) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.AttribList)
	d.Simple(&o.Configs)
	o.ConfigSize = EGLint(d.Int64())
	d.Simple(&o.NumConfig)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglChooseConfig) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglChooseConfig(e, obj.(*EglChooseConfig))
}
func (*binaryClassEglChooseConfig) New() binary.Object {
	return &EglChooseConfig{}
}
func (*binaryClassEglChooseConfig) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglChooseConfig(d, obj.(*EglChooseConfig))
}
func (c *binaryClassEglChooseConfig) Schema() *binary.Entity {
	return &entities[ixǁEglChooseConfig]
}

type binaryClassEglClientWaitSyncKHR struct{}

func (*EglClientWaitSyncKHR) Class() binary.Class {
	return (*binaryClassEglClientWaitSyncKHR)(nil)
}
func doEncodeEglClientWaitSyncKHR(e binary.Encoder, o *EglClientWaitSyncKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Dpy)
	e.Simple(&o.Sync)
	e.Int64(int64(o.SyncFlags))
	e.Uint64(uint64(o.Timeout))
	e.Int64(int64(o.Result))
}
func doDecodeEglClientWaitSyncKHR(d binary.Decoder, o *EglClientWaitSyncKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Sync)
	o.SyncFlags = EGLint(d.Int64())
	o.Timeout = EGLTimeKHR(d.Uint64())
	o.Result = EGLint(d.Int64())
}
func doDecodeRawEglClientWaitSyncKHR(d binary.Decoder, o *EglClientWaitSyncKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Sync)
	o.SyncFlags = EGLint(d.Int64())
	o.Timeout = EGLTimeKHR(d.Uint64())
	o.Result = EGLint(d.Int64())
}
func (*binaryClassEglClientWaitSyncKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglClientWaitSyncKHR(e, obj.(*EglClientWaitSyncKHR))
}
func (*binaryClassEglClientWaitSyncKHR) New() binary.Object {
	return &EglClientWaitSyncKHR{}
}
func (*binaryClassEglClientWaitSyncKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglClientWaitSyncKHR(d, obj.(*EglClientWaitSyncKHR))
}
func (c *binaryClassEglClientWaitSyncKHR) Schema() *binary.Entity {
	return &entities[ixǁEglClientWaitSyncKHR]
}

type binaryClassEglCopyBuffers struct{}

func (*EglCopyBuffers) Class() binary.Class {
	return (*binaryClassEglCopyBuffers)(nil)
}
func doEncodeEglCopyBuffers(e binary.Encoder, o *EglCopyBuffers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Surface)
	e.Simple(&o.NativePixmap)
	e.Int64(int64(o.Result))
}
func doDecodeEglCopyBuffers(d binary.Decoder, o *EglCopyBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	d.Simple(&o.NativePixmap)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglCopyBuffers(d binary.Decoder, o *EglCopyBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	d.Simple(&o.NativePixmap)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglCopyBuffers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglCopyBuffers(e, obj.(*EglCopyBuffers))
}
func (*binaryClassEglCopyBuffers) New() binary.Object {
	return &EglCopyBuffers{}
}
func (*binaryClassEglCopyBuffers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglCopyBuffers(d, obj.(*EglCopyBuffers))
}
func (c *binaryClassEglCopyBuffers) Schema() *binary.Entity {
	return &entities[ixǁEglCopyBuffers]
}

type binaryClassEglCreateContext struct{}

func (*EglCreateContext) Class() binary.Class {
	return (*binaryClassEglCreateContext)(nil)
}
func doEncodeEglCreateContext(e binary.Encoder, o *EglCreateContext) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Config)
	e.Simple(&o.ShareContext)
	e.Simple(&o.AttribList)
	e.Simple(&o.Result)
}
func doDecodeEglCreateContext(d binary.Decoder, o *EglCreateContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Config)
	d.Simple(&o.ShareContext)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func doDecodeRawEglCreateContext(d binary.Decoder, o *EglCreateContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Config)
	d.Simple(&o.ShareContext)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func (*binaryClassEglCreateContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglCreateContext(e, obj.(*EglCreateContext))
}
func (*binaryClassEglCreateContext) New() binary.Object {
	return &EglCreateContext{}
}
func (*binaryClassEglCreateContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglCreateContext(d, obj.(*EglCreateContext))
}
func (c *binaryClassEglCreateContext) Schema() *binary.Entity {
	return &entities[ixǁEglCreateContext]
}

type binaryClassEglCreateImageKHR struct{}

func (*EglCreateImageKHR) Class() binary.Class {
	return (*binaryClassEglCreateImageKHR)(nil)
}
func doEncodeEglCreateImageKHR(e binary.Encoder, o *EglCreateImageKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Dpy)
	e.Simple(&o.Ctx)
	e.Uint32(uint32(o.Target))
	e.Simple(&o.Buffer)
	e.Simple(&o.AttribList)
	e.Simple(&o.Result)
}
func doDecodeEglCreateImageKHR(d binary.Decoder, o *EglCreateImageKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Ctx)
	o.Target = EGLenum(d.Uint32())
	d.Simple(&o.Buffer)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func doDecodeRawEglCreateImageKHR(d binary.Decoder, o *EglCreateImageKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Ctx)
	o.Target = EGLenum(d.Uint32())
	d.Simple(&o.Buffer)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func (*binaryClassEglCreateImageKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglCreateImageKHR(e, obj.(*EglCreateImageKHR))
}
func (*binaryClassEglCreateImageKHR) New() binary.Object {
	return &EglCreateImageKHR{}
}
func (*binaryClassEglCreateImageKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglCreateImageKHR(d, obj.(*EglCreateImageKHR))
}
func (c *binaryClassEglCreateImageKHR) Schema() *binary.Entity {
	return &entities[ixǁEglCreateImageKHR]
}

type binaryClassEglCreatePbufferFromClientBuffer struct{}

func (*EglCreatePbufferFromClientBuffer) Class() binary.Class {
	return (*binaryClassEglCreatePbufferFromClientBuffer)(nil)
}
func doEncodeEglCreatePbufferFromClientBuffer(e binary.Encoder, o *EglCreatePbufferFromClientBuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Uint32(uint32(o.Buftype))
	e.Simple(&o.Buffer)
	e.Simple(&o.Config)
	e.Simple(&o.AttribList)
	e.Simple(&o.Result)
}
func doDecodeEglCreatePbufferFromClientBuffer(d binary.Decoder, o *EglCreatePbufferFromClientBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	o.Buftype = EGLenum(d.Uint32())
	d.Simple(&o.Buffer)
	d.Simple(&o.Config)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func doDecodeRawEglCreatePbufferFromClientBuffer(d binary.Decoder, o *EglCreatePbufferFromClientBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	o.Buftype = EGLenum(d.Uint32())
	d.Simple(&o.Buffer)
	d.Simple(&o.Config)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func (*binaryClassEglCreatePbufferFromClientBuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglCreatePbufferFromClientBuffer(e, obj.(*EglCreatePbufferFromClientBuffer))
}
func (*binaryClassEglCreatePbufferFromClientBuffer) New() binary.Object {
	return &EglCreatePbufferFromClientBuffer{}
}
func (*binaryClassEglCreatePbufferFromClientBuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglCreatePbufferFromClientBuffer(d, obj.(*EglCreatePbufferFromClientBuffer))
}
func (c *binaryClassEglCreatePbufferFromClientBuffer) Schema() *binary.Entity {
	return &entities[ixǁEglCreatePbufferFromClientBuffer]
}

type binaryClassEglCreatePbufferSurface struct{}

func (*EglCreatePbufferSurface) Class() binary.Class {
	return (*binaryClassEglCreatePbufferSurface)(nil)
}
func doEncodeEglCreatePbufferSurface(e binary.Encoder, o *EglCreatePbufferSurface) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Config)
	e.Simple(&o.AttribList)
	e.Simple(&o.Result)
}
func doDecodeEglCreatePbufferSurface(d binary.Decoder, o *EglCreatePbufferSurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Config)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func doDecodeRawEglCreatePbufferSurface(d binary.Decoder, o *EglCreatePbufferSurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Config)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func (*binaryClassEglCreatePbufferSurface) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglCreatePbufferSurface(e, obj.(*EglCreatePbufferSurface))
}
func (*binaryClassEglCreatePbufferSurface) New() binary.Object {
	return &EglCreatePbufferSurface{}
}
func (*binaryClassEglCreatePbufferSurface) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglCreatePbufferSurface(d, obj.(*EglCreatePbufferSurface))
}
func (c *binaryClassEglCreatePbufferSurface) Schema() *binary.Entity {
	return &entities[ixǁEglCreatePbufferSurface]
}

type binaryClassEglCreatePixmapSurface struct{}

func (*EglCreatePixmapSurface) Class() binary.Class {
	return (*binaryClassEglCreatePixmapSurface)(nil)
}
func doEncodeEglCreatePixmapSurface(e binary.Encoder, o *EglCreatePixmapSurface) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Config)
	e.Simple(&o.NativePixmap)
	e.Simple(&o.AttribList)
	e.Simple(&o.Result)
}
func doDecodeEglCreatePixmapSurface(d binary.Decoder, o *EglCreatePixmapSurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Config)
	d.Simple(&o.NativePixmap)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func doDecodeRawEglCreatePixmapSurface(d binary.Decoder, o *EglCreatePixmapSurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Config)
	d.Simple(&o.NativePixmap)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func (*binaryClassEglCreatePixmapSurface) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglCreatePixmapSurface(e, obj.(*EglCreatePixmapSurface))
}
func (*binaryClassEglCreatePixmapSurface) New() binary.Object {
	return &EglCreatePixmapSurface{}
}
func (*binaryClassEglCreatePixmapSurface) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglCreatePixmapSurface(d, obj.(*EglCreatePixmapSurface))
}
func (c *binaryClassEglCreatePixmapSurface) Schema() *binary.Entity {
	return &entities[ixǁEglCreatePixmapSurface]
}

type binaryClassEglCreateSyncKHR struct{}

func (*EglCreateSyncKHR) Class() binary.Class {
	return (*binaryClassEglCreateSyncKHR)(nil)
}
func doEncodeEglCreateSyncKHR(e binary.Encoder, o *EglCreateSyncKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Dpy)
	e.Uint32(uint32(o.Type))
	e.Simple(&o.AttribList)
	e.Simple(&o.Result)
}
func doDecodeEglCreateSyncKHR(d binary.Decoder, o *EglCreateSyncKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	o.Type = EGLenum(d.Uint32())
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func doDecodeRawEglCreateSyncKHR(d binary.Decoder, o *EglCreateSyncKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	o.Type = EGLenum(d.Uint32())
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func (*binaryClassEglCreateSyncKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglCreateSyncKHR(e, obj.(*EglCreateSyncKHR))
}
func (*binaryClassEglCreateSyncKHR) New() binary.Object {
	return &EglCreateSyncKHR{}
}
func (*binaryClassEglCreateSyncKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglCreateSyncKHR(d, obj.(*EglCreateSyncKHR))
}
func (c *binaryClassEglCreateSyncKHR) Schema() *binary.Entity {
	return &entities[ixǁEglCreateSyncKHR]
}

type binaryClassEglCreateWindowSurface struct{}

func (*EglCreateWindowSurface) Class() binary.Class {
	return (*binaryClassEglCreateWindowSurface)(nil)
}
func doEncodeEglCreateWindowSurface(e binary.Encoder, o *EglCreateWindowSurface) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Config)
	e.Simple(&o.NativeWindow)
	e.Simple(&o.AttribList)
	e.Simple(&o.Result)
}
func doDecodeEglCreateWindowSurface(d binary.Decoder, o *EglCreateWindowSurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Config)
	d.Simple(&o.NativeWindow)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func doDecodeRawEglCreateWindowSurface(d binary.Decoder, o *EglCreateWindowSurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Config)
	d.Simple(&o.NativeWindow)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func (*binaryClassEglCreateWindowSurface) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglCreateWindowSurface(e, obj.(*EglCreateWindowSurface))
}
func (*binaryClassEglCreateWindowSurface) New() binary.Object {
	return &EglCreateWindowSurface{}
}
func (*binaryClassEglCreateWindowSurface) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglCreateWindowSurface(d, obj.(*EglCreateWindowSurface))
}
func (c *binaryClassEglCreateWindowSurface) Schema() *binary.Entity {
	return &entities[ixǁEglCreateWindowSurface]
}

type binaryClassEglDestroyContext struct{}

func (*EglDestroyContext) Class() binary.Class {
	return (*binaryClassEglDestroyContext)(nil)
}
func doEncodeEglDestroyContext(e binary.Encoder, o *EglDestroyContext) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Context)
	e.Int64(int64(o.Result))
}
func doDecodeEglDestroyContext(d binary.Decoder, o *EglDestroyContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Context)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglDestroyContext(d binary.Decoder, o *EglDestroyContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Context)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglDestroyContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglDestroyContext(e, obj.(*EglDestroyContext))
}
func (*binaryClassEglDestroyContext) New() binary.Object {
	return &EglDestroyContext{}
}
func (*binaryClassEglDestroyContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglDestroyContext(d, obj.(*EglDestroyContext))
}
func (c *binaryClassEglDestroyContext) Schema() *binary.Entity {
	return &entities[ixǁEglDestroyContext]
}

type binaryClassEglDestroyImageKHR struct{}

func (*EglDestroyImageKHR) Class() binary.Class {
	return (*binaryClassEglDestroyImageKHR)(nil)
}
func doEncodeEglDestroyImageKHR(e binary.Encoder, o *EglDestroyImageKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Dpy)
	e.Simple(&o.Image)
	e.Int64(int64(o.Result))
}
func doDecodeEglDestroyImageKHR(d binary.Decoder, o *EglDestroyImageKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Image)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglDestroyImageKHR(d binary.Decoder, o *EglDestroyImageKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Image)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglDestroyImageKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglDestroyImageKHR(e, obj.(*EglDestroyImageKHR))
}
func (*binaryClassEglDestroyImageKHR) New() binary.Object {
	return &EglDestroyImageKHR{}
}
func (*binaryClassEglDestroyImageKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglDestroyImageKHR(d, obj.(*EglDestroyImageKHR))
}
func (c *binaryClassEglDestroyImageKHR) Schema() *binary.Entity {
	return &entities[ixǁEglDestroyImageKHR]
}

type binaryClassEglDestroySurface struct{}

func (*EglDestroySurface) Class() binary.Class {
	return (*binaryClassEglDestroySurface)(nil)
}
func doEncodeEglDestroySurface(e binary.Encoder, o *EglDestroySurface) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Surface)
	e.Int64(int64(o.Result))
}
func doDecodeEglDestroySurface(d binary.Decoder, o *EglDestroySurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglDestroySurface(d binary.Decoder, o *EglDestroySurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglDestroySurface) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglDestroySurface(e, obj.(*EglDestroySurface))
}
func (*binaryClassEglDestroySurface) New() binary.Object {
	return &EglDestroySurface{}
}
func (*binaryClassEglDestroySurface) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglDestroySurface(d, obj.(*EglDestroySurface))
}
func (c *binaryClassEglDestroySurface) Schema() *binary.Entity {
	return &entities[ixǁEglDestroySurface]
}

type binaryClassEglDestroySyncKHR struct{}

func (*EglDestroySyncKHR) Class() binary.Class {
	return (*binaryClassEglDestroySyncKHR)(nil)
}
func doEncodeEglDestroySyncKHR(e binary.Encoder, o *EglDestroySyncKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Dpy)
	e.Simple(&o.Sync)
	e.Int64(int64(o.Result))
}
func doDecodeEglDestroySyncKHR(d binary.Decoder, o *EglDestroySyncKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Sync)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglDestroySyncKHR(d binary.Decoder, o *EglDestroySyncKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Sync)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglDestroySyncKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglDestroySyncKHR(e, obj.(*EglDestroySyncKHR))
}
func (*binaryClassEglDestroySyncKHR) New() binary.Object {
	return &EglDestroySyncKHR{}
}
func (*binaryClassEglDestroySyncKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglDestroySyncKHR(d, obj.(*EglDestroySyncKHR))
}
func (c *binaryClassEglDestroySyncKHR) Schema() *binary.Entity {
	return &entities[ixǁEglDestroySyncKHR]
}

type binaryClassEglGetConfigAttrib struct{}

func (*EglGetConfigAttrib) Class() binary.Class {
	return (*binaryClassEglGetConfigAttrib)(nil)
}
func doEncodeEglGetConfigAttrib(e binary.Encoder, o *EglGetConfigAttrib) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Config)
	e.Int64(int64(o.Attribute))
	e.Simple(&o.Value)
	e.Int64(int64(o.Result))
}
func doDecodeEglGetConfigAttrib(d binary.Decoder, o *EglGetConfigAttrib) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Config)
	o.Attribute = EGLint(d.Int64())
	d.Simple(&o.Value)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglGetConfigAttrib(d binary.Decoder, o *EglGetConfigAttrib) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Config)
	o.Attribute = EGLint(d.Int64())
	d.Simple(&o.Value)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglGetConfigAttrib) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglGetConfigAttrib(e, obj.(*EglGetConfigAttrib))
}
func (*binaryClassEglGetConfigAttrib) New() binary.Object {
	return &EglGetConfigAttrib{}
}
func (*binaryClassEglGetConfigAttrib) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglGetConfigAttrib(d, obj.(*EglGetConfigAttrib))
}
func (c *binaryClassEglGetConfigAttrib) Schema() *binary.Entity {
	return &entities[ixǁEglGetConfigAttrib]
}

type binaryClassEglGetConfigs struct{}

func (*EglGetConfigs) Class() binary.Class {
	return (*binaryClassEglGetConfigs)(nil)
}
func doEncodeEglGetConfigs(e binary.Encoder, o *EglGetConfigs) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Configs)
	e.Int64(int64(o.ConfigSize))
	e.Simple(&o.NumConfig)
	e.Int64(int64(o.Result))
}
func doDecodeEglGetConfigs(d binary.Decoder, o *EglGetConfigs) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Configs)
	o.ConfigSize = EGLint(d.Int64())
	d.Simple(&o.NumConfig)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglGetConfigs(d binary.Decoder, o *EglGetConfigs) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Configs)
	o.ConfigSize = EGLint(d.Int64())
	d.Simple(&o.NumConfig)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglGetConfigs) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglGetConfigs(e, obj.(*EglGetConfigs))
}
func (*binaryClassEglGetConfigs) New() binary.Object {
	return &EglGetConfigs{}
}
func (*binaryClassEglGetConfigs) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglGetConfigs(d, obj.(*EglGetConfigs))
}
func (c *binaryClassEglGetConfigs) Schema() *binary.Entity {
	return &entities[ixǁEglGetConfigs]
}

type binaryClassEglGetCurrentContext struct{}

func (*EglGetCurrentContext) Class() binary.Class {
	return (*binaryClassEglGetCurrentContext)(nil)
}
func doEncodeEglGetCurrentContext(e binary.Encoder, o *EglGetCurrentContext) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Result)
}
func doDecodeEglGetCurrentContext(d binary.Decoder, o *EglGetCurrentContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Result)
}
func doDecodeRawEglGetCurrentContext(d binary.Decoder, o *EglGetCurrentContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Result)
}
func (*binaryClassEglGetCurrentContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglGetCurrentContext(e, obj.(*EglGetCurrentContext))
}
func (*binaryClassEglGetCurrentContext) New() binary.Object {
	return &EglGetCurrentContext{}
}
func (*binaryClassEglGetCurrentContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglGetCurrentContext(d, obj.(*EglGetCurrentContext))
}
func (c *binaryClassEglGetCurrentContext) Schema() *binary.Entity {
	return &entities[ixǁEglGetCurrentContext]
}

type binaryClassEglGetCurrentDisplay struct{}

func (*EglGetCurrentDisplay) Class() binary.Class {
	return (*binaryClassEglGetCurrentDisplay)(nil)
}
func doEncodeEglGetCurrentDisplay(e binary.Encoder, o *EglGetCurrentDisplay) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Result)
}
func doDecodeEglGetCurrentDisplay(d binary.Decoder, o *EglGetCurrentDisplay) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Result)
}
func doDecodeRawEglGetCurrentDisplay(d binary.Decoder, o *EglGetCurrentDisplay) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Result)
}
func (*binaryClassEglGetCurrentDisplay) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglGetCurrentDisplay(e, obj.(*EglGetCurrentDisplay))
}
func (*binaryClassEglGetCurrentDisplay) New() binary.Object {
	return &EglGetCurrentDisplay{}
}
func (*binaryClassEglGetCurrentDisplay) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglGetCurrentDisplay(d, obj.(*EglGetCurrentDisplay))
}
func (c *binaryClassEglGetCurrentDisplay) Schema() *binary.Entity {
	return &entities[ixǁEglGetCurrentDisplay]
}

type binaryClassEglGetCurrentSurface struct{}

func (*EglGetCurrentSurface) Class() binary.Class {
	return (*binaryClassEglGetCurrentSurface)(nil)
}
func doEncodeEglGetCurrentSurface(e binary.Encoder, o *EglGetCurrentSurface) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int64(int64(o.Readdraw))
	e.Simple(&o.Result)
}
func doDecodeEglGetCurrentSurface(d binary.Decoder, o *EglGetCurrentSurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Readdraw = EGLint(d.Int64())
	d.Simple(&o.Result)
}
func doDecodeRawEglGetCurrentSurface(d binary.Decoder, o *EglGetCurrentSurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Readdraw = EGLint(d.Int64())
	d.Simple(&o.Result)
}
func (*binaryClassEglGetCurrentSurface) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglGetCurrentSurface(e, obj.(*EglGetCurrentSurface))
}
func (*binaryClassEglGetCurrentSurface) New() binary.Object {
	return &EglGetCurrentSurface{}
}
func (*binaryClassEglGetCurrentSurface) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglGetCurrentSurface(d, obj.(*EglGetCurrentSurface))
}
func (c *binaryClassEglGetCurrentSurface) Schema() *binary.Entity {
	return &entities[ixǁEglGetCurrentSurface]
}

type binaryClassEglGetDisplay struct{}

func (*EglGetDisplay) Class() binary.Class {
	return (*binaryClassEglGetDisplay)(nil)
}
func doEncodeEglGetDisplay(e binary.Encoder, o *EglGetDisplay) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int64(int64(o.NativeDisplay))
	e.Simple(&o.Result)
}
func doDecodeEglGetDisplay(d binary.Decoder, o *EglGetDisplay) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NativeDisplay = EGLNativeDisplayType(d.Int64())
	d.Simple(&o.Result)
}
func doDecodeRawEglGetDisplay(d binary.Decoder, o *EglGetDisplay) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NativeDisplay = EGLNativeDisplayType(d.Int64())
	d.Simple(&o.Result)
}
func (*binaryClassEglGetDisplay) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglGetDisplay(e, obj.(*EglGetDisplay))
}
func (*binaryClassEglGetDisplay) New() binary.Object {
	return &EglGetDisplay{}
}
func (*binaryClassEglGetDisplay) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglGetDisplay(d, obj.(*EglGetDisplay))
}
func (c *binaryClassEglGetDisplay) Schema() *binary.Entity {
	return &entities[ixǁEglGetDisplay]
}

type binaryClassEglGetError struct{}

func (*EglGetError) Class() binary.Class {
	return (*binaryClassEglGetError)(nil)
}
func doEncodeEglGetError(e binary.Encoder, o *EglGetError) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int64(int64(o.Result))
}
func doDecodeEglGetError(d binary.Decoder, o *EglGetError) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = EGLint(d.Int64())
}
func doDecodeRawEglGetError(d binary.Decoder, o *EglGetError) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = EGLint(d.Int64())
}
func (*binaryClassEglGetError) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglGetError(e, obj.(*EglGetError))
}
func (*binaryClassEglGetError) New() binary.Object {
	return &EglGetError{}
}
func (*binaryClassEglGetError) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglGetError(d, obj.(*EglGetError))
}
func (c *binaryClassEglGetError) Schema() *binary.Entity {
	return &entities[ixǁEglGetError]
}

type binaryClassEglGetSyncAttribKHR struct{}

func (*EglGetSyncAttribKHR) Class() binary.Class {
	return (*binaryClassEglGetSyncAttribKHR)(nil)
}
func doEncodeEglGetSyncAttribKHR(e binary.Encoder, o *EglGetSyncAttribKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Dpy)
	e.Simple(&o.Sync)
	e.Int64(int64(o.Attribute))
	e.Simple(&o.Value)
	e.Int64(int64(o.Result))
}
func doDecodeEglGetSyncAttribKHR(d binary.Decoder, o *EglGetSyncAttribKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Sync)
	o.Attribute = EGLint(d.Int64())
	d.Simple(&o.Value)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglGetSyncAttribKHR(d binary.Decoder, o *EglGetSyncAttribKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Sync)
	o.Attribute = EGLint(d.Int64())
	d.Simple(&o.Value)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglGetSyncAttribKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglGetSyncAttribKHR(e, obj.(*EglGetSyncAttribKHR))
}
func (*binaryClassEglGetSyncAttribKHR) New() binary.Object {
	return &EglGetSyncAttribKHR{}
}
func (*binaryClassEglGetSyncAttribKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglGetSyncAttribKHR(d, obj.(*EglGetSyncAttribKHR))
}
func (c *binaryClassEglGetSyncAttribKHR) Schema() *binary.Entity {
	return &entities[ixǁEglGetSyncAttribKHR]
}

type binaryClassEglInitialize struct{}

func (*EglInitialize) Class() binary.Class {
	return (*binaryClassEglInitialize)(nil)
}
func doEncodeEglInitialize(e binary.Encoder, o *EglInitialize) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Dpy)
	e.Simple(&o.Major)
	e.Simple(&o.Minor)
	e.Int64(int64(o.Result))
}
func doDecodeEglInitialize(d binary.Decoder, o *EglInitialize) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Major)
	d.Simple(&o.Minor)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglInitialize(d binary.Decoder, o *EglInitialize) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Major)
	d.Simple(&o.Minor)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglInitialize) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglInitialize(e, obj.(*EglInitialize))
}
func (*binaryClassEglInitialize) New() binary.Object {
	return &EglInitialize{}
}
func (*binaryClassEglInitialize) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglInitialize(d, obj.(*EglInitialize))
}
func (c *binaryClassEglInitialize) Schema() *binary.Entity {
	return &entities[ixǁEglInitialize]
}

type binaryClassEglMakeCurrent struct{}

func (*EglMakeCurrent) Class() binary.Class {
	return (*binaryClassEglMakeCurrent)(nil)
}
func doEncodeEglMakeCurrent(e binary.Encoder, o *EglMakeCurrent) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Draw)
	e.Simple(&o.Read)
	e.Simple(&o.Context)
	e.Int64(int64(o.Result))
}
func doDecodeEglMakeCurrent(d binary.Decoder, o *EglMakeCurrent) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Draw)
	d.Simple(&o.Read)
	d.Simple(&o.Context)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglMakeCurrent(d binary.Decoder, o *EglMakeCurrent) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Draw)
	d.Simple(&o.Read)
	d.Simple(&o.Context)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglMakeCurrent) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglMakeCurrent(e, obj.(*EglMakeCurrent))
}
func (*binaryClassEglMakeCurrent) New() binary.Object {
	return &EglMakeCurrent{}
}
func (*binaryClassEglMakeCurrent) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglMakeCurrent(d, obj.(*EglMakeCurrent))
}
func (c *binaryClassEglMakeCurrent) Schema() *binary.Entity {
	return &entities[ixǁEglMakeCurrent]
}

type binaryClassEglQueryAPI struct{}

func (*EglQueryAPI) Class() binary.Class {
	return (*binaryClassEglQueryAPI)(nil)
}
func doEncodeEglQueryAPI(e binary.Encoder, o *EglQueryAPI) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Result))
}
func doDecodeEglQueryAPI(d binary.Decoder, o *EglQueryAPI) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = EGLenum(d.Uint32())
}
func doDecodeRawEglQueryAPI(d binary.Decoder, o *EglQueryAPI) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = EGLenum(d.Uint32())
}
func (*binaryClassEglQueryAPI) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglQueryAPI(e, obj.(*EglQueryAPI))
}
func (*binaryClassEglQueryAPI) New() binary.Object {
	return &EglQueryAPI{}
}
func (*binaryClassEglQueryAPI) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglQueryAPI(d, obj.(*EglQueryAPI))
}
func (c *binaryClassEglQueryAPI) Schema() *binary.Entity {
	return &entities[ixǁEglQueryAPI]
}

type binaryClassEglQueryContext struct{}

func (*EglQueryContext) Class() binary.Class {
	return (*binaryClassEglQueryContext)(nil)
}
func doEncodeEglQueryContext(e binary.Encoder, o *EglQueryContext) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Context)
	e.Int64(int64(o.Attribute))
	e.Simple(&o.Value)
	e.Int64(int64(o.Result))
}
func doDecodeEglQueryContext(d binary.Decoder, o *EglQueryContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Context)
	o.Attribute = EGLint(d.Int64())
	d.Simple(&o.Value)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglQueryContext(d binary.Decoder, o *EglQueryContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Context)
	o.Attribute = EGLint(d.Int64())
	d.Simple(&o.Value)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglQueryContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglQueryContext(e, obj.(*EglQueryContext))
}
func (*binaryClassEglQueryContext) New() binary.Object {
	return &EglQueryContext{}
}
func (*binaryClassEglQueryContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglQueryContext(d, obj.(*EglQueryContext))
}
func (c *binaryClassEglQueryContext) Schema() *binary.Entity {
	return &entities[ixǁEglQueryContext]
}

type binaryClassEglQueryString struct{}

func (*EglQueryString) Class() binary.Class {
	return (*binaryClassEglQueryString)(nil)
}
func doEncodeEglQueryString(e binary.Encoder, o *EglQueryString) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Int64(int64(o.Name))
	e.Simple(&o.Result)
}
func doDecodeEglQueryString(d binary.Decoder, o *EglQueryString) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	o.Name = EGLint(d.Int64())
	d.Simple(&o.Result)
}
func doDecodeRawEglQueryString(d binary.Decoder, o *EglQueryString) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	o.Name = EGLint(d.Int64())
	d.Simple(&o.Result)
}
func (*binaryClassEglQueryString) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglQueryString(e, obj.(*EglQueryString))
}
func (*binaryClassEglQueryString) New() binary.Object {
	return &EglQueryString{}
}
func (*binaryClassEglQueryString) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglQueryString(d, obj.(*EglQueryString))
}
func (c *binaryClassEglQueryString) Schema() *binary.Entity {
	return &entities[ixǁEglQueryString]
}

type binaryClassEglQuerySurface struct{}

func (*EglQuerySurface) Class() binary.Class {
	return (*binaryClassEglQuerySurface)(nil)
}
func doEncodeEglQuerySurface(e binary.Encoder, o *EglQuerySurface) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Surface)
	e.Int64(int64(o.Attribute))
	e.Simple(&o.Value)
	e.Int64(int64(o.Result))
}
func doDecodeEglQuerySurface(d binary.Decoder, o *EglQuerySurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	o.Attribute = EGLint(d.Int64())
	d.Simple(&o.Value)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglQuerySurface(d binary.Decoder, o *EglQuerySurface) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	o.Attribute = EGLint(d.Int64())
	d.Simple(&o.Value)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglQuerySurface) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglQuerySurface(e, obj.(*EglQuerySurface))
}
func (*binaryClassEglQuerySurface) New() binary.Object {
	return &EglQuerySurface{}
}
func (*binaryClassEglQuerySurface) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglQuerySurface(d, obj.(*EglQuerySurface))
}
func (c *binaryClassEglQuerySurface) Schema() *binary.Entity {
	return &entities[ixǁEglQuerySurface]
}

type binaryClassEglReleaseTexImage struct{}

func (*EglReleaseTexImage) Class() binary.Class {
	return (*binaryClassEglReleaseTexImage)(nil)
}
func doEncodeEglReleaseTexImage(e binary.Encoder, o *EglReleaseTexImage) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Surface)
	e.Int64(int64(o.Buffer))
	e.Int64(int64(o.Result))
}
func doDecodeEglReleaseTexImage(d binary.Decoder, o *EglReleaseTexImage) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	o.Buffer = EGLint(d.Int64())
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglReleaseTexImage(d binary.Decoder, o *EglReleaseTexImage) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	o.Buffer = EGLint(d.Int64())
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglReleaseTexImage) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglReleaseTexImage(e, obj.(*EglReleaseTexImage))
}
func (*binaryClassEglReleaseTexImage) New() binary.Object {
	return &EglReleaseTexImage{}
}
func (*binaryClassEglReleaseTexImage) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglReleaseTexImage(d, obj.(*EglReleaseTexImage))
}
func (c *binaryClassEglReleaseTexImage) Schema() *binary.Entity {
	return &entities[ixǁEglReleaseTexImage]
}

type binaryClassEglReleaseThread struct{}

func (*EglReleaseThread) Class() binary.Class {
	return (*binaryClassEglReleaseThread)(nil)
}
func doEncodeEglReleaseThread(e binary.Encoder, o *EglReleaseThread) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int64(int64(o.Result))
}
func doDecodeEglReleaseThread(d binary.Decoder, o *EglReleaseThread) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglReleaseThread(d binary.Decoder, o *EglReleaseThread) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglReleaseThread) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglReleaseThread(e, obj.(*EglReleaseThread))
}
func (*binaryClassEglReleaseThread) New() binary.Object {
	return &EglReleaseThread{}
}
func (*binaryClassEglReleaseThread) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglReleaseThread(d, obj.(*EglReleaseThread))
}
func (c *binaryClassEglReleaseThread) Schema() *binary.Entity {
	return &entities[ixǁEglReleaseThread]
}

type binaryClassEglSignalSyncKHR struct{}

func (*EglSignalSyncKHR) Class() binary.Class {
	return (*binaryClassEglSignalSyncKHR)(nil)
}
func doEncodeEglSignalSyncKHR(e binary.Encoder, o *EglSignalSyncKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Dpy)
	e.Simple(&o.Sync)
	e.Uint32(uint32(o.Mode))
	e.Int64(int64(o.Result))
}
func doDecodeEglSignalSyncKHR(d binary.Decoder, o *EglSignalSyncKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Sync)
	o.Mode = EGLenum(d.Uint32())
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglSignalSyncKHR(d binary.Decoder, o *EglSignalSyncKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Sync)
	o.Mode = EGLenum(d.Uint32())
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglSignalSyncKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglSignalSyncKHR(e, obj.(*EglSignalSyncKHR))
}
func (*binaryClassEglSignalSyncKHR) New() binary.Object {
	return &EglSignalSyncKHR{}
}
func (*binaryClassEglSignalSyncKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglSignalSyncKHR(d, obj.(*EglSignalSyncKHR))
}
func (c *binaryClassEglSignalSyncKHR) Schema() *binary.Entity {
	return &entities[ixǁEglSignalSyncKHR]
}

type binaryClassEglSurfaceAttrib struct{}

func (*EglSurfaceAttrib) Class() binary.Class {
	return (*binaryClassEglSurfaceAttrib)(nil)
}
func doEncodeEglSurfaceAttrib(e binary.Encoder, o *EglSurfaceAttrib) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Surface)
	e.Int64(int64(o.Attribute))
	e.Int64(int64(o.Value))
	e.Int64(int64(o.Result))
}
func doDecodeEglSurfaceAttrib(d binary.Decoder, o *EglSurfaceAttrib) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	o.Attribute = EGLint(d.Int64())
	o.Value = EGLint(d.Int64())
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglSurfaceAttrib(d binary.Decoder, o *EglSurfaceAttrib) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	o.Attribute = EGLint(d.Int64())
	o.Value = EGLint(d.Int64())
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglSurfaceAttrib) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglSurfaceAttrib(e, obj.(*EglSurfaceAttrib))
}
func (*binaryClassEglSurfaceAttrib) New() binary.Object {
	return &EglSurfaceAttrib{}
}
func (*binaryClassEglSurfaceAttrib) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglSurfaceAttrib(d, obj.(*EglSurfaceAttrib))
}
func (c *binaryClassEglSurfaceAttrib) Schema() *binary.Entity {
	return &entities[ixǁEglSurfaceAttrib]
}

type binaryClassVoidᵖ struct{}

func (*Voidᵖ) Class() binary.Class {
	return (*binaryClassVoidᵖ)(nil)
}
func doEncodeVoidᵖ(e binary.Writer, o *Voidᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVoidᵖ(d binary.Reader, o *Voidᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVoidᵖ(d binary.Reader, o *Voidᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVoidᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVoidᵖ(e, obj.(*Voidᵖ))
}
func (*binaryClassVoidᵖ) New() binary.Object {
	return &Voidᵖ{}
}
func (*binaryClassVoidᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVoidᵖ(d, obj.(*Voidᵖ))
}
func (o *Voidᵖ) WriteSimple(w binary.Writer) {
	doEncodeVoidᵖ(w, o)
}
func (o *Voidᵖ) ReadSimple(r binary.Reader) {
	doDecodeVoidᵖ(r, o)
}
func (c *binaryClassVoidᵖ) Schema() *binary.Entity {
	return &entities[ixǁVoidᵖ]
}

type binaryClassEglSwapBuffers struct{}

func (*EglSwapBuffers) Class() binary.Class {
	return (*binaryClassEglSwapBuffers)(nil)
}
func doEncodeEglSwapBuffers(e binary.Encoder, o *EglSwapBuffers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Surface)
	e.Int64(int64(o.Result))
}
func doDecodeEglSwapBuffers(d binary.Decoder, o *EglSwapBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglSwapBuffers(d binary.Decoder, o *EglSwapBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Surface)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglSwapBuffers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglSwapBuffers(e, obj.(*EglSwapBuffers))
}
func (*binaryClassEglSwapBuffers) New() binary.Object {
	return &EglSwapBuffers{}
}
func (*binaryClassEglSwapBuffers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglSwapBuffers(d, obj.(*EglSwapBuffers))
}
func (c *binaryClassEglSwapBuffers) Schema() *binary.Entity {
	return &entities[ixǁEglSwapBuffers]
}

type binaryClassEglSwapBuffersWithDamageKHR struct{}

func (*EglSwapBuffersWithDamageKHR) Class() binary.Class {
	return (*binaryClassEglSwapBuffersWithDamageKHR)(nil)
}
func doEncodeEglSwapBuffersWithDamageKHR(e binary.Encoder, o *EglSwapBuffersWithDamageKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Dpy)
	e.Simple(&o.Surface)
	e.Simple(&o.Rects)
	e.Int64(int64(o.NRects))
	e.Int64(int64(o.Result))
}
func doDecodeEglSwapBuffersWithDamageKHR(d binary.Decoder, o *EglSwapBuffersWithDamageKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Surface)
	d.Simple(&o.Rects)
	o.NRects = EGLint(d.Int64())
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglSwapBuffersWithDamageKHR(d binary.Decoder, o *EglSwapBuffersWithDamageKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Surface)
	d.Simple(&o.Rects)
	o.NRects = EGLint(d.Int64())
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglSwapBuffersWithDamageKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglSwapBuffersWithDamageKHR(e, obj.(*EglSwapBuffersWithDamageKHR))
}
func (*binaryClassEglSwapBuffersWithDamageKHR) New() binary.Object {
	return &EglSwapBuffersWithDamageKHR{}
}
func (*binaryClassEglSwapBuffersWithDamageKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglSwapBuffersWithDamageKHR(d, obj.(*EglSwapBuffersWithDamageKHR))
}
func (c *binaryClassEglSwapBuffersWithDamageKHR) Schema() *binary.Entity {
	return &entities[ixǁEglSwapBuffersWithDamageKHR]
}

type binaryClassEglSwapInterval struct{}

func (*EglSwapInterval) Class() binary.Class {
	return (*binaryClassEglSwapInterval)(nil)
}
func doEncodeEglSwapInterval(e binary.Encoder, o *EglSwapInterval) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Int64(int64(o.Interval))
	e.Int64(int64(o.Result))
}
func doDecodeEglSwapInterval(d binary.Decoder, o *EglSwapInterval) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	o.Interval = EGLint(d.Int64())
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglSwapInterval(d binary.Decoder, o *EglSwapInterval) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	o.Interval = EGLint(d.Int64())
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglSwapInterval) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglSwapInterval(e, obj.(*EglSwapInterval))
}
func (*binaryClassEglSwapInterval) New() binary.Object {
	return &EglSwapInterval{}
}
func (*binaryClassEglSwapInterval) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglSwapInterval(d, obj.(*EglSwapInterval))
}
func (c *binaryClassEglSwapInterval) Schema() *binary.Entity {
	return &entities[ixǁEglSwapInterval]
}

type binaryClassEglTerminate struct{}

func (*EglTerminate) Class() binary.Class {
	return (*binaryClassEglTerminate)(nil)
}
func doEncodeEglTerminate(e binary.Encoder, o *EglTerminate) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Int64(int64(o.Result))
}
func doDecodeEglTerminate(d binary.Decoder, o *EglTerminate) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglTerminate(d binary.Decoder, o *EglTerminate) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglTerminate) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglTerminate(e, obj.(*EglTerminate))
}
func (*binaryClassEglTerminate) New() binary.Object {
	return &EglTerminate{}
}
func (*binaryClassEglTerminate) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglTerminate(d, obj.(*EglTerminate))
}
func (c *binaryClassEglTerminate) Schema() *binary.Entity {
	return &entities[ixǁEglTerminate]
}

type binaryClassEglWaitClient struct{}

func (*EglWaitClient) Class() binary.Class {
	return (*binaryClassEglWaitClient)(nil)
}
func doEncodeEglWaitClient(e binary.Encoder, o *EglWaitClient) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int64(int64(o.Result))
}
func doDecodeEglWaitClient(d binary.Decoder, o *EglWaitClient) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglWaitClient(d binary.Decoder, o *EglWaitClient) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglWaitClient) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglWaitClient(e, obj.(*EglWaitClient))
}
func (*binaryClassEglWaitClient) New() binary.Object {
	return &EglWaitClient{}
}
func (*binaryClassEglWaitClient) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglWaitClient(d, obj.(*EglWaitClient))
}
func (c *binaryClassEglWaitClient) Schema() *binary.Entity {
	return &entities[ixǁEglWaitClient]
}

type binaryClassEglWaitGL struct{}

func (*EglWaitGL) Class() binary.Class {
	return (*binaryClassEglWaitGL)(nil)
}
func doEncodeEglWaitGL(e binary.Encoder, o *EglWaitGL) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int64(int64(o.Result))
}
func doDecodeEglWaitGL(d binary.Decoder, o *EglWaitGL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglWaitGL(d binary.Decoder, o *EglWaitGL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglWaitGL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglWaitGL(e, obj.(*EglWaitGL))
}
func (*binaryClassEglWaitGL) New() binary.Object {
	return &EglWaitGL{}
}
func (*binaryClassEglWaitGL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglWaitGL(d, obj.(*EglWaitGL))
}
func (c *binaryClassEglWaitGL) Schema() *binary.Entity {
	return &entities[ixǁEglWaitGL]
}

type binaryClassEglWaitNative struct{}

func (*EglWaitNative) Class() binary.Class {
	return (*binaryClassEglWaitNative)(nil)
}
func doEncodeEglWaitNative(e binary.Encoder, o *EglWaitNative) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int64(int64(o.Engine))
	e.Int64(int64(o.Result))
}
func doDecodeEglWaitNative(d binary.Decoder, o *EglWaitNative) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Engine = EGLint(d.Int64())
	o.Result = EGLBoolean(d.Int64())
}
func doDecodeRawEglWaitNative(d binary.Decoder, o *EglWaitNative) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Engine = EGLint(d.Int64())
	o.Result = EGLBoolean(d.Int64())
}
func (*binaryClassEglWaitNative) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeEglWaitNative(e, obj.(*EglWaitNative))
}
func (*binaryClassEglWaitNative) New() binary.Object {
	return &EglWaitNative{}
}
func (*binaryClassEglWaitNative) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeEglWaitNative(d, obj.(*EglWaitNative))
}
func (c *binaryClassEglWaitNative) Schema() *binary.Entity {
	return &entities[ixǁEglWaitNative]
}

type binaryClassErrorState struct{}

func (*ErrorState) Class() binary.Class {
	return (*binaryClassErrorState)(nil)
}
func doEncodeErrorState(e binary.Writer, o *ErrorState) {
	e.Uint32(uint32(o.TraceDriversGlError))
	e.Uint32(uint32(o.InterceptorsGlError))
}
func doDecodeErrorState(d binary.Reader, o *ErrorState) {
	o.TraceDriversGlError = GLenum(d.Uint32())
	o.InterceptorsGlError = GLenum(d.Uint32())
}
func doDecodeRawErrorState(d binary.Reader, o *ErrorState) {
	o.TraceDriversGlError = GLenum(d.Uint32())
	o.InterceptorsGlError = GLenum(d.Uint32())
}
func (*binaryClassErrorState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeErrorState(e, obj.(*ErrorState))
}
func (*binaryClassErrorState) New() binary.Object {
	return &ErrorState{}
}
func (*binaryClassErrorState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeErrorState(d, obj.(*ErrorState))
}
func (o *ErrorState) WriteSimple(w binary.Writer) {
	doEncodeErrorState(w, o)
}
func (o *ErrorState) ReadSimple(r binary.Reader) {
	doDecodeErrorState(r, o)
}
func (c *binaryClassErrorState) Schema() *binary.Entity {
	return &entities[ixǁErrorState]
}

type binaryClassF64ˢ struct{}

func (*F64ˢ) Class() binary.Class {
	return (*binaryClassF64ˢ)(nil)
}
func doEncodeF64ˢ(e binary.Writer, o *F64ˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeF64ˢ(d binary.Reader, o *F64ˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawF64ˢ(d binary.Reader, o *F64ˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassF64ˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeF64ˢ(e, obj.(*F64ˢ))
}
func (*binaryClassF64ˢ) New() binary.Object {
	return &F64ˢ{}
}
func (*binaryClassF64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeF64ˢ(d, obj.(*F64ˢ))
}
func (o *F64ˢ) WriteSimple(w binary.Writer) {
	doEncodeF64ˢ(w, o)
}
func (o *F64ˢ) ReadSimple(r binary.Reader) {
	doDecodeF64ˢ(r, o)
}
func (c *binaryClassF64ˢ) Schema() *binary.Entity {
	return &entities[ixǁF64ˢ]
}

type binaryClassFlushPostBuffer struct{}

func (*FlushPostBuffer) Class() binary.Class {
	return (*binaryClassFlushPostBuffer)(nil)
}
func doEncodeFlushPostBuffer(e binary.Encoder, o *FlushPostBuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeFlushPostBuffer(d binary.Decoder, o *FlushPostBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawFlushPostBuffer(d binary.Decoder, o *FlushPostBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassFlushPostBuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeFlushPostBuffer(e, obj.(*FlushPostBuffer))
}
func (*binaryClassFlushPostBuffer) New() binary.Object {
	return &FlushPostBuffer{}
}
func (*binaryClassFlushPostBuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeFlushPostBuffer(d, obj.(*FlushPostBuffer))
}
func (c *binaryClassFlushPostBuffer) Schema() *binary.Entity {
	return &entities[ixǁFlushPostBuffer]
}

type binaryClassFramebufferIdˢ struct{}

func (*FramebufferIdˢ) Class() binary.Class {
	return (*binaryClassFramebufferIdˢ)(nil)
}
func doEncodeFramebufferIdˢ(e binary.Writer, o *FramebufferIdˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeFramebufferIdˢ(d binary.Reader, o *FramebufferIdˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawFramebufferIdˢ(d binary.Reader, o *FramebufferIdˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassFramebufferIdˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeFramebufferIdˢ(e, obj.(*FramebufferIdˢ))
}
func (*binaryClassFramebufferIdˢ) New() binary.Object {
	return &FramebufferIdˢ{}
}
func (*binaryClassFramebufferIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeFramebufferIdˢ(d, obj.(*FramebufferIdˢ))
}
func (o *FramebufferIdˢ) WriteSimple(w binary.Writer) {
	doEncodeFramebufferIdˢ(w, o)
}
func (o *FramebufferIdˢ) ReadSimple(r binary.Reader) {
	doDecodeFramebufferIdˢ(r, o)
}
func (c *binaryClassFramebufferIdˢ) Schema() *binary.Entity {
	return &entities[ixǁFramebufferIdˢ]
}

type binaryClassFramebufferIdᵖ struct{}

func (*FramebufferIdᵖ) Class() binary.Class {
	return (*binaryClassFramebufferIdᵖ)(nil)
}
func doEncodeFramebufferIdᵖ(e binary.Writer, o *FramebufferIdᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeFramebufferIdᵖ(d binary.Reader, o *FramebufferIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawFramebufferIdᵖ(d binary.Reader, o *FramebufferIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassFramebufferIdᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeFramebufferIdᵖ(e, obj.(*FramebufferIdᵖ))
}
func (*binaryClassFramebufferIdᵖ) New() binary.Object {
	return &FramebufferIdᵖ{}
}
func (*binaryClassFramebufferIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeFramebufferIdᵖ(d, obj.(*FramebufferIdᵖ))
}
func (o *FramebufferIdᵖ) WriteSimple(w binary.Writer) {
	doEncodeFramebufferIdᵖ(w, o)
}
func (o *FramebufferIdᵖ) ReadSimple(r binary.Reader) {
	doDecodeFramebufferIdᵖ(r, o)
}
func (c *binaryClassFramebufferIdᵖ) Schema() *binary.Entity {
	return &entities[ixǁFramebufferIdᵖ]
}

type binaryClassFramebufferIdᶜᵖ struct{}

func (*FramebufferIdᶜᵖ) Class() binary.Class {
	return (*binaryClassFramebufferIdᶜᵖ)(nil)
}
func doEncodeFramebufferIdᶜᵖ(e binary.Writer, o *FramebufferIdᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeFramebufferIdᶜᵖ(d binary.Reader, o *FramebufferIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawFramebufferIdᶜᵖ(d binary.Reader, o *FramebufferIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassFramebufferIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeFramebufferIdᶜᵖ(e, obj.(*FramebufferIdᶜᵖ))
}
func (*binaryClassFramebufferIdᶜᵖ) New() binary.Object {
	return &FramebufferIdᶜᵖ{}
}
func (*binaryClassFramebufferIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeFramebufferIdᶜᵖ(d, obj.(*FramebufferIdᶜᵖ))
}
func (o *FramebufferIdᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeFramebufferIdᶜᵖ(w, o)
}
func (o *FramebufferIdᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeFramebufferIdᶜᵖ(r, o)
}
func (c *binaryClassFramebufferIdᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁFramebufferIdᶜᵖ]
}

type binaryClassGLXContext struct{}

func (*GLXContext) Class() binary.Class {
	return (*binaryClassGLXContext)(nil)
}
func doEncodeGLXContext(e binary.Writer, o *GLXContext) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLXContext(d binary.Reader, o *GLXContext) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLXContext(d binary.Reader, o *GLXContext) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLXContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLXContext(e, obj.(*GLXContext))
}
func (*binaryClassGLXContext) New() binary.Object {
	return &GLXContext{}
}
func (*binaryClassGLXContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLXContext(d, obj.(*GLXContext))
}
func (o *GLXContext) WriteSimple(w binary.Writer) {
	doEncodeGLXContext(w, o)
}
func (o *GLXContext) ReadSimple(r binary.Reader) {
	doDecodeGLXContext(r, o)
}
func (c *binaryClassGLXContext) Schema() *binary.Entity {
	return &entities[ixǁGLXContext]
}

type binaryClassGLXDrawable struct{}

func (*GLXDrawable) Class() binary.Class {
	return (*binaryClassGLXDrawable)(nil)
}
func doEncodeGLXDrawable(e binary.Writer, o *GLXDrawable) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLXDrawable(d binary.Reader, o *GLXDrawable) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLXDrawable(d binary.Reader, o *GLXDrawable) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLXDrawable) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLXDrawable(e, obj.(*GLXDrawable))
}
func (*binaryClassGLXDrawable) New() binary.Object {
	return &GLXDrawable{}
}
func (*binaryClassGLXDrawable) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLXDrawable(d, obj.(*GLXDrawable))
}
func (o *GLXDrawable) WriteSimple(w binary.Writer) {
	doEncodeGLXDrawable(w, o)
}
func (o *GLXDrawable) ReadSimple(r binary.Reader) {
	doDecodeGLXDrawable(r, o)
}
func (c *binaryClassGLXDrawable) Schema() *binary.Entity {
	return &entities[ixǁGLXDrawable]
}

type binaryClassGLbooleanː4ᵃ struct{}

func (*GLbooleanː4ᵃ) Class() binary.Class {
	return (*binaryClassGLbooleanː4ᵃ)(nil)
}
func doEncodeGLbooleanː4ᵃ(e binary.Writer, o *GLbooleanː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Uint8(uint8(*curr))
	}
}
func doDecodeGLbooleanː4ᵃ(d binary.Reader, o *GLbooleanː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLboolean(d.Uint8())
	}
}
func doDecodeRawGLbooleanː4ᵃ(d binary.Reader, o *GLbooleanː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLboolean(d.Uint8())
	}
}
func (*binaryClassGLbooleanː4ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLbooleanː4ᵃ(e, obj.(*GLbooleanː4ᵃ))
}
func (*binaryClassGLbooleanː4ᵃ) New() binary.Object {
	return &GLbooleanː4ᵃ{}
}
func (*binaryClassGLbooleanː4ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLbooleanː4ᵃ(d, obj.(*GLbooleanː4ᵃ))
}
func (o *GLbooleanː4ᵃ) WriteSimple(w binary.Writer) {
	doEncodeGLbooleanː4ᵃ(w, o)
}
func (o *GLbooleanː4ᵃ) ReadSimple(r binary.Reader) {
	doDecodeGLbooleanː4ᵃ(r, o)
}
func (c *binaryClassGLbooleanː4ᵃ) Schema() *binary.Entity {
	return &entities[ixǁGLbooleanː4ᵃ]
}

type binaryClassGLbooleanˢ struct{}

func (*GLbooleanˢ) Class() binary.Class {
	return (*binaryClassGLbooleanˢ)(nil)
}
func doEncodeGLbooleanˢ(e binary.Writer, o *GLbooleanˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLbooleanˢ(d binary.Reader, o *GLbooleanˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLbooleanˢ(d binary.Reader, o *GLbooleanˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLbooleanˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLbooleanˢ(e, obj.(*GLbooleanˢ))
}
func (*binaryClassGLbooleanˢ) New() binary.Object {
	return &GLbooleanˢ{}
}
func (*binaryClassGLbooleanˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLbooleanˢ(d, obj.(*GLbooleanˢ))
}
func (o *GLbooleanˢ) WriteSimple(w binary.Writer) {
	doEncodeGLbooleanˢ(w, o)
}
func (o *GLbooleanˢ) ReadSimple(r binary.Reader) {
	doDecodeGLbooleanˢ(r, o)
}
func (c *binaryClassGLbooleanˢ) Schema() *binary.Entity {
	return &entities[ixǁGLbooleanˢ]
}

type binaryClassGLbooleanᵖ struct{}

func (*GLbooleanᵖ) Class() binary.Class {
	return (*binaryClassGLbooleanᵖ)(nil)
}
func doEncodeGLbooleanᵖ(e binary.Writer, o *GLbooleanᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLbooleanᵖ(d binary.Reader, o *GLbooleanᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLbooleanᵖ(d binary.Reader, o *GLbooleanᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLbooleanᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLbooleanᵖ(e, obj.(*GLbooleanᵖ))
}
func (*binaryClassGLbooleanᵖ) New() binary.Object {
	return &GLbooleanᵖ{}
}
func (*binaryClassGLbooleanᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLbooleanᵖ(d, obj.(*GLbooleanᵖ))
}
func (o *GLbooleanᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLbooleanᵖ(w, o)
}
func (o *GLbooleanᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLbooleanᵖ(r, o)
}
func (c *binaryClassGLbooleanᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLbooleanᵖ]
}

type binaryClassGLcharᵖ struct{}

func (*GLcharᵖ) Class() binary.Class {
	return (*binaryClassGLcharᵖ)(nil)
}
func doEncodeGLcharᵖ(e binary.Writer, o *GLcharᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLcharᵖ(d binary.Reader, o *GLcharᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLcharᵖ(d binary.Reader, o *GLcharᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLcharᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLcharᵖ(e, obj.(*GLcharᵖ))
}
func (*binaryClassGLcharᵖ) New() binary.Object {
	return &GLcharᵖ{}
}
func (*binaryClassGLcharᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLcharᵖ(d, obj.(*GLcharᵖ))
}
func (o *GLcharᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLcharᵖ(w, o)
}
func (o *GLcharᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLcharᵖ(r, o)
}
func (c *binaryClassGLcharᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLcharᵖ]
}

type binaryClassGLcharᶜᵖ struct{}

func (*GLcharᶜᵖ) Class() binary.Class {
	return (*binaryClassGLcharᶜᵖ)(nil)
}
func doEncodeGLcharᶜᵖ(e binary.Writer, o *GLcharᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLcharᶜᵖ(d binary.Reader, o *GLcharᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLcharᶜᵖ(d binary.Reader, o *GLcharᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLcharᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLcharᶜᵖ(e, obj.(*GLcharᶜᵖ))
}
func (*binaryClassGLcharᶜᵖ) New() binary.Object {
	return &GLcharᶜᵖ{}
}
func (*binaryClassGLcharᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLcharᶜᵖ(d, obj.(*GLcharᶜᵖ))
}
func (o *GLcharᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLcharᶜᵖ(w, o)
}
func (o *GLcharᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLcharᶜᵖ(r, o)
}
func (c *binaryClassGLcharᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLcharᶜᵖ]
}

type binaryClassGLcharᶜᵖˢ struct{}

func (*GLcharᶜᵖˢ) Class() binary.Class {
	return (*binaryClassGLcharᶜᵖˢ)(nil)
}
func doEncodeGLcharᶜᵖˢ(e binary.Writer, o *GLcharᶜᵖˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLcharᶜᵖˢ(d binary.Reader, o *GLcharᶜᵖˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLcharᶜᵖˢ(d binary.Reader, o *GLcharᶜᵖˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLcharᶜᵖˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLcharᶜᵖˢ(e, obj.(*GLcharᶜᵖˢ))
}
func (*binaryClassGLcharᶜᵖˢ) New() binary.Object {
	return &GLcharᶜᵖˢ{}
}
func (*binaryClassGLcharᶜᵖˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLcharᶜᵖˢ(d, obj.(*GLcharᶜᵖˢ))
}
func (o *GLcharᶜᵖˢ) WriteSimple(w binary.Writer) {
	doEncodeGLcharᶜᵖˢ(w, o)
}
func (o *GLcharᶜᵖˢ) ReadSimple(r binary.Reader) {
	doDecodeGLcharᶜᵖˢ(r, o)
}
func (c *binaryClassGLcharᶜᵖˢ) Schema() *binary.Entity {
	return &entities[ixǁGLcharᶜᵖˢ]
}

type binaryClassGLcharᶜᵖᵖ struct{}

func (*GLcharᶜᵖᵖ) Class() binary.Class {
	return (*binaryClassGLcharᶜᵖᵖ)(nil)
}
func doEncodeGLcharᶜᵖᵖ(e binary.Writer, o *GLcharᶜᵖᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLcharᶜᵖᵖ(d binary.Reader, o *GLcharᶜᵖᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLcharᶜᵖᵖ(d binary.Reader, o *GLcharᶜᵖᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLcharᶜᵖᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLcharᶜᵖᵖ(e, obj.(*GLcharᶜᵖᵖ))
}
func (*binaryClassGLcharᶜᵖᵖ) New() binary.Object {
	return &GLcharᶜᵖᵖ{}
}
func (*binaryClassGLcharᶜᵖᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLcharᶜᵖᵖ(d, obj.(*GLcharᶜᵖᵖ))
}
func (o *GLcharᶜᵖᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLcharᶜᵖᵖ(w, o)
}
func (o *GLcharᶜᵖᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLcharᶜᵖᵖ(r, o)
}
func (c *binaryClassGLcharᶜᵖᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLcharᶜᵖᵖ]
}

type binaryClassGLcharᶜᵖᶜᵖ struct{}

func (*GLcharᶜᵖᶜᵖ) Class() binary.Class {
	return (*binaryClassGLcharᶜᵖᶜᵖ)(nil)
}
func doEncodeGLcharᶜᵖᶜᵖ(e binary.Writer, o *GLcharᶜᵖᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLcharᶜᵖᶜᵖ(d binary.Reader, o *GLcharᶜᵖᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLcharᶜᵖᶜᵖ(d binary.Reader, o *GLcharᶜᵖᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLcharᶜᵖᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLcharᶜᵖᶜᵖ(e, obj.(*GLcharᶜᵖᶜᵖ))
}
func (*binaryClassGLcharᶜᵖᶜᵖ) New() binary.Object {
	return &GLcharᶜᵖᶜᵖ{}
}
func (*binaryClassGLcharᶜᵖᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLcharᶜᵖᶜᵖ(d, obj.(*GLcharᶜᵖᶜᵖ))
}
func (o *GLcharᶜᵖᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLcharᶜᵖᶜᵖ(w, o)
}
func (o *GLcharᶜᵖᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLcharᶜᵖᶜᵖ(r, o)
}
func (c *binaryClassGLcharᶜᵖᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLcharᶜᵖᶜᵖ]
}

type binaryClassGLeglImageOES struct{}

func (*GLeglImageOES) Class() binary.Class {
	return (*binaryClassGLeglImageOES)(nil)
}
func doEncodeGLeglImageOES(e binary.Writer, o *GLeglImageOES) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLeglImageOES(d binary.Reader, o *GLeglImageOES) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLeglImageOES(d binary.Reader, o *GLeglImageOES) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLeglImageOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLeglImageOES(e, obj.(*GLeglImageOES))
}
func (*binaryClassGLeglImageOES) New() binary.Object {
	return &GLeglImageOES{}
}
func (*binaryClassGLeglImageOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLeglImageOES(d, obj.(*GLeglImageOES))
}
func (o *GLeglImageOES) WriteSimple(w binary.Writer) {
	doEncodeGLeglImageOES(w, o)
}
func (o *GLeglImageOES) ReadSimple(r binary.Reader) {
	doDecodeGLeglImageOES(r, o)
}
func (c *binaryClassGLeglImageOES) Schema() *binary.Entity {
	return &entities[ixǁGLeglImageOES]
}

type binaryClassGLenumˢ struct{}

func (*GLenumˢ) Class() binary.Class {
	return (*binaryClassGLenumˢ)(nil)
}
func doEncodeGLenumˢ(e binary.Writer, o *GLenumˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLenumˢ(d binary.Reader, o *GLenumˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLenumˢ(d binary.Reader, o *GLenumˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLenumˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLenumˢ(e, obj.(*GLenumˢ))
}
func (*binaryClassGLenumˢ) New() binary.Object {
	return &GLenumˢ{}
}
func (*binaryClassGLenumˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLenumˢ(d, obj.(*GLenumˢ))
}
func (o *GLenumˢ) WriteSimple(w binary.Writer) {
	doEncodeGLenumˢ(w, o)
}
func (o *GLenumˢ) ReadSimple(r binary.Reader) {
	doDecodeGLenumˢ(r, o)
}
func (c *binaryClassGLenumˢ) Schema() *binary.Entity {
	return &entities[ixǁGLenumˢ]
}

type binaryClassGLenumᶜᵖ struct{}

func (*GLenumᶜᵖ) Class() binary.Class {
	return (*binaryClassGLenumᶜᵖ)(nil)
}
func doEncodeGLenumᶜᵖ(e binary.Writer, o *GLenumᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLenumᶜᵖ(d binary.Reader, o *GLenumᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLenumᶜᵖ(d binary.Reader, o *GLenumᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLenumᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLenumᶜᵖ(e, obj.(*GLenumᶜᵖ))
}
func (*binaryClassGLenumᶜᵖ) New() binary.Object {
	return &GLenumᶜᵖ{}
}
func (*binaryClassGLenumᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLenumᶜᵖ(d, obj.(*GLenumᶜᵖ))
}
func (o *GLenumᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLenumᶜᵖ(w, o)
}
func (o *GLenumᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLenumᶜᵖ(r, o)
}
func (c *binaryClassGLenumᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLenumᶜᵖ]
}

type binaryClassGLfixedˢ struct{}

func (*GLfixedˢ) Class() binary.Class {
	return (*binaryClassGLfixedˢ)(nil)
}
func doEncodeGLfixedˢ(e binary.Writer, o *GLfixedˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLfixedˢ(d binary.Reader, o *GLfixedˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLfixedˢ(d binary.Reader, o *GLfixedˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLfixedˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLfixedˢ(e, obj.(*GLfixedˢ))
}
func (*binaryClassGLfixedˢ) New() binary.Object {
	return &GLfixedˢ{}
}
func (*binaryClassGLfixedˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLfixedˢ(d, obj.(*GLfixedˢ))
}
func (o *GLfixedˢ) WriteSimple(w binary.Writer) {
	doEncodeGLfixedˢ(w, o)
}
func (o *GLfixedˢ) ReadSimple(r binary.Reader) {
	doDecodeGLfixedˢ(r, o)
}
func (c *binaryClassGLfixedˢ) Schema() *binary.Entity {
	return &entities[ixǁGLfixedˢ]
}

type binaryClassGLfixedᵖ struct{}

func (*GLfixedᵖ) Class() binary.Class {
	return (*binaryClassGLfixedᵖ)(nil)
}
func doEncodeGLfixedᵖ(e binary.Writer, o *GLfixedᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLfixedᵖ(d binary.Reader, o *GLfixedᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLfixedᵖ(d binary.Reader, o *GLfixedᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLfixedᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLfixedᵖ(e, obj.(*GLfixedᵖ))
}
func (*binaryClassGLfixedᵖ) New() binary.Object {
	return &GLfixedᵖ{}
}
func (*binaryClassGLfixedᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLfixedᵖ(d, obj.(*GLfixedᵖ))
}
func (o *GLfixedᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLfixedᵖ(w, o)
}
func (o *GLfixedᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLfixedᵖ(r, o)
}
func (c *binaryClassGLfixedᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLfixedᵖ]
}

type binaryClassGLfixedᶜᵖ struct{}

func (*GLfixedᶜᵖ) Class() binary.Class {
	return (*binaryClassGLfixedᶜᵖ)(nil)
}
func doEncodeGLfixedᶜᵖ(e binary.Writer, o *GLfixedᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLfixedᶜᵖ(d binary.Reader, o *GLfixedᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLfixedᶜᵖ(d binary.Reader, o *GLfixedᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLfixedᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLfixedᶜᵖ(e, obj.(*GLfixedᶜᵖ))
}
func (*binaryClassGLfixedᶜᵖ) New() binary.Object {
	return &GLfixedᶜᵖ{}
}
func (*binaryClassGLfixedᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLfixedᶜᵖ(d, obj.(*GLfixedᶜᵖ))
}
func (o *GLfixedᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLfixedᶜᵖ(w, o)
}
func (o *GLfixedᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLfixedᶜᵖ(r, o)
}
func (c *binaryClassGLfixedᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLfixedᶜᵖ]
}

type binaryClassGLfloatː1ᵃ struct{}

func (*GLfloatː1ᵃ) Class() binary.Class {
	return (*binaryClassGLfloatː1ᵃ)(nil)
}
func doEncodeGLfloatː1ᵃ(e binary.Writer, o *GLfloatː1ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Float32(float32(*curr))
	}
}
func doDecodeGLfloatː1ᵃ(d binary.Reader, o *GLfloatː1ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func doDecodeRawGLfloatː1ᵃ(d binary.Reader, o *GLfloatː1ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func (*binaryClassGLfloatː1ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLfloatː1ᵃ(e, obj.(*GLfloatː1ᵃ))
}
func (*binaryClassGLfloatː1ᵃ) New() binary.Object {
	return &GLfloatː1ᵃ{}
}
func (*binaryClassGLfloatː1ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLfloatː1ᵃ(d, obj.(*GLfloatː1ᵃ))
}
func (o *GLfloatː1ᵃ) WriteSimple(w binary.Writer) {
	doEncodeGLfloatː1ᵃ(w, o)
}
func (o *GLfloatː1ᵃ) ReadSimple(r binary.Reader) {
	doDecodeGLfloatː1ᵃ(r, o)
}
func (c *binaryClassGLfloatː1ᵃ) Schema() *binary.Entity {
	return &entities[ixǁGLfloatː1ᵃ]
}

type binaryClassGLfloatː3ᵃ struct{}

func (*GLfloatː3ᵃ) Class() binary.Class {
	return (*binaryClassGLfloatː3ᵃ)(nil)
}
func doEncodeGLfloatː3ᵃ(e binary.Writer, o *GLfloatː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Float32(float32(*curr))
	}
}
func doDecodeGLfloatː3ᵃ(d binary.Reader, o *GLfloatː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func doDecodeRawGLfloatː3ᵃ(d binary.Reader, o *GLfloatː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func (*binaryClassGLfloatː3ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLfloatː3ᵃ(e, obj.(*GLfloatː3ᵃ))
}
func (*binaryClassGLfloatː3ᵃ) New() binary.Object {
	return &GLfloatː3ᵃ{}
}
func (*binaryClassGLfloatː3ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLfloatː3ᵃ(d, obj.(*GLfloatː3ᵃ))
}
func (o *GLfloatː3ᵃ) WriteSimple(w binary.Writer) {
	doEncodeGLfloatː3ᵃ(w, o)
}
func (o *GLfloatː3ᵃ) ReadSimple(r binary.Reader) {
	doDecodeGLfloatː3ᵃ(r, o)
}
func (c *binaryClassGLfloatː3ᵃ) Schema() *binary.Entity {
	return &entities[ixǁGLfloatː3ᵃ]
}

type binaryClassGLfloatː4ᵃ struct{}

func (*GLfloatː4ᵃ) Class() binary.Class {
	return (*binaryClassGLfloatː4ᵃ)(nil)
}
func doEncodeGLfloatː4ᵃ(e binary.Writer, o *GLfloatː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Float32(float32(*curr))
	}
}
func doDecodeGLfloatː4ᵃ(d binary.Reader, o *GLfloatː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func doDecodeRawGLfloatː4ᵃ(d binary.Reader, o *GLfloatː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func (*binaryClassGLfloatː4ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLfloatː4ᵃ(e, obj.(*GLfloatː4ᵃ))
}
func (*binaryClassGLfloatː4ᵃ) New() binary.Object {
	return &GLfloatː4ᵃ{}
}
func (*binaryClassGLfloatː4ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLfloatː4ᵃ(d, obj.(*GLfloatː4ᵃ))
}
func (o *GLfloatː4ᵃ) WriteSimple(w binary.Writer) {
	doEncodeGLfloatː4ᵃ(w, o)
}
func (o *GLfloatː4ᵃ) ReadSimple(r binary.Reader) {
	doDecodeGLfloatː4ᵃ(r, o)
}
func (c *binaryClassGLfloatː4ᵃ) Schema() *binary.Entity {
	return &entities[ixǁGLfloatː4ᵃ]
}

type binaryClassGLfloatˢ struct{}

func (*GLfloatˢ) Class() binary.Class {
	return (*binaryClassGLfloatˢ)(nil)
}
func doEncodeGLfloatˢ(e binary.Writer, o *GLfloatˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLfloatˢ(d binary.Reader, o *GLfloatˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLfloatˢ(d binary.Reader, o *GLfloatˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLfloatˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLfloatˢ(e, obj.(*GLfloatˢ))
}
func (*binaryClassGLfloatˢ) New() binary.Object {
	return &GLfloatˢ{}
}
func (*binaryClassGLfloatˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLfloatˢ(d, obj.(*GLfloatˢ))
}
func (o *GLfloatˢ) WriteSimple(w binary.Writer) {
	doEncodeGLfloatˢ(w, o)
}
func (o *GLfloatˢ) ReadSimple(r binary.Reader) {
	doDecodeGLfloatˢ(r, o)
}
func (c *binaryClassGLfloatˢ) Schema() *binary.Entity {
	return &entities[ixǁGLfloatˢ]
}

type binaryClassGLfloatᵖ struct{}

func (*GLfloatᵖ) Class() binary.Class {
	return (*binaryClassGLfloatᵖ)(nil)
}
func doEncodeGLfloatᵖ(e binary.Writer, o *GLfloatᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLfloatᵖ(d binary.Reader, o *GLfloatᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLfloatᵖ(d binary.Reader, o *GLfloatᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLfloatᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLfloatᵖ(e, obj.(*GLfloatᵖ))
}
func (*binaryClassGLfloatᵖ) New() binary.Object {
	return &GLfloatᵖ{}
}
func (*binaryClassGLfloatᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLfloatᵖ(d, obj.(*GLfloatᵖ))
}
func (o *GLfloatᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLfloatᵖ(w, o)
}
func (o *GLfloatᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLfloatᵖ(r, o)
}
func (c *binaryClassGLfloatᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLfloatᵖ]
}

type binaryClassGLfloatᶜᵖ struct{}

func (*GLfloatᶜᵖ) Class() binary.Class {
	return (*binaryClassGLfloatᶜᵖ)(nil)
}
func doEncodeGLfloatᶜᵖ(e binary.Writer, o *GLfloatᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLfloatᶜᵖ(d binary.Reader, o *GLfloatᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLfloatᶜᵖ(d binary.Reader, o *GLfloatᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLfloatᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLfloatᶜᵖ(e, obj.(*GLfloatᶜᵖ))
}
func (*binaryClassGLfloatᶜᵖ) New() binary.Object {
	return &GLfloatᶜᵖ{}
}
func (*binaryClassGLfloatᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLfloatᶜᵖ(d, obj.(*GLfloatᶜᵖ))
}
func (o *GLfloatᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLfloatᶜᵖ(w, o)
}
func (o *GLfloatᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLfloatᶜᵖ(r, o)
}
func (c *binaryClassGLfloatᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLfloatᶜᵖ]
}

type binaryClassGLint64ˢ struct{}

func (*GLint64ˢ) Class() binary.Class {
	return (*binaryClassGLint64ˢ)(nil)
}
func doEncodeGLint64ˢ(e binary.Writer, o *GLint64ˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLint64ˢ(d binary.Reader, o *GLint64ˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLint64ˢ(d binary.Reader, o *GLint64ˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLint64ˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLint64ˢ(e, obj.(*GLint64ˢ))
}
func (*binaryClassGLint64ˢ) New() binary.Object {
	return &GLint64ˢ{}
}
func (*binaryClassGLint64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLint64ˢ(d, obj.(*GLint64ˢ))
}
func (o *GLint64ˢ) WriteSimple(w binary.Writer) {
	doEncodeGLint64ˢ(w, o)
}
func (o *GLint64ˢ) ReadSimple(r binary.Reader) {
	doDecodeGLint64ˢ(r, o)
}
func (c *binaryClassGLint64ˢ) Schema() *binary.Entity {
	return &entities[ixǁGLint64ˢ]
}

type binaryClassGLint64ᵖ struct{}

func (*GLint64ᵖ) Class() binary.Class {
	return (*binaryClassGLint64ᵖ)(nil)
}
func doEncodeGLint64ᵖ(e binary.Writer, o *GLint64ᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLint64ᵖ(d binary.Reader, o *GLint64ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLint64ᵖ(d binary.Reader, o *GLint64ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLint64ᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLint64ᵖ(e, obj.(*GLint64ᵖ))
}
func (*binaryClassGLint64ᵖ) New() binary.Object {
	return &GLint64ᵖ{}
}
func (*binaryClassGLint64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLint64ᵖ(d, obj.(*GLint64ᵖ))
}
func (o *GLint64ᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLint64ᵖ(w, o)
}
func (o *GLint64ᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLint64ᵖ(r, o)
}
func (c *binaryClassGLint64ᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLint64ᵖ]
}

type binaryClassGLintː1ᵃ struct{}

func (*GLintː1ᵃ) Class() binary.Class {
	return (*binaryClassGLintː1ᵃ)(nil)
}
func doEncodeGLintː1ᵃ(e binary.Writer, o *GLintː1ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Int32(int32(*curr))
	}
}
func doDecodeGLintː1ᵃ(d binary.Reader, o *GLintː1ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func doDecodeRawGLintː1ᵃ(d binary.Reader, o *GLintː1ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func (*binaryClassGLintː1ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLintː1ᵃ(e, obj.(*GLintː1ᵃ))
}
func (*binaryClassGLintː1ᵃ) New() binary.Object {
	return &GLintː1ᵃ{}
}
func (*binaryClassGLintː1ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLintː1ᵃ(d, obj.(*GLintː1ᵃ))
}
func (o *GLintː1ᵃ) WriteSimple(w binary.Writer) {
	doEncodeGLintː1ᵃ(w, o)
}
func (o *GLintː1ᵃ) ReadSimple(r binary.Reader) {
	doDecodeGLintː1ᵃ(r, o)
}
func (c *binaryClassGLintː1ᵃ) Schema() *binary.Entity {
	return &entities[ixǁGLintː1ᵃ]
}

type binaryClassGLintː4ᵃ struct{}

func (*GLintː4ᵃ) Class() binary.Class {
	return (*binaryClassGLintː4ᵃ)(nil)
}
func doEncodeGLintː4ᵃ(e binary.Writer, o *GLintː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Int32(int32(*curr))
	}
}
func doDecodeGLintː4ᵃ(d binary.Reader, o *GLintː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func doDecodeRawGLintː4ᵃ(d binary.Reader, o *GLintː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func (*binaryClassGLintː4ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLintː4ᵃ(e, obj.(*GLintː4ᵃ))
}
func (*binaryClassGLintː4ᵃ) New() binary.Object {
	return &GLintː4ᵃ{}
}
func (*binaryClassGLintː4ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLintː4ᵃ(d, obj.(*GLintː4ᵃ))
}
func (o *GLintː4ᵃ) WriteSimple(w binary.Writer) {
	doEncodeGLintː4ᵃ(w, o)
}
func (o *GLintː4ᵃ) ReadSimple(r binary.Reader) {
	doDecodeGLintː4ᵃ(r, o)
}
func (c *binaryClassGLintː4ᵃ) Schema() *binary.Entity {
	return &entities[ixǁGLintː4ᵃ]
}

type binaryClassGLintˢ struct{}

func (*GLintˢ) Class() binary.Class {
	return (*binaryClassGLintˢ)(nil)
}
func doEncodeGLintˢ(e binary.Writer, o *GLintˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLintˢ(d binary.Reader, o *GLintˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLintˢ(d binary.Reader, o *GLintˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLintˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLintˢ(e, obj.(*GLintˢ))
}
func (*binaryClassGLintˢ) New() binary.Object {
	return &GLintˢ{}
}
func (*binaryClassGLintˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLintˢ(d, obj.(*GLintˢ))
}
func (o *GLintˢ) WriteSimple(w binary.Writer) {
	doEncodeGLintˢ(w, o)
}
func (o *GLintˢ) ReadSimple(r binary.Reader) {
	doDecodeGLintˢ(r, o)
}
func (c *binaryClassGLintˢ) Schema() *binary.Entity {
	return &entities[ixǁGLintˢ]
}

type binaryClassGLintᵖ struct{}

func (*GLintᵖ) Class() binary.Class {
	return (*binaryClassGLintᵖ)(nil)
}
func doEncodeGLintᵖ(e binary.Writer, o *GLintᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLintᵖ(d binary.Reader, o *GLintᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLintᵖ(d binary.Reader, o *GLintᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLintᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLintᵖ(e, obj.(*GLintᵖ))
}
func (*binaryClassGLintᵖ) New() binary.Object {
	return &GLintᵖ{}
}
func (*binaryClassGLintᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLintᵖ(d, obj.(*GLintᵖ))
}
func (o *GLintᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLintᵖ(w, o)
}
func (o *GLintᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLintᵖ(r, o)
}
func (c *binaryClassGLintᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLintᵖ]
}

type binaryClassGLintᶜᵖ struct{}

func (*GLintᶜᵖ) Class() binary.Class {
	return (*binaryClassGLintᶜᵖ)(nil)
}
func doEncodeGLintᶜᵖ(e binary.Writer, o *GLintᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLintᶜᵖ(d binary.Reader, o *GLintᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLintᶜᵖ(d binary.Reader, o *GLintᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLintᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLintᶜᵖ(e, obj.(*GLintᶜᵖ))
}
func (*binaryClassGLintᶜᵖ) New() binary.Object {
	return &GLintᶜᵖ{}
}
func (*binaryClassGLintᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLintᶜᵖ(d, obj.(*GLintᶜᵖ))
}
func (o *GLintᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLintᶜᵖ(w, o)
}
func (o *GLintᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLintᶜᵖ(r, o)
}
func (c *binaryClassGLintᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLintᶜᵖ]
}

type binaryClassGLshortˢ struct{}

func (*GLshortˢ) Class() binary.Class {
	return (*binaryClassGLshortˢ)(nil)
}
func doEncodeGLshortˢ(e binary.Writer, o *GLshortˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLshortˢ(d binary.Reader, o *GLshortˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLshortˢ(d binary.Reader, o *GLshortˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLshortˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLshortˢ(e, obj.(*GLshortˢ))
}
func (*binaryClassGLshortˢ) New() binary.Object {
	return &GLshortˢ{}
}
func (*binaryClassGLshortˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLshortˢ(d, obj.(*GLshortˢ))
}
func (o *GLshortˢ) WriteSimple(w binary.Writer) {
	doEncodeGLshortˢ(w, o)
}
func (o *GLshortˢ) ReadSimple(r binary.Reader) {
	doDecodeGLshortˢ(r, o)
}
func (c *binaryClassGLshortˢ) Schema() *binary.Entity {
	return &entities[ixǁGLshortˢ]
}

type binaryClassGLshortᵖ struct{}

func (*GLshortᵖ) Class() binary.Class {
	return (*binaryClassGLshortᵖ)(nil)
}
func doEncodeGLshortᵖ(e binary.Writer, o *GLshortᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLshortᵖ(d binary.Reader, o *GLshortᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLshortᵖ(d binary.Reader, o *GLshortᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLshortᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLshortᵖ(e, obj.(*GLshortᵖ))
}
func (*binaryClassGLshortᵖ) New() binary.Object {
	return &GLshortᵖ{}
}
func (*binaryClassGLshortᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLshortᵖ(d, obj.(*GLshortᵖ))
}
func (o *GLshortᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLshortᵖ(w, o)
}
func (o *GLshortᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLshortᵖ(r, o)
}
func (c *binaryClassGLshortᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLshortᵖ]
}

type binaryClassGLshortᶜᵖ struct{}

func (*GLshortᶜᵖ) Class() binary.Class {
	return (*binaryClassGLshortᶜᵖ)(nil)
}
func doEncodeGLshortᶜᵖ(e binary.Writer, o *GLshortᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLshortᶜᵖ(d binary.Reader, o *GLshortᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLshortᶜᵖ(d binary.Reader, o *GLshortᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLshortᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLshortᶜᵖ(e, obj.(*GLshortᶜᵖ))
}
func (*binaryClassGLshortᶜᵖ) New() binary.Object {
	return &GLshortᶜᵖ{}
}
func (*binaryClassGLshortᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLshortᶜᵖ(d, obj.(*GLshortᶜᵖ))
}
func (o *GLshortᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLshortᶜᵖ(w, o)
}
func (o *GLshortᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLshortᶜᵖ(r, o)
}
func (c *binaryClassGLshortᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLshortᶜᵖ]
}

type binaryClassGLsizeiˢ struct{}

func (*GLsizeiˢ) Class() binary.Class {
	return (*binaryClassGLsizeiˢ)(nil)
}
func doEncodeGLsizeiˢ(e binary.Writer, o *GLsizeiˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLsizeiˢ(d binary.Reader, o *GLsizeiˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLsizeiˢ(d binary.Reader, o *GLsizeiˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLsizeiˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLsizeiˢ(e, obj.(*GLsizeiˢ))
}
func (*binaryClassGLsizeiˢ) New() binary.Object {
	return &GLsizeiˢ{}
}
func (*binaryClassGLsizeiˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLsizeiˢ(d, obj.(*GLsizeiˢ))
}
func (o *GLsizeiˢ) WriteSimple(w binary.Writer) {
	doEncodeGLsizeiˢ(w, o)
}
func (o *GLsizeiˢ) ReadSimple(r binary.Reader) {
	doDecodeGLsizeiˢ(r, o)
}
func (c *binaryClassGLsizeiˢ) Schema() *binary.Entity {
	return &entities[ixǁGLsizeiˢ]
}

type binaryClassGLsizeiᵖ struct{}

func (*GLsizeiᵖ) Class() binary.Class {
	return (*binaryClassGLsizeiᵖ)(nil)
}
func doEncodeGLsizeiᵖ(e binary.Writer, o *GLsizeiᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLsizeiᵖ(d binary.Reader, o *GLsizeiᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLsizeiᵖ(d binary.Reader, o *GLsizeiᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLsizeiᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLsizeiᵖ(e, obj.(*GLsizeiᵖ))
}
func (*binaryClassGLsizeiᵖ) New() binary.Object {
	return &GLsizeiᵖ{}
}
func (*binaryClassGLsizeiᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLsizeiᵖ(d, obj.(*GLsizeiᵖ))
}
func (o *GLsizeiᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLsizeiᵖ(w, o)
}
func (o *GLsizeiᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLsizeiᵖ(r, o)
}
func (c *binaryClassGLsizeiᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLsizeiᵖ]
}

type binaryClassGLsizeiᶜᵖ struct{}

func (*GLsizeiᶜᵖ) Class() binary.Class {
	return (*binaryClassGLsizeiᶜᵖ)(nil)
}
func doEncodeGLsizeiᶜᵖ(e binary.Writer, o *GLsizeiᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLsizeiᶜᵖ(d binary.Reader, o *GLsizeiᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLsizeiᶜᵖ(d binary.Reader, o *GLsizeiᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLsizeiᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLsizeiᶜᵖ(e, obj.(*GLsizeiᶜᵖ))
}
func (*binaryClassGLsizeiᶜᵖ) New() binary.Object {
	return &GLsizeiᶜᵖ{}
}
func (*binaryClassGLsizeiᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLsizeiᶜᵖ(d, obj.(*GLsizeiᶜᵖ))
}
func (o *GLsizeiᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLsizeiᶜᵖ(w, o)
}
func (o *GLsizeiᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLsizeiᶜᵖ(r, o)
}
func (c *binaryClassGLsizeiᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLsizeiᶜᵖ]
}

type binaryClassGLubyteˢ struct{}

func (*GLubyteˢ) Class() binary.Class {
	return (*binaryClassGLubyteˢ)(nil)
}
func doEncodeGLubyteˢ(e binary.Writer, o *GLubyteˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLubyteˢ(d binary.Reader, o *GLubyteˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLubyteˢ(d binary.Reader, o *GLubyteˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLubyteˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLubyteˢ(e, obj.(*GLubyteˢ))
}
func (*binaryClassGLubyteˢ) New() binary.Object {
	return &GLubyteˢ{}
}
func (*binaryClassGLubyteˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLubyteˢ(d, obj.(*GLubyteˢ))
}
func (o *GLubyteˢ) WriteSimple(w binary.Writer) {
	doEncodeGLubyteˢ(w, o)
}
func (o *GLubyteˢ) ReadSimple(r binary.Reader) {
	doDecodeGLubyteˢ(r, o)
}
func (c *binaryClassGLubyteˢ) Schema() *binary.Entity {
	return &entities[ixǁGLubyteˢ]
}

type binaryClassGLubyteᵖ struct{}

func (*GLubyteᵖ) Class() binary.Class {
	return (*binaryClassGLubyteᵖ)(nil)
}
func doEncodeGLubyteᵖ(e binary.Writer, o *GLubyteᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLubyteᵖ(d binary.Reader, o *GLubyteᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLubyteᵖ(d binary.Reader, o *GLubyteᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLubyteᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLubyteᵖ(e, obj.(*GLubyteᵖ))
}
func (*binaryClassGLubyteᵖ) New() binary.Object {
	return &GLubyteᵖ{}
}
func (*binaryClassGLubyteᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLubyteᵖ(d, obj.(*GLubyteᵖ))
}
func (o *GLubyteᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLubyteᵖ(w, o)
}
func (o *GLubyteᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLubyteᵖ(r, o)
}
func (c *binaryClassGLubyteᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLubyteᵖ]
}

type binaryClassGLubyteᶜᵖ struct{}

func (*GLubyteᶜᵖ) Class() binary.Class {
	return (*binaryClassGLubyteᶜᵖ)(nil)
}
func doEncodeGLubyteᶜᵖ(e binary.Writer, o *GLubyteᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLubyteᶜᵖ(d binary.Reader, o *GLubyteᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLubyteᶜᵖ(d binary.Reader, o *GLubyteᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLubyteᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLubyteᶜᵖ(e, obj.(*GLubyteᶜᵖ))
}
func (*binaryClassGLubyteᶜᵖ) New() binary.Object {
	return &GLubyteᶜᵖ{}
}
func (*binaryClassGLubyteᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLubyteᶜᵖ(d, obj.(*GLubyteᶜᵖ))
}
func (o *GLubyteᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLubyteᶜᵖ(w, o)
}
func (o *GLubyteᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLubyteᶜᵖ(r, o)
}
func (c *binaryClassGLubyteᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLubyteᶜᵖ]
}

type binaryClassGLuint64ˢ struct{}

func (*GLuint64ˢ) Class() binary.Class {
	return (*binaryClassGLuint64ˢ)(nil)
}
func doEncodeGLuint64ˢ(e binary.Writer, o *GLuint64ˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLuint64ˢ(d binary.Reader, o *GLuint64ˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLuint64ˢ(d binary.Reader, o *GLuint64ˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLuint64ˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLuint64ˢ(e, obj.(*GLuint64ˢ))
}
func (*binaryClassGLuint64ˢ) New() binary.Object {
	return &GLuint64ˢ{}
}
func (*binaryClassGLuint64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLuint64ˢ(d, obj.(*GLuint64ˢ))
}
func (o *GLuint64ˢ) WriteSimple(w binary.Writer) {
	doEncodeGLuint64ˢ(w, o)
}
func (o *GLuint64ˢ) ReadSimple(r binary.Reader) {
	doDecodeGLuint64ˢ(r, o)
}
func (c *binaryClassGLuint64ˢ) Schema() *binary.Entity {
	return &entities[ixǁGLuint64ˢ]
}

type binaryClassGLuint64ᵖ struct{}

func (*GLuint64ᵖ) Class() binary.Class {
	return (*binaryClassGLuint64ᵖ)(nil)
}
func doEncodeGLuint64ᵖ(e binary.Writer, o *GLuint64ᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLuint64ᵖ(d binary.Reader, o *GLuint64ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLuint64ᵖ(d binary.Reader, o *GLuint64ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLuint64ᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLuint64ᵖ(e, obj.(*GLuint64ᵖ))
}
func (*binaryClassGLuint64ᵖ) New() binary.Object {
	return &GLuint64ᵖ{}
}
func (*binaryClassGLuint64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLuint64ᵖ(d, obj.(*GLuint64ᵖ))
}
func (o *GLuint64ᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLuint64ᵖ(w, o)
}
func (o *GLuint64ᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLuint64ᵖ(r, o)
}
func (c *binaryClassGLuint64ᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLuint64ᵖ]
}

type binaryClassGLuint64ᶜᵖ struct{}

func (*GLuint64ᶜᵖ) Class() binary.Class {
	return (*binaryClassGLuint64ᶜᵖ)(nil)
}
func doEncodeGLuint64ᶜᵖ(e binary.Writer, o *GLuint64ᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLuint64ᶜᵖ(d binary.Reader, o *GLuint64ᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLuint64ᶜᵖ(d binary.Reader, o *GLuint64ᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLuint64ᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLuint64ᶜᵖ(e, obj.(*GLuint64ᶜᵖ))
}
func (*binaryClassGLuint64ᶜᵖ) New() binary.Object {
	return &GLuint64ᶜᵖ{}
}
func (*binaryClassGLuint64ᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLuint64ᶜᵖ(d, obj.(*GLuint64ᶜᵖ))
}
func (o *GLuint64ᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLuint64ᶜᵖ(w, o)
}
func (o *GLuint64ᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLuint64ᶜᵖ(r, o)
}
func (c *binaryClassGLuint64ᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLuint64ᶜᵖ]
}

type binaryClassGLuintː2ᵃ struct{}

func (*GLuintː2ᵃ) Class() binary.Class {
	return (*binaryClassGLuintː2ᵃ)(nil)
}
func doEncodeGLuintː2ᵃ(e binary.Writer, o *GLuintː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Uint32(uint32(*curr))
	}
}
func doDecodeGLuintː2ᵃ(d binary.Reader, o *GLuintː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLuint(d.Uint32())
	}
}
func doDecodeRawGLuintː2ᵃ(d binary.Reader, o *GLuintː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLuint(d.Uint32())
	}
}
func (*binaryClassGLuintː2ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLuintː2ᵃ(e, obj.(*GLuintː2ᵃ))
}
func (*binaryClassGLuintː2ᵃ) New() binary.Object {
	return &GLuintː2ᵃ{}
}
func (*binaryClassGLuintː2ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLuintː2ᵃ(d, obj.(*GLuintː2ᵃ))
}
func (o *GLuintː2ᵃ) WriteSimple(w binary.Writer) {
	doEncodeGLuintː2ᵃ(w, o)
}
func (o *GLuintː2ᵃ) ReadSimple(r binary.Reader) {
	doDecodeGLuintː2ᵃ(r, o)
}
func (c *binaryClassGLuintː2ᵃ) Schema() *binary.Entity {
	return &entities[ixǁGLuintː2ᵃ]
}

type binaryClassGLuintː3ᵃ struct{}

func (*GLuintː3ᵃ) Class() binary.Class {
	return (*binaryClassGLuintː3ᵃ)(nil)
}
func doEncodeGLuintː3ᵃ(e binary.Writer, o *GLuintː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Uint32(uint32(*curr))
	}
}
func doDecodeGLuintː3ᵃ(d binary.Reader, o *GLuintː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLuint(d.Uint32())
	}
}
func doDecodeRawGLuintː3ᵃ(d binary.Reader, o *GLuintː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLuint(d.Uint32())
	}
}
func (*binaryClassGLuintː3ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLuintː3ᵃ(e, obj.(*GLuintː3ᵃ))
}
func (*binaryClassGLuintː3ᵃ) New() binary.Object {
	return &GLuintː3ᵃ{}
}
func (*binaryClassGLuintː3ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLuintː3ᵃ(d, obj.(*GLuintː3ᵃ))
}
func (o *GLuintː3ᵃ) WriteSimple(w binary.Writer) {
	doEncodeGLuintː3ᵃ(w, o)
}
func (o *GLuintː3ᵃ) ReadSimple(r binary.Reader) {
	doDecodeGLuintː3ᵃ(r, o)
}
func (c *binaryClassGLuintː3ᵃ) Schema() *binary.Entity {
	return &entities[ixǁGLuintː3ᵃ]
}

type binaryClassGLuintː4ᵃ struct{}

func (*GLuintː4ᵃ) Class() binary.Class {
	return (*binaryClassGLuintː4ᵃ)(nil)
}
func doEncodeGLuintː4ᵃ(e binary.Writer, o *GLuintː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Uint32(uint32(*curr))
	}
}
func doDecodeGLuintː4ᵃ(d binary.Reader, o *GLuintː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLuint(d.Uint32())
	}
}
func doDecodeRawGLuintː4ᵃ(d binary.Reader, o *GLuintː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLuint(d.Uint32())
	}
}
func (*binaryClassGLuintː4ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLuintː4ᵃ(e, obj.(*GLuintː4ᵃ))
}
func (*binaryClassGLuintː4ᵃ) New() binary.Object {
	return &GLuintː4ᵃ{}
}
func (*binaryClassGLuintː4ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLuintː4ᵃ(d, obj.(*GLuintː4ᵃ))
}
func (o *GLuintː4ᵃ) WriteSimple(w binary.Writer) {
	doEncodeGLuintː4ᵃ(w, o)
}
func (o *GLuintː4ᵃ) ReadSimple(r binary.Reader) {
	doDecodeGLuintː4ᵃ(r, o)
}
func (c *binaryClassGLuintː4ᵃ) Schema() *binary.Entity {
	return &entities[ixǁGLuintː4ᵃ]
}

type binaryClassGLuintˢ struct{}

func (*GLuintˢ) Class() binary.Class {
	return (*binaryClassGLuintˢ)(nil)
}
func doEncodeGLuintˢ(e binary.Writer, o *GLuintˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLuintˢ(d binary.Reader, o *GLuintˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLuintˢ(d binary.Reader, o *GLuintˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLuintˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLuintˢ(e, obj.(*GLuintˢ))
}
func (*binaryClassGLuintˢ) New() binary.Object {
	return &GLuintˢ{}
}
func (*binaryClassGLuintˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLuintˢ(d, obj.(*GLuintˢ))
}
func (o *GLuintˢ) WriteSimple(w binary.Writer) {
	doEncodeGLuintˢ(w, o)
}
func (o *GLuintˢ) ReadSimple(r binary.Reader) {
	doDecodeGLuintˢ(r, o)
}
func (c *binaryClassGLuintˢ) Schema() *binary.Entity {
	return &entities[ixǁGLuintˢ]
}

type binaryClassGLuintᵖ struct{}

func (*GLuintᵖ) Class() binary.Class {
	return (*binaryClassGLuintᵖ)(nil)
}
func doEncodeGLuintᵖ(e binary.Writer, o *GLuintᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLuintᵖ(d binary.Reader, o *GLuintᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLuintᵖ(d binary.Reader, o *GLuintᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLuintᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLuintᵖ(e, obj.(*GLuintᵖ))
}
func (*binaryClassGLuintᵖ) New() binary.Object {
	return &GLuintᵖ{}
}
func (*binaryClassGLuintᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLuintᵖ(d, obj.(*GLuintᵖ))
}
func (o *GLuintᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLuintᵖ(w, o)
}
func (o *GLuintᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLuintᵖ(r, o)
}
func (c *binaryClassGLuintᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLuintᵖ]
}

type binaryClassGLuintᶜᵖ struct{}

func (*GLuintᶜᵖ) Class() binary.Class {
	return (*binaryClassGLuintᶜᵖ)(nil)
}
func doEncodeGLuintᶜᵖ(e binary.Writer, o *GLuintᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLuintᶜᵖ(d binary.Reader, o *GLuintᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLuintᶜᵖ(d binary.Reader, o *GLuintᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLuintᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLuintᶜᵖ(e, obj.(*GLuintᶜᵖ))
}
func (*binaryClassGLuintᶜᵖ) New() binary.Object {
	return &GLuintᶜᵖ{}
}
func (*binaryClassGLuintᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLuintᶜᵖ(d, obj.(*GLuintᶜᵖ))
}
func (o *GLuintᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLuintᶜᵖ(w, o)
}
func (o *GLuintᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLuintᶜᵖ(r, o)
}
func (c *binaryClassGLuintᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLuintᶜᵖ]
}

type binaryClassGLvoidˢ struct{}

func (*GLvoidˢ) Class() binary.Class {
	return (*binaryClassGLvoidˢ)(nil)
}
func doEncodeGLvoidˢ(e binary.Writer, o *GLvoidˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeGLvoidˢ(d binary.Reader, o *GLvoidˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawGLvoidˢ(d binary.Reader, o *GLvoidˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassGLvoidˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLvoidˢ(e, obj.(*GLvoidˢ))
}
func (*binaryClassGLvoidˢ) New() binary.Object {
	return &GLvoidˢ{}
}
func (*binaryClassGLvoidˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLvoidˢ(d, obj.(*GLvoidˢ))
}
func (o *GLvoidˢ) WriteSimple(w binary.Writer) {
	doEncodeGLvoidˢ(w, o)
}
func (o *GLvoidˢ) ReadSimple(r binary.Reader) {
	doDecodeGLvoidˢ(r, o)
}
func (c *binaryClassGLvoidˢ) Schema() *binary.Entity {
	return &entities[ixǁGLvoidˢ]
}

type binaryClassGLvoidᵖ struct{}

func (*GLvoidᵖ) Class() binary.Class {
	return (*binaryClassGLvoidᵖ)(nil)
}
func doEncodeGLvoidᵖ(e binary.Writer, o *GLvoidᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeGLvoidᵖ(d binary.Reader, o *GLvoidᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawGLvoidᵖ(d binary.Reader, o *GLvoidᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassGLvoidᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGLvoidᵖ(e, obj.(*GLvoidᵖ))
}
func (*binaryClassGLvoidᵖ) New() binary.Object {
	return &GLvoidᵖ{}
}
func (*binaryClassGLvoidᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGLvoidᵖ(d, obj.(*GLvoidᵖ))
}
func (o *GLvoidᵖ) WriteSimple(w binary.Writer) {
	doEncodeGLvoidᵖ(w, o)
}
func (o *GLvoidᵖ) ReadSimple(r binary.Reader) {
	doDecodeGLvoidᵖ(r, o)
}
func (c *binaryClassGLvoidᵖ) Schema() *binary.Entity {
	return &entities[ixǁGLvoidᵖ]
}

type binaryClassGlActiveShaderProgram struct{}

func (*GlActiveShaderProgram) Class() binary.Class {
	return (*binaryClassGlActiveShaderProgram)(nil)
}
func doEncodeGlActiveShaderProgram(e binary.Encoder, o *GlActiveShaderProgram) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
	e.Uint32(uint32(o.Program))
}
func doDecodeGlActiveShaderProgram(d binary.Decoder, o *GlActiveShaderProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Program = ProgramId(d.Uint32())
}
func doDecodeRawGlActiveShaderProgram(d binary.Decoder, o *GlActiveShaderProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Program = ProgramId(d.Uint32())
}
func (*binaryClassGlActiveShaderProgram) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlActiveShaderProgram(e, obj.(*GlActiveShaderProgram))
}
func (*binaryClassGlActiveShaderProgram) New() binary.Object {
	return &GlActiveShaderProgram{}
}
func (*binaryClassGlActiveShaderProgram) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlActiveShaderProgram(d, obj.(*GlActiveShaderProgram))
}
func (c *binaryClassGlActiveShaderProgram) Schema() *binary.Entity {
	return &entities[ixǁGlActiveShaderProgram]
}

type binaryClassGlActiveShaderProgramEXT struct{}

func (*GlActiveShaderProgramEXT) Class() binary.Class {
	return (*binaryClassGlActiveShaderProgramEXT)(nil)
}
func doEncodeGlActiveShaderProgramEXT(e binary.Encoder, o *GlActiveShaderProgramEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
	e.Uint32(uint32(o.Program))
}
func doDecodeGlActiveShaderProgramEXT(d binary.Decoder, o *GlActiveShaderProgramEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Program = ProgramId(d.Uint32())
}
func doDecodeRawGlActiveShaderProgramEXT(d binary.Decoder, o *GlActiveShaderProgramEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Program = ProgramId(d.Uint32())
}
func (*binaryClassGlActiveShaderProgramEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlActiveShaderProgramEXT(e, obj.(*GlActiveShaderProgramEXT))
}
func (*binaryClassGlActiveShaderProgramEXT) New() binary.Object {
	return &GlActiveShaderProgramEXT{}
}
func (*binaryClassGlActiveShaderProgramEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlActiveShaderProgramEXT(d, obj.(*GlActiveShaderProgramEXT))
}
func (c *binaryClassGlActiveShaderProgramEXT) Schema() *binary.Entity {
	return &entities[ixǁGlActiveShaderProgramEXT]
}

type binaryClassGlActiveTexture struct{}

func (*GlActiveTexture) Class() binary.Class {
	return (*binaryClassGlActiveTexture)(nil)
}
func doEncodeGlActiveTexture(e binary.Encoder, o *GlActiveTexture) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Unit))
}
func doDecodeGlActiveTexture(d binary.Decoder, o *GlActiveTexture) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Unit = GLenum(d.Uint32())
}
func doDecodeRawGlActiveTexture(d binary.Decoder, o *GlActiveTexture) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Unit = GLenum(d.Uint32())
}
func (*binaryClassGlActiveTexture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlActiveTexture(e, obj.(*GlActiveTexture))
}
func (*binaryClassGlActiveTexture) New() binary.Object {
	return &GlActiveTexture{}
}
func (*binaryClassGlActiveTexture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlActiveTexture(d, obj.(*GlActiveTexture))
}
func (c *binaryClassGlActiveTexture) Schema() *binary.Entity {
	return &entities[ixǁGlActiveTexture]
}

type binaryClassGlAlphaFunc struct{}

func (*GlAlphaFunc) Class() binary.Class {
	return (*binaryClassGlAlphaFunc)(nil)
}
func doEncodeGlAlphaFunc(e binary.Encoder, o *GlAlphaFunc) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Func))
	e.Float32(float32(o.Ref))
}
func doDecodeGlAlphaFunc(d binary.Decoder, o *GlAlphaFunc) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
	o.Ref = GLfloat(d.Float32())
}
func doDecodeRawGlAlphaFunc(d binary.Decoder, o *GlAlphaFunc) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
	o.Ref = GLfloat(d.Float32())
}
func (*binaryClassGlAlphaFunc) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlAlphaFunc(e, obj.(*GlAlphaFunc))
}
func (*binaryClassGlAlphaFunc) New() binary.Object {
	return &GlAlphaFunc{}
}
func (*binaryClassGlAlphaFunc) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlAlphaFunc(d, obj.(*GlAlphaFunc))
}
func (c *binaryClassGlAlphaFunc) Schema() *binary.Entity {
	return &entities[ixǁGlAlphaFunc]
}

type binaryClassGlAlphaFuncQCOM struct{}

func (*GlAlphaFuncQCOM) Class() binary.Class {
	return (*binaryClassGlAlphaFuncQCOM)(nil)
}
func doEncodeGlAlphaFuncQCOM(e binary.Encoder, o *GlAlphaFuncQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Func))
	e.Float32(float32(o.Ref))
}
func doDecodeGlAlphaFuncQCOM(d binary.Decoder, o *GlAlphaFuncQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
	o.Ref = GLclampf(d.Float32())
}
func doDecodeRawGlAlphaFuncQCOM(d binary.Decoder, o *GlAlphaFuncQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
	o.Ref = GLclampf(d.Float32())
}
func (*binaryClassGlAlphaFuncQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlAlphaFuncQCOM(e, obj.(*GlAlphaFuncQCOM))
}
func (*binaryClassGlAlphaFuncQCOM) New() binary.Object {
	return &GlAlphaFuncQCOM{}
}
func (*binaryClassGlAlphaFuncQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlAlphaFuncQCOM(d, obj.(*GlAlphaFuncQCOM))
}
func (c *binaryClassGlAlphaFuncQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlAlphaFuncQCOM]
}

type binaryClassGlAlphaFuncx struct{}

func (*GlAlphaFuncx) Class() binary.Class {
	return (*binaryClassGlAlphaFuncx)(nil)
}
func doEncodeGlAlphaFuncx(e binary.Encoder, o *GlAlphaFuncx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Func))
	e.Int32(int32(o.Ref))
}
func doDecodeGlAlphaFuncx(d binary.Decoder, o *GlAlphaFuncx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
	o.Ref = GLfixed(d.Int32())
}
func doDecodeRawGlAlphaFuncx(d binary.Decoder, o *GlAlphaFuncx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
	o.Ref = GLfixed(d.Int32())
}
func (*binaryClassGlAlphaFuncx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlAlphaFuncx(e, obj.(*GlAlphaFuncx))
}
func (*binaryClassGlAlphaFuncx) New() binary.Object {
	return &GlAlphaFuncx{}
}
func (*binaryClassGlAlphaFuncx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlAlphaFuncx(d, obj.(*GlAlphaFuncx))
}
func (c *binaryClassGlAlphaFuncx) Schema() *binary.Entity {
	return &entities[ixǁGlAlphaFuncx]
}

type binaryClassGlAlphaFuncxOES struct{}

func (*GlAlphaFuncxOES) Class() binary.Class {
	return (*binaryClassGlAlphaFuncxOES)(nil)
}
func doEncodeGlAlphaFuncxOES(e binary.Encoder, o *GlAlphaFuncxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Func))
	e.Int32(int32(o.Ref))
}
func doDecodeGlAlphaFuncxOES(d binary.Decoder, o *GlAlphaFuncxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
	o.Ref = GLfixed(d.Int32())
}
func doDecodeRawGlAlphaFuncxOES(d binary.Decoder, o *GlAlphaFuncxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
	o.Ref = GLfixed(d.Int32())
}
func (*binaryClassGlAlphaFuncxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlAlphaFuncxOES(e, obj.(*GlAlphaFuncxOES))
}
func (*binaryClassGlAlphaFuncxOES) New() binary.Object {
	return &GlAlphaFuncxOES{}
}
func (*binaryClassGlAlphaFuncxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlAlphaFuncxOES(d, obj.(*GlAlphaFuncxOES))
}
func (c *binaryClassGlAlphaFuncxOES) Schema() *binary.Entity {
	return &entities[ixǁGlAlphaFuncxOES]
}

type binaryClassGlApplyFramebufferAttachmentCMAAINTEL struct{}

func (*GlApplyFramebufferAttachmentCMAAINTEL) Class() binary.Class {
	return (*binaryClassGlApplyFramebufferAttachmentCMAAINTEL)(nil)
}
func doEncodeGlApplyFramebufferAttachmentCMAAINTEL(e binary.Encoder, o *GlApplyFramebufferAttachmentCMAAINTEL) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlApplyFramebufferAttachmentCMAAINTEL(d binary.Decoder, o *GlApplyFramebufferAttachmentCMAAINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlApplyFramebufferAttachmentCMAAINTEL(d binary.Decoder, o *GlApplyFramebufferAttachmentCMAAINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlApplyFramebufferAttachmentCMAAINTEL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlApplyFramebufferAttachmentCMAAINTEL(e, obj.(*GlApplyFramebufferAttachmentCMAAINTEL))
}
func (*binaryClassGlApplyFramebufferAttachmentCMAAINTEL) New() binary.Object {
	return &GlApplyFramebufferAttachmentCMAAINTEL{}
}
func (*binaryClassGlApplyFramebufferAttachmentCMAAINTEL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlApplyFramebufferAttachmentCMAAINTEL(d, obj.(*GlApplyFramebufferAttachmentCMAAINTEL))
}
func (c *binaryClassGlApplyFramebufferAttachmentCMAAINTEL) Schema() *binary.Entity {
	return &entities[ixǁGlApplyFramebufferAttachmentCMAAINTEL]
}

type binaryClassGlAttachShader struct{}

func (*GlAttachShader) Class() binary.Class {
	return (*binaryClassGlAttachShader)(nil)
}
func doEncodeGlAttachShader(e binary.Encoder, o *GlAttachShader) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.Shader))
}
func doDecodeGlAttachShader(d binary.Decoder, o *GlAttachShader) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Shader = ShaderId(d.Uint32())
}
func doDecodeRawGlAttachShader(d binary.Decoder, o *GlAttachShader) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Shader = ShaderId(d.Uint32())
}
func (*binaryClassGlAttachShader) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlAttachShader(e, obj.(*GlAttachShader))
}
func (*binaryClassGlAttachShader) New() binary.Object {
	return &GlAttachShader{}
}
func (*binaryClassGlAttachShader) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlAttachShader(d, obj.(*GlAttachShader))
}
func (c *binaryClassGlAttachShader) Schema() *binary.Entity {
	return &entities[ixǁGlAttachShader]
}

type binaryClassGlBeginConditionalRenderNV struct{}

func (*GlBeginConditionalRenderNV) Class() binary.Class {
	return (*binaryClassGlBeginConditionalRenderNV)(nil)
}
func doEncodeGlBeginConditionalRenderNV(e binary.Encoder, o *GlBeginConditionalRenderNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Id))
	e.Uint32(uint32(o.Mode))
}
func doDecodeGlBeginConditionalRenderNV(d binary.Decoder, o *GlBeginConditionalRenderNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Id = GLuint(d.Uint32())
	o.Mode = GLenum(d.Uint32())
}
func doDecodeRawGlBeginConditionalRenderNV(d binary.Decoder, o *GlBeginConditionalRenderNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Id = GLuint(d.Uint32())
	o.Mode = GLenum(d.Uint32())
}
func (*binaryClassGlBeginConditionalRenderNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBeginConditionalRenderNV(e, obj.(*GlBeginConditionalRenderNV))
}
func (*binaryClassGlBeginConditionalRenderNV) New() binary.Object {
	return &GlBeginConditionalRenderNV{}
}
func (*binaryClassGlBeginConditionalRenderNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBeginConditionalRenderNV(d, obj.(*GlBeginConditionalRenderNV))
}
func (c *binaryClassGlBeginConditionalRenderNV) Schema() *binary.Entity {
	return &entities[ixǁGlBeginConditionalRenderNV]
}

type binaryClassGlBeginPerfMonitorAMD struct{}

func (*GlBeginPerfMonitorAMD) Class() binary.Class {
	return (*binaryClassGlBeginPerfMonitorAMD)(nil)
}
func doEncodeGlBeginPerfMonitorAMD(e binary.Encoder, o *GlBeginPerfMonitorAMD) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Monitor))
}
func doDecodeGlBeginPerfMonitorAMD(d binary.Decoder, o *GlBeginPerfMonitorAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Monitor = GLuint(d.Uint32())
}
func doDecodeRawGlBeginPerfMonitorAMD(d binary.Decoder, o *GlBeginPerfMonitorAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Monitor = GLuint(d.Uint32())
}
func (*binaryClassGlBeginPerfMonitorAMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBeginPerfMonitorAMD(e, obj.(*GlBeginPerfMonitorAMD))
}
func (*binaryClassGlBeginPerfMonitorAMD) New() binary.Object {
	return &GlBeginPerfMonitorAMD{}
}
func (*binaryClassGlBeginPerfMonitorAMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBeginPerfMonitorAMD(d, obj.(*GlBeginPerfMonitorAMD))
}
func (c *binaryClassGlBeginPerfMonitorAMD) Schema() *binary.Entity {
	return &entities[ixǁGlBeginPerfMonitorAMD]
}

type binaryClassGlBeginPerfQueryINTEL struct{}

func (*GlBeginPerfQueryINTEL) Class() binary.Class {
	return (*binaryClassGlBeginPerfQueryINTEL)(nil)
}
func doEncodeGlBeginPerfQueryINTEL(e binary.Encoder, o *GlBeginPerfQueryINTEL) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.QueryHandle))
}
func doDecodeGlBeginPerfQueryINTEL(d binary.Decoder, o *GlBeginPerfQueryINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryHandle = GLuint(d.Uint32())
}
func doDecodeRawGlBeginPerfQueryINTEL(d binary.Decoder, o *GlBeginPerfQueryINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryHandle = GLuint(d.Uint32())
}
func (*binaryClassGlBeginPerfQueryINTEL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBeginPerfQueryINTEL(e, obj.(*GlBeginPerfQueryINTEL))
}
func (*binaryClassGlBeginPerfQueryINTEL) New() binary.Object {
	return &GlBeginPerfQueryINTEL{}
}
func (*binaryClassGlBeginPerfQueryINTEL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBeginPerfQueryINTEL(d, obj.(*GlBeginPerfQueryINTEL))
}
func (c *binaryClassGlBeginPerfQueryINTEL) Schema() *binary.Entity {
	return &entities[ixǁGlBeginPerfQueryINTEL]
}

type binaryClassGlBeginQuery struct{}

func (*GlBeginQuery) Class() binary.Class {
	return (*binaryClassGlBeginQuery)(nil)
}
func doEncodeGlBeginQuery(e binary.Encoder, o *GlBeginQuery) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Query))
}
func doDecodeGlBeginQuery(d binary.Decoder, o *GlBeginQuery) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Query = QueryId(d.Uint32())
}
func doDecodeRawGlBeginQuery(d binary.Decoder, o *GlBeginQuery) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Query = QueryId(d.Uint32())
}
func (*binaryClassGlBeginQuery) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBeginQuery(e, obj.(*GlBeginQuery))
}
func (*binaryClassGlBeginQuery) New() binary.Object {
	return &GlBeginQuery{}
}
func (*binaryClassGlBeginQuery) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBeginQuery(d, obj.(*GlBeginQuery))
}
func (c *binaryClassGlBeginQuery) Schema() *binary.Entity {
	return &entities[ixǁGlBeginQuery]
}

type binaryClassGlBeginQueryEXT struct{}

func (*GlBeginQueryEXT) Class() binary.Class {
	return (*binaryClassGlBeginQueryEXT)(nil)
}
func doEncodeGlBeginQueryEXT(e binary.Encoder, o *GlBeginQueryEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Query))
}
func doDecodeGlBeginQueryEXT(d binary.Decoder, o *GlBeginQueryEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Query = QueryId(d.Uint32())
}
func doDecodeRawGlBeginQueryEXT(d binary.Decoder, o *GlBeginQueryEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Query = QueryId(d.Uint32())
}
func (*binaryClassGlBeginQueryEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBeginQueryEXT(e, obj.(*GlBeginQueryEXT))
}
func (*binaryClassGlBeginQueryEXT) New() binary.Object {
	return &GlBeginQueryEXT{}
}
func (*binaryClassGlBeginQueryEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBeginQueryEXT(d, obj.(*GlBeginQueryEXT))
}
func (c *binaryClassGlBeginQueryEXT) Schema() *binary.Entity {
	return &entities[ixǁGlBeginQueryEXT]
}

type binaryClassGlBeginTransformFeedback struct{}

func (*GlBeginTransformFeedback) Class() binary.Class {
	return (*binaryClassGlBeginTransformFeedback)(nil)
}
func doEncodeGlBeginTransformFeedback(e binary.Encoder, o *GlBeginTransformFeedback) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.PrimitiveMode))
}
func doDecodeGlBeginTransformFeedback(d binary.Decoder, o *GlBeginTransformFeedback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.PrimitiveMode = GLenum(d.Uint32())
}
func doDecodeRawGlBeginTransformFeedback(d binary.Decoder, o *GlBeginTransformFeedback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.PrimitiveMode = GLenum(d.Uint32())
}
func (*binaryClassGlBeginTransformFeedback) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBeginTransformFeedback(e, obj.(*GlBeginTransformFeedback))
}
func (*binaryClassGlBeginTransformFeedback) New() binary.Object {
	return &GlBeginTransformFeedback{}
}
func (*binaryClassGlBeginTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBeginTransformFeedback(d, obj.(*GlBeginTransformFeedback))
}
func (c *binaryClassGlBeginTransformFeedback) Schema() *binary.Entity {
	return &entities[ixǁGlBeginTransformFeedback]
}

type binaryClassGlBindAttribLocation struct{}

func (*GlBindAttribLocation) Class() binary.Class {
	return (*binaryClassGlBindAttribLocation)(nil)
}
func doEncodeGlBindAttribLocation(e binary.Encoder, o *GlBindAttribLocation) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.Location))
	e.String(o.Name)
}
func doDecodeGlBindAttribLocation(d binary.Decoder, o *GlBindAttribLocation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = AttributeLocation(d.Uint32())
	o.Name = string(d.String())
}
func doDecodeRawGlBindAttribLocation(d binary.Decoder, o *GlBindAttribLocation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = AttributeLocation(d.Uint32())
	o.Name = string(d.String())
}
func (*binaryClassGlBindAttribLocation) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindAttribLocation(e, obj.(*GlBindAttribLocation))
}
func (*binaryClassGlBindAttribLocation) New() binary.Object {
	return &GlBindAttribLocation{}
}
func (*binaryClassGlBindAttribLocation) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindAttribLocation(d, obj.(*GlBindAttribLocation))
}
func (c *binaryClassGlBindAttribLocation) Schema() *binary.Entity {
	return &entities[ixǁGlBindAttribLocation]
}

type binaryClassGlBindBuffer struct{}

func (*GlBindBuffer) Class() binary.Class {
	return (*binaryClassGlBindBuffer)(nil)
}
func doEncodeGlBindBuffer(e binary.Encoder, o *GlBindBuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Buffer))
}
func doDecodeGlBindBuffer(d binary.Decoder, o *GlBindBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
}
func doDecodeRawGlBindBuffer(d binary.Decoder, o *GlBindBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
}
func (*binaryClassGlBindBuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindBuffer(e, obj.(*GlBindBuffer))
}
func (*binaryClassGlBindBuffer) New() binary.Object {
	return &GlBindBuffer{}
}
func (*binaryClassGlBindBuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindBuffer(d, obj.(*GlBindBuffer))
}
func (c *binaryClassGlBindBuffer) Schema() *binary.Entity {
	return &entities[ixǁGlBindBuffer]
}

type binaryClassGlBindBufferBase struct{}

func (*GlBindBufferBase) Class() binary.Class {
	return (*binaryClassGlBindBufferBase)(nil)
}
func doEncodeGlBindBufferBase(e binary.Encoder, o *GlBindBufferBase) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.Buffer))
}
func doDecodeGlBindBufferBase(d binary.Decoder, o *GlBindBufferBase) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
}
func doDecodeRawGlBindBufferBase(d binary.Decoder, o *GlBindBufferBase) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
}
func (*binaryClassGlBindBufferBase) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindBufferBase(e, obj.(*GlBindBufferBase))
}
func (*binaryClassGlBindBufferBase) New() binary.Object {
	return &GlBindBufferBase{}
}
func (*binaryClassGlBindBufferBase) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindBufferBase(d, obj.(*GlBindBufferBase))
}
func (c *binaryClassGlBindBufferBase) Schema() *binary.Entity {
	return &entities[ixǁGlBindBufferBase]
}

type binaryClassGlBindBufferRange struct{}

func (*GlBindBufferRange) Class() binary.Class {
	return (*binaryClassGlBindBufferRange)(nil)
}
func doEncodeGlBindBufferRange(e binary.Encoder, o *GlBindBufferRange) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.Buffer))
	e.Int32(int32(o.Offset))
	e.Int32(int32(o.Size))
}
func doDecodeGlBindBufferRange(d binary.Decoder, o *GlBindBufferRange) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func doDecodeRawGlBindBufferRange(d binary.Decoder, o *GlBindBufferRange) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func (*binaryClassGlBindBufferRange) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindBufferRange(e, obj.(*GlBindBufferRange))
}
func (*binaryClassGlBindBufferRange) New() binary.Object {
	return &GlBindBufferRange{}
}
func (*binaryClassGlBindBufferRange) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindBufferRange(d, obj.(*GlBindBufferRange))
}
func (c *binaryClassGlBindBufferRange) Schema() *binary.Entity {
	return &entities[ixǁGlBindBufferRange]
}

type binaryClassGlBindFragDataLocation struct{}

func (*GlBindFragDataLocation) Class() binary.Class {
	return (*binaryClassGlBindFragDataLocation)(nil)
}
func doEncodeGlBindFragDataLocation(e binary.Encoder, o *GlBindFragDataLocation) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.Color))
	e.String(o.Name)
}
func doDecodeGlBindFragDataLocation(d binary.Decoder, o *GlBindFragDataLocation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Color = GLuint(d.Uint32())
	o.Name = string(d.String())
}
func doDecodeRawGlBindFragDataLocation(d binary.Decoder, o *GlBindFragDataLocation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Color = GLuint(d.Uint32())
	o.Name = string(d.String())
}
func (*binaryClassGlBindFragDataLocation) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindFragDataLocation(e, obj.(*GlBindFragDataLocation))
}
func (*binaryClassGlBindFragDataLocation) New() binary.Object {
	return &GlBindFragDataLocation{}
}
func (*binaryClassGlBindFragDataLocation) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindFragDataLocation(d, obj.(*GlBindFragDataLocation))
}
func (c *binaryClassGlBindFragDataLocation) Schema() *binary.Entity {
	return &entities[ixǁGlBindFragDataLocation]
}

type binaryClassGlBindFragDataLocationEXT struct{}

func (*GlBindFragDataLocationEXT) Class() binary.Class {
	return (*binaryClassGlBindFragDataLocationEXT)(nil)
}
func doEncodeGlBindFragDataLocationEXT(e binary.Encoder, o *GlBindFragDataLocationEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.Color))
	e.String(o.Name)
}
func doDecodeGlBindFragDataLocationEXT(d binary.Decoder, o *GlBindFragDataLocationEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Color = GLuint(d.Uint32())
	o.Name = string(d.String())
}
func doDecodeRawGlBindFragDataLocationEXT(d binary.Decoder, o *GlBindFragDataLocationEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Color = GLuint(d.Uint32())
	o.Name = string(d.String())
}
func (*binaryClassGlBindFragDataLocationEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindFragDataLocationEXT(e, obj.(*GlBindFragDataLocationEXT))
}
func (*binaryClassGlBindFragDataLocationEXT) New() binary.Object {
	return &GlBindFragDataLocationEXT{}
}
func (*binaryClassGlBindFragDataLocationEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindFragDataLocationEXT(d, obj.(*GlBindFragDataLocationEXT))
}
func (c *binaryClassGlBindFragDataLocationEXT) Schema() *binary.Entity {
	return &entities[ixǁGlBindFragDataLocationEXT]
}

type binaryClassGlBindFragDataLocationIndexedEXT struct{}

func (*GlBindFragDataLocationIndexedEXT) Class() binary.Class {
	return (*binaryClassGlBindFragDataLocationIndexedEXT)(nil)
}
func doEncodeGlBindFragDataLocationIndexedEXT(e binary.Encoder, o *GlBindFragDataLocationIndexedEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.ColorNumber))
	e.Uint32(uint32(o.Index))
	e.String(o.Name)
}
func doDecodeGlBindFragDataLocationIndexedEXT(d binary.Decoder, o *GlBindFragDataLocationIndexedEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ColorNumber = GLuint(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Name = string(d.String())
}
func doDecodeRawGlBindFragDataLocationIndexedEXT(d binary.Decoder, o *GlBindFragDataLocationIndexedEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ColorNumber = GLuint(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Name = string(d.String())
}
func (*binaryClassGlBindFragDataLocationIndexedEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindFragDataLocationIndexedEXT(e, obj.(*GlBindFragDataLocationIndexedEXT))
}
func (*binaryClassGlBindFragDataLocationIndexedEXT) New() binary.Object {
	return &GlBindFragDataLocationIndexedEXT{}
}
func (*binaryClassGlBindFragDataLocationIndexedEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindFragDataLocationIndexedEXT(d, obj.(*GlBindFragDataLocationIndexedEXT))
}
func (c *binaryClassGlBindFragDataLocationIndexedEXT) Schema() *binary.Entity {
	return &entities[ixǁGlBindFragDataLocationIndexedEXT]
}

type binaryClassGlBindFramebuffer struct{}

func (*GlBindFramebuffer) Class() binary.Class {
	return (*binaryClassGlBindFramebuffer)(nil)
}
func doEncodeGlBindFramebuffer(e binary.Encoder, o *GlBindFramebuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Framebuffer))
}
func doDecodeGlBindFramebuffer(d binary.Decoder, o *GlBindFramebuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Framebuffer = FramebufferId(d.Uint32())
}
func doDecodeRawGlBindFramebuffer(d binary.Decoder, o *GlBindFramebuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Framebuffer = FramebufferId(d.Uint32())
}
func (*binaryClassGlBindFramebuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindFramebuffer(e, obj.(*GlBindFramebuffer))
}
func (*binaryClassGlBindFramebuffer) New() binary.Object {
	return &GlBindFramebuffer{}
}
func (*binaryClassGlBindFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindFramebuffer(d, obj.(*GlBindFramebuffer))
}
func (c *binaryClassGlBindFramebuffer) Schema() *binary.Entity {
	return &entities[ixǁGlBindFramebuffer]
}

type binaryClassGlBindFramebufferOES struct{}

func (*GlBindFramebufferOES) Class() binary.Class {
	return (*binaryClassGlBindFramebufferOES)(nil)
}
func doEncodeGlBindFramebufferOES(e binary.Encoder, o *GlBindFramebufferOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Framebuffer))
}
func doDecodeGlBindFramebufferOES(d binary.Decoder, o *GlBindFramebufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Framebuffer = GLuint(d.Uint32())
}
func doDecodeRawGlBindFramebufferOES(d binary.Decoder, o *GlBindFramebufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Framebuffer = GLuint(d.Uint32())
}
func (*binaryClassGlBindFramebufferOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindFramebufferOES(e, obj.(*GlBindFramebufferOES))
}
func (*binaryClassGlBindFramebufferOES) New() binary.Object {
	return &GlBindFramebufferOES{}
}
func (*binaryClassGlBindFramebufferOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindFramebufferOES(d, obj.(*GlBindFramebufferOES))
}
func (c *binaryClassGlBindFramebufferOES) Schema() *binary.Entity {
	return &entities[ixǁGlBindFramebufferOES]
}

type binaryClassGlBindImageTexture struct{}

func (*GlBindImageTexture) Class() binary.Class {
	return (*binaryClassGlBindImageTexture)(nil)
}
func doEncodeGlBindImageTexture(e binary.Encoder, o *GlBindImageTexture) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Unit))
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.Level))
	e.Uint8(uint8(o.Layered))
	e.Int32(int32(o.Layer))
	e.Uint32(uint32(o.Access))
	e.Uint32(uint32(o.Format))
}
func doDecodeGlBindImageTexture(d binary.Decoder, o *GlBindImageTexture) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Unit = GLuint(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Layered = GLboolean(d.Uint8())
	o.Layer = GLint(d.Int32())
	o.Access = GLenum(d.Uint32())
	o.Format = GLenum(d.Uint32())
}
func doDecodeRawGlBindImageTexture(d binary.Decoder, o *GlBindImageTexture) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Unit = GLuint(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Layered = GLboolean(d.Uint8())
	o.Layer = GLint(d.Int32())
	o.Access = GLenum(d.Uint32())
	o.Format = GLenum(d.Uint32())
}
func (*binaryClassGlBindImageTexture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindImageTexture(e, obj.(*GlBindImageTexture))
}
func (*binaryClassGlBindImageTexture) New() binary.Object {
	return &GlBindImageTexture{}
}
func (*binaryClassGlBindImageTexture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindImageTexture(d, obj.(*GlBindImageTexture))
}
func (c *binaryClassGlBindImageTexture) Schema() *binary.Entity {
	return &entities[ixǁGlBindImageTexture]
}

type binaryClassGlBindProgramPipeline struct{}

func (*GlBindProgramPipeline) Class() binary.Class {
	return (*binaryClassGlBindProgramPipeline)(nil)
}
func doEncodeGlBindProgramPipeline(e binary.Encoder, o *GlBindProgramPipeline) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
}
func doDecodeGlBindProgramPipeline(d binary.Decoder, o *GlBindProgramPipeline) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
}
func doDecodeRawGlBindProgramPipeline(d binary.Decoder, o *GlBindProgramPipeline) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
}
func (*binaryClassGlBindProgramPipeline) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindProgramPipeline(e, obj.(*GlBindProgramPipeline))
}
func (*binaryClassGlBindProgramPipeline) New() binary.Object {
	return &GlBindProgramPipeline{}
}
func (*binaryClassGlBindProgramPipeline) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindProgramPipeline(d, obj.(*GlBindProgramPipeline))
}
func (c *binaryClassGlBindProgramPipeline) Schema() *binary.Entity {
	return &entities[ixǁGlBindProgramPipeline]
}

type binaryClassGlBindProgramPipelineEXT struct{}

func (*GlBindProgramPipelineEXT) Class() binary.Class {
	return (*binaryClassGlBindProgramPipelineEXT)(nil)
}
func doEncodeGlBindProgramPipelineEXT(e binary.Encoder, o *GlBindProgramPipelineEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
}
func doDecodeGlBindProgramPipelineEXT(d binary.Decoder, o *GlBindProgramPipelineEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
}
func doDecodeRawGlBindProgramPipelineEXT(d binary.Decoder, o *GlBindProgramPipelineEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
}
func (*binaryClassGlBindProgramPipelineEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindProgramPipelineEXT(e, obj.(*GlBindProgramPipelineEXT))
}
func (*binaryClassGlBindProgramPipelineEXT) New() binary.Object {
	return &GlBindProgramPipelineEXT{}
}
func (*binaryClassGlBindProgramPipelineEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindProgramPipelineEXT(d, obj.(*GlBindProgramPipelineEXT))
}
func (c *binaryClassGlBindProgramPipelineEXT) Schema() *binary.Entity {
	return &entities[ixǁGlBindProgramPipelineEXT]
}

type binaryClassGlBindRenderbuffer struct{}

func (*GlBindRenderbuffer) Class() binary.Class {
	return (*binaryClassGlBindRenderbuffer)(nil)
}
func doEncodeGlBindRenderbuffer(e binary.Encoder, o *GlBindRenderbuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Renderbuffer))
}
func doDecodeGlBindRenderbuffer(d binary.Decoder, o *GlBindRenderbuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Renderbuffer = RenderbufferId(d.Uint32())
}
func doDecodeRawGlBindRenderbuffer(d binary.Decoder, o *GlBindRenderbuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Renderbuffer = RenderbufferId(d.Uint32())
}
func (*binaryClassGlBindRenderbuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindRenderbuffer(e, obj.(*GlBindRenderbuffer))
}
func (*binaryClassGlBindRenderbuffer) New() binary.Object {
	return &GlBindRenderbuffer{}
}
func (*binaryClassGlBindRenderbuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindRenderbuffer(d, obj.(*GlBindRenderbuffer))
}
func (c *binaryClassGlBindRenderbuffer) Schema() *binary.Entity {
	return &entities[ixǁGlBindRenderbuffer]
}

type binaryClassGlBindRenderbufferOES struct{}

func (*GlBindRenderbufferOES) Class() binary.Class {
	return (*binaryClassGlBindRenderbufferOES)(nil)
}
func doEncodeGlBindRenderbufferOES(e binary.Encoder, o *GlBindRenderbufferOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Renderbuffer))
}
func doDecodeGlBindRenderbufferOES(d binary.Decoder, o *GlBindRenderbufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Renderbuffer = GLuint(d.Uint32())
}
func doDecodeRawGlBindRenderbufferOES(d binary.Decoder, o *GlBindRenderbufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Renderbuffer = GLuint(d.Uint32())
}
func (*binaryClassGlBindRenderbufferOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindRenderbufferOES(e, obj.(*GlBindRenderbufferOES))
}
func (*binaryClassGlBindRenderbufferOES) New() binary.Object {
	return &GlBindRenderbufferOES{}
}
func (*binaryClassGlBindRenderbufferOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindRenderbufferOES(d, obj.(*GlBindRenderbufferOES))
}
func (c *binaryClassGlBindRenderbufferOES) Schema() *binary.Entity {
	return &entities[ixǁGlBindRenderbufferOES]
}

type binaryClassGlBindSampler struct{}

func (*GlBindSampler) Class() binary.Class {
	return (*binaryClassGlBindSampler)(nil)
}
func doEncodeGlBindSampler(e binary.Encoder, o *GlBindSampler) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.Sampler))
}
func doDecodeGlBindSampler(d binary.Decoder, o *GlBindSampler) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = GLuint(d.Uint32())
	o.Sampler = SamplerId(d.Uint32())
}
func doDecodeRawGlBindSampler(d binary.Decoder, o *GlBindSampler) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = GLuint(d.Uint32())
	o.Sampler = SamplerId(d.Uint32())
}
func (*binaryClassGlBindSampler) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindSampler(e, obj.(*GlBindSampler))
}
func (*binaryClassGlBindSampler) New() binary.Object {
	return &GlBindSampler{}
}
func (*binaryClassGlBindSampler) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindSampler(d, obj.(*GlBindSampler))
}
func (c *binaryClassGlBindSampler) Schema() *binary.Entity {
	return &entities[ixǁGlBindSampler]
}

type binaryClassGlBindTexture struct{}

func (*GlBindTexture) Class() binary.Class {
	return (*binaryClassGlBindTexture)(nil)
}
func doEncodeGlBindTexture(e binary.Encoder, o *GlBindTexture) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Texture))
}
func doDecodeGlBindTexture(d binary.Decoder, o *GlBindTexture) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
}
func doDecodeRawGlBindTexture(d binary.Decoder, o *GlBindTexture) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
}
func (*binaryClassGlBindTexture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindTexture(e, obj.(*GlBindTexture))
}
func (*binaryClassGlBindTexture) New() binary.Object {
	return &GlBindTexture{}
}
func (*binaryClassGlBindTexture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindTexture(d, obj.(*GlBindTexture))
}
func (c *binaryClassGlBindTexture) Schema() *binary.Entity {
	return &entities[ixǁGlBindTexture]
}

type binaryClassGlBindTransformFeedback struct{}

func (*GlBindTransformFeedback) Class() binary.Class {
	return (*binaryClassGlBindTransformFeedback)(nil)
}
func doEncodeGlBindTransformFeedback(e binary.Encoder, o *GlBindTransformFeedback) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Id))
}
func doDecodeGlBindTransformFeedback(d binary.Decoder, o *GlBindTransformFeedback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Id = TransformFeedbackId(d.Uint32())
}
func doDecodeRawGlBindTransformFeedback(d binary.Decoder, o *GlBindTransformFeedback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Id = TransformFeedbackId(d.Uint32())
}
func (*binaryClassGlBindTransformFeedback) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindTransformFeedback(e, obj.(*GlBindTransformFeedback))
}
func (*binaryClassGlBindTransformFeedback) New() binary.Object {
	return &GlBindTransformFeedback{}
}
func (*binaryClassGlBindTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindTransformFeedback(d, obj.(*GlBindTransformFeedback))
}
func (c *binaryClassGlBindTransformFeedback) Schema() *binary.Entity {
	return &entities[ixǁGlBindTransformFeedback]
}

type binaryClassGlBindVertexArray struct{}

func (*GlBindVertexArray) Class() binary.Class {
	return (*binaryClassGlBindVertexArray)(nil)
}
func doEncodeGlBindVertexArray(e binary.Encoder, o *GlBindVertexArray) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Array))
}
func doDecodeGlBindVertexArray(d binary.Decoder, o *GlBindVertexArray) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Array = VertexArrayId(d.Uint32())
}
func doDecodeRawGlBindVertexArray(d binary.Decoder, o *GlBindVertexArray) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Array = VertexArrayId(d.Uint32())
}
func (*binaryClassGlBindVertexArray) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindVertexArray(e, obj.(*GlBindVertexArray))
}
func (*binaryClassGlBindVertexArray) New() binary.Object {
	return &GlBindVertexArray{}
}
func (*binaryClassGlBindVertexArray) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindVertexArray(d, obj.(*GlBindVertexArray))
}
func (c *binaryClassGlBindVertexArray) Schema() *binary.Entity {
	return &entities[ixǁGlBindVertexArray]
}

type binaryClassGlBindVertexArrayOES struct{}

func (*GlBindVertexArrayOES) Class() binary.Class {
	return (*binaryClassGlBindVertexArrayOES)(nil)
}
func doEncodeGlBindVertexArrayOES(e binary.Encoder, o *GlBindVertexArrayOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Array))
}
func doDecodeGlBindVertexArrayOES(d binary.Decoder, o *GlBindVertexArrayOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Array = VertexArrayId(d.Uint32())
}
func doDecodeRawGlBindVertexArrayOES(d binary.Decoder, o *GlBindVertexArrayOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Array = VertexArrayId(d.Uint32())
}
func (*binaryClassGlBindVertexArrayOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindVertexArrayOES(e, obj.(*GlBindVertexArrayOES))
}
func (*binaryClassGlBindVertexArrayOES) New() binary.Object {
	return &GlBindVertexArrayOES{}
}
func (*binaryClassGlBindVertexArrayOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindVertexArrayOES(d, obj.(*GlBindVertexArrayOES))
}
func (c *binaryClassGlBindVertexArrayOES) Schema() *binary.Entity {
	return &entities[ixǁGlBindVertexArrayOES]
}

type binaryClassGlBindVertexBuffer struct{}

func (*GlBindVertexBuffer) Class() binary.Class {
	return (*binaryClassGlBindVertexBuffer)(nil)
}
func doEncodeGlBindVertexBuffer(e binary.Encoder, o *GlBindVertexBuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.BindingIndex))
	e.Uint32(uint32(o.Buffer))
	e.Int32(int32(o.Offset))
	e.Int32(int32(o.Stride))
}
func doDecodeGlBindVertexBuffer(d binary.Decoder, o *GlBindVertexBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.BindingIndex = VertexBufferBindingIndex(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Stride = GLsizei(d.Int32())
}
func doDecodeRawGlBindVertexBuffer(d binary.Decoder, o *GlBindVertexBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.BindingIndex = VertexBufferBindingIndex(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Stride = GLsizei(d.Int32())
}
func (*binaryClassGlBindVertexBuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBindVertexBuffer(e, obj.(*GlBindVertexBuffer))
}
func (*binaryClassGlBindVertexBuffer) New() binary.Object {
	return &GlBindVertexBuffer{}
}
func (*binaryClassGlBindVertexBuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBindVertexBuffer(d, obj.(*GlBindVertexBuffer))
}
func (c *binaryClassGlBindVertexBuffer) Schema() *binary.Entity {
	return &entities[ixǁGlBindVertexBuffer]
}

type binaryClassGlBlendBarrier struct{}

func (*GlBlendBarrier) Class() binary.Class {
	return (*binaryClassGlBlendBarrier)(nil)
}
func doEncodeGlBlendBarrier(e binary.Encoder, o *GlBlendBarrier) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlBlendBarrier(d binary.Decoder, o *GlBlendBarrier) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlBlendBarrier(d binary.Decoder, o *GlBlendBarrier) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlBlendBarrier) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendBarrier(e, obj.(*GlBlendBarrier))
}
func (*binaryClassGlBlendBarrier) New() binary.Object {
	return &GlBlendBarrier{}
}
func (*binaryClassGlBlendBarrier) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendBarrier(d, obj.(*GlBlendBarrier))
}
func (c *binaryClassGlBlendBarrier) Schema() *binary.Entity {
	return &entities[ixǁGlBlendBarrier]
}

type binaryClassGlBlendBarrierKHR struct{}

func (*GlBlendBarrierKHR) Class() binary.Class {
	return (*binaryClassGlBlendBarrierKHR)(nil)
}
func doEncodeGlBlendBarrierKHR(e binary.Encoder, o *GlBlendBarrierKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlBlendBarrierKHR(d binary.Decoder, o *GlBlendBarrierKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlBlendBarrierKHR(d binary.Decoder, o *GlBlendBarrierKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlBlendBarrierKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendBarrierKHR(e, obj.(*GlBlendBarrierKHR))
}
func (*binaryClassGlBlendBarrierKHR) New() binary.Object {
	return &GlBlendBarrierKHR{}
}
func (*binaryClassGlBlendBarrierKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendBarrierKHR(d, obj.(*GlBlendBarrierKHR))
}
func (c *binaryClassGlBlendBarrierKHR) Schema() *binary.Entity {
	return &entities[ixǁGlBlendBarrierKHR]
}

type binaryClassGlBlendBarrierNV struct{}

func (*GlBlendBarrierNV) Class() binary.Class {
	return (*binaryClassGlBlendBarrierNV)(nil)
}
func doEncodeGlBlendBarrierNV(e binary.Encoder, o *GlBlendBarrierNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlBlendBarrierNV(d binary.Decoder, o *GlBlendBarrierNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlBlendBarrierNV(d binary.Decoder, o *GlBlendBarrierNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlBlendBarrierNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendBarrierNV(e, obj.(*GlBlendBarrierNV))
}
func (*binaryClassGlBlendBarrierNV) New() binary.Object {
	return &GlBlendBarrierNV{}
}
func (*binaryClassGlBlendBarrierNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendBarrierNV(d, obj.(*GlBlendBarrierNV))
}
func (c *binaryClassGlBlendBarrierNV) Schema() *binary.Entity {
	return &entities[ixǁGlBlendBarrierNV]
}

type binaryClassGlBlendColor struct{}

func (*GlBlendColor) Class() binary.Class {
	return (*binaryClassGlBlendColor)(nil)
}
func doEncodeGlBlendColor(e binary.Encoder, o *GlBlendColor) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Red))
	e.Float32(float32(o.Green))
	e.Float32(float32(o.Blue))
	e.Float32(float32(o.Alpha))
}
func doDecodeGlBlendColor(d binary.Decoder, o *GlBlendColor) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLfloat(d.Float32())
	o.Green = GLfloat(d.Float32())
	o.Blue = GLfloat(d.Float32())
	o.Alpha = GLfloat(d.Float32())
}
func doDecodeRawGlBlendColor(d binary.Decoder, o *GlBlendColor) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLfloat(d.Float32())
	o.Green = GLfloat(d.Float32())
	o.Blue = GLfloat(d.Float32())
	o.Alpha = GLfloat(d.Float32())
}
func (*binaryClassGlBlendColor) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendColor(e, obj.(*GlBlendColor))
}
func (*binaryClassGlBlendColor) New() binary.Object {
	return &GlBlendColor{}
}
func (*binaryClassGlBlendColor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendColor(d, obj.(*GlBlendColor))
}
func (c *binaryClassGlBlendColor) Schema() *binary.Entity {
	return &entities[ixǁGlBlendColor]
}

type binaryClassGlBlendEquation struct{}

func (*GlBlendEquation) Class() binary.Class {
	return (*binaryClassGlBlendEquation)(nil)
}
func doEncodeGlBlendEquation(e binary.Encoder, o *GlBlendEquation) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Equation))
}
func doDecodeGlBlendEquation(d binary.Decoder, o *GlBlendEquation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Equation = GLenum(d.Uint32())
}
func doDecodeRawGlBlendEquation(d binary.Decoder, o *GlBlendEquation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Equation = GLenum(d.Uint32())
}
func (*binaryClassGlBlendEquation) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendEquation(e, obj.(*GlBlendEquation))
}
func (*binaryClassGlBlendEquation) New() binary.Object {
	return &GlBlendEquation{}
}
func (*binaryClassGlBlendEquation) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendEquation(d, obj.(*GlBlendEquation))
}
func (c *binaryClassGlBlendEquation) Schema() *binary.Entity {
	return &entities[ixǁGlBlendEquation]
}

type binaryClassGlBlendEquationOES struct{}

func (*GlBlendEquationOES) Class() binary.Class {
	return (*binaryClassGlBlendEquationOES)(nil)
}
func doEncodeGlBlendEquationOES(e binary.Encoder, o *GlBlendEquationOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
}
func doDecodeGlBlendEquationOES(d binary.Decoder, o *GlBlendEquationOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
}
func doDecodeRawGlBlendEquationOES(d binary.Decoder, o *GlBlendEquationOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
}
func (*binaryClassGlBlendEquationOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendEquationOES(e, obj.(*GlBlendEquationOES))
}
func (*binaryClassGlBlendEquationOES) New() binary.Object {
	return &GlBlendEquationOES{}
}
func (*binaryClassGlBlendEquationOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendEquationOES(d, obj.(*GlBlendEquationOES))
}
func (c *binaryClassGlBlendEquationOES) Schema() *binary.Entity {
	return &entities[ixǁGlBlendEquationOES]
}

type binaryClassGlBlendEquationSeparate struct{}

func (*GlBlendEquationSeparate) Class() binary.Class {
	return (*binaryClassGlBlendEquationSeparate)(nil)
}
func doEncodeGlBlendEquationSeparate(e binary.Encoder, o *GlBlendEquationSeparate) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Rgb))
	e.Uint32(uint32(o.Alpha))
}
func doDecodeGlBlendEquationSeparate(d binary.Decoder, o *GlBlendEquationSeparate) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Rgb = GLenum(d.Uint32())
	o.Alpha = GLenum(d.Uint32())
}
func doDecodeRawGlBlendEquationSeparate(d binary.Decoder, o *GlBlendEquationSeparate) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Rgb = GLenum(d.Uint32())
	o.Alpha = GLenum(d.Uint32())
}
func (*binaryClassGlBlendEquationSeparate) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendEquationSeparate(e, obj.(*GlBlendEquationSeparate))
}
func (*binaryClassGlBlendEquationSeparate) New() binary.Object {
	return &GlBlendEquationSeparate{}
}
func (*binaryClassGlBlendEquationSeparate) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendEquationSeparate(d, obj.(*GlBlendEquationSeparate))
}
func (c *binaryClassGlBlendEquationSeparate) Schema() *binary.Entity {
	return &entities[ixǁGlBlendEquationSeparate]
}

type binaryClassGlBlendEquationSeparateOES struct{}

func (*GlBlendEquationSeparateOES) Class() binary.Class {
	return (*binaryClassGlBlendEquationSeparateOES)(nil)
}
func doEncodeGlBlendEquationSeparateOES(e binary.Encoder, o *GlBlendEquationSeparateOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.ModeRGB))
	e.Uint32(uint32(o.ModeAlpha))
}
func doDecodeGlBlendEquationSeparateOES(d binary.Decoder, o *GlBlendEquationSeparateOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ModeRGB = GLenum(d.Uint32())
	o.ModeAlpha = GLenum(d.Uint32())
}
func doDecodeRawGlBlendEquationSeparateOES(d binary.Decoder, o *GlBlendEquationSeparateOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ModeRGB = GLenum(d.Uint32())
	o.ModeAlpha = GLenum(d.Uint32())
}
func (*binaryClassGlBlendEquationSeparateOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendEquationSeparateOES(e, obj.(*GlBlendEquationSeparateOES))
}
func (*binaryClassGlBlendEquationSeparateOES) New() binary.Object {
	return &GlBlendEquationSeparateOES{}
}
func (*binaryClassGlBlendEquationSeparateOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendEquationSeparateOES(d, obj.(*GlBlendEquationSeparateOES))
}
func (c *binaryClassGlBlendEquationSeparateOES) Schema() *binary.Entity {
	return &entities[ixǁGlBlendEquationSeparateOES]
}

type binaryClassGlBlendEquationSeparatei struct{}

func (*GlBlendEquationSeparatei) Class() binary.Class {
	return (*binaryClassGlBlendEquationSeparatei)(nil)
}
func doEncodeGlBlendEquationSeparatei(e binary.Encoder, o *GlBlendEquationSeparatei) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buf))
	e.Uint32(uint32(o.ModeRGB))
	e.Uint32(uint32(o.ModeAlpha))
}
func doDecodeGlBlendEquationSeparatei(d binary.Decoder, o *GlBlendEquationSeparatei) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.ModeRGB = GLenum(d.Uint32())
	o.ModeAlpha = GLenum(d.Uint32())
}
func doDecodeRawGlBlendEquationSeparatei(d binary.Decoder, o *GlBlendEquationSeparatei) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.ModeRGB = GLenum(d.Uint32())
	o.ModeAlpha = GLenum(d.Uint32())
}
func (*binaryClassGlBlendEquationSeparatei) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendEquationSeparatei(e, obj.(*GlBlendEquationSeparatei))
}
func (*binaryClassGlBlendEquationSeparatei) New() binary.Object {
	return &GlBlendEquationSeparatei{}
}
func (*binaryClassGlBlendEquationSeparatei) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendEquationSeparatei(d, obj.(*GlBlendEquationSeparatei))
}
func (c *binaryClassGlBlendEquationSeparatei) Schema() *binary.Entity {
	return &entities[ixǁGlBlendEquationSeparatei]
}

type binaryClassGlBlendEquationSeparateiEXT struct{}

func (*GlBlendEquationSeparateiEXT) Class() binary.Class {
	return (*binaryClassGlBlendEquationSeparateiEXT)(nil)
}
func doEncodeGlBlendEquationSeparateiEXT(e binary.Encoder, o *GlBlendEquationSeparateiEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buf))
	e.Uint32(uint32(o.ModeRGB))
	e.Uint32(uint32(o.ModeAlpha))
}
func doDecodeGlBlendEquationSeparateiEXT(d binary.Decoder, o *GlBlendEquationSeparateiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.ModeRGB = GLenum(d.Uint32())
	o.ModeAlpha = GLenum(d.Uint32())
}
func doDecodeRawGlBlendEquationSeparateiEXT(d binary.Decoder, o *GlBlendEquationSeparateiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.ModeRGB = GLenum(d.Uint32())
	o.ModeAlpha = GLenum(d.Uint32())
}
func (*binaryClassGlBlendEquationSeparateiEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendEquationSeparateiEXT(e, obj.(*GlBlendEquationSeparateiEXT))
}
func (*binaryClassGlBlendEquationSeparateiEXT) New() binary.Object {
	return &GlBlendEquationSeparateiEXT{}
}
func (*binaryClassGlBlendEquationSeparateiEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendEquationSeparateiEXT(d, obj.(*GlBlendEquationSeparateiEXT))
}
func (c *binaryClassGlBlendEquationSeparateiEXT) Schema() *binary.Entity {
	return &entities[ixǁGlBlendEquationSeparateiEXT]
}

type binaryClassGlBlendEquationSeparateiOES struct{}

func (*GlBlendEquationSeparateiOES) Class() binary.Class {
	return (*binaryClassGlBlendEquationSeparateiOES)(nil)
}
func doEncodeGlBlendEquationSeparateiOES(e binary.Encoder, o *GlBlendEquationSeparateiOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buf))
	e.Uint32(uint32(o.ModeRGB))
	e.Uint32(uint32(o.ModeAlpha))
}
func doDecodeGlBlendEquationSeparateiOES(d binary.Decoder, o *GlBlendEquationSeparateiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.ModeRGB = GLenum(d.Uint32())
	o.ModeAlpha = GLenum(d.Uint32())
}
func doDecodeRawGlBlendEquationSeparateiOES(d binary.Decoder, o *GlBlendEquationSeparateiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.ModeRGB = GLenum(d.Uint32())
	o.ModeAlpha = GLenum(d.Uint32())
}
func (*binaryClassGlBlendEquationSeparateiOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendEquationSeparateiOES(e, obj.(*GlBlendEquationSeparateiOES))
}
func (*binaryClassGlBlendEquationSeparateiOES) New() binary.Object {
	return &GlBlendEquationSeparateiOES{}
}
func (*binaryClassGlBlendEquationSeparateiOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendEquationSeparateiOES(d, obj.(*GlBlendEquationSeparateiOES))
}
func (c *binaryClassGlBlendEquationSeparateiOES) Schema() *binary.Entity {
	return &entities[ixǁGlBlendEquationSeparateiOES]
}

type binaryClassGlBlendEquationi struct{}

func (*GlBlendEquationi) Class() binary.Class {
	return (*binaryClassGlBlendEquationi)(nil)
}
func doEncodeGlBlendEquationi(e binary.Encoder, o *GlBlendEquationi) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buf))
	e.Uint32(uint32(o.Mode))
}
func doDecodeGlBlendEquationi(d binary.Decoder, o *GlBlendEquationi) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.Mode = GLenum(d.Uint32())
}
func doDecodeRawGlBlendEquationi(d binary.Decoder, o *GlBlendEquationi) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.Mode = GLenum(d.Uint32())
}
func (*binaryClassGlBlendEquationi) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendEquationi(e, obj.(*GlBlendEquationi))
}
func (*binaryClassGlBlendEquationi) New() binary.Object {
	return &GlBlendEquationi{}
}
func (*binaryClassGlBlendEquationi) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendEquationi(d, obj.(*GlBlendEquationi))
}
func (c *binaryClassGlBlendEquationi) Schema() *binary.Entity {
	return &entities[ixǁGlBlendEquationi]
}

type binaryClassGlBlendEquationiEXT struct{}

func (*GlBlendEquationiEXT) Class() binary.Class {
	return (*binaryClassGlBlendEquationiEXT)(nil)
}
func doEncodeGlBlendEquationiEXT(e binary.Encoder, o *GlBlendEquationiEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buf))
	e.Uint32(uint32(o.Mode))
}
func doDecodeGlBlendEquationiEXT(d binary.Decoder, o *GlBlendEquationiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.Mode = GLenum(d.Uint32())
}
func doDecodeRawGlBlendEquationiEXT(d binary.Decoder, o *GlBlendEquationiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.Mode = GLenum(d.Uint32())
}
func (*binaryClassGlBlendEquationiEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendEquationiEXT(e, obj.(*GlBlendEquationiEXT))
}
func (*binaryClassGlBlendEquationiEXT) New() binary.Object {
	return &GlBlendEquationiEXT{}
}
func (*binaryClassGlBlendEquationiEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendEquationiEXT(d, obj.(*GlBlendEquationiEXT))
}
func (c *binaryClassGlBlendEquationiEXT) Schema() *binary.Entity {
	return &entities[ixǁGlBlendEquationiEXT]
}

type binaryClassGlBlendEquationiOES struct{}

func (*GlBlendEquationiOES) Class() binary.Class {
	return (*binaryClassGlBlendEquationiOES)(nil)
}
func doEncodeGlBlendEquationiOES(e binary.Encoder, o *GlBlendEquationiOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buf))
	e.Uint32(uint32(o.Mode))
}
func doDecodeGlBlendEquationiOES(d binary.Decoder, o *GlBlendEquationiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.Mode = GLenum(d.Uint32())
}
func doDecodeRawGlBlendEquationiOES(d binary.Decoder, o *GlBlendEquationiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.Mode = GLenum(d.Uint32())
}
func (*binaryClassGlBlendEquationiOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendEquationiOES(e, obj.(*GlBlendEquationiOES))
}
func (*binaryClassGlBlendEquationiOES) New() binary.Object {
	return &GlBlendEquationiOES{}
}
func (*binaryClassGlBlendEquationiOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendEquationiOES(d, obj.(*GlBlendEquationiOES))
}
func (c *binaryClassGlBlendEquationiOES) Schema() *binary.Entity {
	return &entities[ixǁGlBlendEquationiOES]
}

type binaryClassGlBlendFunc struct{}

func (*GlBlendFunc) Class() binary.Class {
	return (*binaryClassGlBlendFunc)(nil)
}
func doEncodeGlBlendFunc(e binary.Encoder, o *GlBlendFunc) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.SrcFactor))
	e.Uint32(uint32(o.DstFactor))
}
func doDecodeGlBlendFunc(d binary.Decoder, o *GlBlendFunc) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcFactor = GLenum(d.Uint32())
	o.DstFactor = GLenum(d.Uint32())
}
func doDecodeRawGlBlendFunc(d binary.Decoder, o *GlBlendFunc) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcFactor = GLenum(d.Uint32())
	o.DstFactor = GLenum(d.Uint32())
}
func (*binaryClassGlBlendFunc) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendFunc(e, obj.(*GlBlendFunc))
}
func (*binaryClassGlBlendFunc) New() binary.Object {
	return &GlBlendFunc{}
}
func (*binaryClassGlBlendFunc) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendFunc(d, obj.(*GlBlendFunc))
}
func (c *binaryClassGlBlendFunc) Schema() *binary.Entity {
	return &entities[ixǁGlBlendFunc]
}

type binaryClassGlBlendFuncSeparate struct{}

func (*GlBlendFuncSeparate) Class() binary.Class {
	return (*binaryClassGlBlendFuncSeparate)(nil)
}
func doEncodeGlBlendFuncSeparate(e binary.Encoder, o *GlBlendFuncSeparate) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.SrcFactorRgb))
	e.Uint32(uint32(o.DstFactorRgb))
	e.Uint32(uint32(o.SrcFactorAlpha))
	e.Uint32(uint32(o.DstFactorAlpha))
}
func doDecodeGlBlendFuncSeparate(d binary.Decoder, o *GlBlendFuncSeparate) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcFactorRgb = GLenum(d.Uint32())
	o.DstFactorRgb = GLenum(d.Uint32())
	o.SrcFactorAlpha = GLenum(d.Uint32())
	o.DstFactorAlpha = GLenum(d.Uint32())
}
func doDecodeRawGlBlendFuncSeparate(d binary.Decoder, o *GlBlendFuncSeparate) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcFactorRgb = GLenum(d.Uint32())
	o.DstFactorRgb = GLenum(d.Uint32())
	o.SrcFactorAlpha = GLenum(d.Uint32())
	o.DstFactorAlpha = GLenum(d.Uint32())
}
func (*binaryClassGlBlendFuncSeparate) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendFuncSeparate(e, obj.(*GlBlendFuncSeparate))
}
func (*binaryClassGlBlendFuncSeparate) New() binary.Object {
	return &GlBlendFuncSeparate{}
}
func (*binaryClassGlBlendFuncSeparate) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendFuncSeparate(d, obj.(*GlBlendFuncSeparate))
}
func (c *binaryClassGlBlendFuncSeparate) Schema() *binary.Entity {
	return &entities[ixǁGlBlendFuncSeparate]
}

type binaryClassGlBlendFuncSeparateOES struct{}

func (*GlBlendFuncSeparateOES) Class() binary.Class {
	return (*binaryClassGlBlendFuncSeparateOES)(nil)
}
func doEncodeGlBlendFuncSeparateOES(e binary.Encoder, o *GlBlendFuncSeparateOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.SrcRGB))
	e.Uint32(uint32(o.DstRGB))
	e.Uint32(uint32(o.SrcAlpha))
	e.Uint32(uint32(o.DstAlpha))
}
func doDecodeGlBlendFuncSeparateOES(d binary.Decoder, o *GlBlendFuncSeparateOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcRGB = GLenum(d.Uint32())
	o.DstRGB = GLenum(d.Uint32())
	o.SrcAlpha = GLenum(d.Uint32())
	o.DstAlpha = GLenum(d.Uint32())
}
func doDecodeRawGlBlendFuncSeparateOES(d binary.Decoder, o *GlBlendFuncSeparateOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcRGB = GLenum(d.Uint32())
	o.DstRGB = GLenum(d.Uint32())
	o.SrcAlpha = GLenum(d.Uint32())
	o.DstAlpha = GLenum(d.Uint32())
}
func (*binaryClassGlBlendFuncSeparateOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendFuncSeparateOES(e, obj.(*GlBlendFuncSeparateOES))
}
func (*binaryClassGlBlendFuncSeparateOES) New() binary.Object {
	return &GlBlendFuncSeparateOES{}
}
func (*binaryClassGlBlendFuncSeparateOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendFuncSeparateOES(d, obj.(*GlBlendFuncSeparateOES))
}
func (c *binaryClassGlBlendFuncSeparateOES) Schema() *binary.Entity {
	return &entities[ixǁGlBlendFuncSeparateOES]
}

type binaryClassGlBlendFuncSeparatei struct{}

func (*GlBlendFuncSeparatei) Class() binary.Class {
	return (*binaryClassGlBlendFuncSeparatei)(nil)
}
func doEncodeGlBlendFuncSeparatei(e binary.Encoder, o *GlBlendFuncSeparatei) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buf))
	e.Uint32(uint32(o.SrcRGB))
	e.Uint32(uint32(o.DstRGB))
	e.Uint32(uint32(o.SrcAlpha))
	e.Uint32(uint32(o.DstAlpha))
}
func doDecodeGlBlendFuncSeparatei(d binary.Decoder, o *GlBlendFuncSeparatei) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.SrcRGB = GLenum(d.Uint32())
	o.DstRGB = GLenum(d.Uint32())
	o.SrcAlpha = GLenum(d.Uint32())
	o.DstAlpha = GLenum(d.Uint32())
}
func doDecodeRawGlBlendFuncSeparatei(d binary.Decoder, o *GlBlendFuncSeparatei) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.SrcRGB = GLenum(d.Uint32())
	o.DstRGB = GLenum(d.Uint32())
	o.SrcAlpha = GLenum(d.Uint32())
	o.DstAlpha = GLenum(d.Uint32())
}
func (*binaryClassGlBlendFuncSeparatei) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendFuncSeparatei(e, obj.(*GlBlendFuncSeparatei))
}
func (*binaryClassGlBlendFuncSeparatei) New() binary.Object {
	return &GlBlendFuncSeparatei{}
}
func (*binaryClassGlBlendFuncSeparatei) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendFuncSeparatei(d, obj.(*GlBlendFuncSeparatei))
}
func (c *binaryClassGlBlendFuncSeparatei) Schema() *binary.Entity {
	return &entities[ixǁGlBlendFuncSeparatei]
}

type binaryClassGlBlendFuncSeparateiEXT struct{}

func (*GlBlendFuncSeparateiEXT) Class() binary.Class {
	return (*binaryClassGlBlendFuncSeparateiEXT)(nil)
}
func doEncodeGlBlendFuncSeparateiEXT(e binary.Encoder, o *GlBlendFuncSeparateiEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buf))
	e.Uint32(uint32(o.SrcRGB))
	e.Uint32(uint32(o.DstRGB))
	e.Uint32(uint32(o.SrcAlpha))
	e.Uint32(uint32(o.DstAlpha))
}
func doDecodeGlBlendFuncSeparateiEXT(d binary.Decoder, o *GlBlendFuncSeparateiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.SrcRGB = GLenum(d.Uint32())
	o.DstRGB = GLenum(d.Uint32())
	o.SrcAlpha = GLenum(d.Uint32())
	o.DstAlpha = GLenum(d.Uint32())
}
func doDecodeRawGlBlendFuncSeparateiEXT(d binary.Decoder, o *GlBlendFuncSeparateiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.SrcRGB = GLenum(d.Uint32())
	o.DstRGB = GLenum(d.Uint32())
	o.SrcAlpha = GLenum(d.Uint32())
	o.DstAlpha = GLenum(d.Uint32())
}
func (*binaryClassGlBlendFuncSeparateiEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendFuncSeparateiEXT(e, obj.(*GlBlendFuncSeparateiEXT))
}
func (*binaryClassGlBlendFuncSeparateiEXT) New() binary.Object {
	return &GlBlendFuncSeparateiEXT{}
}
func (*binaryClassGlBlendFuncSeparateiEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendFuncSeparateiEXT(d, obj.(*GlBlendFuncSeparateiEXT))
}
func (c *binaryClassGlBlendFuncSeparateiEXT) Schema() *binary.Entity {
	return &entities[ixǁGlBlendFuncSeparateiEXT]
}

type binaryClassGlBlendFuncSeparateiOES struct{}

func (*GlBlendFuncSeparateiOES) Class() binary.Class {
	return (*binaryClassGlBlendFuncSeparateiOES)(nil)
}
func doEncodeGlBlendFuncSeparateiOES(e binary.Encoder, o *GlBlendFuncSeparateiOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buf))
	e.Uint32(uint32(o.SrcRGB))
	e.Uint32(uint32(o.DstRGB))
	e.Uint32(uint32(o.SrcAlpha))
	e.Uint32(uint32(o.DstAlpha))
}
func doDecodeGlBlendFuncSeparateiOES(d binary.Decoder, o *GlBlendFuncSeparateiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.SrcRGB = GLenum(d.Uint32())
	o.DstRGB = GLenum(d.Uint32())
	o.SrcAlpha = GLenum(d.Uint32())
	o.DstAlpha = GLenum(d.Uint32())
}
func doDecodeRawGlBlendFuncSeparateiOES(d binary.Decoder, o *GlBlendFuncSeparateiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.SrcRGB = GLenum(d.Uint32())
	o.DstRGB = GLenum(d.Uint32())
	o.SrcAlpha = GLenum(d.Uint32())
	o.DstAlpha = GLenum(d.Uint32())
}
func (*binaryClassGlBlendFuncSeparateiOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendFuncSeparateiOES(e, obj.(*GlBlendFuncSeparateiOES))
}
func (*binaryClassGlBlendFuncSeparateiOES) New() binary.Object {
	return &GlBlendFuncSeparateiOES{}
}
func (*binaryClassGlBlendFuncSeparateiOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendFuncSeparateiOES(d, obj.(*GlBlendFuncSeparateiOES))
}
func (c *binaryClassGlBlendFuncSeparateiOES) Schema() *binary.Entity {
	return &entities[ixǁGlBlendFuncSeparateiOES]
}

type binaryClassGlBlendFunci struct{}

func (*GlBlendFunci) Class() binary.Class {
	return (*binaryClassGlBlendFunci)(nil)
}
func doEncodeGlBlendFunci(e binary.Encoder, o *GlBlendFunci) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buf))
	e.Uint32(uint32(o.Src))
	e.Uint32(uint32(o.Dst))
}
func doDecodeGlBlendFunci(d binary.Decoder, o *GlBlendFunci) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.Src = GLenum(d.Uint32())
	o.Dst = GLenum(d.Uint32())
}
func doDecodeRawGlBlendFunci(d binary.Decoder, o *GlBlendFunci) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.Src = GLenum(d.Uint32())
	o.Dst = GLenum(d.Uint32())
}
func (*binaryClassGlBlendFunci) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendFunci(e, obj.(*GlBlendFunci))
}
func (*binaryClassGlBlendFunci) New() binary.Object {
	return &GlBlendFunci{}
}
func (*binaryClassGlBlendFunci) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendFunci(d, obj.(*GlBlendFunci))
}
func (c *binaryClassGlBlendFunci) Schema() *binary.Entity {
	return &entities[ixǁGlBlendFunci]
}

type binaryClassGlBlendFunciEXT struct{}

func (*GlBlendFunciEXT) Class() binary.Class {
	return (*binaryClassGlBlendFunciEXT)(nil)
}
func doEncodeGlBlendFunciEXT(e binary.Encoder, o *GlBlendFunciEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buf))
	e.Uint32(uint32(o.Src))
	e.Uint32(uint32(o.Dst))
}
func doDecodeGlBlendFunciEXT(d binary.Decoder, o *GlBlendFunciEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.Src = GLenum(d.Uint32())
	o.Dst = GLenum(d.Uint32())
}
func doDecodeRawGlBlendFunciEXT(d binary.Decoder, o *GlBlendFunciEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.Src = GLenum(d.Uint32())
	o.Dst = GLenum(d.Uint32())
}
func (*binaryClassGlBlendFunciEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendFunciEXT(e, obj.(*GlBlendFunciEXT))
}
func (*binaryClassGlBlendFunciEXT) New() binary.Object {
	return &GlBlendFunciEXT{}
}
func (*binaryClassGlBlendFunciEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendFunciEXT(d, obj.(*GlBlendFunciEXT))
}
func (c *binaryClassGlBlendFunciEXT) Schema() *binary.Entity {
	return &entities[ixǁGlBlendFunciEXT]
}

type binaryClassGlBlendFunciOES struct{}

func (*GlBlendFunciOES) Class() binary.Class {
	return (*binaryClassGlBlendFunciOES)(nil)
}
func doEncodeGlBlendFunciOES(e binary.Encoder, o *GlBlendFunciOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buf))
	e.Uint32(uint32(o.Src))
	e.Uint32(uint32(o.Dst))
}
func doDecodeGlBlendFunciOES(d binary.Decoder, o *GlBlendFunciOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.Src = GLenum(d.Uint32())
	o.Dst = GLenum(d.Uint32())
}
func doDecodeRawGlBlendFunciOES(d binary.Decoder, o *GlBlendFunciOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buf = DrawBufferIndex(d.Uint32())
	o.Src = GLenum(d.Uint32())
	o.Dst = GLenum(d.Uint32())
}
func (*binaryClassGlBlendFunciOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendFunciOES(e, obj.(*GlBlendFunciOES))
}
func (*binaryClassGlBlendFunciOES) New() binary.Object {
	return &GlBlendFunciOES{}
}
func (*binaryClassGlBlendFunciOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendFunciOES(d, obj.(*GlBlendFunciOES))
}
func (c *binaryClassGlBlendFunciOES) Schema() *binary.Entity {
	return &entities[ixǁGlBlendFunciOES]
}

type binaryClassGlBlendParameteriNV struct{}

func (*GlBlendParameteriNV) Class() binary.Class {
	return (*binaryClassGlBlendParameteriNV)(nil)
}
func doEncodeGlBlendParameteriNV(e binary.Encoder, o *GlBlendParameteriNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Value))
}
func doDecodeGlBlendParameteriNV(d binary.Decoder, o *GlBlendParameteriNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func doDecodeRawGlBlendParameteriNV(d binary.Decoder, o *GlBlendParameteriNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func (*binaryClassGlBlendParameteriNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlendParameteriNV(e, obj.(*GlBlendParameteriNV))
}
func (*binaryClassGlBlendParameteriNV) New() binary.Object {
	return &GlBlendParameteriNV{}
}
func (*binaryClassGlBlendParameteriNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlendParameteriNV(d, obj.(*GlBlendParameteriNV))
}
func (c *binaryClassGlBlendParameteriNV) Schema() *binary.Entity {
	return &entities[ixǁGlBlendParameteriNV]
}

type binaryClassGlBlitFramebuffer struct{}

func (*GlBlitFramebuffer) Class() binary.Class {
	return (*binaryClassGlBlitFramebuffer)(nil)
}
func doEncodeGlBlitFramebuffer(e binary.Encoder, o *GlBlitFramebuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.SrcX0))
	e.Int32(int32(o.SrcY0))
	e.Int32(int32(o.SrcX1))
	e.Int32(int32(o.SrcY1))
	e.Int32(int32(o.DstX0))
	e.Int32(int32(o.DstY0))
	e.Int32(int32(o.DstX1))
	e.Int32(int32(o.DstY1))
	e.Uint32(uint32(o.Mask))
	e.Uint32(uint32(o.Filter))
}
func doDecodeGlBlitFramebuffer(d binary.Decoder, o *GlBlitFramebuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcX0 = GLint(d.Int32())
	o.SrcY0 = GLint(d.Int32())
	o.SrcX1 = GLint(d.Int32())
	o.SrcY1 = GLint(d.Int32())
	o.DstX0 = GLint(d.Int32())
	o.DstY0 = GLint(d.Int32())
	o.DstX1 = GLint(d.Int32())
	o.DstY1 = GLint(d.Int32())
	o.Mask = GLbitfield(d.Uint32())
	o.Filter = GLenum(d.Uint32())
}
func doDecodeRawGlBlitFramebuffer(d binary.Decoder, o *GlBlitFramebuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcX0 = GLint(d.Int32())
	o.SrcY0 = GLint(d.Int32())
	o.SrcX1 = GLint(d.Int32())
	o.SrcY1 = GLint(d.Int32())
	o.DstX0 = GLint(d.Int32())
	o.DstY0 = GLint(d.Int32())
	o.DstX1 = GLint(d.Int32())
	o.DstY1 = GLint(d.Int32())
	o.Mask = GLbitfield(d.Uint32())
	o.Filter = GLenum(d.Uint32())
}
func (*binaryClassGlBlitFramebuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlitFramebuffer(e, obj.(*GlBlitFramebuffer))
}
func (*binaryClassGlBlitFramebuffer) New() binary.Object {
	return &GlBlitFramebuffer{}
}
func (*binaryClassGlBlitFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlitFramebuffer(d, obj.(*GlBlitFramebuffer))
}
func (c *binaryClassGlBlitFramebuffer) Schema() *binary.Entity {
	return &entities[ixǁGlBlitFramebuffer]
}

type binaryClassGlBlitFramebufferANGLE struct{}

func (*GlBlitFramebufferANGLE) Class() binary.Class {
	return (*binaryClassGlBlitFramebufferANGLE)(nil)
}
func doEncodeGlBlitFramebufferANGLE(e binary.Encoder, o *GlBlitFramebufferANGLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.SrcX0))
	e.Int32(int32(o.SrcY0))
	e.Int32(int32(o.SrcX1))
	e.Int32(int32(o.SrcY1))
	e.Int32(int32(o.DstX0))
	e.Int32(int32(o.DstY0))
	e.Int32(int32(o.DstX1))
	e.Int32(int32(o.DstY1))
	e.Uint32(uint32(o.Mask))
	e.Uint32(uint32(o.Filter))
}
func doDecodeGlBlitFramebufferANGLE(d binary.Decoder, o *GlBlitFramebufferANGLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcX0 = GLint(d.Int32())
	o.SrcY0 = GLint(d.Int32())
	o.SrcX1 = GLint(d.Int32())
	o.SrcY1 = GLint(d.Int32())
	o.DstX0 = GLint(d.Int32())
	o.DstY0 = GLint(d.Int32())
	o.DstX1 = GLint(d.Int32())
	o.DstY1 = GLint(d.Int32())
	o.Mask = GLbitfield(d.Uint32())
	o.Filter = GLenum(d.Uint32())
}
func doDecodeRawGlBlitFramebufferANGLE(d binary.Decoder, o *GlBlitFramebufferANGLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcX0 = GLint(d.Int32())
	o.SrcY0 = GLint(d.Int32())
	o.SrcX1 = GLint(d.Int32())
	o.SrcY1 = GLint(d.Int32())
	o.DstX0 = GLint(d.Int32())
	o.DstY0 = GLint(d.Int32())
	o.DstX1 = GLint(d.Int32())
	o.DstY1 = GLint(d.Int32())
	o.Mask = GLbitfield(d.Uint32())
	o.Filter = GLenum(d.Uint32())
}
func (*binaryClassGlBlitFramebufferANGLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlitFramebufferANGLE(e, obj.(*GlBlitFramebufferANGLE))
}
func (*binaryClassGlBlitFramebufferANGLE) New() binary.Object {
	return &GlBlitFramebufferANGLE{}
}
func (*binaryClassGlBlitFramebufferANGLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlitFramebufferANGLE(d, obj.(*GlBlitFramebufferANGLE))
}
func (c *binaryClassGlBlitFramebufferANGLE) Schema() *binary.Entity {
	return &entities[ixǁGlBlitFramebufferANGLE]
}

type binaryClassGlBlitFramebufferNV struct{}

func (*GlBlitFramebufferNV) Class() binary.Class {
	return (*binaryClassGlBlitFramebufferNV)(nil)
}
func doEncodeGlBlitFramebufferNV(e binary.Encoder, o *GlBlitFramebufferNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.SrcX0))
	e.Int32(int32(o.SrcY0))
	e.Int32(int32(o.SrcX1))
	e.Int32(int32(o.SrcY1))
	e.Int32(int32(o.DstX0))
	e.Int32(int32(o.DstY0))
	e.Int32(int32(o.DstX1))
	e.Int32(int32(o.DstY1))
	e.Uint32(uint32(o.Mask))
	e.Uint32(uint32(o.Filter))
}
func doDecodeGlBlitFramebufferNV(d binary.Decoder, o *GlBlitFramebufferNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcX0 = GLint(d.Int32())
	o.SrcY0 = GLint(d.Int32())
	o.SrcX1 = GLint(d.Int32())
	o.SrcY1 = GLint(d.Int32())
	o.DstX0 = GLint(d.Int32())
	o.DstY0 = GLint(d.Int32())
	o.DstX1 = GLint(d.Int32())
	o.DstY1 = GLint(d.Int32())
	o.Mask = GLbitfield(d.Uint32())
	o.Filter = GLenum(d.Uint32())
}
func doDecodeRawGlBlitFramebufferNV(d binary.Decoder, o *GlBlitFramebufferNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcX0 = GLint(d.Int32())
	o.SrcY0 = GLint(d.Int32())
	o.SrcX1 = GLint(d.Int32())
	o.SrcY1 = GLint(d.Int32())
	o.DstX0 = GLint(d.Int32())
	o.DstY0 = GLint(d.Int32())
	o.DstX1 = GLint(d.Int32())
	o.DstY1 = GLint(d.Int32())
	o.Mask = GLbitfield(d.Uint32())
	o.Filter = GLenum(d.Uint32())
}
func (*binaryClassGlBlitFramebufferNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBlitFramebufferNV(e, obj.(*GlBlitFramebufferNV))
}
func (*binaryClassGlBlitFramebufferNV) New() binary.Object {
	return &GlBlitFramebufferNV{}
}
func (*binaryClassGlBlitFramebufferNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBlitFramebufferNV(d, obj.(*GlBlitFramebufferNV))
}
func (c *binaryClassGlBlitFramebufferNV) Schema() *binary.Entity {
	return &entities[ixǁGlBlitFramebufferNV]
}

type binaryClassGlBufferData struct{}

func (*GlBufferData) Class() binary.Class {
	return (*binaryClassGlBufferData)(nil)
}
func doEncodeGlBufferData(e binary.Encoder, o *GlBufferData) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Size))
	e.Simple(&o.Data)
	e.Uint32(uint32(o.Usage))
}
func doDecodeGlBufferData(d binary.Decoder, o *GlBufferData) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Size = GLsizeiptr(d.Int32())
	d.Simple(&o.Data)
	o.Usage = GLenum(d.Uint32())
}
func doDecodeRawGlBufferData(d binary.Decoder, o *GlBufferData) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Size = GLsizeiptr(d.Int32())
	d.Simple(&o.Data)
	o.Usage = GLenum(d.Uint32())
}
func (*binaryClassGlBufferData) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBufferData(e, obj.(*GlBufferData))
}
func (*binaryClassGlBufferData) New() binary.Object {
	return &GlBufferData{}
}
func (*binaryClassGlBufferData) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBufferData(d, obj.(*GlBufferData))
}
func (c *binaryClassGlBufferData) Schema() *binary.Entity {
	return &entities[ixǁGlBufferData]
}

type binaryClassGlBufferStorageEXT struct{}

func (*GlBufferStorageEXT) Class() binary.Class {
	return (*binaryClassGlBufferStorageEXT)(nil)
}
func doEncodeGlBufferStorageEXT(e binary.Encoder, o *GlBufferStorageEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Size))
	e.Simple(&o.Data)
	e.Uint32(uint32(o.Flag))
}
func doDecodeGlBufferStorageEXT(d binary.Decoder, o *GlBufferStorageEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Size = GLsizeiptr(d.Int32())
	d.Simple(&o.Data)
	o.Flag = GLbitfield(d.Uint32())
}
func doDecodeRawGlBufferStorageEXT(d binary.Decoder, o *GlBufferStorageEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Size = GLsizeiptr(d.Int32())
	d.Simple(&o.Data)
	o.Flag = GLbitfield(d.Uint32())
}
func (*binaryClassGlBufferStorageEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBufferStorageEXT(e, obj.(*GlBufferStorageEXT))
}
func (*binaryClassGlBufferStorageEXT) New() binary.Object {
	return &GlBufferStorageEXT{}
}
func (*binaryClassGlBufferStorageEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBufferStorageEXT(d, obj.(*GlBufferStorageEXT))
}
func (c *binaryClassGlBufferStorageEXT) Schema() *binary.Entity {
	return &entities[ixǁGlBufferStorageEXT]
}

type binaryClassGlBufferSubData struct{}

func (*GlBufferSubData) Class() binary.Class {
	return (*binaryClassGlBufferSubData)(nil)
}
func doEncodeGlBufferSubData(e binary.Encoder, o *GlBufferSubData) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Offset))
	e.Int32(int32(o.Size))
	e.Simple(&o.Data)
}
func doDecodeGlBufferSubData(d binary.Decoder, o *GlBufferSubData) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
	d.Simple(&o.Data)
}
func doDecodeRawGlBufferSubData(d binary.Decoder, o *GlBufferSubData) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
	d.Simple(&o.Data)
}
func (*binaryClassGlBufferSubData) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlBufferSubData(e, obj.(*GlBufferSubData))
}
func (*binaryClassGlBufferSubData) New() binary.Object {
	return &GlBufferSubData{}
}
func (*binaryClassGlBufferSubData) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlBufferSubData(d, obj.(*GlBufferSubData))
}
func (c *binaryClassGlBufferSubData) Schema() *binary.Entity {
	return &entities[ixǁGlBufferSubData]
}

type binaryClassGlCheckFramebufferStatus struct{}

func (*GlCheckFramebufferStatus) Class() binary.Class {
	return (*binaryClassGlCheckFramebufferStatus)(nil)
}
func doEncodeGlCheckFramebufferStatus(e binary.Encoder, o *GlCheckFramebufferStatus) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Result))
}
func doDecodeGlCheckFramebufferStatus(d binary.Decoder, o *GlCheckFramebufferStatus) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Result = GLenum(d.Uint32())
}
func doDecodeRawGlCheckFramebufferStatus(d binary.Decoder, o *GlCheckFramebufferStatus) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Result = GLenum(d.Uint32())
}
func (*binaryClassGlCheckFramebufferStatus) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCheckFramebufferStatus(e, obj.(*GlCheckFramebufferStatus))
}
func (*binaryClassGlCheckFramebufferStatus) New() binary.Object {
	return &GlCheckFramebufferStatus{}
}
func (*binaryClassGlCheckFramebufferStatus) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCheckFramebufferStatus(d, obj.(*GlCheckFramebufferStatus))
}
func (c *binaryClassGlCheckFramebufferStatus) Schema() *binary.Entity {
	return &entities[ixǁGlCheckFramebufferStatus]
}

type binaryClassGlCheckFramebufferStatusOES struct{}

func (*GlCheckFramebufferStatusOES) Class() binary.Class {
	return (*binaryClassGlCheckFramebufferStatusOES)(nil)
}
func doEncodeGlCheckFramebufferStatusOES(e binary.Encoder, o *GlCheckFramebufferStatusOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Result))
}
func doDecodeGlCheckFramebufferStatusOES(d binary.Decoder, o *GlCheckFramebufferStatusOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Result = GLenum(d.Uint32())
}
func doDecodeRawGlCheckFramebufferStatusOES(d binary.Decoder, o *GlCheckFramebufferStatusOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Result = GLenum(d.Uint32())
}
func (*binaryClassGlCheckFramebufferStatusOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCheckFramebufferStatusOES(e, obj.(*GlCheckFramebufferStatusOES))
}
func (*binaryClassGlCheckFramebufferStatusOES) New() binary.Object {
	return &GlCheckFramebufferStatusOES{}
}
func (*binaryClassGlCheckFramebufferStatusOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCheckFramebufferStatusOES(d, obj.(*GlCheckFramebufferStatusOES))
}
func (c *binaryClassGlCheckFramebufferStatusOES) Schema() *binary.Entity {
	return &entities[ixǁGlCheckFramebufferStatusOES]
}

type binaryClassGlClear struct{}

func (*GlClear) Class() binary.Class {
	return (*binaryClassGlClear)(nil)
}
func doEncodeGlClear(e binary.Encoder, o *GlClear) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mask))
}
func doDecodeGlClear(d binary.Decoder, o *GlClear) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mask = GLbitfield(d.Uint32())
}
func doDecodeRawGlClear(d binary.Decoder, o *GlClear) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mask = GLbitfield(d.Uint32())
}
func (*binaryClassGlClear) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClear(e, obj.(*GlClear))
}
func (*binaryClassGlClear) New() binary.Object {
	return &GlClear{}
}
func (*binaryClassGlClear) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClear(d, obj.(*GlClear))
}
func (c *binaryClassGlClear) Schema() *binary.Entity {
	return &entities[ixǁGlClear]
}

type binaryClassGlClearBufferfi struct{}

func (*GlClearBufferfi) Class() binary.Class {
	return (*binaryClassGlClearBufferfi)(nil)
}
func doEncodeGlClearBufferfi(e binary.Encoder, o *GlClearBufferfi) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buffer))
	e.Int32(int32(o.Drawbuffer))
	e.Float32(float32(o.Depth))
	e.Int32(int32(o.Stencil))
}
func doDecodeGlClearBufferfi(d binary.Decoder, o *GlClearBufferfi) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buffer = GLenum(d.Uint32())
	o.Drawbuffer = GLint(d.Int32())
	o.Depth = GLfloat(d.Float32())
	o.Stencil = GLint(d.Int32())
}
func doDecodeRawGlClearBufferfi(d binary.Decoder, o *GlClearBufferfi) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buffer = GLenum(d.Uint32())
	o.Drawbuffer = GLint(d.Int32())
	o.Depth = GLfloat(d.Float32())
	o.Stencil = GLint(d.Int32())
}
func (*binaryClassGlClearBufferfi) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClearBufferfi(e, obj.(*GlClearBufferfi))
}
func (*binaryClassGlClearBufferfi) New() binary.Object {
	return &GlClearBufferfi{}
}
func (*binaryClassGlClearBufferfi) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClearBufferfi(d, obj.(*GlClearBufferfi))
}
func (c *binaryClassGlClearBufferfi) Schema() *binary.Entity {
	return &entities[ixǁGlClearBufferfi]
}

type binaryClassGlClearBufferfv struct{}

func (*GlClearBufferfv) Class() binary.Class {
	return (*binaryClassGlClearBufferfv)(nil)
}
func doEncodeGlClearBufferfv(e binary.Encoder, o *GlClearBufferfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buffer))
	e.Int32(int32(o.Drawbuffer))
	e.Simple(&o.Value)
}
func doDecodeGlClearBufferfv(d binary.Decoder, o *GlClearBufferfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buffer = GLenum(d.Uint32())
	o.Drawbuffer = GLint(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlClearBufferfv(d binary.Decoder, o *GlClearBufferfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buffer = GLenum(d.Uint32())
	o.Drawbuffer = GLint(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlClearBufferfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClearBufferfv(e, obj.(*GlClearBufferfv))
}
func (*binaryClassGlClearBufferfv) New() binary.Object {
	return &GlClearBufferfv{}
}
func (*binaryClassGlClearBufferfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClearBufferfv(d, obj.(*GlClearBufferfv))
}
func (c *binaryClassGlClearBufferfv) Schema() *binary.Entity {
	return &entities[ixǁGlClearBufferfv]
}

type binaryClassGlClearBufferiv struct{}

func (*GlClearBufferiv) Class() binary.Class {
	return (*binaryClassGlClearBufferiv)(nil)
}
func doEncodeGlClearBufferiv(e binary.Encoder, o *GlClearBufferiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buffer))
	e.Int32(int32(o.Drawbuffer))
	e.Simple(&o.Value)
}
func doDecodeGlClearBufferiv(d binary.Decoder, o *GlClearBufferiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buffer = GLenum(d.Uint32())
	o.Drawbuffer = GLint(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlClearBufferiv(d binary.Decoder, o *GlClearBufferiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buffer = GLenum(d.Uint32())
	o.Drawbuffer = GLint(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlClearBufferiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClearBufferiv(e, obj.(*GlClearBufferiv))
}
func (*binaryClassGlClearBufferiv) New() binary.Object {
	return &GlClearBufferiv{}
}
func (*binaryClassGlClearBufferiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClearBufferiv(d, obj.(*GlClearBufferiv))
}
func (c *binaryClassGlClearBufferiv) Schema() *binary.Entity {
	return &entities[ixǁGlClearBufferiv]
}

type binaryClassGlClearBufferuiv struct{}

func (*GlClearBufferuiv) Class() binary.Class {
	return (*binaryClassGlClearBufferuiv)(nil)
}
func doEncodeGlClearBufferuiv(e binary.Encoder, o *GlClearBufferuiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buffer))
	e.Int32(int32(o.Drawbuffer))
	e.Simple(&o.Value)
}
func doDecodeGlClearBufferuiv(d binary.Decoder, o *GlClearBufferuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buffer = GLenum(d.Uint32())
	o.Drawbuffer = GLint(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlClearBufferuiv(d binary.Decoder, o *GlClearBufferuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buffer = GLenum(d.Uint32())
	o.Drawbuffer = GLint(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlClearBufferuiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClearBufferuiv(e, obj.(*GlClearBufferuiv))
}
func (*binaryClassGlClearBufferuiv) New() binary.Object {
	return &GlClearBufferuiv{}
}
func (*binaryClassGlClearBufferuiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClearBufferuiv(d, obj.(*GlClearBufferuiv))
}
func (c *binaryClassGlClearBufferuiv) Schema() *binary.Entity {
	return &entities[ixǁGlClearBufferuiv]
}

type binaryClassGlClearColor struct{}

func (*GlClearColor) Class() binary.Class {
	return (*binaryClassGlClearColor)(nil)
}
func doEncodeGlClearColor(e binary.Encoder, o *GlClearColor) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.R))
	e.Float32(float32(o.G))
	e.Float32(float32(o.B))
	e.Float32(float32(o.A))
}
func doDecodeGlClearColor(d binary.Decoder, o *GlClearColor) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.R = GLfloat(d.Float32())
	o.G = GLfloat(d.Float32())
	o.B = GLfloat(d.Float32())
	o.A = GLfloat(d.Float32())
}
func doDecodeRawGlClearColor(d binary.Decoder, o *GlClearColor) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.R = GLfloat(d.Float32())
	o.G = GLfloat(d.Float32())
	o.B = GLfloat(d.Float32())
	o.A = GLfloat(d.Float32())
}
func (*binaryClassGlClearColor) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClearColor(e, obj.(*GlClearColor))
}
func (*binaryClassGlClearColor) New() binary.Object {
	return &GlClearColor{}
}
func (*binaryClassGlClearColor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClearColor(d, obj.(*GlClearColor))
}
func (c *binaryClassGlClearColor) Schema() *binary.Entity {
	return &entities[ixǁGlClearColor]
}

type binaryClassGlClearColorx struct{}

func (*GlClearColorx) Class() binary.Class {
	return (*binaryClassGlClearColorx)(nil)
}
func doEncodeGlClearColorx(e binary.Encoder, o *GlClearColorx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Red))
	e.Int32(int32(o.Green))
	e.Int32(int32(o.Blue))
	e.Int32(int32(o.Alpha))
}
func doDecodeGlClearColorx(d binary.Decoder, o *GlClearColorx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLfixed(d.Int32())
	o.Green = GLfixed(d.Int32())
	o.Blue = GLfixed(d.Int32())
	o.Alpha = GLfixed(d.Int32())
}
func doDecodeRawGlClearColorx(d binary.Decoder, o *GlClearColorx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLfixed(d.Int32())
	o.Green = GLfixed(d.Int32())
	o.Blue = GLfixed(d.Int32())
	o.Alpha = GLfixed(d.Int32())
}
func (*binaryClassGlClearColorx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClearColorx(e, obj.(*GlClearColorx))
}
func (*binaryClassGlClearColorx) New() binary.Object {
	return &GlClearColorx{}
}
func (*binaryClassGlClearColorx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClearColorx(d, obj.(*GlClearColorx))
}
func (c *binaryClassGlClearColorx) Schema() *binary.Entity {
	return &entities[ixǁGlClearColorx]
}

type binaryClassGlClearColorxOES struct{}

func (*GlClearColorxOES) Class() binary.Class {
	return (*binaryClassGlClearColorxOES)(nil)
}
func doEncodeGlClearColorxOES(e binary.Encoder, o *GlClearColorxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Red))
	e.Int32(int32(o.Green))
	e.Int32(int32(o.Blue))
	e.Int32(int32(o.Alpha))
}
func doDecodeGlClearColorxOES(d binary.Decoder, o *GlClearColorxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLfixed(d.Int32())
	o.Green = GLfixed(d.Int32())
	o.Blue = GLfixed(d.Int32())
	o.Alpha = GLfixed(d.Int32())
}
func doDecodeRawGlClearColorxOES(d binary.Decoder, o *GlClearColorxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLfixed(d.Int32())
	o.Green = GLfixed(d.Int32())
	o.Blue = GLfixed(d.Int32())
	o.Alpha = GLfixed(d.Int32())
}
func (*binaryClassGlClearColorxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClearColorxOES(e, obj.(*GlClearColorxOES))
}
func (*binaryClassGlClearColorxOES) New() binary.Object {
	return &GlClearColorxOES{}
}
func (*binaryClassGlClearColorxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClearColorxOES(d, obj.(*GlClearColorxOES))
}
func (c *binaryClassGlClearColorxOES) Schema() *binary.Entity {
	return &entities[ixǁGlClearColorxOES]
}

type binaryClassGlClearDepthf struct{}

func (*GlClearDepthf) Class() binary.Class {
	return (*binaryClassGlClearDepthf)(nil)
}
func doEncodeGlClearDepthf(e binary.Encoder, o *GlClearDepthf) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Depth))
}
func doDecodeGlClearDepthf(d binary.Decoder, o *GlClearDepthf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Depth = GLfloat(d.Float32())
}
func doDecodeRawGlClearDepthf(d binary.Decoder, o *GlClearDepthf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Depth = GLfloat(d.Float32())
}
func (*binaryClassGlClearDepthf) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClearDepthf(e, obj.(*GlClearDepthf))
}
func (*binaryClassGlClearDepthf) New() binary.Object {
	return &GlClearDepthf{}
}
func (*binaryClassGlClearDepthf) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClearDepthf(d, obj.(*GlClearDepthf))
}
func (c *binaryClassGlClearDepthf) Schema() *binary.Entity {
	return &entities[ixǁGlClearDepthf]
}

type binaryClassGlClearDepthfOES struct{}

func (*GlClearDepthfOES) Class() binary.Class {
	return (*binaryClassGlClearDepthfOES)(nil)
}
func doEncodeGlClearDepthfOES(e binary.Encoder, o *GlClearDepthfOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Depth))
}
func doDecodeGlClearDepthfOES(d binary.Decoder, o *GlClearDepthfOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Depth = GLclampf(d.Float32())
}
func doDecodeRawGlClearDepthfOES(d binary.Decoder, o *GlClearDepthfOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Depth = GLclampf(d.Float32())
}
func (*binaryClassGlClearDepthfOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClearDepthfOES(e, obj.(*GlClearDepthfOES))
}
func (*binaryClassGlClearDepthfOES) New() binary.Object {
	return &GlClearDepthfOES{}
}
func (*binaryClassGlClearDepthfOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClearDepthfOES(d, obj.(*GlClearDepthfOES))
}
func (c *binaryClassGlClearDepthfOES) Schema() *binary.Entity {
	return &entities[ixǁGlClearDepthfOES]
}

type binaryClassGlClearDepthx struct{}

func (*GlClearDepthx) Class() binary.Class {
	return (*binaryClassGlClearDepthx)(nil)
}
func doEncodeGlClearDepthx(e binary.Encoder, o *GlClearDepthx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Depth))
}
func doDecodeGlClearDepthx(d binary.Decoder, o *GlClearDepthx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Depth = GLfixed(d.Int32())
}
func doDecodeRawGlClearDepthx(d binary.Decoder, o *GlClearDepthx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Depth = GLfixed(d.Int32())
}
func (*binaryClassGlClearDepthx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClearDepthx(e, obj.(*GlClearDepthx))
}
func (*binaryClassGlClearDepthx) New() binary.Object {
	return &GlClearDepthx{}
}
func (*binaryClassGlClearDepthx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClearDepthx(d, obj.(*GlClearDepthx))
}
func (c *binaryClassGlClearDepthx) Schema() *binary.Entity {
	return &entities[ixǁGlClearDepthx]
}

type binaryClassGlClearDepthxOES struct{}

func (*GlClearDepthxOES) Class() binary.Class {
	return (*binaryClassGlClearDepthxOES)(nil)
}
func doEncodeGlClearDepthxOES(e binary.Encoder, o *GlClearDepthxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Depth))
}
func doDecodeGlClearDepthxOES(d binary.Decoder, o *GlClearDepthxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Depth = GLfixed(d.Int32())
}
func doDecodeRawGlClearDepthxOES(d binary.Decoder, o *GlClearDepthxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Depth = GLfixed(d.Int32())
}
func (*binaryClassGlClearDepthxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClearDepthxOES(e, obj.(*GlClearDepthxOES))
}
func (*binaryClassGlClearDepthxOES) New() binary.Object {
	return &GlClearDepthxOES{}
}
func (*binaryClassGlClearDepthxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClearDepthxOES(d, obj.(*GlClearDepthxOES))
}
func (c *binaryClassGlClearDepthxOES) Schema() *binary.Entity {
	return &entities[ixǁGlClearDepthxOES]
}

type binaryClassGlClearStencil struct{}

func (*GlClearStencil) Class() binary.Class {
	return (*binaryClassGlClearStencil)(nil)
}
func doEncodeGlClearStencil(e binary.Encoder, o *GlClearStencil) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Stencil))
}
func doDecodeGlClearStencil(d binary.Decoder, o *GlClearStencil) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Stencil = GLint(d.Int32())
}
func doDecodeRawGlClearStencil(d binary.Decoder, o *GlClearStencil) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Stencil = GLint(d.Int32())
}
func (*binaryClassGlClearStencil) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClearStencil(e, obj.(*GlClearStencil))
}
func (*binaryClassGlClearStencil) New() binary.Object {
	return &GlClearStencil{}
}
func (*binaryClassGlClearStencil) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClearStencil(d, obj.(*GlClearStencil))
}
func (c *binaryClassGlClearStencil) Schema() *binary.Entity {
	return &entities[ixǁGlClearStencil]
}

type binaryClassGlClientActiveTexture struct{}

func (*GlClientActiveTexture) Class() binary.Class {
	return (*binaryClassGlClientActiveTexture)(nil)
}
func doEncodeGlClientActiveTexture(e binary.Encoder, o *GlClientActiveTexture) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
}
func doDecodeGlClientActiveTexture(d binary.Decoder, o *GlClientActiveTexture) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = GLenum(d.Uint32())
}
func doDecodeRawGlClientActiveTexture(d binary.Decoder, o *GlClientActiveTexture) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = GLenum(d.Uint32())
}
func (*binaryClassGlClientActiveTexture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClientActiveTexture(e, obj.(*GlClientActiveTexture))
}
func (*binaryClassGlClientActiveTexture) New() binary.Object {
	return &GlClientActiveTexture{}
}
func (*binaryClassGlClientActiveTexture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClientActiveTexture(d, obj.(*GlClientActiveTexture))
}
func (c *binaryClassGlClientActiveTexture) Schema() *binary.Entity {
	return &entities[ixǁGlClientActiveTexture]
}

type binaryClassGlClientWaitSync struct{}

func (*GlClientWaitSync) Class() binary.Class {
	return (*binaryClassGlClientWaitSync)(nil)
}
func doEncodeGlClientWaitSync(e binary.Encoder, o *GlClientWaitSync) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Sync)
	e.Uint32(uint32(o.SyncFlags))
	e.Uint64(uint64(o.Timeout))
	e.Uint32(uint32(o.Result))
}
func doDecodeGlClientWaitSync(d binary.Decoder, o *GlClientWaitSync) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.SyncFlags = GLbitfield(d.Uint32())
	o.Timeout = GLuint64(d.Uint64())
	o.Result = GLenum(d.Uint32())
}
func doDecodeRawGlClientWaitSync(d binary.Decoder, o *GlClientWaitSync) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.SyncFlags = GLbitfield(d.Uint32())
	o.Timeout = GLuint64(d.Uint64())
	o.Result = GLenum(d.Uint32())
}
func (*binaryClassGlClientWaitSync) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClientWaitSync(e, obj.(*GlClientWaitSync))
}
func (*binaryClassGlClientWaitSync) New() binary.Object {
	return &GlClientWaitSync{}
}
func (*binaryClassGlClientWaitSync) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClientWaitSync(d, obj.(*GlClientWaitSync))
}
func (c *binaryClassGlClientWaitSync) Schema() *binary.Entity {
	return &entities[ixǁGlClientWaitSync]
}

type binaryClassGlClientWaitSyncAPPLE struct{}

func (*GlClientWaitSyncAPPLE) Class() binary.Class {
	return (*binaryClassGlClientWaitSyncAPPLE)(nil)
}
func doEncodeGlClientWaitSyncAPPLE(e binary.Encoder, o *GlClientWaitSyncAPPLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Sync)
	e.Uint32(uint32(o.Flag))
	e.Uint64(uint64(o.Timeout))
	e.Uint32(uint32(o.Result))
}
func doDecodeGlClientWaitSyncAPPLE(d binary.Decoder, o *GlClientWaitSyncAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.Flag = GLbitfield(d.Uint32())
	o.Timeout = GLuint64(d.Uint64())
	o.Result = GLenum(d.Uint32())
}
func doDecodeRawGlClientWaitSyncAPPLE(d binary.Decoder, o *GlClientWaitSyncAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.Flag = GLbitfield(d.Uint32())
	o.Timeout = GLuint64(d.Uint64())
	o.Result = GLenum(d.Uint32())
}
func (*binaryClassGlClientWaitSyncAPPLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClientWaitSyncAPPLE(e, obj.(*GlClientWaitSyncAPPLE))
}
func (*binaryClassGlClientWaitSyncAPPLE) New() binary.Object {
	return &GlClientWaitSyncAPPLE{}
}
func (*binaryClassGlClientWaitSyncAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClientWaitSyncAPPLE(d, obj.(*GlClientWaitSyncAPPLE))
}
func (c *binaryClassGlClientWaitSyncAPPLE) Schema() *binary.Entity {
	return &entities[ixǁGlClientWaitSyncAPPLE]
}

type binaryClassGlClipPlanef struct{}

func (*GlClipPlanef) Class() binary.Class {
	return (*binaryClassGlClipPlanef)(nil)
}
func doEncodeGlClipPlanef(e binary.Encoder, o *GlClipPlanef) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.P))
	e.Simple(&o.Eqn)
}
func doDecodeGlClipPlanef(d binary.Decoder, o *GlClipPlanef) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.P = GLenum(d.Uint32())
	d.Simple(&o.Eqn)
}
func doDecodeRawGlClipPlanef(d binary.Decoder, o *GlClipPlanef) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.P = GLenum(d.Uint32())
	d.Simple(&o.Eqn)
}
func (*binaryClassGlClipPlanef) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClipPlanef(e, obj.(*GlClipPlanef))
}
func (*binaryClassGlClipPlanef) New() binary.Object {
	return &GlClipPlanef{}
}
func (*binaryClassGlClipPlanef) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClipPlanef(d, obj.(*GlClipPlanef))
}
func (c *binaryClassGlClipPlanef) Schema() *binary.Entity {
	return &entities[ixǁGlClipPlanef]
}

type binaryClassGlClipPlanefIMG struct{}

func (*GlClipPlanefIMG) Class() binary.Class {
	return (*binaryClassGlClipPlanefIMG)(nil)
}
func doEncodeGlClipPlanefIMG(e binary.Encoder, o *GlClipPlanefIMG) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.P))
	e.Simple(&o.Eqn)
}
func doDecodeGlClipPlanefIMG(d binary.Decoder, o *GlClipPlanefIMG) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.P = GLenum(d.Uint32())
	d.Simple(&o.Eqn)
}
func doDecodeRawGlClipPlanefIMG(d binary.Decoder, o *GlClipPlanefIMG) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.P = GLenum(d.Uint32())
	d.Simple(&o.Eqn)
}
func (*binaryClassGlClipPlanefIMG) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClipPlanefIMG(e, obj.(*GlClipPlanefIMG))
}
func (*binaryClassGlClipPlanefIMG) New() binary.Object {
	return &GlClipPlanefIMG{}
}
func (*binaryClassGlClipPlanefIMG) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClipPlanefIMG(d, obj.(*GlClipPlanefIMG))
}
func (c *binaryClassGlClipPlanefIMG) Schema() *binary.Entity {
	return &entities[ixǁGlClipPlanefIMG]
}

type binaryClassGlClipPlanefOES struct{}

func (*GlClipPlanefOES) Class() binary.Class {
	return (*binaryClassGlClipPlanefOES)(nil)
}
func doEncodeGlClipPlanefOES(e binary.Encoder, o *GlClipPlanefOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Plane))
	e.Simple(&o.Equation)
}
func doDecodeGlClipPlanefOES(d binary.Decoder, o *GlClipPlanefOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func doDecodeRawGlClipPlanefOES(d binary.Decoder, o *GlClipPlanefOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func (*binaryClassGlClipPlanefOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClipPlanefOES(e, obj.(*GlClipPlanefOES))
}
func (*binaryClassGlClipPlanefOES) New() binary.Object {
	return &GlClipPlanefOES{}
}
func (*binaryClassGlClipPlanefOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClipPlanefOES(d, obj.(*GlClipPlanefOES))
}
func (c *binaryClassGlClipPlanefOES) Schema() *binary.Entity {
	return &entities[ixǁGlClipPlanefOES]
}

type binaryClassGlClipPlanex struct{}

func (*GlClipPlanex) Class() binary.Class {
	return (*binaryClassGlClipPlanex)(nil)
}
func doEncodeGlClipPlanex(e binary.Encoder, o *GlClipPlanex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Plane))
	e.Simple(&o.Equation)
}
func doDecodeGlClipPlanex(d binary.Decoder, o *GlClipPlanex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func doDecodeRawGlClipPlanex(d binary.Decoder, o *GlClipPlanex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func (*binaryClassGlClipPlanex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClipPlanex(e, obj.(*GlClipPlanex))
}
func (*binaryClassGlClipPlanex) New() binary.Object {
	return &GlClipPlanex{}
}
func (*binaryClassGlClipPlanex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClipPlanex(d, obj.(*GlClipPlanex))
}
func (c *binaryClassGlClipPlanex) Schema() *binary.Entity {
	return &entities[ixǁGlClipPlanex]
}

type binaryClassGlClipPlanexIMG struct{}

func (*GlClipPlanexIMG) Class() binary.Class {
	return (*binaryClassGlClipPlanexIMG)(nil)
}
func doEncodeGlClipPlanexIMG(e binary.Encoder, o *GlClipPlanexIMG) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.P))
	e.Simple(&o.Eqn)
}
func doDecodeGlClipPlanexIMG(d binary.Decoder, o *GlClipPlanexIMG) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.P = GLenum(d.Uint32())
	d.Simple(&o.Eqn)
}
func doDecodeRawGlClipPlanexIMG(d binary.Decoder, o *GlClipPlanexIMG) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.P = GLenum(d.Uint32())
	d.Simple(&o.Eqn)
}
func (*binaryClassGlClipPlanexIMG) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClipPlanexIMG(e, obj.(*GlClipPlanexIMG))
}
func (*binaryClassGlClipPlanexIMG) New() binary.Object {
	return &GlClipPlanexIMG{}
}
func (*binaryClassGlClipPlanexIMG) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClipPlanexIMG(d, obj.(*GlClipPlanexIMG))
}
func (c *binaryClassGlClipPlanexIMG) Schema() *binary.Entity {
	return &entities[ixǁGlClipPlanexIMG]
}

type binaryClassGlClipPlanexOES struct{}

func (*GlClipPlanexOES) Class() binary.Class {
	return (*binaryClassGlClipPlanexOES)(nil)
}
func doEncodeGlClipPlanexOES(e binary.Encoder, o *GlClipPlanexOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Plane))
	e.Simple(&o.Equation)
}
func doDecodeGlClipPlanexOES(d binary.Decoder, o *GlClipPlanexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func doDecodeRawGlClipPlanexOES(d binary.Decoder, o *GlClipPlanexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func (*binaryClassGlClipPlanexOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlClipPlanexOES(e, obj.(*GlClipPlanexOES))
}
func (*binaryClassGlClipPlanexOES) New() binary.Object {
	return &GlClipPlanexOES{}
}
func (*binaryClassGlClipPlanexOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlClipPlanexOES(d, obj.(*GlClipPlanexOES))
}
func (c *binaryClassGlClipPlanexOES) Schema() *binary.Entity {
	return &entities[ixǁGlClipPlanexOES]
}

type binaryClassGlColor4f struct{}

func (*GlColor4f) Class() binary.Class {
	return (*binaryClassGlColor4f)(nil)
}
func doEncodeGlColor4f(e binary.Encoder, o *GlColor4f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Red))
	e.Float32(float32(o.Green))
	e.Float32(float32(o.Blue))
	e.Float32(float32(o.Alpha))
}
func doDecodeGlColor4f(d binary.Decoder, o *GlColor4f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLfloat(d.Float32())
	o.Green = GLfloat(d.Float32())
	o.Blue = GLfloat(d.Float32())
	o.Alpha = GLfloat(d.Float32())
}
func doDecodeRawGlColor4f(d binary.Decoder, o *GlColor4f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLfloat(d.Float32())
	o.Green = GLfloat(d.Float32())
	o.Blue = GLfloat(d.Float32())
	o.Alpha = GLfloat(d.Float32())
}
func (*binaryClassGlColor4f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlColor4f(e, obj.(*GlColor4f))
}
func (*binaryClassGlColor4f) New() binary.Object {
	return &GlColor4f{}
}
func (*binaryClassGlColor4f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlColor4f(d, obj.(*GlColor4f))
}
func (c *binaryClassGlColor4f) Schema() *binary.Entity {
	return &entities[ixǁGlColor4f]
}

type binaryClassGlColor4ub struct{}

func (*GlColor4ub) Class() binary.Class {
	return (*binaryClassGlColor4ub)(nil)
}
func doEncodeGlColor4ub(e binary.Encoder, o *GlColor4ub) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint8(uint8(o.Red))
	e.Uint8(uint8(o.Green))
	e.Uint8(uint8(o.Blue))
	e.Uint8(uint8(o.Alpha))
}
func doDecodeGlColor4ub(d binary.Decoder, o *GlColor4ub) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLubyte(d.Uint8())
	o.Green = GLubyte(d.Uint8())
	o.Blue = GLubyte(d.Uint8())
	o.Alpha = GLubyte(d.Uint8())
}
func doDecodeRawGlColor4ub(d binary.Decoder, o *GlColor4ub) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLubyte(d.Uint8())
	o.Green = GLubyte(d.Uint8())
	o.Blue = GLubyte(d.Uint8())
	o.Alpha = GLubyte(d.Uint8())
}
func (*binaryClassGlColor4ub) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlColor4ub(e, obj.(*GlColor4ub))
}
func (*binaryClassGlColor4ub) New() binary.Object {
	return &GlColor4ub{}
}
func (*binaryClassGlColor4ub) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlColor4ub(d, obj.(*GlColor4ub))
}
func (c *binaryClassGlColor4ub) Schema() *binary.Entity {
	return &entities[ixǁGlColor4ub]
}

type binaryClassGlColor4x struct{}

func (*GlColor4x) Class() binary.Class {
	return (*binaryClassGlColor4x)(nil)
}
func doEncodeGlColor4x(e binary.Encoder, o *GlColor4x) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Red))
	e.Int32(int32(o.Green))
	e.Int32(int32(o.Blue))
	e.Int32(int32(o.Alpha))
}
func doDecodeGlColor4x(d binary.Decoder, o *GlColor4x) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLfixed(d.Int32())
	o.Green = GLfixed(d.Int32())
	o.Blue = GLfixed(d.Int32())
	o.Alpha = GLfixed(d.Int32())
}
func doDecodeRawGlColor4x(d binary.Decoder, o *GlColor4x) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLfixed(d.Int32())
	o.Green = GLfixed(d.Int32())
	o.Blue = GLfixed(d.Int32())
	o.Alpha = GLfixed(d.Int32())
}
func (*binaryClassGlColor4x) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlColor4x(e, obj.(*GlColor4x))
}
func (*binaryClassGlColor4x) New() binary.Object {
	return &GlColor4x{}
}
func (*binaryClassGlColor4x) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlColor4x(d, obj.(*GlColor4x))
}
func (c *binaryClassGlColor4x) Schema() *binary.Entity {
	return &entities[ixǁGlColor4x]
}

type binaryClassGlColor4xOES struct{}

func (*GlColor4xOES) Class() binary.Class {
	return (*binaryClassGlColor4xOES)(nil)
}
func doEncodeGlColor4xOES(e binary.Encoder, o *GlColor4xOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Red))
	e.Int32(int32(o.Green))
	e.Int32(int32(o.Blue))
	e.Int32(int32(o.Alpha))
}
func doDecodeGlColor4xOES(d binary.Decoder, o *GlColor4xOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLfixed(d.Int32())
	o.Green = GLfixed(d.Int32())
	o.Blue = GLfixed(d.Int32())
	o.Alpha = GLfixed(d.Int32())
}
func doDecodeRawGlColor4xOES(d binary.Decoder, o *GlColor4xOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLfixed(d.Int32())
	o.Green = GLfixed(d.Int32())
	o.Blue = GLfixed(d.Int32())
	o.Alpha = GLfixed(d.Int32())
}
func (*binaryClassGlColor4xOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlColor4xOES(e, obj.(*GlColor4xOES))
}
func (*binaryClassGlColor4xOES) New() binary.Object {
	return &GlColor4xOES{}
}
func (*binaryClassGlColor4xOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlColor4xOES(d, obj.(*GlColor4xOES))
}
func (c *binaryClassGlColor4xOES) Schema() *binary.Entity {
	return &entities[ixǁGlColor4xOES]
}

type binaryClassGlColorMask struct{}

func (*GlColorMask) Class() binary.Class {
	return (*binaryClassGlColorMask)(nil)
}
func doEncodeGlColorMask(e binary.Encoder, o *GlColorMask) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint8(uint8(o.Red))
	e.Uint8(uint8(o.Green))
	e.Uint8(uint8(o.Blue))
	e.Uint8(uint8(o.Alpha))
}
func doDecodeGlColorMask(d binary.Decoder, o *GlColorMask) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLboolean(d.Uint8())
	o.Green = GLboolean(d.Uint8())
	o.Blue = GLboolean(d.Uint8())
	o.Alpha = GLboolean(d.Uint8())
}
func doDecodeRawGlColorMask(d binary.Decoder, o *GlColorMask) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Red = GLboolean(d.Uint8())
	o.Green = GLboolean(d.Uint8())
	o.Blue = GLboolean(d.Uint8())
	o.Alpha = GLboolean(d.Uint8())
}
func (*binaryClassGlColorMask) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlColorMask(e, obj.(*GlColorMask))
}
func (*binaryClassGlColorMask) New() binary.Object {
	return &GlColorMask{}
}
func (*binaryClassGlColorMask) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlColorMask(d, obj.(*GlColorMask))
}
func (c *binaryClassGlColorMask) Schema() *binary.Entity {
	return &entities[ixǁGlColorMask]
}

type binaryClassGlColorMaski struct{}

func (*GlColorMaski) Class() binary.Class {
	return (*binaryClassGlColorMaski)(nil)
}
func doEncodeGlColorMaski(e binary.Encoder, o *GlColorMaski) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint8(uint8(o.R))
	e.Uint8(uint8(o.G))
	e.Uint8(uint8(o.B))
	e.Uint8(uint8(o.A))
}
func doDecodeGlColorMaski(d binary.Decoder, o *GlColorMaski) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = DrawBufferIndex(d.Uint32())
	o.R = GLboolean(d.Uint8())
	o.G = GLboolean(d.Uint8())
	o.B = GLboolean(d.Uint8())
	o.A = GLboolean(d.Uint8())
}
func doDecodeRawGlColorMaski(d binary.Decoder, o *GlColorMaski) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = DrawBufferIndex(d.Uint32())
	o.R = GLboolean(d.Uint8())
	o.G = GLboolean(d.Uint8())
	o.B = GLboolean(d.Uint8())
	o.A = GLboolean(d.Uint8())
}
func (*binaryClassGlColorMaski) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlColorMaski(e, obj.(*GlColorMaski))
}
func (*binaryClassGlColorMaski) New() binary.Object {
	return &GlColorMaski{}
}
func (*binaryClassGlColorMaski) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlColorMaski(d, obj.(*GlColorMaski))
}
func (c *binaryClassGlColorMaski) Schema() *binary.Entity {
	return &entities[ixǁGlColorMaski]
}

type binaryClassGlColorMaskiEXT struct{}

func (*GlColorMaskiEXT) Class() binary.Class {
	return (*binaryClassGlColorMaskiEXT)(nil)
}
func doEncodeGlColorMaskiEXT(e binary.Encoder, o *GlColorMaskiEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint8(uint8(o.R))
	e.Uint8(uint8(o.G))
	e.Uint8(uint8(o.B))
	e.Uint8(uint8(o.A))
}
func doDecodeGlColorMaskiEXT(d binary.Decoder, o *GlColorMaskiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = DrawBufferIndex(d.Uint32())
	o.R = GLboolean(d.Uint8())
	o.G = GLboolean(d.Uint8())
	o.B = GLboolean(d.Uint8())
	o.A = GLboolean(d.Uint8())
}
func doDecodeRawGlColorMaskiEXT(d binary.Decoder, o *GlColorMaskiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = DrawBufferIndex(d.Uint32())
	o.R = GLboolean(d.Uint8())
	o.G = GLboolean(d.Uint8())
	o.B = GLboolean(d.Uint8())
	o.A = GLboolean(d.Uint8())
}
func (*binaryClassGlColorMaskiEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlColorMaskiEXT(e, obj.(*GlColorMaskiEXT))
}
func (*binaryClassGlColorMaskiEXT) New() binary.Object {
	return &GlColorMaskiEXT{}
}
func (*binaryClassGlColorMaskiEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlColorMaskiEXT(d, obj.(*GlColorMaskiEXT))
}
func (c *binaryClassGlColorMaskiEXT) Schema() *binary.Entity {
	return &entities[ixǁGlColorMaskiEXT]
}

type binaryClassGlColorMaskiOES struct{}

func (*GlColorMaskiOES) Class() binary.Class {
	return (*binaryClassGlColorMaskiOES)(nil)
}
func doEncodeGlColorMaskiOES(e binary.Encoder, o *GlColorMaskiOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint8(uint8(o.R))
	e.Uint8(uint8(o.G))
	e.Uint8(uint8(o.B))
	e.Uint8(uint8(o.A))
}
func doDecodeGlColorMaskiOES(d binary.Decoder, o *GlColorMaskiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = DrawBufferIndex(d.Uint32())
	o.R = GLboolean(d.Uint8())
	o.G = GLboolean(d.Uint8())
	o.B = GLboolean(d.Uint8())
	o.A = GLboolean(d.Uint8())
}
func doDecodeRawGlColorMaskiOES(d binary.Decoder, o *GlColorMaskiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = DrawBufferIndex(d.Uint32())
	o.R = GLboolean(d.Uint8())
	o.G = GLboolean(d.Uint8())
	o.B = GLboolean(d.Uint8())
	o.A = GLboolean(d.Uint8())
}
func (*binaryClassGlColorMaskiOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlColorMaskiOES(e, obj.(*GlColorMaskiOES))
}
func (*binaryClassGlColorMaskiOES) New() binary.Object {
	return &GlColorMaskiOES{}
}
func (*binaryClassGlColorMaskiOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlColorMaskiOES(d, obj.(*GlColorMaskiOES))
}
func (c *binaryClassGlColorMaskiOES) Schema() *binary.Entity {
	return &entities[ixǁGlColorMaskiOES]
}

type binaryClassGlColorPointer struct{}

func (*GlColorPointer) Class() binary.Class {
	return (*binaryClassGlColorPointer)(nil)
}
func doEncodeGlColorPointer(e binary.Encoder, o *GlColorPointer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
}
func doDecodeGlColorPointer(d binary.Decoder, o *GlColorPointer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func doDecodeRawGlColorPointer(d binary.Decoder, o *GlColorPointer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func (*binaryClassGlColorPointer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlColorPointer(e, obj.(*GlColorPointer))
}
func (*binaryClassGlColorPointer) New() binary.Object {
	return &GlColorPointer{}
}
func (*binaryClassGlColorPointer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlColorPointer(d, obj.(*GlColorPointer))
}
func (c *binaryClassGlColorPointer) Schema() *binary.Entity {
	return &entities[ixǁGlColorPointer]
}

type binaryClassGlColorPointerBounds struct{}

func (*GlColorPointerBounds) Class() binary.Class {
	return (*binaryClassGlColorPointerBounds)(nil)
}
func doEncodeGlColorPointerBounds(e binary.Encoder, o *GlColorPointerBounds) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
	e.Int32(int32(o.Count))
}
func doDecodeGlColorPointerBounds(d binary.Decoder, o *GlColorPointerBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func doDecodeRawGlColorPointerBounds(d binary.Decoder, o *GlColorPointerBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func (*binaryClassGlColorPointerBounds) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlColorPointerBounds(e, obj.(*GlColorPointerBounds))
}
func (*binaryClassGlColorPointerBounds) New() binary.Object {
	return &GlColorPointerBounds{}
}
func (*binaryClassGlColorPointerBounds) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlColorPointerBounds(d, obj.(*GlColorPointerBounds))
}
func (c *binaryClassGlColorPointerBounds) Schema() *binary.Entity {
	return &entities[ixǁGlColorPointerBounds]
}

type binaryClassGlCompileShader struct{}

func (*GlCompileShader) Class() binary.Class {
	return (*binaryClassGlCompileShader)(nil)
}
func doEncodeGlCompileShader(e binary.Encoder, o *GlCompileShader) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Shader))
}
func doDecodeGlCompileShader(d binary.Decoder, o *GlCompileShader) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
}
func doDecodeRawGlCompileShader(d binary.Decoder, o *GlCompileShader) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
}
func (*binaryClassGlCompileShader) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCompileShader(e, obj.(*GlCompileShader))
}
func (*binaryClassGlCompileShader) New() binary.Object {
	return &GlCompileShader{}
}
func (*binaryClassGlCompileShader) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCompileShader(d, obj.(*GlCompileShader))
}
func (c *binaryClassGlCompileShader) Schema() *binary.Entity {
	return &entities[ixǁGlCompileShader]
}

type binaryClassTexturePointer struct{}

func (*TexturePointer) Class() binary.Class {
	return (*binaryClassTexturePointer)(nil)
}
func doEncodeTexturePointer(e binary.Writer, o *TexturePointer) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeTexturePointer(d binary.Reader, o *TexturePointer) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawTexturePointer(d binary.Reader, o *TexturePointer) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassTexturePointer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTexturePointer(e, obj.(*TexturePointer))
}
func (*binaryClassTexturePointer) New() binary.Object {
	return &TexturePointer{}
}
func (*binaryClassTexturePointer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTexturePointer(d, obj.(*TexturePointer))
}
func (o *TexturePointer) WriteSimple(w binary.Writer) {
	doEncodeTexturePointer(w, o)
}
func (o *TexturePointer) ReadSimple(r binary.Reader) {
	doDecodeTexturePointer(r, o)
}
func (c *binaryClassTexturePointer) Schema() *binary.Entity {
	return &entities[ixǁTexturePointer]
}

type binaryClassGlCompressedTexImage2D struct{}

func (*GlCompressedTexImage2D) Class() binary.Class {
	return (*binaryClassGlCompressedTexImage2D)(nil)
}
func doEncodeGlCompressedTexImage2D(e binary.Encoder, o *GlCompressedTexImage2D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Uint32(uint32(o.Format))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Border))
	e.Int32(int32(o.ImageSize))
	e.Simple(&o.Data)
}
func doDecodeGlCompressedTexImage2D(d binary.Decoder, o *GlCompressedTexImage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
	o.ImageSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func doDecodeRawGlCompressedTexImage2D(d binary.Decoder, o *GlCompressedTexImage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
	o.ImageSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func (*binaryClassGlCompressedTexImage2D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCompressedTexImage2D(e, obj.(*GlCompressedTexImage2D))
}
func (*binaryClassGlCompressedTexImage2D) New() binary.Object {
	return &GlCompressedTexImage2D{}
}
func (*binaryClassGlCompressedTexImage2D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCompressedTexImage2D(d, obj.(*GlCompressedTexImage2D))
}
func (c *binaryClassGlCompressedTexImage2D) Schema() *binary.Entity {
	return &entities[ixǁGlCompressedTexImage2D]
}

type binaryClassGlCompressedTexImage3D struct{}

func (*GlCompressedTexImage3D) Class() binary.Class {
	return (*binaryClassGlCompressedTexImage3D)(nil)
}
func doEncodeGlCompressedTexImage3D(e binary.Encoder, o *GlCompressedTexImage3D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
	e.Int32(int32(o.Border))
	e.Int32(int32(o.ImageSize))
	e.Simple(&o.Data)
}
func doDecodeGlCompressedTexImage3D(d binary.Decoder, o *GlCompressedTexImage3D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
	o.ImageSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func doDecodeRawGlCompressedTexImage3D(d binary.Decoder, o *GlCompressedTexImage3D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
	o.ImageSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func (*binaryClassGlCompressedTexImage3D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCompressedTexImage3D(e, obj.(*GlCompressedTexImage3D))
}
func (*binaryClassGlCompressedTexImage3D) New() binary.Object {
	return &GlCompressedTexImage3D{}
}
func (*binaryClassGlCompressedTexImage3D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCompressedTexImage3D(d, obj.(*GlCompressedTexImage3D))
}
func (c *binaryClassGlCompressedTexImage3D) Schema() *binary.Entity {
	return &entities[ixǁGlCompressedTexImage3D]
}

type binaryClassGlCompressedTexImage3DOES struct{}

func (*GlCompressedTexImage3DOES) Class() binary.Class {
	return (*binaryClassGlCompressedTexImage3DOES)(nil)
}
func doEncodeGlCompressedTexImage3DOES(e binary.Encoder, o *GlCompressedTexImage3DOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
	e.Int32(int32(o.Border))
	e.Int32(int32(o.ImageSize))
	e.Simple(&o.Data)
}
func doDecodeGlCompressedTexImage3DOES(d binary.Decoder, o *GlCompressedTexImage3DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
	o.ImageSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func doDecodeRawGlCompressedTexImage3DOES(d binary.Decoder, o *GlCompressedTexImage3DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
	o.ImageSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func (*binaryClassGlCompressedTexImage3DOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCompressedTexImage3DOES(e, obj.(*GlCompressedTexImage3DOES))
}
func (*binaryClassGlCompressedTexImage3DOES) New() binary.Object {
	return &GlCompressedTexImage3DOES{}
}
func (*binaryClassGlCompressedTexImage3DOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCompressedTexImage3DOES(d, obj.(*GlCompressedTexImage3DOES))
}
func (c *binaryClassGlCompressedTexImage3DOES) Schema() *binary.Entity {
	return &entities[ixǁGlCompressedTexImage3DOES]
}

type binaryClassGlCompressedTexSubImage2D struct{}

func (*GlCompressedTexSubImage2D) Class() binary.Class {
	return (*binaryClassGlCompressedTexSubImage2D)(nil)
}
func doEncodeGlCompressedTexSubImage2D(e binary.Encoder, o *GlCompressedTexSubImage2D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Xoffset))
	e.Int32(int32(o.Yoffset))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Uint32(uint32(o.Format))
	e.Int32(int32(o.ImageSize))
	e.Simple(&o.Data)
}
func doDecodeGlCompressedTexSubImage2D(d binary.Decoder, o *GlCompressedTexSubImage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.ImageSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func doDecodeRawGlCompressedTexSubImage2D(d binary.Decoder, o *GlCompressedTexSubImage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.ImageSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func (*binaryClassGlCompressedTexSubImage2D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCompressedTexSubImage2D(e, obj.(*GlCompressedTexSubImage2D))
}
func (*binaryClassGlCompressedTexSubImage2D) New() binary.Object {
	return &GlCompressedTexSubImage2D{}
}
func (*binaryClassGlCompressedTexSubImage2D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCompressedTexSubImage2D(d, obj.(*GlCompressedTexSubImage2D))
}
func (c *binaryClassGlCompressedTexSubImage2D) Schema() *binary.Entity {
	return &entities[ixǁGlCompressedTexSubImage2D]
}

type binaryClassGlCompressedTexSubImage3D struct{}

func (*GlCompressedTexSubImage3D) Class() binary.Class {
	return (*binaryClassGlCompressedTexSubImage3D)(nil)
}
func doEncodeGlCompressedTexSubImage3D(e binary.Encoder, o *GlCompressedTexSubImage3D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Xoffset))
	e.Int32(int32(o.Yoffset))
	e.Int32(int32(o.Zoffset))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
	e.Uint32(uint32(o.Format))
	e.Int32(int32(o.ImageSize))
	e.Simple(&o.Data)
}
func doDecodeGlCompressedTexSubImage3D(d binary.Decoder, o *GlCompressedTexSubImage3D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.ImageSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func doDecodeRawGlCompressedTexSubImage3D(d binary.Decoder, o *GlCompressedTexSubImage3D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.ImageSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func (*binaryClassGlCompressedTexSubImage3D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCompressedTexSubImage3D(e, obj.(*GlCompressedTexSubImage3D))
}
func (*binaryClassGlCompressedTexSubImage3D) New() binary.Object {
	return &GlCompressedTexSubImage3D{}
}
func (*binaryClassGlCompressedTexSubImage3D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCompressedTexSubImage3D(d, obj.(*GlCompressedTexSubImage3D))
}
func (c *binaryClassGlCompressedTexSubImage3D) Schema() *binary.Entity {
	return &entities[ixǁGlCompressedTexSubImage3D]
}

type binaryClassGlCompressedTexSubImage3DOES struct{}

func (*GlCompressedTexSubImage3DOES) Class() binary.Class {
	return (*binaryClassGlCompressedTexSubImage3DOES)(nil)
}
func doEncodeGlCompressedTexSubImage3DOES(e binary.Encoder, o *GlCompressedTexSubImage3DOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Xoffset))
	e.Int32(int32(o.Yoffset))
	e.Int32(int32(o.Zoffset))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
	e.Uint32(uint32(o.Format))
	e.Int32(int32(o.ImageSize))
	e.Simple(&o.Data)
}
func doDecodeGlCompressedTexSubImage3DOES(d binary.Decoder, o *GlCompressedTexSubImage3DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.ImageSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func doDecodeRawGlCompressedTexSubImage3DOES(d binary.Decoder, o *GlCompressedTexSubImage3DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.ImageSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func (*binaryClassGlCompressedTexSubImage3DOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCompressedTexSubImage3DOES(e, obj.(*GlCompressedTexSubImage3DOES))
}
func (*binaryClassGlCompressedTexSubImage3DOES) New() binary.Object {
	return &GlCompressedTexSubImage3DOES{}
}
func (*binaryClassGlCompressedTexSubImage3DOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCompressedTexSubImage3DOES(d, obj.(*GlCompressedTexSubImage3DOES))
}
func (c *binaryClassGlCompressedTexSubImage3DOES) Schema() *binary.Entity {
	return &entities[ixǁGlCompressedTexSubImage3DOES]
}

type binaryClassGlCopyBufferSubData struct{}

func (*GlCopyBufferSubData) Class() binary.Class {
	return (*binaryClassGlCopyBufferSubData)(nil)
}
func doEncodeGlCopyBufferSubData(e binary.Encoder, o *GlCopyBufferSubData) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.ReadTarget))
	e.Uint32(uint32(o.WriteTarget))
	e.Int32(int32(o.ReadOffset))
	e.Int32(int32(o.WriteOffset))
	e.Int32(int32(o.Size))
}
func doDecodeGlCopyBufferSubData(d binary.Decoder, o *GlCopyBufferSubData) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ReadTarget = GLenum(d.Uint32())
	o.WriteTarget = GLenum(d.Uint32())
	o.ReadOffset = GLintptr(d.Int32())
	o.WriteOffset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func doDecodeRawGlCopyBufferSubData(d binary.Decoder, o *GlCopyBufferSubData) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ReadTarget = GLenum(d.Uint32())
	o.WriteTarget = GLenum(d.Uint32())
	o.ReadOffset = GLintptr(d.Int32())
	o.WriteOffset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func (*binaryClassGlCopyBufferSubData) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCopyBufferSubData(e, obj.(*GlCopyBufferSubData))
}
func (*binaryClassGlCopyBufferSubData) New() binary.Object {
	return &GlCopyBufferSubData{}
}
func (*binaryClassGlCopyBufferSubData) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCopyBufferSubData(d, obj.(*GlCopyBufferSubData))
}
func (c *binaryClassGlCopyBufferSubData) Schema() *binary.Entity {
	return &entities[ixǁGlCopyBufferSubData]
}

type binaryClassGlCopyBufferSubDataNV struct{}

func (*GlCopyBufferSubDataNV) Class() binary.Class {
	return (*binaryClassGlCopyBufferSubDataNV)(nil)
}
func doEncodeGlCopyBufferSubDataNV(e binary.Encoder, o *GlCopyBufferSubDataNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.ReadTarget))
	e.Uint32(uint32(o.WriteTarget))
	e.Int32(int32(o.ReadOffset))
	e.Int32(int32(o.WriteOffset))
	e.Int32(int32(o.Size))
}
func doDecodeGlCopyBufferSubDataNV(d binary.Decoder, o *GlCopyBufferSubDataNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ReadTarget = GLenum(d.Uint32())
	o.WriteTarget = GLenum(d.Uint32())
	o.ReadOffset = GLintptr(d.Int32())
	o.WriteOffset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func doDecodeRawGlCopyBufferSubDataNV(d binary.Decoder, o *GlCopyBufferSubDataNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ReadTarget = GLenum(d.Uint32())
	o.WriteTarget = GLenum(d.Uint32())
	o.ReadOffset = GLintptr(d.Int32())
	o.WriteOffset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func (*binaryClassGlCopyBufferSubDataNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCopyBufferSubDataNV(e, obj.(*GlCopyBufferSubDataNV))
}
func (*binaryClassGlCopyBufferSubDataNV) New() binary.Object {
	return &GlCopyBufferSubDataNV{}
}
func (*binaryClassGlCopyBufferSubDataNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCopyBufferSubDataNV(d, obj.(*GlCopyBufferSubDataNV))
}
func (c *binaryClassGlCopyBufferSubDataNV) Schema() *binary.Entity {
	return &entities[ixǁGlCopyBufferSubDataNV]
}

type binaryClassGlCopyImageSubData struct{}

func (*GlCopyImageSubData) Class() binary.Class {
	return (*binaryClassGlCopyImageSubData)(nil)
}
func doEncodeGlCopyImageSubData(e binary.Encoder, o *GlCopyImageSubData) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.SrcName))
	e.Uint32(uint32(o.SrcTarget))
	e.Int32(int32(o.SrcLevel))
	e.Int32(int32(o.SrcX))
	e.Int32(int32(o.SrcY))
	e.Int32(int32(o.SrcZ))
	e.Uint32(uint32(o.DstName))
	e.Uint32(uint32(o.DstTarget))
	e.Int32(int32(o.DstLevel))
	e.Int32(int32(o.DstX))
	e.Int32(int32(o.DstY))
	e.Int32(int32(o.DstZ))
	e.Int32(int32(o.SrcWidth))
	e.Int32(int32(o.SrcHeight))
	e.Int32(int32(o.SrcDepth))
}
func doDecodeGlCopyImageSubData(d binary.Decoder, o *GlCopyImageSubData) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcName = GLuint(d.Uint32())
	o.SrcTarget = GLenum(d.Uint32())
	o.SrcLevel = GLint(d.Int32())
	o.SrcX = GLint(d.Int32())
	o.SrcY = GLint(d.Int32())
	o.SrcZ = GLint(d.Int32())
	o.DstName = GLuint(d.Uint32())
	o.DstTarget = GLenum(d.Uint32())
	o.DstLevel = GLint(d.Int32())
	o.DstX = GLint(d.Int32())
	o.DstY = GLint(d.Int32())
	o.DstZ = GLint(d.Int32())
	o.SrcWidth = GLsizei(d.Int32())
	o.SrcHeight = GLsizei(d.Int32())
	o.SrcDepth = GLsizei(d.Int32())
}
func doDecodeRawGlCopyImageSubData(d binary.Decoder, o *GlCopyImageSubData) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcName = GLuint(d.Uint32())
	o.SrcTarget = GLenum(d.Uint32())
	o.SrcLevel = GLint(d.Int32())
	o.SrcX = GLint(d.Int32())
	o.SrcY = GLint(d.Int32())
	o.SrcZ = GLint(d.Int32())
	o.DstName = GLuint(d.Uint32())
	o.DstTarget = GLenum(d.Uint32())
	o.DstLevel = GLint(d.Int32())
	o.DstX = GLint(d.Int32())
	o.DstY = GLint(d.Int32())
	o.DstZ = GLint(d.Int32())
	o.SrcWidth = GLsizei(d.Int32())
	o.SrcHeight = GLsizei(d.Int32())
	o.SrcDepth = GLsizei(d.Int32())
}
func (*binaryClassGlCopyImageSubData) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCopyImageSubData(e, obj.(*GlCopyImageSubData))
}
func (*binaryClassGlCopyImageSubData) New() binary.Object {
	return &GlCopyImageSubData{}
}
func (*binaryClassGlCopyImageSubData) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCopyImageSubData(d, obj.(*GlCopyImageSubData))
}
func (c *binaryClassGlCopyImageSubData) Schema() *binary.Entity {
	return &entities[ixǁGlCopyImageSubData]
}

type binaryClassGlCopyImageSubDataEXT struct{}

func (*GlCopyImageSubDataEXT) Class() binary.Class {
	return (*binaryClassGlCopyImageSubDataEXT)(nil)
}
func doEncodeGlCopyImageSubDataEXT(e binary.Encoder, o *GlCopyImageSubDataEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.SrcName))
	e.Uint32(uint32(o.SrcTarget))
	e.Int32(int32(o.SrcLevel))
	e.Int32(int32(o.SrcX))
	e.Int32(int32(o.SrcY))
	e.Int32(int32(o.SrcZ))
	e.Uint32(uint32(o.DstName))
	e.Uint32(uint32(o.DstTarget))
	e.Int32(int32(o.DstLevel))
	e.Int32(int32(o.DstX))
	e.Int32(int32(o.DstY))
	e.Int32(int32(o.DstZ))
	e.Int32(int32(o.SrcWidth))
	e.Int32(int32(o.SrcHeight))
	e.Int32(int32(o.SrcDepth))
}
func doDecodeGlCopyImageSubDataEXT(d binary.Decoder, o *GlCopyImageSubDataEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcName = GLuint(d.Uint32())
	o.SrcTarget = GLenum(d.Uint32())
	o.SrcLevel = GLint(d.Int32())
	o.SrcX = GLint(d.Int32())
	o.SrcY = GLint(d.Int32())
	o.SrcZ = GLint(d.Int32())
	o.DstName = GLuint(d.Uint32())
	o.DstTarget = GLenum(d.Uint32())
	o.DstLevel = GLint(d.Int32())
	o.DstX = GLint(d.Int32())
	o.DstY = GLint(d.Int32())
	o.DstZ = GLint(d.Int32())
	o.SrcWidth = GLsizei(d.Int32())
	o.SrcHeight = GLsizei(d.Int32())
	o.SrcDepth = GLsizei(d.Int32())
}
func doDecodeRawGlCopyImageSubDataEXT(d binary.Decoder, o *GlCopyImageSubDataEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcName = GLuint(d.Uint32())
	o.SrcTarget = GLenum(d.Uint32())
	o.SrcLevel = GLint(d.Int32())
	o.SrcX = GLint(d.Int32())
	o.SrcY = GLint(d.Int32())
	o.SrcZ = GLint(d.Int32())
	o.DstName = GLuint(d.Uint32())
	o.DstTarget = GLenum(d.Uint32())
	o.DstLevel = GLint(d.Int32())
	o.DstX = GLint(d.Int32())
	o.DstY = GLint(d.Int32())
	o.DstZ = GLint(d.Int32())
	o.SrcWidth = GLsizei(d.Int32())
	o.SrcHeight = GLsizei(d.Int32())
	o.SrcDepth = GLsizei(d.Int32())
}
func (*binaryClassGlCopyImageSubDataEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCopyImageSubDataEXT(e, obj.(*GlCopyImageSubDataEXT))
}
func (*binaryClassGlCopyImageSubDataEXT) New() binary.Object {
	return &GlCopyImageSubDataEXT{}
}
func (*binaryClassGlCopyImageSubDataEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCopyImageSubDataEXT(d, obj.(*GlCopyImageSubDataEXT))
}
func (c *binaryClassGlCopyImageSubDataEXT) Schema() *binary.Entity {
	return &entities[ixǁGlCopyImageSubDataEXT]
}

type binaryClassGlCopyImageSubDataOES struct{}

func (*GlCopyImageSubDataOES) Class() binary.Class {
	return (*binaryClassGlCopyImageSubDataOES)(nil)
}
func doEncodeGlCopyImageSubDataOES(e binary.Encoder, o *GlCopyImageSubDataOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.SrcName))
	e.Uint32(uint32(o.SrcTarget))
	e.Int32(int32(o.SrcLevel))
	e.Int32(int32(o.SrcX))
	e.Int32(int32(o.SrcY))
	e.Int32(int32(o.SrcZ))
	e.Uint32(uint32(o.DstName))
	e.Uint32(uint32(o.DstTarget))
	e.Int32(int32(o.DstLevel))
	e.Int32(int32(o.DstX))
	e.Int32(int32(o.DstY))
	e.Int32(int32(o.DstZ))
	e.Int32(int32(o.SrcWidth))
	e.Int32(int32(o.SrcHeight))
	e.Int32(int32(o.SrcDepth))
}
func doDecodeGlCopyImageSubDataOES(d binary.Decoder, o *GlCopyImageSubDataOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcName = GLuint(d.Uint32())
	o.SrcTarget = GLenum(d.Uint32())
	o.SrcLevel = GLint(d.Int32())
	o.SrcX = GLint(d.Int32())
	o.SrcY = GLint(d.Int32())
	o.SrcZ = GLint(d.Int32())
	o.DstName = GLuint(d.Uint32())
	o.DstTarget = GLenum(d.Uint32())
	o.DstLevel = GLint(d.Int32())
	o.DstX = GLint(d.Int32())
	o.DstY = GLint(d.Int32())
	o.DstZ = GLint(d.Int32())
	o.SrcWidth = GLsizei(d.Int32())
	o.SrcHeight = GLsizei(d.Int32())
	o.SrcDepth = GLsizei(d.Int32())
}
func doDecodeRawGlCopyImageSubDataOES(d binary.Decoder, o *GlCopyImageSubDataOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.SrcName = GLuint(d.Uint32())
	o.SrcTarget = GLenum(d.Uint32())
	o.SrcLevel = GLint(d.Int32())
	o.SrcX = GLint(d.Int32())
	o.SrcY = GLint(d.Int32())
	o.SrcZ = GLint(d.Int32())
	o.DstName = GLuint(d.Uint32())
	o.DstTarget = GLenum(d.Uint32())
	o.DstLevel = GLint(d.Int32())
	o.DstX = GLint(d.Int32())
	o.DstY = GLint(d.Int32())
	o.DstZ = GLint(d.Int32())
	o.SrcWidth = GLsizei(d.Int32())
	o.SrcHeight = GLsizei(d.Int32())
	o.SrcDepth = GLsizei(d.Int32())
}
func (*binaryClassGlCopyImageSubDataOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCopyImageSubDataOES(e, obj.(*GlCopyImageSubDataOES))
}
func (*binaryClassGlCopyImageSubDataOES) New() binary.Object {
	return &GlCopyImageSubDataOES{}
}
func (*binaryClassGlCopyImageSubDataOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCopyImageSubDataOES(d, obj.(*GlCopyImageSubDataOES))
}
func (c *binaryClassGlCopyImageSubDataOES) Schema() *binary.Entity {
	return &entities[ixǁGlCopyImageSubDataOES]
}

type binaryClassGlCopyPathNV struct{}

func (*GlCopyPathNV) Class() binary.Class {
	return (*binaryClassGlCopyPathNV)(nil)
}
func doEncodeGlCopyPathNV(e binary.Encoder, o *GlCopyPathNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.ResultPath))
	e.Uint32(uint32(o.SrcPath))
}
func doDecodeGlCopyPathNV(d binary.Decoder, o *GlCopyPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ResultPath = GLuint(d.Uint32())
	o.SrcPath = GLuint(d.Uint32())
}
func doDecodeRawGlCopyPathNV(d binary.Decoder, o *GlCopyPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ResultPath = GLuint(d.Uint32())
	o.SrcPath = GLuint(d.Uint32())
}
func (*binaryClassGlCopyPathNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCopyPathNV(e, obj.(*GlCopyPathNV))
}
func (*binaryClassGlCopyPathNV) New() binary.Object {
	return &GlCopyPathNV{}
}
func (*binaryClassGlCopyPathNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCopyPathNV(d, obj.(*GlCopyPathNV))
}
func (c *binaryClassGlCopyPathNV) Schema() *binary.Entity {
	return &entities[ixǁGlCopyPathNV]
}

type binaryClassGlCopyTexImage2D struct{}

func (*GlCopyTexImage2D) Class() binary.Class {
	return (*binaryClassGlCopyTexImage2D)(nil)
}
func doEncodeGlCopyTexImage2D(e binary.Encoder, o *GlCopyTexImage2D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Border))
}
func doDecodeGlCopyTexImage2D(d binary.Decoder, o *GlCopyTexImage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
}
func doDecodeRawGlCopyTexImage2D(d binary.Decoder, o *GlCopyTexImage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
}
func (*binaryClassGlCopyTexImage2D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCopyTexImage2D(e, obj.(*GlCopyTexImage2D))
}
func (*binaryClassGlCopyTexImage2D) New() binary.Object {
	return &GlCopyTexImage2D{}
}
func (*binaryClassGlCopyTexImage2D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCopyTexImage2D(d, obj.(*GlCopyTexImage2D))
}
func (c *binaryClassGlCopyTexImage2D) Schema() *binary.Entity {
	return &entities[ixǁGlCopyTexImage2D]
}

type binaryClassGlCopyTexSubImage2D struct{}

func (*GlCopyTexSubImage2D) Class() binary.Class {
	return (*binaryClassGlCopyTexSubImage2D)(nil)
}
func doEncodeGlCopyTexSubImage2D(e binary.Encoder, o *GlCopyTexSubImage2D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Xoffset))
	e.Int32(int32(o.Yoffset))
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlCopyTexSubImage2D(d binary.Decoder, o *GlCopyTexSubImage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlCopyTexSubImage2D(d binary.Decoder, o *GlCopyTexSubImage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlCopyTexSubImage2D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCopyTexSubImage2D(e, obj.(*GlCopyTexSubImage2D))
}
func (*binaryClassGlCopyTexSubImage2D) New() binary.Object {
	return &GlCopyTexSubImage2D{}
}
func (*binaryClassGlCopyTexSubImage2D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCopyTexSubImage2D(d, obj.(*GlCopyTexSubImage2D))
}
func (c *binaryClassGlCopyTexSubImage2D) Schema() *binary.Entity {
	return &entities[ixǁGlCopyTexSubImage2D]
}

type binaryClassGlCopyTexSubImage3D struct{}

func (*GlCopyTexSubImage3D) Class() binary.Class {
	return (*binaryClassGlCopyTexSubImage3D)(nil)
}
func doEncodeGlCopyTexSubImage3D(e binary.Encoder, o *GlCopyTexSubImage3D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Xoffset))
	e.Int32(int32(o.Yoffset))
	e.Int32(int32(o.Zoffset))
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlCopyTexSubImage3D(d binary.Decoder, o *GlCopyTexSubImage3D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlCopyTexSubImage3D(d binary.Decoder, o *GlCopyTexSubImage3D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlCopyTexSubImage3D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCopyTexSubImage3D(e, obj.(*GlCopyTexSubImage3D))
}
func (*binaryClassGlCopyTexSubImage3D) New() binary.Object {
	return &GlCopyTexSubImage3D{}
}
func (*binaryClassGlCopyTexSubImage3D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCopyTexSubImage3D(d, obj.(*GlCopyTexSubImage3D))
}
func (c *binaryClassGlCopyTexSubImage3D) Schema() *binary.Entity {
	return &entities[ixǁGlCopyTexSubImage3D]
}

type binaryClassGlCopyTexSubImage3DOES struct{}

func (*GlCopyTexSubImage3DOES) Class() binary.Class {
	return (*binaryClassGlCopyTexSubImage3DOES)(nil)
}
func doEncodeGlCopyTexSubImage3DOES(e binary.Encoder, o *GlCopyTexSubImage3DOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Xoffset))
	e.Int32(int32(o.Yoffset))
	e.Int32(int32(o.Zoffset))
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlCopyTexSubImage3DOES(d binary.Decoder, o *GlCopyTexSubImage3DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlCopyTexSubImage3DOES(d binary.Decoder, o *GlCopyTexSubImage3DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlCopyTexSubImage3DOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCopyTexSubImage3DOES(e, obj.(*GlCopyTexSubImage3DOES))
}
func (*binaryClassGlCopyTexSubImage3DOES) New() binary.Object {
	return &GlCopyTexSubImage3DOES{}
}
func (*binaryClassGlCopyTexSubImage3DOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCopyTexSubImage3DOES(d, obj.(*GlCopyTexSubImage3DOES))
}
func (c *binaryClassGlCopyTexSubImage3DOES) Schema() *binary.Entity {
	return &entities[ixǁGlCopyTexSubImage3DOES]
}

type binaryClassGlCopyTextureLevelsAPPLE struct{}

func (*GlCopyTextureLevelsAPPLE) Class() binary.Class {
	return (*binaryClassGlCopyTextureLevelsAPPLE)(nil)
}
func doEncodeGlCopyTextureLevelsAPPLE(e binary.Encoder, o *GlCopyTextureLevelsAPPLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DestinationTexture))
	e.Uint32(uint32(o.SourceTexture))
	e.Int32(int32(o.SourceBaseLevel))
	e.Int32(int32(o.SourceLevelCount))
}
func doDecodeGlCopyTextureLevelsAPPLE(d binary.Decoder, o *GlCopyTextureLevelsAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DestinationTexture = GLuint(d.Uint32())
	o.SourceTexture = GLuint(d.Uint32())
	o.SourceBaseLevel = GLint(d.Int32())
	o.SourceLevelCount = GLsizei(d.Int32())
}
func doDecodeRawGlCopyTextureLevelsAPPLE(d binary.Decoder, o *GlCopyTextureLevelsAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DestinationTexture = GLuint(d.Uint32())
	o.SourceTexture = GLuint(d.Uint32())
	o.SourceBaseLevel = GLint(d.Int32())
	o.SourceLevelCount = GLsizei(d.Int32())
}
func (*binaryClassGlCopyTextureLevelsAPPLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCopyTextureLevelsAPPLE(e, obj.(*GlCopyTextureLevelsAPPLE))
}
func (*binaryClassGlCopyTextureLevelsAPPLE) New() binary.Object {
	return &GlCopyTextureLevelsAPPLE{}
}
func (*binaryClassGlCopyTextureLevelsAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCopyTextureLevelsAPPLE(d, obj.(*GlCopyTextureLevelsAPPLE))
}
func (c *binaryClassGlCopyTextureLevelsAPPLE) Schema() *binary.Entity {
	return &entities[ixǁGlCopyTextureLevelsAPPLE]
}

type binaryClassGlCoverFillPathInstancedNV struct{}

func (*GlCoverFillPathInstancedNV) Class() binary.Class {
	return (*binaryClassGlCoverFillPathInstancedNV)(nil)
}
func doEncodeGlCoverFillPathInstancedNV(e binary.Encoder, o *GlCoverFillPathInstancedNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.NumPaths))
	e.Uint32(uint32(o.PathNameType))
	e.Simple(&o.Paths)
	e.Uint32(uint32(o.PathBase))
	e.Uint32(uint32(o.CoverMode))
	e.Uint32(uint32(o.TransformType))
	e.Simple(&o.TransformValues)
}
func doDecodeGlCoverFillPathInstancedNV(d binary.Decoder, o *GlCoverFillPathInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func doDecodeRawGlCoverFillPathInstancedNV(d binary.Decoder, o *GlCoverFillPathInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func (*binaryClassGlCoverFillPathInstancedNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCoverFillPathInstancedNV(e, obj.(*GlCoverFillPathInstancedNV))
}
func (*binaryClassGlCoverFillPathInstancedNV) New() binary.Object {
	return &GlCoverFillPathInstancedNV{}
}
func (*binaryClassGlCoverFillPathInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCoverFillPathInstancedNV(d, obj.(*GlCoverFillPathInstancedNV))
}
func (c *binaryClassGlCoverFillPathInstancedNV) Schema() *binary.Entity {
	return &entities[ixǁGlCoverFillPathInstancedNV]
}

type binaryClassGlCoverFillPathNV struct{}

func (*GlCoverFillPathNV) Class() binary.Class {
	return (*binaryClassGlCoverFillPathNV)(nil)
}
func doEncodeGlCoverFillPathNV(e binary.Encoder, o *GlCoverFillPathNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint32(uint32(o.CoverMode))
}
func doDecodeGlCoverFillPathNV(d binary.Decoder, o *GlCoverFillPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
}
func doDecodeRawGlCoverFillPathNV(d binary.Decoder, o *GlCoverFillPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
}
func (*binaryClassGlCoverFillPathNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCoverFillPathNV(e, obj.(*GlCoverFillPathNV))
}
func (*binaryClassGlCoverFillPathNV) New() binary.Object {
	return &GlCoverFillPathNV{}
}
func (*binaryClassGlCoverFillPathNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCoverFillPathNV(d, obj.(*GlCoverFillPathNV))
}
func (c *binaryClassGlCoverFillPathNV) Schema() *binary.Entity {
	return &entities[ixǁGlCoverFillPathNV]
}

type binaryClassGlCoverStrokePathInstancedNV struct{}

func (*GlCoverStrokePathInstancedNV) Class() binary.Class {
	return (*binaryClassGlCoverStrokePathInstancedNV)(nil)
}
func doEncodeGlCoverStrokePathInstancedNV(e binary.Encoder, o *GlCoverStrokePathInstancedNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.NumPaths))
	e.Uint32(uint32(o.PathNameType))
	e.Simple(&o.Paths)
	e.Uint32(uint32(o.PathBase))
	e.Uint32(uint32(o.CoverMode))
	e.Uint32(uint32(o.TransformType))
	e.Simple(&o.TransformValues)
}
func doDecodeGlCoverStrokePathInstancedNV(d binary.Decoder, o *GlCoverStrokePathInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func doDecodeRawGlCoverStrokePathInstancedNV(d binary.Decoder, o *GlCoverStrokePathInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func (*binaryClassGlCoverStrokePathInstancedNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCoverStrokePathInstancedNV(e, obj.(*GlCoverStrokePathInstancedNV))
}
func (*binaryClassGlCoverStrokePathInstancedNV) New() binary.Object {
	return &GlCoverStrokePathInstancedNV{}
}
func (*binaryClassGlCoverStrokePathInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCoverStrokePathInstancedNV(d, obj.(*GlCoverStrokePathInstancedNV))
}
func (c *binaryClassGlCoverStrokePathInstancedNV) Schema() *binary.Entity {
	return &entities[ixǁGlCoverStrokePathInstancedNV]
}

type binaryClassGlCoverStrokePathNV struct{}

func (*GlCoverStrokePathNV) Class() binary.Class {
	return (*binaryClassGlCoverStrokePathNV)(nil)
}
func doEncodeGlCoverStrokePathNV(e binary.Encoder, o *GlCoverStrokePathNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint32(uint32(o.CoverMode))
}
func doDecodeGlCoverStrokePathNV(d binary.Decoder, o *GlCoverStrokePathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
}
func doDecodeRawGlCoverStrokePathNV(d binary.Decoder, o *GlCoverStrokePathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
}
func (*binaryClassGlCoverStrokePathNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCoverStrokePathNV(e, obj.(*GlCoverStrokePathNV))
}
func (*binaryClassGlCoverStrokePathNV) New() binary.Object {
	return &GlCoverStrokePathNV{}
}
func (*binaryClassGlCoverStrokePathNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCoverStrokePathNV(d, obj.(*GlCoverStrokePathNV))
}
func (c *binaryClassGlCoverStrokePathNV) Schema() *binary.Entity {
	return &entities[ixǁGlCoverStrokePathNV]
}

type binaryClassGlCoverageMaskNV struct{}

func (*GlCoverageMaskNV) Class() binary.Class {
	return (*binaryClassGlCoverageMaskNV)(nil)
}
func doEncodeGlCoverageMaskNV(e binary.Encoder, o *GlCoverageMaskNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint8(uint8(o.Mask))
}
func doDecodeGlCoverageMaskNV(d binary.Decoder, o *GlCoverageMaskNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mask = GLboolean(d.Uint8())
}
func doDecodeRawGlCoverageMaskNV(d binary.Decoder, o *GlCoverageMaskNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mask = GLboolean(d.Uint8())
}
func (*binaryClassGlCoverageMaskNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCoverageMaskNV(e, obj.(*GlCoverageMaskNV))
}
func (*binaryClassGlCoverageMaskNV) New() binary.Object {
	return &GlCoverageMaskNV{}
}
func (*binaryClassGlCoverageMaskNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCoverageMaskNV(d, obj.(*GlCoverageMaskNV))
}
func (c *binaryClassGlCoverageMaskNV) Schema() *binary.Entity {
	return &entities[ixǁGlCoverageMaskNV]
}

type binaryClassGlCoverageModulationNV struct{}

func (*GlCoverageModulationNV) Class() binary.Class {
	return (*binaryClassGlCoverageModulationNV)(nil)
}
func doEncodeGlCoverageModulationNV(e binary.Encoder, o *GlCoverageModulationNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Components))
}
func doDecodeGlCoverageModulationNV(d binary.Decoder, o *GlCoverageModulationNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Components = GLenum(d.Uint32())
}
func doDecodeRawGlCoverageModulationNV(d binary.Decoder, o *GlCoverageModulationNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Components = GLenum(d.Uint32())
}
func (*binaryClassGlCoverageModulationNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCoverageModulationNV(e, obj.(*GlCoverageModulationNV))
}
func (*binaryClassGlCoverageModulationNV) New() binary.Object {
	return &GlCoverageModulationNV{}
}
func (*binaryClassGlCoverageModulationNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCoverageModulationNV(d, obj.(*GlCoverageModulationNV))
}
func (c *binaryClassGlCoverageModulationNV) Schema() *binary.Entity {
	return &entities[ixǁGlCoverageModulationNV]
}

type binaryClassGlCoverageModulationTableNV struct{}

func (*GlCoverageModulationTableNV) Class() binary.Class {
	return (*binaryClassGlCoverageModulationTableNV)(nil)
}
func doEncodeGlCoverageModulationTableNV(e binary.Encoder, o *GlCoverageModulationTableNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.V)
}
func doDecodeGlCoverageModulationTableNV(d binary.Decoder, o *GlCoverageModulationTableNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func doDecodeRawGlCoverageModulationTableNV(d binary.Decoder, o *GlCoverageModulationTableNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func (*binaryClassGlCoverageModulationTableNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCoverageModulationTableNV(e, obj.(*GlCoverageModulationTableNV))
}
func (*binaryClassGlCoverageModulationTableNV) New() binary.Object {
	return &GlCoverageModulationTableNV{}
}
func (*binaryClassGlCoverageModulationTableNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCoverageModulationTableNV(d, obj.(*GlCoverageModulationTableNV))
}
func (c *binaryClassGlCoverageModulationTableNV) Schema() *binary.Entity {
	return &entities[ixǁGlCoverageModulationTableNV]
}

type binaryClassGlCoverageOperationNV struct{}

func (*GlCoverageOperationNV) Class() binary.Class {
	return (*binaryClassGlCoverageOperationNV)(nil)
}
func doEncodeGlCoverageOperationNV(e binary.Encoder, o *GlCoverageOperationNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Operation))
}
func doDecodeGlCoverageOperationNV(d binary.Decoder, o *GlCoverageOperationNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Operation = GLenum(d.Uint32())
}
func doDecodeRawGlCoverageOperationNV(d binary.Decoder, o *GlCoverageOperationNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Operation = GLenum(d.Uint32())
}
func (*binaryClassGlCoverageOperationNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCoverageOperationNV(e, obj.(*GlCoverageOperationNV))
}
func (*binaryClassGlCoverageOperationNV) New() binary.Object {
	return &GlCoverageOperationNV{}
}
func (*binaryClassGlCoverageOperationNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCoverageOperationNV(d, obj.(*GlCoverageOperationNV))
}
func (c *binaryClassGlCoverageOperationNV) Schema() *binary.Entity {
	return &entities[ixǁGlCoverageOperationNV]
}

type binaryClassGlCreatePerfQueryINTEL struct{}

func (*GlCreatePerfQueryINTEL) Class() binary.Class {
	return (*binaryClassGlCreatePerfQueryINTEL)(nil)
}
func doEncodeGlCreatePerfQueryINTEL(e binary.Encoder, o *GlCreatePerfQueryINTEL) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.QueryId))
	e.Simple(&o.QueryHandle)
}
func doDecodeGlCreatePerfQueryINTEL(d binary.Decoder, o *GlCreatePerfQueryINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryId = GLuint(d.Uint32())
	d.Simple(&o.QueryHandle)
}
func doDecodeRawGlCreatePerfQueryINTEL(d binary.Decoder, o *GlCreatePerfQueryINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryId = GLuint(d.Uint32())
	d.Simple(&o.QueryHandle)
}
func (*binaryClassGlCreatePerfQueryINTEL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCreatePerfQueryINTEL(e, obj.(*GlCreatePerfQueryINTEL))
}
func (*binaryClassGlCreatePerfQueryINTEL) New() binary.Object {
	return &GlCreatePerfQueryINTEL{}
}
func (*binaryClassGlCreatePerfQueryINTEL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCreatePerfQueryINTEL(d, obj.(*GlCreatePerfQueryINTEL))
}
func (c *binaryClassGlCreatePerfQueryINTEL) Schema() *binary.Entity {
	return &entities[ixǁGlCreatePerfQueryINTEL]
}

type binaryClassGlCreateProgram struct{}

func (*GlCreateProgram) Class() binary.Class {
	return (*binaryClassGlCreateProgram)(nil)
}
func doEncodeGlCreateProgram(e binary.Encoder, o *GlCreateProgram) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Result))
}
func doDecodeGlCreateProgram(d binary.Decoder, o *GlCreateProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = ProgramId(d.Uint32())
}
func doDecodeRawGlCreateProgram(d binary.Decoder, o *GlCreateProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = ProgramId(d.Uint32())
}
func (*binaryClassGlCreateProgram) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCreateProgram(e, obj.(*GlCreateProgram))
}
func (*binaryClassGlCreateProgram) New() binary.Object {
	return &GlCreateProgram{}
}
func (*binaryClassGlCreateProgram) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCreateProgram(d, obj.(*GlCreateProgram))
}
func (c *binaryClassGlCreateProgram) Schema() *binary.Entity {
	return &entities[ixǁGlCreateProgram]
}

type binaryClassGlCreateShader struct{}

func (*GlCreateShader) Class() binary.Class {
	return (*binaryClassGlCreateShader)(nil)
}
func doEncodeGlCreateShader(e binary.Encoder, o *GlCreateShader) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Type))
	e.Uint32(uint32(o.Result))
}
func doDecodeGlCreateShader(d binary.Decoder, o *GlCreateShader) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Result = ShaderId(d.Uint32())
}
func doDecodeRawGlCreateShader(d binary.Decoder, o *GlCreateShader) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Result = ShaderId(d.Uint32())
}
func (*binaryClassGlCreateShader) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCreateShader(e, obj.(*GlCreateShader))
}
func (*binaryClassGlCreateShader) New() binary.Object {
	return &GlCreateShader{}
}
func (*binaryClassGlCreateShader) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCreateShader(d, obj.(*GlCreateShader))
}
func (c *binaryClassGlCreateShader) Schema() *binary.Entity {
	return &entities[ixǁGlCreateShader]
}

type binaryClassGlCreateShaderProgramv struct{}

func (*GlCreateShaderProgramv) Class() binary.Class {
	return (*binaryClassGlCreateShaderProgramv)(nil)
}
func doEncodeGlCreateShaderProgramv(e binary.Encoder, o *GlCreateShaderProgramv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Count))
	e.Simple(&o.Strings)
	e.Uint32(uint32(o.Result))
}
func doDecodeGlCreateShaderProgramv(d binary.Decoder, o *GlCreateShaderProgramv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Strings)
	o.Result = ProgramId(d.Uint32())
}
func doDecodeRawGlCreateShaderProgramv(d binary.Decoder, o *GlCreateShaderProgramv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Strings)
	o.Result = ProgramId(d.Uint32())
}
func (*binaryClassGlCreateShaderProgramv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCreateShaderProgramv(e, obj.(*GlCreateShaderProgramv))
}
func (*binaryClassGlCreateShaderProgramv) New() binary.Object {
	return &GlCreateShaderProgramv{}
}
func (*binaryClassGlCreateShaderProgramv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCreateShaderProgramv(d, obj.(*GlCreateShaderProgramv))
}
func (c *binaryClassGlCreateShaderProgramv) Schema() *binary.Entity {
	return &entities[ixǁGlCreateShaderProgramv]
}

type binaryClassGlCreateShaderProgramvEXT struct{}

func (*GlCreateShaderProgramvEXT) Class() binary.Class {
	return (*binaryClassGlCreateShaderProgramvEXT)(nil)
}
func doEncodeGlCreateShaderProgramvEXT(e binary.Encoder, o *GlCreateShaderProgramvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Count))
	e.Simple(&o.Strings)
	e.Uint32(uint32(o.Result))
}
func doDecodeGlCreateShaderProgramvEXT(d binary.Decoder, o *GlCreateShaderProgramvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Strings)
	o.Result = GLuint(d.Uint32())
}
func doDecodeRawGlCreateShaderProgramvEXT(d binary.Decoder, o *GlCreateShaderProgramvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Strings)
	o.Result = GLuint(d.Uint32())
}
func (*binaryClassGlCreateShaderProgramvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCreateShaderProgramvEXT(e, obj.(*GlCreateShaderProgramvEXT))
}
func (*binaryClassGlCreateShaderProgramvEXT) New() binary.Object {
	return &GlCreateShaderProgramvEXT{}
}
func (*binaryClassGlCreateShaderProgramvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCreateShaderProgramvEXT(d, obj.(*GlCreateShaderProgramvEXT))
}
func (c *binaryClassGlCreateShaderProgramvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlCreateShaderProgramvEXT]
}

type binaryClassGlCullFace struct{}

func (*GlCullFace) Class() binary.Class {
	return (*binaryClassGlCullFace)(nil)
}
func doEncodeGlCullFace(e binary.Encoder, o *GlCullFace) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
}
func doDecodeGlCullFace(d binary.Decoder, o *GlCullFace) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
}
func doDecodeRawGlCullFace(d binary.Decoder, o *GlCullFace) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
}
func (*binaryClassGlCullFace) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCullFace(e, obj.(*GlCullFace))
}
func (*binaryClassGlCullFace) New() binary.Object {
	return &GlCullFace{}
}
func (*binaryClassGlCullFace) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCullFace(d, obj.(*GlCullFace))
}
func (c *binaryClassGlCullFace) Schema() *binary.Entity {
	return &entities[ixǁGlCullFace]
}

type binaryClassGlCurrentPaletteMatrixOES struct{}

func (*GlCurrentPaletteMatrixOES) Class() binary.Class {
	return (*binaryClassGlCurrentPaletteMatrixOES)(nil)
}
func doEncodeGlCurrentPaletteMatrixOES(e binary.Encoder, o *GlCurrentPaletteMatrixOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Matrixpaletteindex))
}
func doDecodeGlCurrentPaletteMatrixOES(d binary.Decoder, o *GlCurrentPaletteMatrixOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Matrixpaletteindex = GLuint(d.Uint32())
}
func doDecodeRawGlCurrentPaletteMatrixOES(d binary.Decoder, o *GlCurrentPaletteMatrixOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Matrixpaletteindex = GLuint(d.Uint32())
}
func (*binaryClassGlCurrentPaletteMatrixOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlCurrentPaletteMatrixOES(e, obj.(*GlCurrentPaletteMatrixOES))
}
func (*binaryClassGlCurrentPaletteMatrixOES) New() binary.Object {
	return &GlCurrentPaletteMatrixOES{}
}
func (*binaryClassGlCurrentPaletteMatrixOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlCurrentPaletteMatrixOES(d, obj.(*GlCurrentPaletteMatrixOES))
}
func (c *binaryClassGlCurrentPaletteMatrixOES) Schema() *binary.Entity {
	return &entities[ixǁGlCurrentPaletteMatrixOES]
}

type binaryClassGlDebugMessageCallback struct{}

func (*GlDebugMessageCallback) Class() binary.Class {
	return (*binaryClassGlDebugMessageCallback)(nil)
}
func doEncodeGlDebugMessageCallback(e binary.Encoder, o *GlDebugMessageCallback) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Callback)
	e.Simple(&o.UserParam)
}
func doDecodeGlDebugMessageCallback(d binary.Decoder, o *GlDebugMessageCallback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Callback)
	d.Simple(&o.UserParam)
}
func doDecodeRawGlDebugMessageCallback(d binary.Decoder, o *GlDebugMessageCallback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Callback)
	d.Simple(&o.UserParam)
}
func (*binaryClassGlDebugMessageCallback) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDebugMessageCallback(e, obj.(*GlDebugMessageCallback))
}
func (*binaryClassGlDebugMessageCallback) New() binary.Object {
	return &GlDebugMessageCallback{}
}
func (*binaryClassGlDebugMessageCallback) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDebugMessageCallback(d, obj.(*GlDebugMessageCallback))
}
func (c *binaryClassGlDebugMessageCallback) Schema() *binary.Entity {
	return &entities[ixǁGlDebugMessageCallback]
}

type binaryClassGlDebugMessageCallbackKHR struct{}

func (*GlDebugMessageCallbackKHR) Class() binary.Class {
	return (*binaryClassGlDebugMessageCallbackKHR)(nil)
}
func doEncodeGlDebugMessageCallbackKHR(e binary.Encoder, o *GlDebugMessageCallbackKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Callback)
	e.Simple(&o.UserParam)
}
func doDecodeGlDebugMessageCallbackKHR(d binary.Decoder, o *GlDebugMessageCallbackKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Callback)
	d.Simple(&o.UserParam)
}
func doDecodeRawGlDebugMessageCallbackKHR(d binary.Decoder, o *GlDebugMessageCallbackKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Callback)
	d.Simple(&o.UserParam)
}
func (*binaryClassGlDebugMessageCallbackKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDebugMessageCallbackKHR(e, obj.(*GlDebugMessageCallbackKHR))
}
func (*binaryClassGlDebugMessageCallbackKHR) New() binary.Object {
	return &GlDebugMessageCallbackKHR{}
}
func (*binaryClassGlDebugMessageCallbackKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDebugMessageCallbackKHR(d, obj.(*GlDebugMessageCallbackKHR))
}
func (c *binaryClassGlDebugMessageCallbackKHR) Schema() *binary.Entity {
	return &entities[ixǁGlDebugMessageCallbackKHR]
}

type binaryClassGlDebugMessageControl struct{}

func (*GlDebugMessageControl) Class() binary.Class {
	return (*binaryClassGlDebugMessageControl)(nil)
}
func doEncodeGlDebugMessageControl(e binary.Encoder, o *GlDebugMessageControl) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Source))
	e.Uint32(uint32(o.Type))
	e.Uint32(uint32(o.Severity))
	e.Int32(int32(o.Count))
	e.Simple(&o.Ids)
	e.Uint8(uint8(o.Enabled))
}
func doDecodeGlDebugMessageControl(d binary.Decoder, o *GlDebugMessageControl) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Source = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.Severity = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Ids)
	o.Enabled = GLboolean(d.Uint8())
}
func doDecodeRawGlDebugMessageControl(d binary.Decoder, o *GlDebugMessageControl) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Source = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.Severity = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Ids)
	o.Enabled = GLboolean(d.Uint8())
}
func (*binaryClassGlDebugMessageControl) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDebugMessageControl(e, obj.(*GlDebugMessageControl))
}
func (*binaryClassGlDebugMessageControl) New() binary.Object {
	return &GlDebugMessageControl{}
}
func (*binaryClassGlDebugMessageControl) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDebugMessageControl(d, obj.(*GlDebugMessageControl))
}
func (c *binaryClassGlDebugMessageControl) Schema() *binary.Entity {
	return &entities[ixǁGlDebugMessageControl]
}

type binaryClassGlDebugMessageControlKHR struct{}

func (*GlDebugMessageControlKHR) Class() binary.Class {
	return (*binaryClassGlDebugMessageControlKHR)(nil)
}
func doEncodeGlDebugMessageControlKHR(e binary.Encoder, o *GlDebugMessageControlKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Source))
	e.Uint32(uint32(o.Type))
	e.Uint32(uint32(o.Severity))
	e.Int32(int32(o.Count))
	e.Simple(&o.Ids)
	e.Uint8(uint8(o.Enabled))
}
func doDecodeGlDebugMessageControlKHR(d binary.Decoder, o *GlDebugMessageControlKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Source = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.Severity = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Ids)
	o.Enabled = GLboolean(d.Uint8())
}
func doDecodeRawGlDebugMessageControlKHR(d binary.Decoder, o *GlDebugMessageControlKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Source = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.Severity = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Ids)
	o.Enabled = GLboolean(d.Uint8())
}
func (*binaryClassGlDebugMessageControlKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDebugMessageControlKHR(e, obj.(*GlDebugMessageControlKHR))
}
func (*binaryClassGlDebugMessageControlKHR) New() binary.Object {
	return &GlDebugMessageControlKHR{}
}
func (*binaryClassGlDebugMessageControlKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDebugMessageControlKHR(d, obj.(*GlDebugMessageControlKHR))
}
func (c *binaryClassGlDebugMessageControlKHR) Schema() *binary.Entity {
	return &entities[ixǁGlDebugMessageControlKHR]
}

type binaryClassGlDebugMessageInsert struct{}

func (*GlDebugMessageInsert) Class() binary.Class {
	return (*binaryClassGlDebugMessageInsert)(nil)
}
func doEncodeGlDebugMessageInsert(e binary.Encoder, o *GlDebugMessageInsert) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Source))
	e.Uint32(uint32(o.Type))
	e.Uint32(uint32(o.Id))
	e.Uint32(uint32(o.Severity))
	e.Int32(int32(o.Length))
	e.Simple(&o.Message)
}
func doDecodeGlDebugMessageInsert(d binary.Decoder, o *GlDebugMessageInsert) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Source = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.Id = GLuint(d.Uint32())
	o.Severity = GLenum(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Message)
}
func doDecodeRawGlDebugMessageInsert(d binary.Decoder, o *GlDebugMessageInsert) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Source = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.Id = GLuint(d.Uint32())
	o.Severity = GLenum(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Message)
}
func (*binaryClassGlDebugMessageInsert) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDebugMessageInsert(e, obj.(*GlDebugMessageInsert))
}
func (*binaryClassGlDebugMessageInsert) New() binary.Object {
	return &GlDebugMessageInsert{}
}
func (*binaryClassGlDebugMessageInsert) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDebugMessageInsert(d, obj.(*GlDebugMessageInsert))
}
func (c *binaryClassGlDebugMessageInsert) Schema() *binary.Entity {
	return &entities[ixǁGlDebugMessageInsert]
}

type binaryClassGlDebugMessageInsertKHR struct{}

func (*GlDebugMessageInsertKHR) Class() binary.Class {
	return (*binaryClassGlDebugMessageInsertKHR)(nil)
}
func doEncodeGlDebugMessageInsertKHR(e binary.Encoder, o *GlDebugMessageInsertKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Source))
	e.Uint32(uint32(o.Type))
	e.Uint32(uint32(o.Id))
	e.Uint32(uint32(o.Severity))
	e.Int32(int32(o.Length))
	e.Simple(&o.Message)
}
func doDecodeGlDebugMessageInsertKHR(d binary.Decoder, o *GlDebugMessageInsertKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Source = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.Id = GLuint(d.Uint32())
	o.Severity = GLenum(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Message)
}
func doDecodeRawGlDebugMessageInsertKHR(d binary.Decoder, o *GlDebugMessageInsertKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Source = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.Id = GLuint(d.Uint32())
	o.Severity = GLenum(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Message)
}
func (*binaryClassGlDebugMessageInsertKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDebugMessageInsertKHR(e, obj.(*GlDebugMessageInsertKHR))
}
func (*binaryClassGlDebugMessageInsertKHR) New() binary.Object {
	return &GlDebugMessageInsertKHR{}
}
func (*binaryClassGlDebugMessageInsertKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDebugMessageInsertKHR(d, obj.(*GlDebugMessageInsertKHR))
}
func (c *binaryClassGlDebugMessageInsertKHR) Schema() *binary.Entity {
	return &entities[ixǁGlDebugMessageInsertKHR]
}

type binaryClassGlDeleteBuffers struct{}

func (*GlDeleteBuffers) Class() binary.Class {
	return (*binaryClassGlDeleteBuffers)(nil)
}
func doEncodeGlDeleteBuffers(e binary.Encoder, o *GlDeleteBuffers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Buffers)
}
func doDecodeGlDeleteBuffers(d binary.Decoder, o *GlDeleteBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Buffers)
}
func doDecodeRawGlDeleteBuffers(d binary.Decoder, o *GlDeleteBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Buffers)
}
func (*binaryClassGlDeleteBuffers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteBuffers(e, obj.(*GlDeleteBuffers))
}
func (*binaryClassGlDeleteBuffers) New() binary.Object {
	return &GlDeleteBuffers{}
}
func (*binaryClassGlDeleteBuffers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteBuffers(d, obj.(*GlDeleteBuffers))
}
func (c *binaryClassGlDeleteBuffers) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteBuffers]
}

type binaryClassGlDeleteFencesNV struct{}

func (*GlDeleteFencesNV) Class() binary.Class {
	return (*binaryClassGlDeleteFencesNV)(nil)
}
func doEncodeGlDeleteFencesNV(e binary.Encoder, o *GlDeleteFencesNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Fences)
}
func doDecodeGlDeleteFencesNV(d binary.Decoder, o *GlDeleteFencesNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Fences)
}
func doDecodeRawGlDeleteFencesNV(d binary.Decoder, o *GlDeleteFencesNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Fences)
}
func (*binaryClassGlDeleteFencesNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteFencesNV(e, obj.(*GlDeleteFencesNV))
}
func (*binaryClassGlDeleteFencesNV) New() binary.Object {
	return &GlDeleteFencesNV{}
}
func (*binaryClassGlDeleteFencesNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteFencesNV(d, obj.(*GlDeleteFencesNV))
}
func (c *binaryClassGlDeleteFencesNV) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteFencesNV]
}

type binaryClassGlDeleteFramebuffers struct{}

func (*GlDeleteFramebuffers) Class() binary.Class {
	return (*binaryClassGlDeleteFramebuffers)(nil)
}
func doEncodeGlDeleteFramebuffers(e binary.Encoder, o *GlDeleteFramebuffers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Framebuffers)
}
func doDecodeGlDeleteFramebuffers(d binary.Decoder, o *GlDeleteFramebuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Framebuffers)
}
func doDecodeRawGlDeleteFramebuffers(d binary.Decoder, o *GlDeleteFramebuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Framebuffers)
}
func (*binaryClassGlDeleteFramebuffers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteFramebuffers(e, obj.(*GlDeleteFramebuffers))
}
func (*binaryClassGlDeleteFramebuffers) New() binary.Object {
	return &GlDeleteFramebuffers{}
}
func (*binaryClassGlDeleteFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteFramebuffers(d, obj.(*GlDeleteFramebuffers))
}
func (c *binaryClassGlDeleteFramebuffers) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteFramebuffers]
}

type binaryClassGlDeleteFramebuffersOES struct{}

func (*GlDeleteFramebuffersOES) Class() binary.Class {
	return (*binaryClassGlDeleteFramebuffersOES)(nil)
}
func doEncodeGlDeleteFramebuffersOES(e binary.Encoder, o *GlDeleteFramebuffersOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Framebuffers)
}
func doDecodeGlDeleteFramebuffersOES(d binary.Decoder, o *GlDeleteFramebuffersOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Framebuffers)
}
func doDecodeRawGlDeleteFramebuffersOES(d binary.Decoder, o *GlDeleteFramebuffersOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Framebuffers)
}
func (*binaryClassGlDeleteFramebuffersOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteFramebuffersOES(e, obj.(*GlDeleteFramebuffersOES))
}
func (*binaryClassGlDeleteFramebuffersOES) New() binary.Object {
	return &GlDeleteFramebuffersOES{}
}
func (*binaryClassGlDeleteFramebuffersOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteFramebuffersOES(d, obj.(*GlDeleteFramebuffersOES))
}
func (c *binaryClassGlDeleteFramebuffersOES) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteFramebuffersOES]
}

type binaryClassGlDeletePathsNV struct{}

func (*GlDeletePathsNV) Class() binary.Class {
	return (*binaryClassGlDeletePathsNV)(nil)
}
func doEncodeGlDeletePathsNV(e binary.Encoder, o *GlDeletePathsNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Int32(int32(o.Range))
}
func doDecodeGlDeletePathsNV(d binary.Decoder, o *GlDeletePathsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Range = GLsizei(d.Int32())
}
func doDecodeRawGlDeletePathsNV(d binary.Decoder, o *GlDeletePathsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Range = GLsizei(d.Int32())
}
func (*binaryClassGlDeletePathsNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeletePathsNV(e, obj.(*GlDeletePathsNV))
}
func (*binaryClassGlDeletePathsNV) New() binary.Object {
	return &GlDeletePathsNV{}
}
func (*binaryClassGlDeletePathsNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeletePathsNV(d, obj.(*GlDeletePathsNV))
}
func (c *binaryClassGlDeletePathsNV) Schema() *binary.Entity {
	return &entities[ixǁGlDeletePathsNV]
}

type binaryClassGlDeletePerfMonitorsAMD struct{}

func (*GlDeletePerfMonitorsAMD) Class() binary.Class {
	return (*binaryClassGlDeletePerfMonitorsAMD)(nil)
}
func doEncodeGlDeletePerfMonitorsAMD(e binary.Encoder, o *GlDeletePerfMonitorsAMD) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Monitors)
}
func doDecodeGlDeletePerfMonitorsAMD(d binary.Decoder, o *GlDeletePerfMonitorsAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Monitors)
}
func doDecodeRawGlDeletePerfMonitorsAMD(d binary.Decoder, o *GlDeletePerfMonitorsAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Monitors)
}
func (*binaryClassGlDeletePerfMonitorsAMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeletePerfMonitorsAMD(e, obj.(*GlDeletePerfMonitorsAMD))
}
func (*binaryClassGlDeletePerfMonitorsAMD) New() binary.Object {
	return &GlDeletePerfMonitorsAMD{}
}
func (*binaryClassGlDeletePerfMonitorsAMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeletePerfMonitorsAMD(d, obj.(*GlDeletePerfMonitorsAMD))
}
func (c *binaryClassGlDeletePerfMonitorsAMD) Schema() *binary.Entity {
	return &entities[ixǁGlDeletePerfMonitorsAMD]
}

type binaryClassGlDeletePerfQueryINTEL struct{}

func (*GlDeletePerfQueryINTEL) Class() binary.Class {
	return (*binaryClassGlDeletePerfQueryINTEL)(nil)
}
func doEncodeGlDeletePerfQueryINTEL(e binary.Encoder, o *GlDeletePerfQueryINTEL) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.QueryHandle))
}
func doDecodeGlDeletePerfQueryINTEL(d binary.Decoder, o *GlDeletePerfQueryINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryHandle = GLuint(d.Uint32())
}
func doDecodeRawGlDeletePerfQueryINTEL(d binary.Decoder, o *GlDeletePerfQueryINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryHandle = GLuint(d.Uint32())
}
func (*binaryClassGlDeletePerfQueryINTEL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeletePerfQueryINTEL(e, obj.(*GlDeletePerfQueryINTEL))
}
func (*binaryClassGlDeletePerfQueryINTEL) New() binary.Object {
	return &GlDeletePerfQueryINTEL{}
}
func (*binaryClassGlDeletePerfQueryINTEL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeletePerfQueryINTEL(d, obj.(*GlDeletePerfQueryINTEL))
}
func (c *binaryClassGlDeletePerfQueryINTEL) Schema() *binary.Entity {
	return &entities[ixǁGlDeletePerfQueryINTEL]
}

type binaryClassGlDeleteProgram struct{}

func (*GlDeleteProgram) Class() binary.Class {
	return (*binaryClassGlDeleteProgram)(nil)
}
func doEncodeGlDeleteProgram(e binary.Encoder, o *GlDeleteProgram) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
}
func doDecodeGlDeleteProgram(d binary.Decoder, o *GlDeleteProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
}
func doDecodeRawGlDeleteProgram(d binary.Decoder, o *GlDeleteProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
}
func (*binaryClassGlDeleteProgram) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteProgram(e, obj.(*GlDeleteProgram))
}
func (*binaryClassGlDeleteProgram) New() binary.Object {
	return &GlDeleteProgram{}
}
func (*binaryClassGlDeleteProgram) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteProgram(d, obj.(*GlDeleteProgram))
}
func (c *binaryClassGlDeleteProgram) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteProgram]
}

type binaryClassPipelineIdᶜᵖ struct{}

func (*PipelineIdᶜᵖ) Class() binary.Class {
	return (*binaryClassPipelineIdᶜᵖ)(nil)
}
func doEncodePipelineIdᶜᵖ(e binary.Writer, o *PipelineIdᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodePipelineIdᶜᵖ(d binary.Reader, o *PipelineIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawPipelineIdᶜᵖ(d binary.Reader, o *PipelineIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassPipelineIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodePipelineIdᶜᵖ(e, obj.(*PipelineIdᶜᵖ))
}
func (*binaryClassPipelineIdᶜᵖ) New() binary.Object {
	return &PipelineIdᶜᵖ{}
}
func (*binaryClassPipelineIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodePipelineIdᶜᵖ(d, obj.(*PipelineIdᶜᵖ))
}
func (o *PipelineIdᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodePipelineIdᶜᵖ(w, o)
}
func (o *PipelineIdᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodePipelineIdᶜᵖ(r, o)
}
func (c *binaryClassPipelineIdᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁPipelineIdᶜᵖ]
}

type binaryClassGlDeleteProgramPipelines struct{}

func (*GlDeleteProgramPipelines) Class() binary.Class {
	return (*binaryClassGlDeleteProgramPipelines)(nil)
}
func doEncodeGlDeleteProgramPipelines(e binary.Encoder, o *GlDeleteProgramPipelines) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Pipelines)
}
func doDecodeGlDeleteProgramPipelines(d binary.Decoder, o *GlDeleteProgramPipelines) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Pipelines)
}
func doDecodeRawGlDeleteProgramPipelines(d binary.Decoder, o *GlDeleteProgramPipelines) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Pipelines)
}
func (*binaryClassGlDeleteProgramPipelines) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteProgramPipelines(e, obj.(*GlDeleteProgramPipelines))
}
func (*binaryClassGlDeleteProgramPipelines) New() binary.Object {
	return &GlDeleteProgramPipelines{}
}
func (*binaryClassGlDeleteProgramPipelines) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteProgramPipelines(d, obj.(*GlDeleteProgramPipelines))
}
func (c *binaryClassGlDeleteProgramPipelines) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteProgramPipelines]
}

type binaryClassGlDeleteProgramPipelinesEXT struct{}

func (*GlDeleteProgramPipelinesEXT) Class() binary.Class {
	return (*binaryClassGlDeleteProgramPipelinesEXT)(nil)
}
func doEncodeGlDeleteProgramPipelinesEXT(e binary.Encoder, o *GlDeleteProgramPipelinesEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Pipelines)
}
func doDecodeGlDeleteProgramPipelinesEXT(d binary.Decoder, o *GlDeleteProgramPipelinesEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Pipelines)
}
func doDecodeRawGlDeleteProgramPipelinesEXT(d binary.Decoder, o *GlDeleteProgramPipelinesEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Pipelines)
}
func (*binaryClassGlDeleteProgramPipelinesEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteProgramPipelinesEXT(e, obj.(*GlDeleteProgramPipelinesEXT))
}
func (*binaryClassGlDeleteProgramPipelinesEXT) New() binary.Object {
	return &GlDeleteProgramPipelinesEXT{}
}
func (*binaryClassGlDeleteProgramPipelinesEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteProgramPipelinesEXT(d, obj.(*GlDeleteProgramPipelinesEXT))
}
func (c *binaryClassGlDeleteProgramPipelinesEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteProgramPipelinesEXT]
}

type binaryClassQueryIdᶜᵖ struct{}

func (*QueryIdᶜᵖ) Class() binary.Class {
	return (*binaryClassQueryIdᶜᵖ)(nil)
}
func doEncodeQueryIdᶜᵖ(e binary.Writer, o *QueryIdᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeQueryIdᶜᵖ(d binary.Reader, o *QueryIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawQueryIdᶜᵖ(d binary.Reader, o *QueryIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassQueryIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeQueryIdᶜᵖ(e, obj.(*QueryIdᶜᵖ))
}
func (*binaryClassQueryIdᶜᵖ) New() binary.Object {
	return &QueryIdᶜᵖ{}
}
func (*binaryClassQueryIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeQueryIdᶜᵖ(d, obj.(*QueryIdᶜᵖ))
}
func (o *QueryIdᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeQueryIdᶜᵖ(w, o)
}
func (o *QueryIdᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeQueryIdᶜᵖ(r, o)
}
func (c *binaryClassQueryIdᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁQueryIdᶜᵖ]
}

type binaryClassGlDeleteQueries struct{}

func (*GlDeleteQueries) Class() binary.Class {
	return (*binaryClassGlDeleteQueries)(nil)
}
func doEncodeGlDeleteQueries(e binary.Encoder, o *GlDeleteQueries) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Queries)
}
func doDecodeGlDeleteQueries(d binary.Decoder, o *GlDeleteQueries) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Queries)
}
func doDecodeRawGlDeleteQueries(d binary.Decoder, o *GlDeleteQueries) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Queries)
}
func (*binaryClassGlDeleteQueries) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteQueries(e, obj.(*GlDeleteQueries))
}
func (*binaryClassGlDeleteQueries) New() binary.Object {
	return &GlDeleteQueries{}
}
func (*binaryClassGlDeleteQueries) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteQueries(d, obj.(*GlDeleteQueries))
}
func (c *binaryClassGlDeleteQueries) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteQueries]
}

type binaryClassGlDeleteQueriesEXT struct{}

func (*GlDeleteQueriesEXT) Class() binary.Class {
	return (*binaryClassGlDeleteQueriesEXT)(nil)
}
func doEncodeGlDeleteQueriesEXT(e binary.Encoder, o *GlDeleteQueriesEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Queries)
}
func doDecodeGlDeleteQueriesEXT(d binary.Decoder, o *GlDeleteQueriesEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Queries)
}
func doDecodeRawGlDeleteQueriesEXT(d binary.Decoder, o *GlDeleteQueriesEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Queries)
}
func (*binaryClassGlDeleteQueriesEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteQueriesEXT(e, obj.(*GlDeleteQueriesEXT))
}
func (*binaryClassGlDeleteQueriesEXT) New() binary.Object {
	return &GlDeleteQueriesEXT{}
}
func (*binaryClassGlDeleteQueriesEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteQueriesEXT(d, obj.(*GlDeleteQueriesEXT))
}
func (c *binaryClassGlDeleteQueriesEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteQueriesEXT]
}

type binaryClassRenderbufferIdᶜᵖ struct{}

func (*RenderbufferIdᶜᵖ) Class() binary.Class {
	return (*binaryClassRenderbufferIdᶜᵖ)(nil)
}
func doEncodeRenderbufferIdᶜᵖ(e binary.Writer, o *RenderbufferIdᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeRenderbufferIdᶜᵖ(d binary.Reader, o *RenderbufferIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawRenderbufferIdᶜᵖ(d binary.Reader, o *RenderbufferIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassRenderbufferIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeRenderbufferIdᶜᵖ(e, obj.(*RenderbufferIdᶜᵖ))
}
func (*binaryClassRenderbufferIdᶜᵖ) New() binary.Object {
	return &RenderbufferIdᶜᵖ{}
}
func (*binaryClassRenderbufferIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeRenderbufferIdᶜᵖ(d, obj.(*RenderbufferIdᶜᵖ))
}
func (o *RenderbufferIdᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeRenderbufferIdᶜᵖ(w, o)
}
func (o *RenderbufferIdᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeRenderbufferIdᶜᵖ(r, o)
}
func (c *binaryClassRenderbufferIdᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁRenderbufferIdᶜᵖ]
}

type binaryClassGlDeleteRenderbuffers struct{}

func (*GlDeleteRenderbuffers) Class() binary.Class {
	return (*binaryClassGlDeleteRenderbuffers)(nil)
}
func doEncodeGlDeleteRenderbuffers(e binary.Encoder, o *GlDeleteRenderbuffers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Renderbuffers)
}
func doDecodeGlDeleteRenderbuffers(d binary.Decoder, o *GlDeleteRenderbuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Renderbuffers)
}
func doDecodeRawGlDeleteRenderbuffers(d binary.Decoder, o *GlDeleteRenderbuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Renderbuffers)
}
func (*binaryClassGlDeleteRenderbuffers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteRenderbuffers(e, obj.(*GlDeleteRenderbuffers))
}
func (*binaryClassGlDeleteRenderbuffers) New() binary.Object {
	return &GlDeleteRenderbuffers{}
}
func (*binaryClassGlDeleteRenderbuffers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteRenderbuffers(d, obj.(*GlDeleteRenderbuffers))
}
func (c *binaryClassGlDeleteRenderbuffers) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteRenderbuffers]
}

type binaryClassGlDeleteRenderbuffersOES struct{}

func (*GlDeleteRenderbuffersOES) Class() binary.Class {
	return (*binaryClassGlDeleteRenderbuffersOES)(nil)
}
func doEncodeGlDeleteRenderbuffersOES(e binary.Encoder, o *GlDeleteRenderbuffersOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Renderbuffers)
}
func doDecodeGlDeleteRenderbuffersOES(d binary.Decoder, o *GlDeleteRenderbuffersOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Renderbuffers)
}
func doDecodeRawGlDeleteRenderbuffersOES(d binary.Decoder, o *GlDeleteRenderbuffersOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Renderbuffers)
}
func (*binaryClassGlDeleteRenderbuffersOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteRenderbuffersOES(e, obj.(*GlDeleteRenderbuffersOES))
}
func (*binaryClassGlDeleteRenderbuffersOES) New() binary.Object {
	return &GlDeleteRenderbuffersOES{}
}
func (*binaryClassGlDeleteRenderbuffersOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteRenderbuffersOES(d, obj.(*GlDeleteRenderbuffersOES))
}
func (c *binaryClassGlDeleteRenderbuffersOES) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteRenderbuffersOES]
}

type binaryClassSamplerIdᶜᵖ struct{}

func (*SamplerIdᶜᵖ) Class() binary.Class {
	return (*binaryClassSamplerIdᶜᵖ)(nil)
}
func doEncodeSamplerIdᶜᵖ(e binary.Writer, o *SamplerIdᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeSamplerIdᶜᵖ(d binary.Reader, o *SamplerIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawSamplerIdᶜᵖ(d binary.Reader, o *SamplerIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassSamplerIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeSamplerIdᶜᵖ(e, obj.(*SamplerIdᶜᵖ))
}
func (*binaryClassSamplerIdᶜᵖ) New() binary.Object {
	return &SamplerIdᶜᵖ{}
}
func (*binaryClassSamplerIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeSamplerIdᶜᵖ(d, obj.(*SamplerIdᶜᵖ))
}
func (o *SamplerIdᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeSamplerIdᶜᵖ(w, o)
}
func (o *SamplerIdᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeSamplerIdᶜᵖ(r, o)
}
func (c *binaryClassSamplerIdᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁSamplerIdᶜᵖ]
}

type binaryClassGlDeleteSamplers struct{}

func (*GlDeleteSamplers) Class() binary.Class {
	return (*binaryClassGlDeleteSamplers)(nil)
}
func doEncodeGlDeleteSamplers(e binary.Encoder, o *GlDeleteSamplers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Samplers)
}
func doDecodeGlDeleteSamplers(d binary.Decoder, o *GlDeleteSamplers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Samplers)
}
func doDecodeRawGlDeleteSamplers(d binary.Decoder, o *GlDeleteSamplers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Samplers)
}
func (*binaryClassGlDeleteSamplers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteSamplers(e, obj.(*GlDeleteSamplers))
}
func (*binaryClassGlDeleteSamplers) New() binary.Object {
	return &GlDeleteSamplers{}
}
func (*binaryClassGlDeleteSamplers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteSamplers(d, obj.(*GlDeleteSamplers))
}
func (c *binaryClassGlDeleteSamplers) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteSamplers]
}

type binaryClassGlDeleteShader struct{}

func (*GlDeleteShader) Class() binary.Class {
	return (*binaryClassGlDeleteShader)(nil)
}
func doEncodeGlDeleteShader(e binary.Encoder, o *GlDeleteShader) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Shader))
}
func doDecodeGlDeleteShader(d binary.Decoder, o *GlDeleteShader) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
}
func doDecodeRawGlDeleteShader(d binary.Decoder, o *GlDeleteShader) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
}
func (*binaryClassGlDeleteShader) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteShader(e, obj.(*GlDeleteShader))
}
func (*binaryClassGlDeleteShader) New() binary.Object {
	return &GlDeleteShader{}
}
func (*binaryClassGlDeleteShader) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteShader(d, obj.(*GlDeleteShader))
}
func (c *binaryClassGlDeleteShader) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteShader]
}

type binaryClassGlDeleteSync struct{}

func (*GlDeleteSync) Class() binary.Class {
	return (*binaryClassGlDeleteSync)(nil)
}
func doEncodeGlDeleteSync(e binary.Encoder, o *GlDeleteSync) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Sync)
}
func doDecodeGlDeleteSync(d binary.Decoder, o *GlDeleteSync) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
}
func doDecodeRawGlDeleteSync(d binary.Decoder, o *GlDeleteSync) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
}
func (*binaryClassGlDeleteSync) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteSync(e, obj.(*GlDeleteSync))
}
func (*binaryClassGlDeleteSync) New() binary.Object {
	return &GlDeleteSync{}
}
func (*binaryClassGlDeleteSync) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteSync(d, obj.(*GlDeleteSync))
}
func (c *binaryClassGlDeleteSync) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteSync]
}

type binaryClassGlDeleteSyncAPPLE struct{}

func (*GlDeleteSyncAPPLE) Class() binary.Class {
	return (*binaryClassGlDeleteSyncAPPLE)(nil)
}
func doEncodeGlDeleteSyncAPPLE(e binary.Encoder, o *GlDeleteSyncAPPLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Sync)
}
func doDecodeGlDeleteSyncAPPLE(d binary.Decoder, o *GlDeleteSyncAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
}
func doDecodeRawGlDeleteSyncAPPLE(d binary.Decoder, o *GlDeleteSyncAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
}
func (*binaryClassGlDeleteSyncAPPLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteSyncAPPLE(e, obj.(*GlDeleteSyncAPPLE))
}
func (*binaryClassGlDeleteSyncAPPLE) New() binary.Object {
	return &GlDeleteSyncAPPLE{}
}
func (*binaryClassGlDeleteSyncAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteSyncAPPLE(d, obj.(*GlDeleteSyncAPPLE))
}
func (c *binaryClassGlDeleteSyncAPPLE) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteSyncAPPLE]
}

type binaryClassTextureIdᶜᵖ struct{}

func (*TextureIdᶜᵖ) Class() binary.Class {
	return (*binaryClassTextureIdᶜᵖ)(nil)
}
func doEncodeTextureIdᶜᵖ(e binary.Writer, o *TextureIdᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeTextureIdᶜᵖ(d binary.Reader, o *TextureIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawTextureIdᶜᵖ(d binary.Reader, o *TextureIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassTextureIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTextureIdᶜᵖ(e, obj.(*TextureIdᶜᵖ))
}
func (*binaryClassTextureIdᶜᵖ) New() binary.Object {
	return &TextureIdᶜᵖ{}
}
func (*binaryClassTextureIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTextureIdᶜᵖ(d, obj.(*TextureIdᶜᵖ))
}
func (o *TextureIdᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeTextureIdᶜᵖ(w, o)
}
func (o *TextureIdᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeTextureIdᶜᵖ(r, o)
}
func (c *binaryClassTextureIdᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁTextureIdᶜᵖ]
}

type binaryClassGlDeleteTextures struct{}

func (*GlDeleteTextures) Class() binary.Class {
	return (*binaryClassGlDeleteTextures)(nil)
}
func doEncodeGlDeleteTextures(e binary.Encoder, o *GlDeleteTextures) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Textures)
}
func doDecodeGlDeleteTextures(d binary.Decoder, o *GlDeleteTextures) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Textures)
}
func doDecodeRawGlDeleteTextures(d binary.Decoder, o *GlDeleteTextures) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Textures)
}
func (*binaryClassGlDeleteTextures) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteTextures(e, obj.(*GlDeleteTextures))
}
func (*binaryClassGlDeleteTextures) New() binary.Object {
	return &GlDeleteTextures{}
}
func (*binaryClassGlDeleteTextures) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteTextures(d, obj.(*GlDeleteTextures))
}
func (c *binaryClassGlDeleteTextures) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteTextures]
}

type binaryClassTransformFeedbackIdᶜᵖ struct{}

func (*TransformFeedbackIdᶜᵖ) Class() binary.Class {
	return (*binaryClassTransformFeedbackIdᶜᵖ)(nil)
}
func doEncodeTransformFeedbackIdᶜᵖ(e binary.Writer, o *TransformFeedbackIdᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeTransformFeedbackIdᶜᵖ(d binary.Reader, o *TransformFeedbackIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawTransformFeedbackIdᶜᵖ(d binary.Reader, o *TransformFeedbackIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassTransformFeedbackIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTransformFeedbackIdᶜᵖ(e, obj.(*TransformFeedbackIdᶜᵖ))
}
func (*binaryClassTransformFeedbackIdᶜᵖ) New() binary.Object {
	return &TransformFeedbackIdᶜᵖ{}
}
func (*binaryClassTransformFeedbackIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTransformFeedbackIdᶜᵖ(d, obj.(*TransformFeedbackIdᶜᵖ))
}
func (o *TransformFeedbackIdᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeTransformFeedbackIdᶜᵖ(w, o)
}
func (o *TransformFeedbackIdᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeTransformFeedbackIdᶜᵖ(r, o)
}
func (c *binaryClassTransformFeedbackIdᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁTransformFeedbackIdᶜᵖ]
}

type binaryClassGlDeleteTransformFeedbacks struct{}

func (*GlDeleteTransformFeedbacks) Class() binary.Class {
	return (*binaryClassGlDeleteTransformFeedbacks)(nil)
}
func doEncodeGlDeleteTransformFeedbacks(e binary.Encoder, o *GlDeleteTransformFeedbacks) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Ids)
}
func doDecodeGlDeleteTransformFeedbacks(d binary.Decoder, o *GlDeleteTransformFeedbacks) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Ids)
}
func doDecodeRawGlDeleteTransformFeedbacks(d binary.Decoder, o *GlDeleteTransformFeedbacks) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Ids)
}
func (*binaryClassGlDeleteTransformFeedbacks) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteTransformFeedbacks(e, obj.(*GlDeleteTransformFeedbacks))
}
func (*binaryClassGlDeleteTransformFeedbacks) New() binary.Object {
	return &GlDeleteTransformFeedbacks{}
}
func (*binaryClassGlDeleteTransformFeedbacks) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteTransformFeedbacks(d, obj.(*GlDeleteTransformFeedbacks))
}
func (c *binaryClassGlDeleteTransformFeedbacks) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteTransformFeedbacks]
}

type binaryClassVertexArrayIdᶜᵖ struct{}

func (*VertexArrayIdᶜᵖ) Class() binary.Class {
	return (*binaryClassVertexArrayIdᶜᵖ)(nil)
}
func doEncodeVertexArrayIdᶜᵖ(e binary.Writer, o *VertexArrayIdᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVertexArrayIdᶜᵖ(d binary.Reader, o *VertexArrayIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVertexArrayIdᶜᵖ(d binary.Reader, o *VertexArrayIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVertexArrayIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVertexArrayIdᶜᵖ(e, obj.(*VertexArrayIdᶜᵖ))
}
func (*binaryClassVertexArrayIdᶜᵖ) New() binary.Object {
	return &VertexArrayIdᶜᵖ{}
}
func (*binaryClassVertexArrayIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVertexArrayIdᶜᵖ(d, obj.(*VertexArrayIdᶜᵖ))
}
func (o *VertexArrayIdᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeVertexArrayIdᶜᵖ(w, o)
}
func (o *VertexArrayIdᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeVertexArrayIdᶜᵖ(r, o)
}
func (c *binaryClassVertexArrayIdᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁVertexArrayIdᶜᵖ]
}

type binaryClassGlDeleteVertexArrays struct{}

func (*GlDeleteVertexArrays) Class() binary.Class {
	return (*binaryClassGlDeleteVertexArrays)(nil)
}
func doEncodeGlDeleteVertexArrays(e binary.Encoder, o *GlDeleteVertexArrays) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Arrays)
}
func doDecodeGlDeleteVertexArrays(d binary.Decoder, o *GlDeleteVertexArrays) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Arrays)
}
func doDecodeRawGlDeleteVertexArrays(d binary.Decoder, o *GlDeleteVertexArrays) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Arrays)
}
func (*binaryClassGlDeleteVertexArrays) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteVertexArrays(e, obj.(*GlDeleteVertexArrays))
}
func (*binaryClassGlDeleteVertexArrays) New() binary.Object {
	return &GlDeleteVertexArrays{}
}
func (*binaryClassGlDeleteVertexArrays) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteVertexArrays(d, obj.(*GlDeleteVertexArrays))
}
func (c *binaryClassGlDeleteVertexArrays) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteVertexArrays]
}

type binaryClassGlDeleteVertexArraysOES struct{}

func (*GlDeleteVertexArraysOES) Class() binary.Class {
	return (*binaryClassGlDeleteVertexArraysOES)(nil)
}
func doEncodeGlDeleteVertexArraysOES(e binary.Encoder, o *GlDeleteVertexArraysOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Arrays)
}
func doDecodeGlDeleteVertexArraysOES(d binary.Decoder, o *GlDeleteVertexArraysOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Arrays)
}
func doDecodeRawGlDeleteVertexArraysOES(d binary.Decoder, o *GlDeleteVertexArraysOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Arrays)
}
func (*binaryClassGlDeleteVertexArraysOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDeleteVertexArraysOES(e, obj.(*GlDeleteVertexArraysOES))
}
func (*binaryClassGlDeleteVertexArraysOES) New() binary.Object {
	return &GlDeleteVertexArraysOES{}
}
func (*binaryClassGlDeleteVertexArraysOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDeleteVertexArraysOES(d, obj.(*GlDeleteVertexArraysOES))
}
func (c *binaryClassGlDeleteVertexArraysOES) Schema() *binary.Entity {
	return &entities[ixǁGlDeleteVertexArraysOES]
}

type binaryClassGlDepthFunc struct{}

func (*GlDepthFunc) Class() binary.Class {
	return (*binaryClassGlDepthFunc)(nil)
}
func doEncodeGlDepthFunc(e binary.Encoder, o *GlDepthFunc) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Function))
}
func doDecodeGlDepthFunc(d binary.Decoder, o *GlDepthFunc) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Function = GLenum(d.Uint32())
}
func doDecodeRawGlDepthFunc(d binary.Decoder, o *GlDepthFunc) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Function = GLenum(d.Uint32())
}
func (*binaryClassGlDepthFunc) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDepthFunc(e, obj.(*GlDepthFunc))
}
func (*binaryClassGlDepthFunc) New() binary.Object {
	return &GlDepthFunc{}
}
func (*binaryClassGlDepthFunc) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDepthFunc(d, obj.(*GlDepthFunc))
}
func (c *binaryClassGlDepthFunc) Schema() *binary.Entity {
	return &entities[ixǁGlDepthFunc]
}

type binaryClassGlDepthMask struct{}

func (*GlDepthMask) Class() binary.Class {
	return (*binaryClassGlDepthMask)(nil)
}
func doEncodeGlDepthMask(e binary.Encoder, o *GlDepthMask) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint8(uint8(o.Enabled))
}
func doDecodeGlDepthMask(d binary.Decoder, o *GlDepthMask) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Enabled = GLboolean(d.Uint8())
}
func doDecodeRawGlDepthMask(d binary.Decoder, o *GlDepthMask) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Enabled = GLboolean(d.Uint8())
}
func (*binaryClassGlDepthMask) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDepthMask(e, obj.(*GlDepthMask))
}
func (*binaryClassGlDepthMask) New() binary.Object {
	return &GlDepthMask{}
}
func (*binaryClassGlDepthMask) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDepthMask(d, obj.(*GlDepthMask))
}
func (c *binaryClassGlDepthMask) Schema() *binary.Entity {
	return &entities[ixǁGlDepthMask]
}

type binaryClassGlDepthRangeArrayfvNV struct{}

func (*GlDepthRangeArrayfvNV) Class() binary.Class {
	return (*binaryClassGlDepthRangeArrayfvNV)(nil)
}
func doEncodeGlDepthRangeArrayfvNV(e binary.Encoder, o *GlDepthRangeArrayfvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.First))
	e.Int32(int32(o.Count))
	e.Simple(&o.V)
}
func doDecodeGlDepthRangeArrayfvNV(d binary.Decoder, o *GlDepthRangeArrayfvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.First = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func doDecodeRawGlDepthRangeArrayfvNV(d binary.Decoder, o *GlDepthRangeArrayfvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.First = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func (*binaryClassGlDepthRangeArrayfvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDepthRangeArrayfvNV(e, obj.(*GlDepthRangeArrayfvNV))
}
func (*binaryClassGlDepthRangeArrayfvNV) New() binary.Object {
	return &GlDepthRangeArrayfvNV{}
}
func (*binaryClassGlDepthRangeArrayfvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDepthRangeArrayfvNV(d, obj.(*GlDepthRangeArrayfvNV))
}
func (c *binaryClassGlDepthRangeArrayfvNV) Schema() *binary.Entity {
	return &entities[ixǁGlDepthRangeArrayfvNV]
}

type binaryClassGlDepthRangeIndexedfNV struct{}

func (*GlDepthRangeIndexedfNV) Class() binary.Class {
	return (*binaryClassGlDepthRangeIndexedfNV)(nil)
}
func doEncodeGlDepthRangeIndexedfNV(e binary.Encoder, o *GlDepthRangeIndexedfNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Float32(float32(o.N))
	e.Float32(float32(o.F))
}
func doDecodeGlDepthRangeIndexedfNV(d binary.Decoder, o *GlDepthRangeIndexedfNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = GLuint(d.Uint32())
	o.N = GLfloat(d.Float32())
	o.F = GLfloat(d.Float32())
}
func doDecodeRawGlDepthRangeIndexedfNV(d binary.Decoder, o *GlDepthRangeIndexedfNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = GLuint(d.Uint32())
	o.N = GLfloat(d.Float32())
	o.F = GLfloat(d.Float32())
}
func (*binaryClassGlDepthRangeIndexedfNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDepthRangeIndexedfNV(e, obj.(*GlDepthRangeIndexedfNV))
}
func (*binaryClassGlDepthRangeIndexedfNV) New() binary.Object {
	return &GlDepthRangeIndexedfNV{}
}
func (*binaryClassGlDepthRangeIndexedfNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDepthRangeIndexedfNV(d, obj.(*GlDepthRangeIndexedfNV))
}
func (c *binaryClassGlDepthRangeIndexedfNV) Schema() *binary.Entity {
	return &entities[ixǁGlDepthRangeIndexedfNV]
}

type binaryClassGlDepthRangef struct{}

func (*GlDepthRangef) Class() binary.Class {
	return (*binaryClassGlDepthRangef)(nil)
}
func doEncodeGlDepthRangef(e binary.Encoder, o *GlDepthRangef) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Near))
	e.Float32(float32(o.Far))
}
func doDecodeGlDepthRangef(d binary.Decoder, o *GlDepthRangef) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Near = GLfloat(d.Float32())
	o.Far = GLfloat(d.Float32())
}
func doDecodeRawGlDepthRangef(d binary.Decoder, o *GlDepthRangef) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Near = GLfloat(d.Float32())
	o.Far = GLfloat(d.Float32())
}
func (*binaryClassGlDepthRangef) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDepthRangef(e, obj.(*GlDepthRangef))
}
func (*binaryClassGlDepthRangef) New() binary.Object {
	return &GlDepthRangef{}
}
func (*binaryClassGlDepthRangef) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDepthRangef(d, obj.(*GlDepthRangef))
}
func (c *binaryClassGlDepthRangef) Schema() *binary.Entity {
	return &entities[ixǁGlDepthRangef]
}

type binaryClassGlDepthRangefOES struct{}

func (*GlDepthRangefOES) Class() binary.Class {
	return (*binaryClassGlDepthRangefOES)(nil)
}
func doEncodeGlDepthRangefOES(e binary.Encoder, o *GlDepthRangefOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.N))
	e.Float32(float32(o.F))
}
func doDecodeGlDepthRangefOES(d binary.Decoder, o *GlDepthRangefOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLclampf(d.Float32())
	o.F = GLclampf(d.Float32())
}
func doDecodeRawGlDepthRangefOES(d binary.Decoder, o *GlDepthRangefOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLclampf(d.Float32())
	o.F = GLclampf(d.Float32())
}
func (*binaryClassGlDepthRangefOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDepthRangefOES(e, obj.(*GlDepthRangefOES))
}
func (*binaryClassGlDepthRangefOES) New() binary.Object {
	return &GlDepthRangefOES{}
}
func (*binaryClassGlDepthRangefOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDepthRangefOES(d, obj.(*GlDepthRangefOES))
}
func (c *binaryClassGlDepthRangefOES) Schema() *binary.Entity {
	return &entities[ixǁGlDepthRangefOES]
}

type binaryClassGlDepthRangex struct{}

func (*GlDepthRangex) Class() binary.Class {
	return (*binaryClassGlDepthRangex)(nil)
}
func doEncodeGlDepthRangex(e binary.Encoder, o *GlDepthRangex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Int32(int32(o.F))
}
func doDecodeGlDepthRangex(d binary.Decoder, o *GlDepthRangex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLfixed(d.Int32())
	o.F = GLfixed(d.Int32())
}
func doDecodeRawGlDepthRangex(d binary.Decoder, o *GlDepthRangex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLfixed(d.Int32())
	o.F = GLfixed(d.Int32())
}
func (*binaryClassGlDepthRangex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDepthRangex(e, obj.(*GlDepthRangex))
}
func (*binaryClassGlDepthRangex) New() binary.Object {
	return &GlDepthRangex{}
}
func (*binaryClassGlDepthRangex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDepthRangex(d, obj.(*GlDepthRangex))
}
func (c *binaryClassGlDepthRangex) Schema() *binary.Entity {
	return &entities[ixǁGlDepthRangex]
}

type binaryClassGlDepthRangexOES struct{}

func (*GlDepthRangexOES) Class() binary.Class {
	return (*binaryClassGlDepthRangexOES)(nil)
}
func doEncodeGlDepthRangexOES(e binary.Encoder, o *GlDepthRangexOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Int32(int32(o.F))
}
func doDecodeGlDepthRangexOES(d binary.Decoder, o *GlDepthRangexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLfixed(d.Int32())
	o.F = GLfixed(d.Int32())
}
func doDecodeRawGlDepthRangexOES(d binary.Decoder, o *GlDepthRangexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLfixed(d.Int32())
	o.F = GLfixed(d.Int32())
}
func (*binaryClassGlDepthRangexOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDepthRangexOES(e, obj.(*GlDepthRangexOES))
}
func (*binaryClassGlDepthRangexOES) New() binary.Object {
	return &GlDepthRangexOES{}
}
func (*binaryClassGlDepthRangexOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDepthRangexOES(d, obj.(*GlDepthRangexOES))
}
func (c *binaryClassGlDepthRangexOES) Schema() *binary.Entity {
	return &entities[ixǁGlDepthRangexOES]
}

type binaryClassGlDetachShader struct{}

func (*GlDetachShader) Class() binary.Class {
	return (*binaryClassGlDetachShader)(nil)
}
func doEncodeGlDetachShader(e binary.Encoder, o *GlDetachShader) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.Shader))
}
func doDecodeGlDetachShader(d binary.Decoder, o *GlDetachShader) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Shader = ShaderId(d.Uint32())
}
func doDecodeRawGlDetachShader(d binary.Decoder, o *GlDetachShader) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Shader = ShaderId(d.Uint32())
}
func (*binaryClassGlDetachShader) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDetachShader(e, obj.(*GlDetachShader))
}
func (*binaryClassGlDetachShader) New() binary.Object {
	return &GlDetachShader{}
}
func (*binaryClassGlDetachShader) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDetachShader(d, obj.(*GlDetachShader))
}
func (c *binaryClassGlDetachShader) Schema() *binary.Entity {
	return &entities[ixǁGlDetachShader]
}

type binaryClassGlDisable struct{}

func (*GlDisable) Class() binary.Class {
	return (*binaryClassGlDisable)(nil)
}
func doEncodeGlDisable(e binary.Encoder, o *GlDisable) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Capability))
}
func doDecodeGlDisable(d binary.Decoder, o *GlDisable) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Capability = GLenum(d.Uint32())
}
func doDecodeRawGlDisable(d binary.Decoder, o *GlDisable) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Capability = GLenum(d.Uint32())
}
func (*binaryClassGlDisable) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDisable(e, obj.(*GlDisable))
}
func (*binaryClassGlDisable) New() binary.Object {
	return &GlDisable{}
}
func (*binaryClassGlDisable) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDisable(d, obj.(*GlDisable))
}
func (c *binaryClassGlDisable) Schema() *binary.Entity {
	return &entities[ixǁGlDisable]
}

type binaryClassGlDisableClientState struct{}

func (*GlDisableClientState) Class() binary.Class {
	return (*binaryClassGlDisableClientState)(nil)
}
func doEncodeGlDisableClientState(e binary.Encoder, o *GlDisableClientState) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Array))
}
func doDecodeGlDisableClientState(d binary.Decoder, o *GlDisableClientState) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Array = GLenum(d.Uint32())
}
func doDecodeRawGlDisableClientState(d binary.Decoder, o *GlDisableClientState) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Array = GLenum(d.Uint32())
}
func (*binaryClassGlDisableClientState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDisableClientState(e, obj.(*GlDisableClientState))
}
func (*binaryClassGlDisableClientState) New() binary.Object {
	return &GlDisableClientState{}
}
func (*binaryClassGlDisableClientState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDisableClientState(d, obj.(*GlDisableClientState))
}
func (c *binaryClassGlDisableClientState) Schema() *binary.Entity {
	return &entities[ixǁGlDisableClientState]
}

type binaryClassGlDisableDriverControlQCOM struct{}

func (*GlDisableDriverControlQCOM) Class() binary.Class {
	return (*binaryClassGlDisableDriverControlQCOM)(nil)
}
func doEncodeGlDisableDriverControlQCOM(e binary.Encoder, o *GlDisableDriverControlQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DriverControl))
}
func doDecodeGlDisableDriverControlQCOM(d binary.Decoder, o *GlDisableDriverControlQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DriverControl = GLuint(d.Uint32())
}
func doDecodeRawGlDisableDriverControlQCOM(d binary.Decoder, o *GlDisableDriverControlQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DriverControl = GLuint(d.Uint32())
}
func (*binaryClassGlDisableDriverControlQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDisableDriverControlQCOM(e, obj.(*GlDisableDriverControlQCOM))
}
func (*binaryClassGlDisableDriverControlQCOM) New() binary.Object {
	return &GlDisableDriverControlQCOM{}
}
func (*binaryClassGlDisableDriverControlQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDisableDriverControlQCOM(d, obj.(*GlDisableDriverControlQCOM))
}
func (c *binaryClassGlDisableDriverControlQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlDisableDriverControlQCOM]
}

type binaryClassGlDisableVertexAttribArray struct{}

func (*GlDisableVertexAttribArray) Class() binary.Class {
	return (*binaryClassGlDisableVertexAttribArray)(nil)
}
func doEncodeGlDisableVertexAttribArray(e binary.Encoder, o *GlDisableVertexAttribArray) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Location))
}
func doDecodeGlDisableVertexAttribArray(d binary.Decoder, o *GlDisableVertexAttribArray) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
}
func doDecodeRawGlDisableVertexAttribArray(d binary.Decoder, o *GlDisableVertexAttribArray) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
}
func (*binaryClassGlDisableVertexAttribArray) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDisableVertexAttribArray(e, obj.(*GlDisableVertexAttribArray))
}
func (*binaryClassGlDisableVertexAttribArray) New() binary.Object {
	return &GlDisableVertexAttribArray{}
}
func (*binaryClassGlDisableVertexAttribArray) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDisableVertexAttribArray(d, obj.(*GlDisableVertexAttribArray))
}
func (c *binaryClassGlDisableVertexAttribArray) Schema() *binary.Entity {
	return &entities[ixǁGlDisableVertexAttribArray]
}

type binaryClassGlDisablei struct{}

func (*GlDisablei) Class() binary.Class {
	return (*binaryClassGlDisablei)(nil)
}
func doEncodeGlDisablei(e binary.Encoder, o *GlDisablei) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Capability))
	e.Uint32(uint32(o.Index))
}
func doDecodeGlDisablei(d binary.Decoder, o *GlDisablei) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Capability = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func doDecodeRawGlDisablei(d binary.Decoder, o *GlDisablei) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Capability = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func (*binaryClassGlDisablei) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDisablei(e, obj.(*GlDisablei))
}
func (*binaryClassGlDisablei) New() binary.Object {
	return &GlDisablei{}
}
func (*binaryClassGlDisablei) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDisablei(d, obj.(*GlDisablei))
}
func (c *binaryClassGlDisablei) Schema() *binary.Entity {
	return &entities[ixǁGlDisablei]
}

type binaryClassGlDisableiEXT struct{}

func (*GlDisableiEXT) Class() binary.Class {
	return (*binaryClassGlDisableiEXT)(nil)
}
func doEncodeGlDisableiEXT(e binary.Encoder, o *GlDisableiEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
}
func doDecodeGlDisableiEXT(d binary.Decoder, o *GlDisableiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func doDecodeRawGlDisableiEXT(d binary.Decoder, o *GlDisableiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func (*binaryClassGlDisableiEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDisableiEXT(e, obj.(*GlDisableiEXT))
}
func (*binaryClassGlDisableiEXT) New() binary.Object {
	return &GlDisableiEXT{}
}
func (*binaryClassGlDisableiEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDisableiEXT(d, obj.(*GlDisableiEXT))
}
func (c *binaryClassGlDisableiEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDisableiEXT]
}

type binaryClassGlDisableiNV struct{}

func (*GlDisableiNV) Class() binary.Class {
	return (*binaryClassGlDisableiNV)(nil)
}
func doEncodeGlDisableiNV(e binary.Encoder, o *GlDisableiNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
}
func doDecodeGlDisableiNV(d binary.Decoder, o *GlDisableiNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func doDecodeRawGlDisableiNV(d binary.Decoder, o *GlDisableiNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func (*binaryClassGlDisableiNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDisableiNV(e, obj.(*GlDisableiNV))
}
func (*binaryClassGlDisableiNV) New() binary.Object {
	return &GlDisableiNV{}
}
func (*binaryClassGlDisableiNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDisableiNV(d, obj.(*GlDisableiNV))
}
func (c *binaryClassGlDisableiNV) Schema() *binary.Entity {
	return &entities[ixǁGlDisableiNV]
}

type binaryClassGlDisableiOES struct{}

func (*GlDisableiOES) Class() binary.Class {
	return (*binaryClassGlDisableiOES)(nil)
}
func doEncodeGlDisableiOES(e binary.Encoder, o *GlDisableiOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
}
func doDecodeGlDisableiOES(d binary.Decoder, o *GlDisableiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func doDecodeRawGlDisableiOES(d binary.Decoder, o *GlDisableiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func (*binaryClassGlDisableiOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDisableiOES(e, obj.(*GlDisableiOES))
}
func (*binaryClassGlDisableiOES) New() binary.Object {
	return &GlDisableiOES{}
}
func (*binaryClassGlDisableiOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDisableiOES(d, obj.(*GlDisableiOES))
}
func (c *binaryClassGlDisableiOES) Schema() *binary.Entity {
	return &entities[ixǁGlDisableiOES]
}

type binaryClassGlDiscardFramebufferEXT struct{}

func (*GlDiscardFramebufferEXT) Class() binary.Class {
	return (*binaryClassGlDiscardFramebufferEXT)(nil)
}
func doEncodeGlDiscardFramebufferEXT(e binary.Encoder, o *GlDiscardFramebufferEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.NumAttachments))
	e.Simple(&o.Attachments)
}
func doDecodeGlDiscardFramebufferEXT(d binary.Decoder, o *GlDiscardFramebufferEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.NumAttachments = GLsizei(d.Int32())
	d.Simple(&o.Attachments)
}
func doDecodeRawGlDiscardFramebufferEXT(d binary.Decoder, o *GlDiscardFramebufferEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.NumAttachments = GLsizei(d.Int32())
	d.Simple(&o.Attachments)
}
func (*binaryClassGlDiscardFramebufferEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDiscardFramebufferEXT(e, obj.(*GlDiscardFramebufferEXT))
}
func (*binaryClassGlDiscardFramebufferEXT) New() binary.Object {
	return &GlDiscardFramebufferEXT{}
}
func (*binaryClassGlDiscardFramebufferEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDiscardFramebufferEXT(d, obj.(*GlDiscardFramebufferEXT))
}
func (c *binaryClassGlDiscardFramebufferEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDiscardFramebufferEXT]
}

type binaryClassGlDispatchCompute struct{}

func (*GlDispatchCompute) Class() binary.Class {
	return (*binaryClassGlDispatchCompute)(nil)
}
func doEncodeGlDispatchCompute(e binary.Encoder, o *GlDispatchCompute) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.NumGroupsX))
	e.Uint32(uint32(o.NumGroupsY))
	e.Uint32(uint32(o.NumGroupsZ))
}
func doDecodeGlDispatchCompute(d binary.Decoder, o *GlDispatchCompute) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumGroupsX = GLuint(d.Uint32())
	o.NumGroupsY = GLuint(d.Uint32())
	o.NumGroupsZ = GLuint(d.Uint32())
}
func doDecodeRawGlDispatchCompute(d binary.Decoder, o *GlDispatchCompute) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumGroupsX = GLuint(d.Uint32())
	o.NumGroupsY = GLuint(d.Uint32())
	o.NumGroupsZ = GLuint(d.Uint32())
}
func (*binaryClassGlDispatchCompute) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDispatchCompute(e, obj.(*GlDispatchCompute))
}
func (*binaryClassGlDispatchCompute) New() binary.Object {
	return &GlDispatchCompute{}
}
func (*binaryClassGlDispatchCompute) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDispatchCompute(d, obj.(*GlDispatchCompute))
}
func (c *binaryClassGlDispatchCompute) Schema() *binary.Entity {
	return &entities[ixǁGlDispatchCompute]
}

type binaryClassGlDispatchComputeIndirect struct{}

func (*GlDispatchComputeIndirect) Class() binary.Class {
	return (*binaryClassGlDispatchComputeIndirect)(nil)
}
func doEncodeGlDispatchComputeIndirect(e binary.Encoder, o *GlDispatchComputeIndirect) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Indirect))
}
func doDecodeGlDispatchComputeIndirect(d binary.Decoder, o *GlDispatchComputeIndirect) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Indirect = GLintptr(d.Int32())
}
func doDecodeRawGlDispatchComputeIndirect(d binary.Decoder, o *GlDispatchComputeIndirect) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Indirect = GLintptr(d.Int32())
}
func (*binaryClassGlDispatchComputeIndirect) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDispatchComputeIndirect(e, obj.(*GlDispatchComputeIndirect))
}
func (*binaryClassGlDispatchComputeIndirect) New() binary.Object {
	return &GlDispatchComputeIndirect{}
}
func (*binaryClassGlDispatchComputeIndirect) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDispatchComputeIndirect(d, obj.(*GlDispatchComputeIndirect))
}
func (c *binaryClassGlDispatchComputeIndirect) Schema() *binary.Entity {
	return &entities[ixǁGlDispatchComputeIndirect]
}

var _ drawCall = (*GlDrawArrays)(nil) // Interface compliance check.
type binaryClassGlDrawArrays struct{}

func (*GlDrawArrays) Class() binary.Class {
	return (*binaryClassGlDrawArrays)(nil)
}
func doEncodeGlDrawArrays(e binary.Encoder, o *GlDrawArrays) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DrawMode))
	e.Int32(int32(o.FirstIndex))
	e.Int32(int32(o.IndicesCount))
}
func doDecodeGlDrawArrays(d binary.Decoder, o *GlDrawArrays) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.FirstIndex = GLint(d.Int32())
	o.IndicesCount = GLsizei(d.Int32())
}
func doDecodeRawGlDrawArrays(d binary.Decoder, o *GlDrawArrays) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.FirstIndex = GLint(d.Int32())
	o.IndicesCount = GLsizei(d.Int32())
}
func (*binaryClassGlDrawArrays) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawArrays(e, obj.(*GlDrawArrays))
}
func (*binaryClassGlDrawArrays) New() binary.Object {
	return &GlDrawArrays{}
}
func (*binaryClassGlDrawArrays) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawArrays(d, obj.(*GlDrawArrays))
}
func (c *binaryClassGlDrawArrays) Schema() *binary.Entity {
	return &entities[ixǁGlDrawArrays]
}

var _ drawCall = (*GlDrawArraysIndirect)(nil) // Interface compliance check.
type binaryClassGlDrawArraysIndirect struct{}

func (*GlDrawArraysIndirect) Class() binary.Class {
	return (*binaryClassGlDrawArraysIndirect)(nil)
}
func doEncodeGlDrawArraysIndirect(e binary.Encoder, o *GlDrawArraysIndirect) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DrawMode))
	e.Simple(&o.Indirect)
}
func doDecodeGlDrawArraysIndirect(d binary.Decoder, o *GlDrawArraysIndirect) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	d.Simple(&o.Indirect)
}
func doDecodeRawGlDrawArraysIndirect(d binary.Decoder, o *GlDrawArraysIndirect) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	d.Simple(&o.Indirect)
}
func (*binaryClassGlDrawArraysIndirect) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawArraysIndirect(e, obj.(*GlDrawArraysIndirect))
}
func (*binaryClassGlDrawArraysIndirect) New() binary.Object {
	return &GlDrawArraysIndirect{}
}
func (*binaryClassGlDrawArraysIndirect) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawArraysIndirect(d, obj.(*GlDrawArraysIndirect))
}
func (c *binaryClassGlDrawArraysIndirect) Schema() *binary.Entity {
	return &entities[ixǁGlDrawArraysIndirect]
}

var _ drawCall = (*GlDrawArraysInstanced)(nil) // Interface compliance check.
type binaryClassGlDrawArraysInstanced struct{}

func (*GlDrawArraysInstanced) Class() binary.Class {
	return (*binaryClassGlDrawArraysInstanced)(nil)
}
func doEncodeGlDrawArraysInstanced(e binary.Encoder, o *GlDrawArraysInstanced) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DrawMode))
	e.Int32(int32(o.FirstIndex))
	e.Int32(int32(o.IndicesCount))
	e.Int32(int32(o.InstanceCount))
}
func doDecodeGlDrawArraysInstanced(d binary.Decoder, o *GlDrawArraysInstanced) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.FirstIndex = GLint(d.Int32())
	o.IndicesCount = GLsizei(d.Int32())
	o.InstanceCount = GLsizei(d.Int32())
}
func doDecodeRawGlDrawArraysInstanced(d binary.Decoder, o *GlDrawArraysInstanced) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.FirstIndex = GLint(d.Int32())
	o.IndicesCount = GLsizei(d.Int32())
	o.InstanceCount = GLsizei(d.Int32())
}
func (*binaryClassGlDrawArraysInstanced) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawArraysInstanced(e, obj.(*GlDrawArraysInstanced))
}
func (*binaryClassGlDrawArraysInstanced) New() binary.Object {
	return &GlDrawArraysInstanced{}
}
func (*binaryClassGlDrawArraysInstanced) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawArraysInstanced(d, obj.(*GlDrawArraysInstanced))
}
func (c *binaryClassGlDrawArraysInstanced) Schema() *binary.Entity {
	return &entities[ixǁGlDrawArraysInstanced]
}

var _ drawCall = (*GlDrawArraysInstancedANGLE)(nil) // Interface compliance check.
type binaryClassGlDrawArraysInstancedANGLE struct{}

func (*GlDrawArraysInstancedANGLE) Class() binary.Class {
	return (*binaryClassGlDrawArraysInstancedANGLE)(nil)
}
func doEncodeGlDrawArraysInstancedANGLE(e binary.Encoder, o *GlDrawArraysInstancedANGLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.First))
	e.Int32(int32(o.Count))
	e.Int32(int32(o.Primcount))
}
func doDecodeGlDrawArraysInstancedANGLE(d binary.Decoder, o *GlDrawArraysInstancedANGLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.First = GLint(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Primcount = GLsizei(d.Int32())
}
func doDecodeRawGlDrawArraysInstancedANGLE(d binary.Decoder, o *GlDrawArraysInstancedANGLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.First = GLint(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Primcount = GLsizei(d.Int32())
}
func (*binaryClassGlDrawArraysInstancedANGLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawArraysInstancedANGLE(e, obj.(*GlDrawArraysInstancedANGLE))
}
func (*binaryClassGlDrawArraysInstancedANGLE) New() binary.Object {
	return &GlDrawArraysInstancedANGLE{}
}
func (*binaryClassGlDrawArraysInstancedANGLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawArraysInstancedANGLE(d, obj.(*GlDrawArraysInstancedANGLE))
}
func (c *binaryClassGlDrawArraysInstancedANGLE) Schema() *binary.Entity {
	return &entities[ixǁGlDrawArraysInstancedANGLE]
}

var _ drawCall = (*GlDrawArraysInstancedBaseInstanceEXT)(nil) // Interface compliance check.
type binaryClassGlDrawArraysInstancedBaseInstanceEXT struct{}

func (*GlDrawArraysInstancedBaseInstanceEXT) Class() binary.Class {
	return (*binaryClassGlDrawArraysInstancedBaseInstanceEXT)(nil)
}
func doEncodeGlDrawArraysInstancedBaseInstanceEXT(e binary.Encoder, o *GlDrawArraysInstancedBaseInstanceEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.First))
	e.Int32(int32(o.Count))
	e.Int32(int32(o.Instancecount))
	e.Uint32(uint32(o.Baseinstance))
}
func doDecodeGlDrawArraysInstancedBaseInstanceEXT(d binary.Decoder, o *GlDrawArraysInstancedBaseInstanceEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.First = GLint(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Instancecount = GLsizei(d.Int32())
	o.Baseinstance = GLuint(d.Uint32())
}
func doDecodeRawGlDrawArraysInstancedBaseInstanceEXT(d binary.Decoder, o *GlDrawArraysInstancedBaseInstanceEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.First = GLint(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Instancecount = GLsizei(d.Int32())
	o.Baseinstance = GLuint(d.Uint32())
}
func (*binaryClassGlDrawArraysInstancedBaseInstanceEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawArraysInstancedBaseInstanceEXT(e, obj.(*GlDrawArraysInstancedBaseInstanceEXT))
}
func (*binaryClassGlDrawArraysInstancedBaseInstanceEXT) New() binary.Object {
	return &GlDrawArraysInstancedBaseInstanceEXT{}
}
func (*binaryClassGlDrawArraysInstancedBaseInstanceEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawArraysInstancedBaseInstanceEXT(d, obj.(*GlDrawArraysInstancedBaseInstanceEXT))
}
func (c *binaryClassGlDrawArraysInstancedBaseInstanceEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDrawArraysInstancedBaseInstanceEXT]
}

var _ drawCall = (*GlDrawArraysInstancedEXT)(nil) // Interface compliance check.
type binaryClassGlDrawArraysInstancedEXT struct{}

func (*GlDrawArraysInstancedEXT) Class() binary.Class {
	return (*binaryClassGlDrawArraysInstancedEXT)(nil)
}
func doEncodeGlDrawArraysInstancedEXT(e binary.Encoder, o *GlDrawArraysInstancedEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.Start))
	e.Int32(int32(o.Count))
	e.Int32(int32(o.Primcount))
}
func doDecodeGlDrawArraysInstancedEXT(d binary.Decoder, o *GlDrawArraysInstancedEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Start = GLint(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Primcount = GLsizei(d.Int32())
}
func doDecodeRawGlDrawArraysInstancedEXT(d binary.Decoder, o *GlDrawArraysInstancedEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Start = GLint(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Primcount = GLsizei(d.Int32())
}
func (*binaryClassGlDrawArraysInstancedEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawArraysInstancedEXT(e, obj.(*GlDrawArraysInstancedEXT))
}
func (*binaryClassGlDrawArraysInstancedEXT) New() binary.Object {
	return &GlDrawArraysInstancedEXT{}
}
func (*binaryClassGlDrawArraysInstancedEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawArraysInstancedEXT(d, obj.(*GlDrawArraysInstancedEXT))
}
func (c *binaryClassGlDrawArraysInstancedEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDrawArraysInstancedEXT]
}

var _ drawCall = (*GlDrawArraysInstancedNV)(nil) // Interface compliance check.
type binaryClassGlDrawArraysInstancedNV struct{}

func (*GlDrawArraysInstancedNV) Class() binary.Class {
	return (*binaryClassGlDrawArraysInstancedNV)(nil)
}
func doEncodeGlDrawArraysInstancedNV(e binary.Encoder, o *GlDrawArraysInstancedNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.First))
	e.Int32(int32(o.Count))
	e.Int32(int32(o.Primcount))
}
func doDecodeGlDrawArraysInstancedNV(d binary.Decoder, o *GlDrawArraysInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.First = GLint(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Primcount = GLsizei(d.Int32())
}
func doDecodeRawGlDrawArraysInstancedNV(d binary.Decoder, o *GlDrawArraysInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.First = GLint(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Primcount = GLsizei(d.Int32())
}
func (*binaryClassGlDrawArraysInstancedNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawArraysInstancedNV(e, obj.(*GlDrawArraysInstancedNV))
}
func (*binaryClassGlDrawArraysInstancedNV) New() binary.Object {
	return &GlDrawArraysInstancedNV{}
}
func (*binaryClassGlDrawArraysInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawArraysInstancedNV(d, obj.(*GlDrawArraysInstancedNV))
}
func (c *binaryClassGlDrawArraysInstancedNV) Schema() *binary.Entity {
	return &entities[ixǁGlDrawArraysInstancedNV]
}

type binaryClassGlDrawBuffers struct{}

func (*GlDrawBuffers) Class() binary.Class {
	return (*binaryClassGlDrawBuffers)(nil)
}
func doEncodeGlDrawBuffers(e binary.Encoder, o *GlDrawBuffers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Bufs)
}
func doDecodeGlDrawBuffers(d binary.Decoder, o *GlDrawBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Bufs)
}
func doDecodeRawGlDrawBuffers(d binary.Decoder, o *GlDrawBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Bufs)
}
func (*binaryClassGlDrawBuffers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawBuffers(e, obj.(*GlDrawBuffers))
}
func (*binaryClassGlDrawBuffers) New() binary.Object {
	return &GlDrawBuffers{}
}
func (*binaryClassGlDrawBuffers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawBuffers(d, obj.(*GlDrawBuffers))
}
func (c *binaryClassGlDrawBuffers) Schema() *binary.Entity {
	return &entities[ixǁGlDrawBuffers]
}

type binaryClassGlDrawBuffersEXT struct{}

func (*GlDrawBuffersEXT) Class() binary.Class {
	return (*binaryClassGlDrawBuffersEXT)(nil)
}
func doEncodeGlDrawBuffersEXT(e binary.Encoder, o *GlDrawBuffersEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Bufs)
}
func doDecodeGlDrawBuffersEXT(d binary.Decoder, o *GlDrawBuffersEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Bufs)
}
func doDecodeRawGlDrawBuffersEXT(d binary.Decoder, o *GlDrawBuffersEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Bufs)
}
func (*binaryClassGlDrawBuffersEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawBuffersEXT(e, obj.(*GlDrawBuffersEXT))
}
func (*binaryClassGlDrawBuffersEXT) New() binary.Object {
	return &GlDrawBuffersEXT{}
}
func (*binaryClassGlDrawBuffersEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawBuffersEXT(d, obj.(*GlDrawBuffersEXT))
}
func (c *binaryClassGlDrawBuffersEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDrawBuffersEXT]
}

type binaryClassGlDrawBuffersIndexedEXT struct{}

func (*GlDrawBuffersIndexedEXT) Class() binary.Class {
	return (*binaryClassGlDrawBuffersIndexedEXT)(nil)
}
func doEncodeGlDrawBuffersIndexedEXT(e binary.Encoder, o *GlDrawBuffersIndexedEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Location)
	e.Simple(&o.Indices)
}
func doDecodeGlDrawBuffersIndexedEXT(d binary.Decoder, o *GlDrawBuffersIndexedEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLint(d.Int32())
	d.Simple(&o.Location)
	d.Simple(&o.Indices)
}
func doDecodeRawGlDrawBuffersIndexedEXT(d binary.Decoder, o *GlDrawBuffersIndexedEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLint(d.Int32())
	d.Simple(&o.Location)
	d.Simple(&o.Indices)
}
func (*binaryClassGlDrawBuffersIndexedEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawBuffersIndexedEXT(e, obj.(*GlDrawBuffersIndexedEXT))
}
func (*binaryClassGlDrawBuffersIndexedEXT) New() binary.Object {
	return &GlDrawBuffersIndexedEXT{}
}
func (*binaryClassGlDrawBuffersIndexedEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawBuffersIndexedEXT(d, obj.(*GlDrawBuffersIndexedEXT))
}
func (c *binaryClassGlDrawBuffersIndexedEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDrawBuffersIndexedEXT]
}

type binaryClassGlDrawBuffersNV struct{}

func (*GlDrawBuffersNV) Class() binary.Class {
	return (*binaryClassGlDrawBuffersNV)(nil)
}
func doEncodeGlDrawBuffersNV(e binary.Encoder, o *GlDrawBuffersNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Bufs)
}
func doDecodeGlDrawBuffersNV(d binary.Decoder, o *GlDrawBuffersNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Bufs)
}
func doDecodeRawGlDrawBuffersNV(d binary.Decoder, o *GlDrawBuffersNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Bufs)
}
func (*binaryClassGlDrawBuffersNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawBuffersNV(e, obj.(*GlDrawBuffersNV))
}
func (*binaryClassGlDrawBuffersNV) New() binary.Object {
	return &GlDrawBuffersNV{}
}
func (*binaryClassGlDrawBuffersNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawBuffersNV(d, obj.(*GlDrawBuffersNV))
}
func (c *binaryClassGlDrawBuffersNV) Schema() *binary.Entity {
	return &entities[ixǁGlDrawBuffersNV]
}

type binaryClassIndicesPointer struct{}

func (*IndicesPointer) Class() binary.Class {
	return (*binaryClassIndicesPointer)(nil)
}
func doEncodeIndicesPointer(e binary.Writer, o *IndicesPointer) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeIndicesPointer(d binary.Reader, o *IndicesPointer) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawIndicesPointer(d binary.Reader, o *IndicesPointer) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassIndicesPointer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeIndicesPointer(e, obj.(*IndicesPointer))
}
func (*binaryClassIndicesPointer) New() binary.Object {
	return &IndicesPointer{}
}
func (*binaryClassIndicesPointer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeIndicesPointer(d, obj.(*IndicesPointer))
}
func (o *IndicesPointer) WriteSimple(w binary.Writer) {
	doEncodeIndicesPointer(w, o)
}
func (o *IndicesPointer) ReadSimple(r binary.Reader) {
	doDecodeIndicesPointer(r, o)
}
func (c *binaryClassIndicesPointer) Schema() *binary.Entity {
	return &entities[ixǁIndicesPointer]
}

var _ drawCall = (*GlDrawElements)(nil) // Interface compliance check.
type binaryClassGlDrawElements struct{}

func (*GlDrawElements) Class() binary.Class {
	return (*binaryClassGlDrawElements)(nil)
}
func doEncodeGlDrawElements(e binary.Encoder, o *GlDrawElements) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DrawMode))
	e.Int32(int32(o.IndicesCount))
	e.Uint32(uint32(o.IndicesType))
	e.Simple(&o.Indices)
}
func doDecodeGlDrawElements(d binary.Decoder, o *GlDrawElements) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.IndicesCount = GLsizei(d.Int32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indices)
}
func doDecodeRawGlDrawElements(d binary.Decoder, o *GlDrawElements) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.IndicesCount = GLsizei(d.Int32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indices)
}
func (*binaryClassGlDrawElements) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElements(e, obj.(*GlDrawElements))
}
func (*binaryClassGlDrawElements) New() binary.Object {
	return &GlDrawElements{}
}
func (*binaryClassGlDrawElements) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElements(d, obj.(*GlDrawElements))
}
func (c *binaryClassGlDrawElements) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElements]
}

var _ drawCall = (*GlDrawElementsBaseVertex)(nil) // Interface compliance check.
type binaryClassGlDrawElementsBaseVertex struct{}

func (*GlDrawElementsBaseVertex) Class() binary.Class {
	return (*binaryClassGlDrawElementsBaseVertex)(nil)
}
func doEncodeGlDrawElementsBaseVertex(e binary.Encoder, o *GlDrawElementsBaseVertex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DrawMode))
	e.Int32(int32(o.IndicesCount))
	e.Uint32(uint32(o.IndicesType))
	e.Simple(&o.Indices)
	e.Int32(int32(o.BaseVertex))
}
func doDecodeGlDrawElementsBaseVertex(d binary.Decoder, o *GlDrawElementsBaseVertex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.IndicesCount = GLsizei(d.Int32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.BaseVertex = GLint(d.Int32())
}
func doDecodeRawGlDrawElementsBaseVertex(d binary.Decoder, o *GlDrawElementsBaseVertex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.IndicesCount = GLsizei(d.Int32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.BaseVertex = GLint(d.Int32())
}
func (*binaryClassGlDrawElementsBaseVertex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsBaseVertex(e, obj.(*GlDrawElementsBaseVertex))
}
func (*binaryClassGlDrawElementsBaseVertex) New() binary.Object {
	return &GlDrawElementsBaseVertex{}
}
func (*binaryClassGlDrawElementsBaseVertex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsBaseVertex(d, obj.(*GlDrawElementsBaseVertex))
}
func (c *binaryClassGlDrawElementsBaseVertex) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsBaseVertex]
}

var _ drawCall = (*GlDrawElementsBaseVertexEXT)(nil) // Interface compliance check.
type binaryClassGlDrawElementsBaseVertexEXT struct{}

func (*GlDrawElementsBaseVertexEXT) Class() binary.Class {
	return (*binaryClassGlDrawElementsBaseVertexEXT)(nil)
}
func doEncodeGlDrawElementsBaseVertexEXT(e binary.Encoder, o *GlDrawElementsBaseVertexEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.Count))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Basevertex))
}
func doDecodeGlDrawElementsBaseVertexEXT(d binary.Decoder, o *GlDrawElementsBaseVertexEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Basevertex = GLint(d.Int32())
}
func doDecodeRawGlDrawElementsBaseVertexEXT(d binary.Decoder, o *GlDrawElementsBaseVertexEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Basevertex = GLint(d.Int32())
}
func (*binaryClassGlDrawElementsBaseVertexEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsBaseVertexEXT(e, obj.(*GlDrawElementsBaseVertexEXT))
}
func (*binaryClassGlDrawElementsBaseVertexEXT) New() binary.Object {
	return &GlDrawElementsBaseVertexEXT{}
}
func (*binaryClassGlDrawElementsBaseVertexEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsBaseVertexEXT(d, obj.(*GlDrawElementsBaseVertexEXT))
}
func (c *binaryClassGlDrawElementsBaseVertexEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsBaseVertexEXT]
}

var _ drawCall = (*GlDrawElementsBaseVertexOES)(nil) // Interface compliance check.
type binaryClassGlDrawElementsBaseVertexOES struct{}

func (*GlDrawElementsBaseVertexOES) Class() binary.Class {
	return (*binaryClassGlDrawElementsBaseVertexOES)(nil)
}
func doEncodeGlDrawElementsBaseVertexOES(e binary.Encoder, o *GlDrawElementsBaseVertexOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.Count))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Basevertex))
}
func doDecodeGlDrawElementsBaseVertexOES(d binary.Decoder, o *GlDrawElementsBaseVertexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Basevertex = GLint(d.Int32())
}
func doDecodeRawGlDrawElementsBaseVertexOES(d binary.Decoder, o *GlDrawElementsBaseVertexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Basevertex = GLint(d.Int32())
}
func (*binaryClassGlDrawElementsBaseVertexOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsBaseVertexOES(e, obj.(*GlDrawElementsBaseVertexOES))
}
func (*binaryClassGlDrawElementsBaseVertexOES) New() binary.Object {
	return &GlDrawElementsBaseVertexOES{}
}
func (*binaryClassGlDrawElementsBaseVertexOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsBaseVertexOES(d, obj.(*GlDrawElementsBaseVertexOES))
}
func (c *binaryClassGlDrawElementsBaseVertexOES) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsBaseVertexOES]
}

var _ drawCall = (*GlDrawElementsIndirect)(nil) // Interface compliance check.
type binaryClassGlDrawElementsIndirect struct{}

func (*GlDrawElementsIndirect) Class() binary.Class {
	return (*binaryClassGlDrawElementsIndirect)(nil)
}
func doEncodeGlDrawElementsIndirect(e binary.Encoder, o *GlDrawElementsIndirect) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DrawMode))
	e.Uint32(uint32(o.IndicesType))
	e.Simple(&o.Indirect)
}
func doDecodeGlDrawElementsIndirect(d binary.Decoder, o *GlDrawElementsIndirect) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indirect)
}
func doDecodeRawGlDrawElementsIndirect(d binary.Decoder, o *GlDrawElementsIndirect) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indirect)
}
func (*binaryClassGlDrawElementsIndirect) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsIndirect(e, obj.(*GlDrawElementsIndirect))
}
func (*binaryClassGlDrawElementsIndirect) New() binary.Object {
	return &GlDrawElementsIndirect{}
}
func (*binaryClassGlDrawElementsIndirect) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsIndirect(d, obj.(*GlDrawElementsIndirect))
}
func (c *binaryClassGlDrawElementsIndirect) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsIndirect]
}

var _ drawCall = (*GlDrawElementsInstanced)(nil) // Interface compliance check.
type binaryClassGlDrawElementsInstanced struct{}

func (*GlDrawElementsInstanced) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstanced)(nil)
}
func doEncodeGlDrawElementsInstanced(e binary.Encoder, o *GlDrawElementsInstanced) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DrawMode))
	e.Int32(int32(o.IndicesCount))
	e.Uint32(uint32(o.IndicesType))
	e.Simple(&o.Indices)
	e.Int32(int32(o.InstanceCount))
}
func doDecodeGlDrawElementsInstanced(d binary.Decoder, o *GlDrawElementsInstanced) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.IndicesCount = GLsizei(d.Int32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.InstanceCount = GLsizei(d.Int32())
}
func doDecodeRawGlDrawElementsInstanced(d binary.Decoder, o *GlDrawElementsInstanced) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.IndicesCount = GLsizei(d.Int32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.InstanceCount = GLsizei(d.Int32())
}
func (*binaryClassGlDrawElementsInstanced) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsInstanced(e, obj.(*GlDrawElementsInstanced))
}
func (*binaryClassGlDrawElementsInstanced) New() binary.Object {
	return &GlDrawElementsInstanced{}
}
func (*binaryClassGlDrawElementsInstanced) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsInstanced(d, obj.(*GlDrawElementsInstanced))
}
func (c *binaryClassGlDrawElementsInstanced) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsInstanced]
}

var _ drawCall = (*GlDrawElementsInstancedANGLE)(nil) // Interface compliance check.
type binaryClassGlDrawElementsInstancedANGLE struct{}

func (*GlDrawElementsInstancedANGLE) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedANGLE)(nil)
}
func doEncodeGlDrawElementsInstancedANGLE(e binary.Encoder, o *GlDrawElementsInstancedANGLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.Count))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Primcount))
}
func doDecodeGlDrawElementsInstancedANGLE(d binary.Decoder, o *GlDrawElementsInstancedANGLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Primcount = GLsizei(d.Int32())
}
func doDecodeRawGlDrawElementsInstancedANGLE(d binary.Decoder, o *GlDrawElementsInstancedANGLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Primcount = GLsizei(d.Int32())
}
func (*binaryClassGlDrawElementsInstancedANGLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsInstancedANGLE(e, obj.(*GlDrawElementsInstancedANGLE))
}
func (*binaryClassGlDrawElementsInstancedANGLE) New() binary.Object {
	return &GlDrawElementsInstancedANGLE{}
}
func (*binaryClassGlDrawElementsInstancedANGLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsInstancedANGLE(d, obj.(*GlDrawElementsInstancedANGLE))
}
func (c *binaryClassGlDrawElementsInstancedANGLE) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsInstancedANGLE]
}

var _ drawCall = (*GlDrawElementsInstancedBaseInstanceEXT)(nil) // Interface compliance check.
type binaryClassGlDrawElementsInstancedBaseInstanceEXT struct{}

func (*GlDrawElementsInstancedBaseInstanceEXT) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedBaseInstanceEXT)(nil)
}
func doEncodeGlDrawElementsInstancedBaseInstanceEXT(e binary.Encoder, o *GlDrawElementsInstancedBaseInstanceEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.Count))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Instancecount))
	e.Uint32(uint32(o.Baseinstance))
}
func doDecodeGlDrawElementsInstancedBaseInstanceEXT(d binary.Decoder, o *GlDrawElementsInstancedBaseInstanceEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Instancecount = GLsizei(d.Int32())
	o.Baseinstance = GLuint(d.Uint32())
}
func doDecodeRawGlDrawElementsInstancedBaseInstanceEXT(d binary.Decoder, o *GlDrawElementsInstancedBaseInstanceEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Instancecount = GLsizei(d.Int32())
	o.Baseinstance = GLuint(d.Uint32())
}
func (*binaryClassGlDrawElementsInstancedBaseInstanceEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsInstancedBaseInstanceEXT(e, obj.(*GlDrawElementsInstancedBaseInstanceEXT))
}
func (*binaryClassGlDrawElementsInstancedBaseInstanceEXT) New() binary.Object {
	return &GlDrawElementsInstancedBaseInstanceEXT{}
}
func (*binaryClassGlDrawElementsInstancedBaseInstanceEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsInstancedBaseInstanceEXT(d, obj.(*GlDrawElementsInstancedBaseInstanceEXT))
}
func (c *binaryClassGlDrawElementsInstancedBaseInstanceEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsInstancedBaseInstanceEXT]
}

var _ drawCall = (*GlDrawElementsInstancedBaseVertex)(nil) // Interface compliance check.
type binaryClassGlDrawElementsInstancedBaseVertex struct{}

func (*GlDrawElementsInstancedBaseVertex) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedBaseVertex)(nil)
}
func doEncodeGlDrawElementsInstancedBaseVertex(e binary.Encoder, o *GlDrawElementsInstancedBaseVertex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DrawMode))
	e.Int32(int32(o.IndicesCount))
	e.Uint32(uint32(o.IndicesType))
	e.Simple(&o.Indices)
	e.Int32(int32(o.InstanceCount))
	e.Int32(int32(o.BaseVertex))
}
func doDecodeGlDrawElementsInstancedBaseVertex(d binary.Decoder, o *GlDrawElementsInstancedBaseVertex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.IndicesCount = GLsizei(d.Int32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.InstanceCount = GLsizei(d.Int32())
	o.BaseVertex = GLint(d.Int32())
}
func doDecodeRawGlDrawElementsInstancedBaseVertex(d binary.Decoder, o *GlDrawElementsInstancedBaseVertex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.IndicesCount = GLsizei(d.Int32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.InstanceCount = GLsizei(d.Int32())
	o.BaseVertex = GLint(d.Int32())
}
func (*binaryClassGlDrawElementsInstancedBaseVertex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsInstancedBaseVertex(e, obj.(*GlDrawElementsInstancedBaseVertex))
}
func (*binaryClassGlDrawElementsInstancedBaseVertex) New() binary.Object {
	return &GlDrawElementsInstancedBaseVertex{}
}
func (*binaryClassGlDrawElementsInstancedBaseVertex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsInstancedBaseVertex(d, obj.(*GlDrawElementsInstancedBaseVertex))
}
func (c *binaryClassGlDrawElementsInstancedBaseVertex) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsInstancedBaseVertex]
}

var _ drawCall = (*GlDrawElementsInstancedBaseVertexBaseInstanceEXT)(nil) // Interface compliance check.
type binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT struct{}

func (*GlDrawElementsInstancedBaseVertexBaseInstanceEXT) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT)(nil)
}
func doEncodeGlDrawElementsInstancedBaseVertexBaseInstanceEXT(e binary.Encoder, o *GlDrawElementsInstancedBaseVertexBaseInstanceEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.Count))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Instancecount))
	e.Int32(int32(o.Basevertex))
	e.Uint32(uint32(o.Baseinstance))
}
func doDecodeGlDrawElementsInstancedBaseVertexBaseInstanceEXT(d binary.Decoder, o *GlDrawElementsInstancedBaseVertexBaseInstanceEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Instancecount = GLsizei(d.Int32())
	o.Basevertex = GLint(d.Int32())
	o.Baseinstance = GLuint(d.Uint32())
}
func doDecodeRawGlDrawElementsInstancedBaseVertexBaseInstanceEXT(d binary.Decoder, o *GlDrawElementsInstancedBaseVertexBaseInstanceEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Instancecount = GLsizei(d.Int32())
	o.Basevertex = GLint(d.Int32())
	o.Baseinstance = GLuint(d.Uint32())
}
func (*binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsInstancedBaseVertexBaseInstanceEXT(e, obj.(*GlDrawElementsInstancedBaseVertexBaseInstanceEXT))
}
func (*binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT) New() binary.Object {
	return &GlDrawElementsInstancedBaseVertexBaseInstanceEXT{}
}
func (*binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsInstancedBaseVertexBaseInstanceEXT(d, obj.(*GlDrawElementsInstancedBaseVertexBaseInstanceEXT))
}
func (c *binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsInstancedBaseVertexBaseInstanceEXT]
}

var _ drawCall = (*GlDrawElementsInstancedBaseVertexEXT)(nil) // Interface compliance check.
type binaryClassGlDrawElementsInstancedBaseVertexEXT struct{}

func (*GlDrawElementsInstancedBaseVertexEXT) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedBaseVertexEXT)(nil)
}
func doEncodeGlDrawElementsInstancedBaseVertexEXT(e binary.Encoder, o *GlDrawElementsInstancedBaseVertexEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.Count))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Instancecount))
	e.Int32(int32(o.Basevertex))
}
func doDecodeGlDrawElementsInstancedBaseVertexEXT(d binary.Decoder, o *GlDrawElementsInstancedBaseVertexEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Instancecount = GLsizei(d.Int32())
	o.Basevertex = GLint(d.Int32())
}
func doDecodeRawGlDrawElementsInstancedBaseVertexEXT(d binary.Decoder, o *GlDrawElementsInstancedBaseVertexEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Instancecount = GLsizei(d.Int32())
	o.Basevertex = GLint(d.Int32())
}
func (*binaryClassGlDrawElementsInstancedBaseVertexEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsInstancedBaseVertexEXT(e, obj.(*GlDrawElementsInstancedBaseVertexEXT))
}
func (*binaryClassGlDrawElementsInstancedBaseVertexEXT) New() binary.Object {
	return &GlDrawElementsInstancedBaseVertexEXT{}
}
func (*binaryClassGlDrawElementsInstancedBaseVertexEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsInstancedBaseVertexEXT(d, obj.(*GlDrawElementsInstancedBaseVertexEXT))
}
func (c *binaryClassGlDrawElementsInstancedBaseVertexEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsInstancedBaseVertexEXT]
}

var _ drawCall = (*GlDrawElementsInstancedBaseVertexOES)(nil) // Interface compliance check.
type binaryClassGlDrawElementsInstancedBaseVertexOES struct{}

func (*GlDrawElementsInstancedBaseVertexOES) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedBaseVertexOES)(nil)
}
func doEncodeGlDrawElementsInstancedBaseVertexOES(e binary.Encoder, o *GlDrawElementsInstancedBaseVertexOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.Count))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Instancecount))
	e.Int32(int32(o.Basevertex))
}
func doDecodeGlDrawElementsInstancedBaseVertexOES(d binary.Decoder, o *GlDrawElementsInstancedBaseVertexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Instancecount = GLsizei(d.Int32())
	o.Basevertex = GLint(d.Int32())
}
func doDecodeRawGlDrawElementsInstancedBaseVertexOES(d binary.Decoder, o *GlDrawElementsInstancedBaseVertexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Instancecount = GLsizei(d.Int32())
	o.Basevertex = GLint(d.Int32())
}
func (*binaryClassGlDrawElementsInstancedBaseVertexOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsInstancedBaseVertexOES(e, obj.(*GlDrawElementsInstancedBaseVertexOES))
}
func (*binaryClassGlDrawElementsInstancedBaseVertexOES) New() binary.Object {
	return &GlDrawElementsInstancedBaseVertexOES{}
}
func (*binaryClassGlDrawElementsInstancedBaseVertexOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsInstancedBaseVertexOES(d, obj.(*GlDrawElementsInstancedBaseVertexOES))
}
func (c *binaryClassGlDrawElementsInstancedBaseVertexOES) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsInstancedBaseVertexOES]
}

var _ drawCall = (*GlDrawElementsInstancedEXT)(nil) // Interface compliance check.
type binaryClassGlDrawElementsInstancedEXT struct{}

func (*GlDrawElementsInstancedEXT) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedEXT)(nil)
}
func doEncodeGlDrawElementsInstancedEXT(e binary.Encoder, o *GlDrawElementsInstancedEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.Count))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Primcount))
}
func doDecodeGlDrawElementsInstancedEXT(d binary.Decoder, o *GlDrawElementsInstancedEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Primcount = GLsizei(d.Int32())
}
func doDecodeRawGlDrawElementsInstancedEXT(d binary.Decoder, o *GlDrawElementsInstancedEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Primcount = GLsizei(d.Int32())
}
func (*binaryClassGlDrawElementsInstancedEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsInstancedEXT(e, obj.(*GlDrawElementsInstancedEXT))
}
func (*binaryClassGlDrawElementsInstancedEXT) New() binary.Object {
	return &GlDrawElementsInstancedEXT{}
}
func (*binaryClassGlDrawElementsInstancedEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsInstancedEXT(d, obj.(*GlDrawElementsInstancedEXT))
}
func (c *binaryClassGlDrawElementsInstancedEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsInstancedEXT]
}

var _ drawCall = (*GlDrawElementsInstancedNV)(nil) // Interface compliance check.
type binaryClassGlDrawElementsInstancedNV struct{}

func (*GlDrawElementsInstancedNV) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedNV)(nil)
}
func doEncodeGlDrawElementsInstancedNV(e binary.Encoder, o *GlDrawElementsInstancedNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Int32(int32(o.Count))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Primcount))
}
func doDecodeGlDrawElementsInstancedNV(d binary.Decoder, o *GlDrawElementsInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Primcount = GLsizei(d.Int32())
}
func doDecodeRawGlDrawElementsInstancedNV(d binary.Decoder, o *GlDrawElementsInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Primcount = GLsizei(d.Int32())
}
func (*binaryClassGlDrawElementsInstancedNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawElementsInstancedNV(e, obj.(*GlDrawElementsInstancedNV))
}
func (*binaryClassGlDrawElementsInstancedNV) New() binary.Object {
	return &GlDrawElementsInstancedNV{}
}
func (*binaryClassGlDrawElementsInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawElementsInstancedNV(d, obj.(*GlDrawElementsInstancedNV))
}
func (c *binaryClassGlDrawElementsInstancedNV) Schema() *binary.Entity {
	return &entities[ixǁGlDrawElementsInstancedNV]
}

var _ drawCall = (*GlDrawRangeElements)(nil) // Interface compliance check.
type binaryClassGlDrawRangeElements struct{}

func (*GlDrawRangeElements) Class() binary.Class {
	return (*binaryClassGlDrawRangeElements)(nil)
}
func doEncodeGlDrawRangeElements(e binary.Encoder, o *GlDrawRangeElements) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DrawMode))
	e.Uint32(uint32(o.Start))
	e.Uint32(uint32(o.End))
	e.Int32(int32(o.IndicesCount))
	e.Uint32(uint32(o.IndicesType))
	e.Simple(&o.Indices)
}
func doDecodeGlDrawRangeElements(d binary.Decoder, o *GlDrawRangeElements) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.Start = GLuint(d.Uint32())
	o.End = GLuint(d.Uint32())
	o.IndicesCount = GLsizei(d.Int32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indices)
}
func doDecodeRawGlDrawRangeElements(d binary.Decoder, o *GlDrawRangeElements) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.Start = GLuint(d.Uint32())
	o.End = GLuint(d.Uint32())
	o.IndicesCount = GLsizei(d.Int32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indices)
}
func (*binaryClassGlDrawRangeElements) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawRangeElements(e, obj.(*GlDrawRangeElements))
}
func (*binaryClassGlDrawRangeElements) New() binary.Object {
	return &GlDrawRangeElements{}
}
func (*binaryClassGlDrawRangeElements) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawRangeElements(d, obj.(*GlDrawRangeElements))
}
func (c *binaryClassGlDrawRangeElements) Schema() *binary.Entity {
	return &entities[ixǁGlDrawRangeElements]
}

var _ drawCall = (*GlDrawRangeElementsBaseVertex)(nil) // Interface compliance check.
type binaryClassGlDrawRangeElementsBaseVertex struct{}

func (*GlDrawRangeElementsBaseVertex) Class() binary.Class {
	return (*binaryClassGlDrawRangeElementsBaseVertex)(nil)
}
func doEncodeGlDrawRangeElementsBaseVertex(e binary.Encoder, o *GlDrawRangeElementsBaseVertex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DrawMode))
	e.Uint32(uint32(o.Start))
	e.Uint32(uint32(o.End))
	e.Int32(int32(o.IndicesCount))
	e.Uint32(uint32(o.IndicesType))
	e.Simple(&o.Indices)
	e.Int32(int32(o.BaseVertex))
}
func doDecodeGlDrawRangeElementsBaseVertex(d binary.Decoder, o *GlDrawRangeElementsBaseVertex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.Start = GLuint(d.Uint32())
	o.End = GLuint(d.Uint32())
	o.IndicesCount = GLsizei(d.Int32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.BaseVertex = GLint(d.Int32())
}
func doDecodeRawGlDrawRangeElementsBaseVertex(d binary.Decoder, o *GlDrawRangeElementsBaseVertex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DrawMode = GLenum(d.Uint32())
	o.Start = GLuint(d.Uint32())
	o.End = GLuint(d.Uint32())
	o.IndicesCount = GLsizei(d.Int32())
	o.IndicesType = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.BaseVertex = GLint(d.Int32())
}
func (*binaryClassGlDrawRangeElementsBaseVertex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawRangeElementsBaseVertex(e, obj.(*GlDrawRangeElementsBaseVertex))
}
func (*binaryClassGlDrawRangeElementsBaseVertex) New() binary.Object {
	return &GlDrawRangeElementsBaseVertex{}
}
func (*binaryClassGlDrawRangeElementsBaseVertex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawRangeElementsBaseVertex(d, obj.(*GlDrawRangeElementsBaseVertex))
}
func (c *binaryClassGlDrawRangeElementsBaseVertex) Schema() *binary.Entity {
	return &entities[ixǁGlDrawRangeElementsBaseVertex]
}

var _ drawCall = (*GlDrawRangeElementsBaseVertexEXT)(nil) // Interface compliance check.
type binaryClassGlDrawRangeElementsBaseVertexEXT struct{}

func (*GlDrawRangeElementsBaseVertexEXT) Class() binary.Class {
	return (*binaryClassGlDrawRangeElementsBaseVertexEXT)(nil)
}
func doEncodeGlDrawRangeElementsBaseVertexEXT(e binary.Encoder, o *GlDrawRangeElementsBaseVertexEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Uint32(uint32(o.Start))
	e.Uint32(uint32(o.End))
	e.Int32(int32(o.Count))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Basevertex))
}
func doDecodeGlDrawRangeElementsBaseVertexEXT(d binary.Decoder, o *GlDrawRangeElementsBaseVertexEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Start = GLuint(d.Uint32())
	o.End = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Basevertex = GLint(d.Int32())
}
func doDecodeRawGlDrawRangeElementsBaseVertexEXT(d binary.Decoder, o *GlDrawRangeElementsBaseVertexEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Start = GLuint(d.Uint32())
	o.End = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Basevertex = GLint(d.Int32())
}
func (*binaryClassGlDrawRangeElementsBaseVertexEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawRangeElementsBaseVertexEXT(e, obj.(*GlDrawRangeElementsBaseVertexEXT))
}
func (*binaryClassGlDrawRangeElementsBaseVertexEXT) New() binary.Object {
	return &GlDrawRangeElementsBaseVertexEXT{}
}
func (*binaryClassGlDrawRangeElementsBaseVertexEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawRangeElementsBaseVertexEXT(d, obj.(*GlDrawRangeElementsBaseVertexEXT))
}
func (c *binaryClassGlDrawRangeElementsBaseVertexEXT) Schema() *binary.Entity {
	return &entities[ixǁGlDrawRangeElementsBaseVertexEXT]
}

var _ drawCall = (*GlDrawRangeElementsBaseVertexOES)(nil) // Interface compliance check.
type binaryClassGlDrawRangeElementsBaseVertexOES struct{}

func (*GlDrawRangeElementsBaseVertexOES) Class() binary.Class {
	return (*binaryClassGlDrawRangeElementsBaseVertexOES)(nil)
}
func doEncodeGlDrawRangeElementsBaseVertexOES(e binary.Encoder, o *GlDrawRangeElementsBaseVertexOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Uint32(uint32(o.Start))
	e.Uint32(uint32(o.End))
	e.Int32(int32(o.Count))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Basevertex))
}
func doDecodeGlDrawRangeElementsBaseVertexOES(d binary.Decoder, o *GlDrawRangeElementsBaseVertexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Start = GLuint(d.Uint32())
	o.End = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Basevertex = GLint(d.Int32())
}
func doDecodeRawGlDrawRangeElementsBaseVertexOES(d binary.Decoder, o *GlDrawRangeElementsBaseVertexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Start = GLuint(d.Uint32())
	o.End = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Basevertex = GLint(d.Int32())
}
func (*binaryClassGlDrawRangeElementsBaseVertexOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawRangeElementsBaseVertexOES(e, obj.(*GlDrawRangeElementsBaseVertexOES))
}
func (*binaryClassGlDrawRangeElementsBaseVertexOES) New() binary.Object {
	return &GlDrawRangeElementsBaseVertexOES{}
}
func (*binaryClassGlDrawRangeElementsBaseVertexOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawRangeElementsBaseVertexOES(d, obj.(*GlDrawRangeElementsBaseVertexOES))
}
func (c *binaryClassGlDrawRangeElementsBaseVertexOES) Schema() *binary.Entity {
	return &entities[ixǁGlDrawRangeElementsBaseVertexOES]
}

var _ drawCall = (*GlDrawTexfOES)(nil) // Interface compliance check.
type binaryClassGlDrawTexfOES struct{}

func (*GlDrawTexfOES) Class() binary.Class {
	return (*binaryClassGlDrawTexfOES)(nil)
}
func doEncodeGlDrawTexfOES(e binary.Encoder, o *GlDrawTexfOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.X))
	e.Float32(float32(o.Y))
	e.Float32(float32(o.Z))
	e.Float32(float32(o.Width))
	e.Float32(float32(o.Height))
}
func doDecodeGlDrawTexfOES(d binary.Decoder, o *GlDrawTexfOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.Z = GLfloat(d.Float32())
	o.Width = GLfloat(d.Float32())
	o.Height = GLfloat(d.Float32())
}
func doDecodeRawGlDrawTexfOES(d binary.Decoder, o *GlDrawTexfOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.Z = GLfloat(d.Float32())
	o.Width = GLfloat(d.Float32())
	o.Height = GLfloat(d.Float32())
}
func (*binaryClassGlDrawTexfOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawTexfOES(e, obj.(*GlDrawTexfOES))
}
func (*binaryClassGlDrawTexfOES) New() binary.Object {
	return &GlDrawTexfOES{}
}
func (*binaryClassGlDrawTexfOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawTexfOES(d, obj.(*GlDrawTexfOES))
}
func (c *binaryClassGlDrawTexfOES) Schema() *binary.Entity {
	return &entities[ixǁGlDrawTexfOES]
}

var _ drawCall = (*GlDrawTexfvOES)(nil) // Interface compliance check.
type binaryClassGlDrawTexfvOES struct{}

func (*GlDrawTexfvOES) Class() binary.Class {
	return (*binaryClassGlDrawTexfvOES)(nil)
}
func doEncodeGlDrawTexfvOES(e binary.Encoder, o *GlDrawTexfvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Coords)
}
func doDecodeGlDrawTexfvOES(d binary.Decoder, o *GlDrawTexfvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Coords)
}
func doDecodeRawGlDrawTexfvOES(d binary.Decoder, o *GlDrawTexfvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Coords)
}
func (*binaryClassGlDrawTexfvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawTexfvOES(e, obj.(*GlDrawTexfvOES))
}
func (*binaryClassGlDrawTexfvOES) New() binary.Object {
	return &GlDrawTexfvOES{}
}
func (*binaryClassGlDrawTexfvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawTexfvOES(d, obj.(*GlDrawTexfvOES))
}
func (c *binaryClassGlDrawTexfvOES) Schema() *binary.Entity {
	return &entities[ixǁGlDrawTexfvOES]
}

var _ drawCall = (*GlDrawTexiOES)(nil) // Interface compliance check.
type binaryClassGlDrawTexiOES struct{}

func (*GlDrawTexiOES) Class() binary.Class {
	return (*binaryClassGlDrawTexiOES)(nil)
}
func doEncodeGlDrawTexiOES(e binary.Encoder, o *GlDrawTexiOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Z))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlDrawTexiOES(d binary.Decoder, o *GlDrawTexiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Z = GLint(d.Int32())
	o.Width = GLint(d.Int32())
	o.Height = GLint(d.Int32())
}
func doDecodeRawGlDrawTexiOES(d binary.Decoder, o *GlDrawTexiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Z = GLint(d.Int32())
	o.Width = GLint(d.Int32())
	o.Height = GLint(d.Int32())
}
func (*binaryClassGlDrawTexiOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawTexiOES(e, obj.(*GlDrawTexiOES))
}
func (*binaryClassGlDrawTexiOES) New() binary.Object {
	return &GlDrawTexiOES{}
}
func (*binaryClassGlDrawTexiOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawTexiOES(d, obj.(*GlDrawTexiOES))
}
func (c *binaryClassGlDrawTexiOES) Schema() *binary.Entity {
	return &entities[ixǁGlDrawTexiOES]
}

var _ drawCall = (*GlDrawTexivOES)(nil) // Interface compliance check.
type binaryClassGlDrawTexivOES struct{}

func (*GlDrawTexivOES) Class() binary.Class {
	return (*binaryClassGlDrawTexivOES)(nil)
}
func doEncodeGlDrawTexivOES(e binary.Encoder, o *GlDrawTexivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Coords)
}
func doDecodeGlDrawTexivOES(d binary.Decoder, o *GlDrawTexivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Coords)
}
func doDecodeRawGlDrawTexivOES(d binary.Decoder, o *GlDrawTexivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Coords)
}
func (*binaryClassGlDrawTexivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawTexivOES(e, obj.(*GlDrawTexivOES))
}
func (*binaryClassGlDrawTexivOES) New() binary.Object {
	return &GlDrawTexivOES{}
}
func (*binaryClassGlDrawTexivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawTexivOES(d, obj.(*GlDrawTexivOES))
}
func (c *binaryClassGlDrawTexivOES) Schema() *binary.Entity {
	return &entities[ixǁGlDrawTexivOES]
}

var _ drawCall = (*GlDrawTexsOES)(nil) // Interface compliance check.
type binaryClassGlDrawTexsOES struct{}

func (*GlDrawTexsOES) Class() binary.Class {
	return (*binaryClassGlDrawTexsOES)(nil)
}
func doEncodeGlDrawTexsOES(e binary.Encoder, o *GlDrawTexsOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int16(int16(o.X))
	e.Int16(int16(o.Y))
	e.Int16(int16(o.Z))
	e.Int16(int16(o.Width))
	e.Int16(int16(o.Height))
}
func doDecodeGlDrawTexsOES(d binary.Decoder, o *GlDrawTexsOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLshort(d.Int16())
	o.Y = GLshort(d.Int16())
	o.Z = GLshort(d.Int16())
	o.Width = GLshort(d.Int16())
	o.Height = GLshort(d.Int16())
}
func doDecodeRawGlDrawTexsOES(d binary.Decoder, o *GlDrawTexsOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLshort(d.Int16())
	o.Y = GLshort(d.Int16())
	o.Z = GLshort(d.Int16())
	o.Width = GLshort(d.Int16())
	o.Height = GLshort(d.Int16())
}
func (*binaryClassGlDrawTexsOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawTexsOES(e, obj.(*GlDrawTexsOES))
}
func (*binaryClassGlDrawTexsOES) New() binary.Object {
	return &GlDrawTexsOES{}
}
func (*binaryClassGlDrawTexsOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawTexsOES(d, obj.(*GlDrawTexsOES))
}
func (c *binaryClassGlDrawTexsOES) Schema() *binary.Entity {
	return &entities[ixǁGlDrawTexsOES]
}

var _ drawCall = (*GlDrawTexsvOES)(nil) // Interface compliance check.
type binaryClassGlDrawTexsvOES struct{}

func (*GlDrawTexsvOES) Class() binary.Class {
	return (*binaryClassGlDrawTexsvOES)(nil)
}
func doEncodeGlDrawTexsvOES(e binary.Encoder, o *GlDrawTexsvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Coords)
}
func doDecodeGlDrawTexsvOES(d binary.Decoder, o *GlDrawTexsvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Coords)
}
func doDecodeRawGlDrawTexsvOES(d binary.Decoder, o *GlDrawTexsvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Coords)
}
func (*binaryClassGlDrawTexsvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawTexsvOES(e, obj.(*GlDrawTexsvOES))
}
func (*binaryClassGlDrawTexsvOES) New() binary.Object {
	return &GlDrawTexsvOES{}
}
func (*binaryClassGlDrawTexsvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawTexsvOES(d, obj.(*GlDrawTexsvOES))
}
func (c *binaryClassGlDrawTexsvOES) Schema() *binary.Entity {
	return &entities[ixǁGlDrawTexsvOES]
}

var _ drawCall = (*GlDrawTexxOES)(nil) // Interface compliance check.
type binaryClassGlDrawTexxOES struct{}

func (*GlDrawTexxOES) Class() binary.Class {
	return (*binaryClassGlDrawTexxOES)(nil)
}
func doEncodeGlDrawTexxOES(e binary.Encoder, o *GlDrawTexxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Z))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlDrawTexxOES(d binary.Decoder, o *GlDrawTexxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
	o.Width = GLfixed(d.Int32())
	o.Height = GLfixed(d.Int32())
}
func doDecodeRawGlDrawTexxOES(d binary.Decoder, o *GlDrawTexxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
	o.Width = GLfixed(d.Int32())
	o.Height = GLfixed(d.Int32())
}
func (*binaryClassGlDrawTexxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawTexxOES(e, obj.(*GlDrawTexxOES))
}
func (*binaryClassGlDrawTexxOES) New() binary.Object {
	return &GlDrawTexxOES{}
}
func (*binaryClassGlDrawTexxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawTexxOES(d, obj.(*GlDrawTexxOES))
}
func (c *binaryClassGlDrawTexxOES) Schema() *binary.Entity {
	return &entities[ixǁGlDrawTexxOES]
}

var _ drawCall = (*GlDrawTexxvOES)(nil) // Interface compliance check.
type binaryClassGlDrawTexxvOES struct{}

func (*GlDrawTexxvOES) Class() binary.Class {
	return (*binaryClassGlDrawTexxvOES)(nil)
}
func doEncodeGlDrawTexxvOES(e binary.Encoder, o *GlDrawTexxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Coords)
}
func doDecodeGlDrawTexxvOES(d binary.Decoder, o *GlDrawTexxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Coords)
}
func doDecodeRawGlDrawTexxvOES(d binary.Decoder, o *GlDrawTexxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Coords)
}
func (*binaryClassGlDrawTexxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlDrawTexxvOES(e, obj.(*GlDrawTexxvOES))
}
func (*binaryClassGlDrawTexxvOES) New() binary.Object {
	return &GlDrawTexxvOES{}
}
func (*binaryClassGlDrawTexxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlDrawTexxvOES(d, obj.(*GlDrawTexxvOES))
}
func (c *binaryClassGlDrawTexxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlDrawTexxvOES]
}

type binaryClassGlEGLImageTargetRenderbufferStorageOES struct{}

func (*GlEGLImageTargetRenderbufferStorageOES) Class() binary.Class {
	return (*binaryClassGlEGLImageTargetRenderbufferStorageOES)(nil)
}
func doEncodeGlEGLImageTargetRenderbufferStorageOES(e binary.Encoder, o *GlEGLImageTargetRenderbufferStorageOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Simple(&o.Image)
}
func doDecodeGlEGLImageTargetRenderbufferStorageOES(d binary.Decoder, o *GlEGLImageTargetRenderbufferStorageOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	d.Simple(&o.Image)
}
func doDecodeRawGlEGLImageTargetRenderbufferStorageOES(d binary.Decoder, o *GlEGLImageTargetRenderbufferStorageOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	d.Simple(&o.Image)
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEGLImageTargetRenderbufferStorageOES(e, obj.(*GlEGLImageTargetRenderbufferStorageOES))
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) New() binary.Object {
	return &GlEGLImageTargetRenderbufferStorageOES{}
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEGLImageTargetRenderbufferStorageOES(d, obj.(*GlEGLImageTargetRenderbufferStorageOES))
}
func (c *binaryClassGlEGLImageTargetRenderbufferStorageOES) Schema() *binary.Entity {
	return &entities[ixǁGlEGLImageTargetRenderbufferStorageOES]
}

type binaryClassGlEGLImageTargetTexture2DOES struct{}

func (*GlEGLImageTargetTexture2DOES) Class() binary.Class {
	return (*binaryClassGlEGLImageTargetTexture2DOES)(nil)
}
func doEncodeGlEGLImageTargetTexture2DOES(e binary.Encoder, o *GlEGLImageTargetTexture2DOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Simple(&o.Image)
}
func doDecodeGlEGLImageTargetTexture2DOES(d binary.Decoder, o *GlEGLImageTargetTexture2DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	d.Simple(&o.Image)
}
func doDecodeRawGlEGLImageTargetTexture2DOES(d binary.Decoder, o *GlEGLImageTargetTexture2DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	d.Simple(&o.Image)
}
func (*binaryClassGlEGLImageTargetTexture2DOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEGLImageTargetTexture2DOES(e, obj.(*GlEGLImageTargetTexture2DOES))
}
func (*binaryClassGlEGLImageTargetTexture2DOES) New() binary.Object {
	return &GlEGLImageTargetTexture2DOES{}
}
func (*binaryClassGlEGLImageTargetTexture2DOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEGLImageTargetTexture2DOES(d, obj.(*GlEGLImageTargetTexture2DOES))
}
func (c *binaryClassGlEGLImageTargetTexture2DOES) Schema() *binary.Entity {
	return &entities[ixǁGlEGLImageTargetTexture2DOES]
}

type binaryClassGlEnable struct{}

func (*GlEnable) Class() binary.Class {
	return (*binaryClassGlEnable)(nil)
}
func doEncodeGlEnable(e binary.Encoder, o *GlEnable) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Capability))
}
func doDecodeGlEnable(d binary.Decoder, o *GlEnable) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Capability = GLenum(d.Uint32())
}
func doDecodeRawGlEnable(d binary.Decoder, o *GlEnable) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Capability = GLenum(d.Uint32())
}
func (*binaryClassGlEnable) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEnable(e, obj.(*GlEnable))
}
func (*binaryClassGlEnable) New() binary.Object {
	return &GlEnable{}
}
func (*binaryClassGlEnable) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEnable(d, obj.(*GlEnable))
}
func (c *binaryClassGlEnable) Schema() *binary.Entity {
	return &entities[ixǁGlEnable]
}

type binaryClassGlEnableClientState struct{}

func (*GlEnableClientState) Class() binary.Class {
	return (*binaryClassGlEnableClientState)(nil)
}
func doEncodeGlEnableClientState(e binary.Encoder, o *GlEnableClientState) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Array))
}
func doDecodeGlEnableClientState(d binary.Decoder, o *GlEnableClientState) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Array = GLenum(d.Uint32())
}
func doDecodeRawGlEnableClientState(d binary.Decoder, o *GlEnableClientState) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Array = GLenum(d.Uint32())
}
func (*binaryClassGlEnableClientState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEnableClientState(e, obj.(*GlEnableClientState))
}
func (*binaryClassGlEnableClientState) New() binary.Object {
	return &GlEnableClientState{}
}
func (*binaryClassGlEnableClientState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEnableClientState(d, obj.(*GlEnableClientState))
}
func (c *binaryClassGlEnableClientState) Schema() *binary.Entity {
	return &entities[ixǁGlEnableClientState]
}

type binaryClassGlEnableDriverControlQCOM struct{}

func (*GlEnableDriverControlQCOM) Class() binary.Class {
	return (*binaryClassGlEnableDriverControlQCOM)(nil)
}
func doEncodeGlEnableDriverControlQCOM(e binary.Encoder, o *GlEnableDriverControlQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DriverControl))
}
func doDecodeGlEnableDriverControlQCOM(d binary.Decoder, o *GlEnableDriverControlQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DriverControl = GLuint(d.Uint32())
}
func doDecodeRawGlEnableDriverControlQCOM(d binary.Decoder, o *GlEnableDriverControlQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DriverControl = GLuint(d.Uint32())
}
func (*binaryClassGlEnableDriverControlQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEnableDriverControlQCOM(e, obj.(*GlEnableDriverControlQCOM))
}
func (*binaryClassGlEnableDriverControlQCOM) New() binary.Object {
	return &GlEnableDriverControlQCOM{}
}
func (*binaryClassGlEnableDriverControlQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEnableDriverControlQCOM(d, obj.(*GlEnableDriverControlQCOM))
}
func (c *binaryClassGlEnableDriverControlQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlEnableDriverControlQCOM]
}

type binaryClassGlEnableVertexAttribArray struct{}

func (*GlEnableVertexAttribArray) Class() binary.Class {
	return (*binaryClassGlEnableVertexAttribArray)(nil)
}
func doEncodeGlEnableVertexAttribArray(e binary.Encoder, o *GlEnableVertexAttribArray) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Location))
}
func doDecodeGlEnableVertexAttribArray(d binary.Decoder, o *GlEnableVertexAttribArray) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
}
func doDecodeRawGlEnableVertexAttribArray(d binary.Decoder, o *GlEnableVertexAttribArray) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
}
func (*binaryClassGlEnableVertexAttribArray) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEnableVertexAttribArray(e, obj.(*GlEnableVertexAttribArray))
}
func (*binaryClassGlEnableVertexAttribArray) New() binary.Object {
	return &GlEnableVertexAttribArray{}
}
func (*binaryClassGlEnableVertexAttribArray) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEnableVertexAttribArray(d, obj.(*GlEnableVertexAttribArray))
}
func (c *binaryClassGlEnableVertexAttribArray) Schema() *binary.Entity {
	return &entities[ixǁGlEnableVertexAttribArray]
}

type binaryClassGlEnablei struct{}

func (*GlEnablei) Class() binary.Class {
	return (*binaryClassGlEnablei)(nil)
}
func doEncodeGlEnablei(e binary.Encoder, o *GlEnablei) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Capability))
	e.Uint32(uint32(o.Index))
}
func doDecodeGlEnablei(d binary.Decoder, o *GlEnablei) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Capability = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func doDecodeRawGlEnablei(d binary.Decoder, o *GlEnablei) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Capability = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func (*binaryClassGlEnablei) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEnablei(e, obj.(*GlEnablei))
}
func (*binaryClassGlEnablei) New() binary.Object {
	return &GlEnablei{}
}
func (*binaryClassGlEnablei) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEnablei(d, obj.(*GlEnablei))
}
func (c *binaryClassGlEnablei) Schema() *binary.Entity {
	return &entities[ixǁGlEnablei]
}

type binaryClassGlEnableiEXT struct{}

func (*GlEnableiEXT) Class() binary.Class {
	return (*binaryClassGlEnableiEXT)(nil)
}
func doEncodeGlEnableiEXT(e binary.Encoder, o *GlEnableiEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
}
func doDecodeGlEnableiEXT(d binary.Decoder, o *GlEnableiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func doDecodeRawGlEnableiEXT(d binary.Decoder, o *GlEnableiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func (*binaryClassGlEnableiEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEnableiEXT(e, obj.(*GlEnableiEXT))
}
func (*binaryClassGlEnableiEXT) New() binary.Object {
	return &GlEnableiEXT{}
}
func (*binaryClassGlEnableiEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEnableiEXT(d, obj.(*GlEnableiEXT))
}
func (c *binaryClassGlEnableiEXT) Schema() *binary.Entity {
	return &entities[ixǁGlEnableiEXT]
}

type binaryClassGlEnableiNV struct{}

func (*GlEnableiNV) Class() binary.Class {
	return (*binaryClassGlEnableiNV)(nil)
}
func doEncodeGlEnableiNV(e binary.Encoder, o *GlEnableiNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
}
func doDecodeGlEnableiNV(d binary.Decoder, o *GlEnableiNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func doDecodeRawGlEnableiNV(d binary.Decoder, o *GlEnableiNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func (*binaryClassGlEnableiNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEnableiNV(e, obj.(*GlEnableiNV))
}
func (*binaryClassGlEnableiNV) New() binary.Object {
	return &GlEnableiNV{}
}
func (*binaryClassGlEnableiNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEnableiNV(d, obj.(*GlEnableiNV))
}
func (c *binaryClassGlEnableiNV) Schema() *binary.Entity {
	return &entities[ixǁGlEnableiNV]
}

type binaryClassGlEnableiOES struct{}

func (*GlEnableiOES) Class() binary.Class {
	return (*binaryClassGlEnableiOES)(nil)
}
func doEncodeGlEnableiOES(e binary.Encoder, o *GlEnableiOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
}
func doDecodeGlEnableiOES(d binary.Decoder, o *GlEnableiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func doDecodeRawGlEnableiOES(d binary.Decoder, o *GlEnableiOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
}
func (*binaryClassGlEnableiOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEnableiOES(e, obj.(*GlEnableiOES))
}
func (*binaryClassGlEnableiOES) New() binary.Object {
	return &GlEnableiOES{}
}
func (*binaryClassGlEnableiOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEnableiOES(d, obj.(*GlEnableiOES))
}
func (c *binaryClassGlEnableiOES) Schema() *binary.Entity {
	return &entities[ixǁGlEnableiOES]
}

type binaryClassGlEndConditionalRenderNV struct{}

func (*GlEndConditionalRenderNV) Class() binary.Class {
	return (*binaryClassGlEndConditionalRenderNV)(nil)
}
func doEncodeGlEndConditionalRenderNV(e binary.Encoder, o *GlEndConditionalRenderNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlEndConditionalRenderNV(d binary.Decoder, o *GlEndConditionalRenderNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlEndConditionalRenderNV(d binary.Decoder, o *GlEndConditionalRenderNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlEndConditionalRenderNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEndConditionalRenderNV(e, obj.(*GlEndConditionalRenderNV))
}
func (*binaryClassGlEndConditionalRenderNV) New() binary.Object {
	return &GlEndConditionalRenderNV{}
}
func (*binaryClassGlEndConditionalRenderNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEndConditionalRenderNV(d, obj.(*GlEndConditionalRenderNV))
}
func (c *binaryClassGlEndConditionalRenderNV) Schema() *binary.Entity {
	return &entities[ixǁGlEndConditionalRenderNV]
}

type binaryClassGlEndPerfMonitorAMD struct{}

func (*GlEndPerfMonitorAMD) Class() binary.Class {
	return (*binaryClassGlEndPerfMonitorAMD)(nil)
}
func doEncodeGlEndPerfMonitorAMD(e binary.Encoder, o *GlEndPerfMonitorAMD) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Monitor))
}
func doDecodeGlEndPerfMonitorAMD(d binary.Decoder, o *GlEndPerfMonitorAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Monitor = GLuint(d.Uint32())
}
func doDecodeRawGlEndPerfMonitorAMD(d binary.Decoder, o *GlEndPerfMonitorAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Monitor = GLuint(d.Uint32())
}
func (*binaryClassGlEndPerfMonitorAMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEndPerfMonitorAMD(e, obj.(*GlEndPerfMonitorAMD))
}
func (*binaryClassGlEndPerfMonitorAMD) New() binary.Object {
	return &GlEndPerfMonitorAMD{}
}
func (*binaryClassGlEndPerfMonitorAMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEndPerfMonitorAMD(d, obj.(*GlEndPerfMonitorAMD))
}
func (c *binaryClassGlEndPerfMonitorAMD) Schema() *binary.Entity {
	return &entities[ixǁGlEndPerfMonitorAMD]
}

type binaryClassGlEndPerfQueryINTEL struct{}

func (*GlEndPerfQueryINTEL) Class() binary.Class {
	return (*binaryClassGlEndPerfQueryINTEL)(nil)
}
func doEncodeGlEndPerfQueryINTEL(e binary.Encoder, o *GlEndPerfQueryINTEL) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.QueryHandle))
}
func doDecodeGlEndPerfQueryINTEL(d binary.Decoder, o *GlEndPerfQueryINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryHandle = GLuint(d.Uint32())
}
func doDecodeRawGlEndPerfQueryINTEL(d binary.Decoder, o *GlEndPerfQueryINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryHandle = GLuint(d.Uint32())
}
func (*binaryClassGlEndPerfQueryINTEL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEndPerfQueryINTEL(e, obj.(*GlEndPerfQueryINTEL))
}
func (*binaryClassGlEndPerfQueryINTEL) New() binary.Object {
	return &GlEndPerfQueryINTEL{}
}
func (*binaryClassGlEndPerfQueryINTEL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEndPerfQueryINTEL(d, obj.(*GlEndPerfQueryINTEL))
}
func (c *binaryClassGlEndPerfQueryINTEL) Schema() *binary.Entity {
	return &entities[ixǁGlEndPerfQueryINTEL]
}

type binaryClassGlEndQuery struct{}

func (*GlEndQuery) Class() binary.Class {
	return (*binaryClassGlEndQuery)(nil)
}
func doEncodeGlEndQuery(e binary.Encoder, o *GlEndQuery) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
}
func doDecodeGlEndQuery(d binary.Decoder, o *GlEndQuery) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
}
func doDecodeRawGlEndQuery(d binary.Decoder, o *GlEndQuery) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
}
func (*binaryClassGlEndQuery) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEndQuery(e, obj.(*GlEndQuery))
}
func (*binaryClassGlEndQuery) New() binary.Object {
	return &GlEndQuery{}
}
func (*binaryClassGlEndQuery) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEndQuery(d, obj.(*GlEndQuery))
}
func (c *binaryClassGlEndQuery) Schema() *binary.Entity {
	return &entities[ixǁGlEndQuery]
}

type binaryClassGlEndQueryEXT struct{}

func (*GlEndQueryEXT) Class() binary.Class {
	return (*binaryClassGlEndQueryEXT)(nil)
}
func doEncodeGlEndQueryEXT(e binary.Encoder, o *GlEndQueryEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
}
func doDecodeGlEndQueryEXT(d binary.Decoder, o *GlEndQueryEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
}
func doDecodeRawGlEndQueryEXT(d binary.Decoder, o *GlEndQueryEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
}
func (*binaryClassGlEndQueryEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEndQueryEXT(e, obj.(*GlEndQueryEXT))
}
func (*binaryClassGlEndQueryEXT) New() binary.Object {
	return &GlEndQueryEXT{}
}
func (*binaryClassGlEndQueryEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEndQueryEXT(d, obj.(*GlEndQueryEXT))
}
func (c *binaryClassGlEndQueryEXT) Schema() *binary.Entity {
	return &entities[ixǁGlEndQueryEXT]
}

type binaryClassGlEndTilingQCOM struct{}

func (*GlEndTilingQCOM) Class() binary.Class {
	return (*binaryClassGlEndTilingQCOM)(nil)
}
func doEncodeGlEndTilingQCOM(e binary.Encoder, o *GlEndTilingQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.PreserveMask))
}
func doDecodeGlEndTilingQCOM(d binary.Decoder, o *GlEndTilingQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.PreserveMask = GLbitfield(d.Uint32())
}
func doDecodeRawGlEndTilingQCOM(d binary.Decoder, o *GlEndTilingQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.PreserveMask = GLbitfield(d.Uint32())
}
func (*binaryClassGlEndTilingQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEndTilingQCOM(e, obj.(*GlEndTilingQCOM))
}
func (*binaryClassGlEndTilingQCOM) New() binary.Object {
	return &GlEndTilingQCOM{}
}
func (*binaryClassGlEndTilingQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEndTilingQCOM(d, obj.(*GlEndTilingQCOM))
}
func (c *binaryClassGlEndTilingQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlEndTilingQCOM]
}

type binaryClassGlEndTransformFeedback struct{}

func (*GlEndTransformFeedback) Class() binary.Class {
	return (*binaryClassGlEndTransformFeedback)(nil)
}
func doEncodeGlEndTransformFeedback(e binary.Encoder, o *GlEndTransformFeedback) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlEndTransformFeedback(d binary.Decoder, o *GlEndTransformFeedback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlEndTransformFeedback(d binary.Decoder, o *GlEndTransformFeedback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlEndTransformFeedback) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlEndTransformFeedback(e, obj.(*GlEndTransformFeedback))
}
func (*binaryClassGlEndTransformFeedback) New() binary.Object {
	return &GlEndTransformFeedback{}
}
func (*binaryClassGlEndTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlEndTransformFeedback(d, obj.(*GlEndTransformFeedback))
}
func (c *binaryClassGlEndTransformFeedback) Schema() *binary.Entity {
	return &entities[ixǁGlEndTransformFeedback]
}

type binaryClassVoidᵖᵖ struct{}

func (*Voidᵖᵖ) Class() binary.Class {
	return (*binaryClassVoidᵖᵖ)(nil)
}
func doEncodeVoidᵖᵖ(e binary.Writer, o *Voidᵖᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVoidᵖᵖ(d binary.Reader, o *Voidᵖᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVoidᵖᵖ(d binary.Reader, o *Voidᵖᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVoidᵖᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVoidᵖᵖ(e, obj.(*Voidᵖᵖ))
}
func (*binaryClassVoidᵖᵖ) New() binary.Object {
	return &Voidᵖᵖ{}
}
func (*binaryClassVoidᵖᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVoidᵖᵖ(d, obj.(*Voidᵖᵖ))
}
func (o *Voidᵖᵖ) WriteSimple(w binary.Writer) {
	doEncodeVoidᵖᵖ(w, o)
}
func (o *Voidᵖᵖ) ReadSimple(r binary.Reader) {
	doDecodeVoidᵖᵖ(r, o)
}
func (c *binaryClassVoidᵖᵖ) Schema() *binary.Entity {
	return &entities[ixǁVoidᵖᵖ]
}

type binaryClassGlExtGetBufferPointervQCOM struct{}

func (*GlExtGetBufferPointervQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetBufferPointervQCOM)(nil)
}
func doEncodeGlExtGetBufferPointervQCOM(e binary.Encoder, o *GlExtGetBufferPointervQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Simple(&o.Params)
}
func doDecodeGlExtGetBufferPointervQCOM(d binary.Decoder, o *GlExtGetBufferPointervQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlExtGetBufferPointervQCOM(d binary.Decoder, o *GlExtGetBufferPointervQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlExtGetBufferPointervQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlExtGetBufferPointervQCOM(e, obj.(*GlExtGetBufferPointervQCOM))
}
func (*binaryClassGlExtGetBufferPointervQCOM) New() binary.Object {
	return &GlExtGetBufferPointervQCOM{}
}
func (*binaryClassGlExtGetBufferPointervQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlExtGetBufferPointervQCOM(d, obj.(*GlExtGetBufferPointervQCOM))
}
func (c *binaryClassGlExtGetBufferPointervQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlExtGetBufferPointervQCOM]
}

type binaryClassGlExtGetBuffersQCOM struct{}

func (*GlExtGetBuffersQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetBuffersQCOM)(nil)
}
func doEncodeGlExtGetBuffersQCOM(e binary.Encoder, o *GlExtGetBuffersQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Buffers)
	e.Int32(int32(o.MaxBuffers))
	e.Simple(&o.NumBuffers)
}
func doDecodeGlExtGetBuffersQCOM(d binary.Decoder, o *GlExtGetBuffersQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Buffers)
	o.MaxBuffers = GLint(d.Int32())
	d.Simple(&o.NumBuffers)
}
func doDecodeRawGlExtGetBuffersQCOM(d binary.Decoder, o *GlExtGetBuffersQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Buffers)
	o.MaxBuffers = GLint(d.Int32())
	d.Simple(&o.NumBuffers)
}
func (*binaryClassGlExtGetBuffersQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlExtGetBuffersQCOM(e, obj.(*GlExtGetBuffersQCOM))
}
func (*binaryClassGlExtGetBuffersQCOM) New() binary.Object {
	return &GlExtGetBuffersQCOM{}
}
func (*binaryClassGlExtGetBuffersQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlExtGetBuffersQCOM(d, obj.(*GlExtGetBuffersQCOM))
}
func (c *binaryClassGlExtGetBuffersQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlExtGetBuffersQCOM]
}

type binaryClassGlExtGetFramebuffersQCOM struct{}

func (*GlExtGetFramebuffersQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetFramebuffersQCOM)(nil)
}
func doEncodeGlExtGetFramebuffersQCOM(e binary.Encoder, o *GlExtGetFramebuffersQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Framebuffers)
	e.Int32(int32(o.MaxFramebuffers))
	e.Simple(&o.NumFramebuffers)
}
func doDecodeGlExtGetFramebuffersQCOM(d binary.Decoder, o *GlExtGetFramebuffersQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Framebuffers)
	o.MaxFramebuffers = GLint(d.Int32())
	d.Simple(&o.NumFramebuffers)
}
func doDecodeRawGlExtGetFramebuffersQCOM(d binary.Decoder, o *GlExtGetFramebuffersQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Framebuffers)
	o.MaxFramebuffers = GLint(d.Int32())
	d.Simple(&o.NumFramebuffers)
}
func (*binaryClassGlExtGetFramebuffersQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlExtGetFramebuffersQCOM(e, obj.(*GlExtGetFramebuffersQCOM))
}
func (*binaryClassGlExtGetFramebuffersQCOM) New() binary.Object {
	return &GlExtGetFramebuffersQCOM{}
}
func (*binaryClassGlExtGetFramebuffersQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlExtGetFramebuffersQCOM(d, obj.(*GlExtGetFramebuffersQCOM))
}
func (c *binaryClassGlExtGetFramebuffersQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlExtGetFramebuffersQCOM]
}

type binaryClassGlExtGetProgramBinarySourceQCOM struct{}

func (*GlExtGetProgramBinarySourceQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetProgramBinarySourceQCOM)(nil)
}
func doEncodeGlExtGetProgramBinarySourceQCOM(e binary.Encoder, o *GlExtGetProgramBinarySourceQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.Shadertype))
	e.Simple(&o.Source)
	e.Simple(&o.Length)
}
func doDecodeGlExtGetProgramBinarySourceQCOM(d binary.Decoder, o *GlExtGetProgramBinarySourceQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Shadertype = GLenum(d.Uint32())
	d.Simple(&o.Source)
	d.Simple(&o.Length)
}
func doDecodeRawGlExtGetProgramBinarySourceQCOM(d binary.Decoder, o *GlExtGetProgramBinarySourceQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Shadertype = GLenum(d.Uint32())
	d.Simple(&o.Source)
	d.Simple(&o.Length)
}
func (*binaryClassGlExtGetProgramBinarySourceQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlExtGetProgramBinarySourceQCOM(e, obj.(*GlExtGetProgramBinarySourceQCOM))
}
func (*binaryClassGlExtGetProgramBinarySourceQCOM) New() binary.Object {
	return &GlExtGetProgramBinarySourceQCOM{}
}
func (*binaryClassGlExtGetProgramBinarySourceQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlExtGetProgramBinarySourceQCOM(d, obj.(*GlExtGetProgramBinarySourceQCOM))
}
func (c *binaryClassGlExtGetProgramBinarySourceQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlExtGetProgramBinarySourceQCOM]
}

type binaryClassProgramIdᵖ struct{}

func (*ProgramIdᵖ) Class() binary.Class {
	return (*binaryClassProgramIdᵖ)(nil)
}
func doEncodeProgramIdᵖ(e binary.Writer, o *ProgramIdᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeProgramIdᵖ(d binary.Reader, o *ProgramIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawProgramIdᵖ(d binary.Reader, o *ProgramIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassProgramIdᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeProgramIdᵖ(e, obj.(*ProgramIdᵖ))
}
func (*binaryClassProgramIdᵖ) New() binary.Object {
	return &ProgramIdᵖ{}
}
func (*binaryClassProgramIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeProgramIdᵖ(d, obj.(*ProgramIdᵖ))
}
func (o *ProgramIdᵖ) WriteSimple(w binary.Writer) {
	doEncodeProgramIdᵖ(w, o)
}
func (o *ProgramIdᵖ) ReadSimple(r binary.Reader) {
	doDecodeProgramIdᵖ(r, o)
}
func (c *binaryClassProgramIdᵖ) Schema() *binary.Entity {
	return &entities[ixǁProgramIdᵖ]
}

type binaryClassGlExtGetProgramsQCOM struct{}

func (*GlExtGetProgramsQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetProgramsQCOM)(nil)
}
func doEncodeGlExtGetProgramsQCOM(e binary.Encoder, o *GlExtGetProgramsQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Programs)
	e.Int32(int32(o.MaxPrograms))
	e.Simple(&o.NumPrograms)
}
func doDecodeGlExtGetProgramsQCOM(d binary.Decoder, o *GlExtGetProgramsQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Programs)
	o.MaxPrograms = GLint(d.Int32())
	d.Simple(&o.NumPrograms)
}
func doDecodeRawGlExtGetProgramsQCOM(d binary.Decoder, o *GlExtGetProgramsQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Programs)
	o.MaxPrograms = GLint(d.Int32())
	d.Simple(&o.NumPrograms)
}
func (*binaryClassGlExtGetProgramsQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlExtGetProgramsQCOM(e, obj.(*GlExtGetProgramsQCOM))
}
func (*binaryClassGlExtGetProgramsQCOM) New() binary.Object {
	return &GlExtGetProgramsQCOM{}
}
func (*binaryClassGlExtGetProgramsQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlExtGetProgramsQCOM(d, obj.(*GlExtGetProgramsQCOM))
}
func (c *binaryClassGlExtGetProgramsQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlExtGetProgramsQCOM]
}

type binaryClassRenderbufferIdᵖ struct{}

func (*RenderbufferIdᵖ) Class() binary.Class {
	return (*binaryClassRenderbufferIdᵖ)(nil)
}
func doEncodeRenderbufferIdᵖ(e binary.Writer, o *RenderbufferIdᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeRenderbufferIdᵖ(d binary.Reader, o *RenderbufferIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawRenderbufferIdᵖ(d binary.Reader, o *RenderbufferIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassRenderbufferIdᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeRenderbufferIdᵖ(e, obj.(*RenderbufferIdᵖ))
}
func (*binaryClassRenderbufferIdᵖ) New() binary.Object {
	return &RenderbufferIdᵖ{}
}
func (*binaryClassRenderbufferIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeRenderbufferIdᵖ(d, obj.(*RenderbufferIdᵖ))
}
func (o *RenderbufferIdᵖ) WriteSimple(w binary.Writer) {
	doEncodeRenderbufferIdᵖ(w, o)
}
func (o *RenderbufferIdᵖ) ReadSimple(r binary.Reader) {
	doDecodeRenderbufferIdᵖ(r, o)
}
func (c *binaryClassRenderbufferIdᵖ) Schema() *binary.Entity {
	return &entities[ixǁRenderbufferIdᵖ]
}

type binaryClassGlExtGetRenderbuffersQCOM struct{}

func (*GlExtGetRenderbuffersQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetRenderbuffersQCOM)(nil)
}
func doEncodeGlExtGetRenderbuffersQCOM(e binary.Encoder, o *GlExtGetRenderbuffersQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Renderbuffers)
	e.Int32(int32(o.MaxRenderbuffers))
	e.Simple(&o.NumRenderbuffers)
}
func doDecodeGlExtGetRenderbuffersQCOM(d binary.Decoder, o *GlExtGetRenderbuffersQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Renderbuffers)
	o.MaxRenderbuffers = GLint(d.Int32())
	d.Simple(&o.NumRenderbuffers)
}
func doDecodeRawGlExtGetRenderbuffersQCOM(d binary.Decoder, o *GlExtGetRenderbuffersQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Renderbuffers)
	o.MaxRenderbuffers = GLint(d.Int32())
	d.Simple(&o.NumRenderbuffers)
}
func (*binaryClassGlExtGetRenderbuffersQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlExtGetRenderbuffersQCOM(e, obj.(*GlExtGetRenderbuffersQCOM))
}
func (*binaryClassGlExtGetRenderbuffersQCOM) New() binary.Object {
	return &GlExtGetRenderbuffersQCOM{}
}
func (*binaryClassGlExtGetRenderbuffersQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlExtGetRenderbuffersQCOM(d, obj.(*GlExtGetRenderbuffersQCOM))
}
func (c *binaryClassGlExtGetRenderbuffersQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlExtGetRenderbuffersQCOM]
}

type binaryClassShaderIdᵖ struct{}

func (*ShaderIdᵖ) Class() binary.Class {
	return (*binaryClassShaderIdᵖ)(nil)
}
func doEncodeShaderIdᵖ(e binary.Writer, o *ShaderIdᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeShaderIdᵖ(d binary.Reader, o *ShaderIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawShaderIdᵖ(d binary.Reader, o *ShaderIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassShaderIdᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeShaderIdᵖ(e, obj.(*ShaderIdᵖ))
}
func (*binaryClassShaderIdᵖ) New() binary.Object {
	return &ShaderIdᵖ{}
}
func (*binaryClassShaderIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeShaderIdᵖ(d, obj.(*ShaderIdᵖ))
}
func (o *ShaderIdᵖ) WriteSimple(w binary.Writer) {
	doEncodeShaderIdᵖ(w, o)
}
func (o *ShaderIdᵖ) ReadSimple(r binary.Reader) {
	doDecodeShaderIdᵖ(r, o)
}
func (c *binaryClassShaderIdᵖ) Schema() *binary.Entity {
	return &entities[ixǁShaderIdᵖ]
}

type binaryClassGlExtGetShadersQCOM struct{}

func (*GlExtGetShadersQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetShadersQCOM)(nil)
}
func doEncodeGlExtGetShadersQCOM(e binary.Encoder, o *GlExtGetShadersQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Shaders)
	e.Int32(int32(o.MaxShaders))
	e.Simple(&o.NumShaders)
}
func doDecodeGlExtGetShadersQCOM(d binary.Decoder, o *GlExtGetShadersQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Shaders)
	o.MaxShaders = GLint(d.Int32())
	d.Simple(&o.NumShaders)
}
func doDecodeRawGlExtGetShadersQCOM(d binary.Decoder, o *GlExtGetShadersQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Shaders)
	o.MaxShaders = GLint(d.Int32())
	d.Simple(&o.NumShaders)
}
func (*binaryClassGlExtGetShadersQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlExtGetShadersQCOM(e, obj.(*GlExtGetShadersQCOM))
}
func (*binaryClassGlExtGetShadersQCOM) New() binary.Object {
	return &GlExtGetShadersQCOM{}
}
func (*binaryClassGlExtGetShadersQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlExtGetShadersQCOM(d, obj.(*GlExtGetShadersQCOM))
}
func (c *binaryClassGlExtGetShadersQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlExtGetShadersQCOM]
}

type binaryClassGlExtGetTexLevelParameterivQCOM struct{}

func (*GlExtGetTexLevelParameterivQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetTexLevelParameterivQCOM)(nil)
}
func doEncodeGlExtGetTexLevelParameterivQCOM(e binary.Encoder, o *GlExtGetTexLevelParameterivQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
	e.Uint32(uint32(o.Face))
	e.Int32(int32(o.Level))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlExtGetTexLevelParameterivQCOM(d binary.Decoder, o *GlExtGetTexLevelParameterivQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Face = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlExtGetTexLevelParameterivQCOM(d binary.Decoder, o *GlExtGetTexLevelParameterivQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Face = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlExtGetTexLevelParameterivQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlExtGetTexLevelParameterivQCOM(e, obj.(*GlExtGetTexLevelParameterivQCOM))
}
func (*binaryClassGlExtGetTexLevelParameterivQCOM) New() binary.Object {
	return &GlExtGetTexLevelParameterivQCOM{}
}
func (*binaryClassGlExtGetTexLevelParameterivQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlExtGetTexLevelParameterivQCOM(d, obj.(*GlExtGetTexLevelParameterivQCOM))
}
func (c *binaryClassGlExtGetTexLevelParameterivQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlExtGetTexLevelParameterivQCOM]
}

type binaryClassGlExtGetTexSubImageQCOM struct{}

func (*GlExtGetTexSubImageQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetTexSubImageQCOM)(nil)
}
func doEncodeGlExtGetTexSubImageQCOM(e binary.Encoder, o *GlExtGetTexSubImageQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Xoffset))
	e.Int32(int32(o.Yoffset))
	e.Int32(int32(o.Zoffset))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
	e.Uint32(uint32(o.Format))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Texels)
}
func doDecodeGlExtGetTexSubImageQCOM(d binary.Decoder, o *GlExtGetTexSubImageQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Texels)
}
func doDecodeRawGlExtGetTexSubImageQCOM(d binary.Decoder, o *GlExtGetTexSubImageQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Texels)
}
func (*binaryClassGlExtGetTexSubImageQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlExtGetTexSubImageQCOM(e, obj.(*GlExtGetTexSubImageQCOM))
}
func (*binaryClassGlExtGetTexSubImageQCOM) New() binary.Object {
	return &GlExtGetTexSubImageQCOM{}
}
func (*binaryClassGlExtGetTexSubImageQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlExtGetTexSubImageQCOM(d, obj.(*GlExtGetTexSubImageQCOM))
}
func (c *binaryClassGlExtGetTexSubImageQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlExtGetTexSubImageQCOM]
}

type binaryClassTextureIdᵖ struct{}

func (*TextureIdᵖ) Class() binary.Class {
	return (*binaryClassTextureIdᵖ)(nil)
}
func doEncodeTextureIdᵖ(e binary.Writer, o *TextureIdᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeTextureIdᵖ(d binary.Reader, o *TextureIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawTextureIdᵖ(d binary.Reader, o *TextureIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassTextureIdᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTextureIdᵖ(e, obj.(*TextureIdᵖ))
}
func (*binaryClassTextureIdᵖ) New() binary.Object {
	return &TextureIdᵖ{}
}
func (*binaryClassTextureIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTextureIdᵖ(d, obj.(*TextureIdᵖ))
}
func (o *TextureIdᵖ) WriteSimple(w binary.Writer) {
	doEncodeTextureIdᵖ(w, o)
}
func (o *TextureIdᵖ) ReadSimple(r binary.Reader) {
	doDecodeTextureIdᵖ(r, o)
}
func (c *binaryClassTextureIdᵖ) Schema() *binary.Entity {
	return &entities[ixǁTextureIdᵖ]
}

type binaryClassGlExtGetTexturesQCOM struct{}

func (*GlExtGetTexturesQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetTexturesQCOM)(nil)
}
func doEncodeGlExtGetTexturesQCOM(e binary.Encoder, o *GlExtGetTexturesQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Textures)
	e.Int32(int32(o.MaxTextures))
	e.Simple(&o.NumTextures)
}
func doDecodeGlExtGetTexturesQCOM(d binary.Decoder, o *GlExtGetTexturesQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Textures)
	o.MaxTextures = GLint(d.Int32())
	d.Simple(&o.NumTextures)
}
func doDecodeRawGlExtGetTexturesQCOM(d binary.Decoder, o *GlExtGetTexturesQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Textures)
	o.MaxTextures = GLint(d.Int32())
	d.Simple(&o.NumTextures)
}
func (*binaryClassGlExtGetTexturesQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlExtGetTexturesQCOM(e, obj.(*GlExtGetTexturesQCOM))
}
func (*binaryClassGlExtGetTexturesQCOM) New() binary.Object {
	return &GlExtGetTexturesQCOM{}
}
func (*binaryClassGlExtGetTexturesQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlExtGetTexturesQCOM(d, obj.(*GlExtGetTexturesQCOM))
}
func (c *binaryClassGlExtGetTexturesQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlExtGetTexturesQCOM]
}

type binaryClassGlExtIsProgramBinaryQCOM struct{}

func (*GlExtIsProgramBinaryQCOM) Class() binary.Class {
	return (*binaryClassGlExtIsProgramBinaryQCOM)(nil)
}
func doEncodeGlExtIsProgramBinaryQCOM(e binary.Encoder, o *GlExtIsProgramBinaryQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlExtIsProgramBinaryQCOM(d binary.Decoder, o *GlExtIsProgramBinaryQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlExtIsProgramBinaryQCOM(d binary.Decoder, o *GlExtIsProgramBinaryQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlExtIsProgramBinaryQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlExtIsProgramBinaryQCOM(e, obj.(*GlExtIsProgramBinaryQCOM))
}
func (*binaryClassGlExtIsProgramBinaryQCOM) New() binary.Object {
	return &GlExtIsProgramBinaryQCOM{}
}
func (*binaryClassGlExtIsProgramBinaryQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlExtIsProgramBinaryQCOM(d, obj.(*GlExtIsProgramBinaryQCOM))
}
func (c *binaryClassGlExtIsProgramBinaryQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlExtIsProgramBinaryQCOM]
}

type binaryClassGlExtTexObjectStateOverrideiQCOM struct{}

func (*GlExtTexObjectStateOverrideiQCOM) Class() binary.Class {
	return (*binaryClassGlExtTexObjectStateOverrideiQCOM)(nil)
}
func doEncodeGlExtTexObjectStateOverrideiQCOM(e binary.Encoder, o *GlExtTexObjectStateOverrideiQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlExtTexObjectStateOverrideiQCOM(d binary.Decoder, o *GlExtTexObjectStateOverrideiQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLint(d.Int32())
}
func doDecodeRawGlExtTexObjectStateOverrideiQCOM(d binary.Decoder, o *GlExtTexObjectStateOverrideiQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLint(d.Int32())
}
func (*binaryClassGlExtTexObjectStateOverrideiQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlExtTexObjectStateOverrideiQCOM(e, obj.(*GlExtTexObjectStateOverrideiQCOM))
}
func (*binaryClassGlExtTexObjectStateOverrideiQCOM) New() binary.Object {
	return &GlExtTexObjectStateOverrideiQCOM{}
}
func (*binaryClassGlExtTexObjectStateOverrideiQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlExtTexObjectStateOverrideiQCOM(d, obj.(*GlExtTexObjectStateOverrideiQCOM))
}
func (c *binaryClassGlExtTexObjectStateOverrideiQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlExtTexObjectStateOverrideiQCOM]
}

type binaryClassGlFenceSync struct{}

func (*GlFenceSync) Class() binary.Class {
	return (*binaryClassGlFenceSync)(nil)
}
func doEncodeGlFenceSync(e binary.Encoder, o *GlFenceSync) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Condition))
	e.Uint32(uint32(o.SyncFlags))
	e.Simple(&o.Result)
}
func doDecodeGlFenceSync(d binary.Decoder, o *GlFenceSync) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Condition = GLenum(d.Uint32())
	o.SyncFlags = GLbitfield(d.Uint32())
	d.Simple(&o.Result)
}
func doDecodeRawGlFenceSync(d binary.Decoder, o *GlFenceSync) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Condition = GLenum(d.Uint32())
	o.SyncFlags = GLbitfield(d.Uint32())
	d.Simple(&o.Result)
}
func (*binaryClassGlFenceSync) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFenceSync(e, obj.(*GlFenceSync))
}
func (*binaryClassGlFenceSync) New() binary.Object {
	return &GlFenceSync{}
}
func (*binaryClassGlFenceSync) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFenceSync(d, obj.(*GlFenceSync))
}
func (c *binaryClassGlFenceSync) Schema() *binary.Entity {
	return &entities[ixǁGlFenceSync]
}

type binaryClassGlFenceSyncAPPLE struct{}

func (*GlFenceSyncAPPLE) Class() binary.Class {
	return (*binaryClassGlFenceSyncAPPLE)(nil)
}
func doEncodeGlFenceSyncAPPLE(e binary.Encoder, o *GlFenceSyncAPPLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Condition))
	e.Uint32(uint32(o.Flag))
	e.Simple(&o.Result)
}
func doDecodeGlFenceSyncAPPLE(d binary.Decoder, o *GlFenceSyncAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Condition = GLenum(d.Uint32())
	o.Flag = GLbitfield(d.Uint32())
	d.Simple(&o.Result)
}
func doDecodeRawGlFenceSyncAPPLE(d binary.Decoder, o *GlFenceSyncAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Condition = GLenum(d.Uint32())
	o.Flag = GLbitfield(d.Uint32())
	d.Simple(&o.Result)
}
func (*binaryClassGlFenceSyncAPPLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFenceSyncAPPLE(e, obj.(*GlFenceSyncAPPLE))
}
func (*binaryClassGlFenceSyncAPPLE) New() binary.Object {
	return &GlFenceSyncAPPLE{}
}
func (*binaryClassGlFenceSyncAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFenceSyncAPPLE(d, obj.(*GlFenceSyncAPPLE))
}
func (c *binaryClassGlFenceSyncAPPLE) Schema() *binary.Entity {
	return &entities[ixǁGlFenceSyncAPPLE]
}

type binaryClassGlFinish struct{}

func (*GlFinish) Class() binary.Class {
	return (*binaryClassGlFinish)(nil)
}
func doEncodeGlFinish(e binary.Encoder, o *GlFinish) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlFinish(d binary.Decoder, o *GlFinish) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlFinish(d binary.Decoder, o *GlFinish) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlFinish) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFinish(e, obj.(*GlFinish))
}
func (*binaryClassGlFinish) New() binary.Object {
	return &GlFinish{}
}
func (*binaryClassGlFinish) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFinish(d, obj.(*GlFinish))
}
func (c *binaryClassGlFinish) Schema() *binary.Entity {
	return &entities[ixǁGlFinish]
}

type binaryClassGlFinishFenceNV struct{}

func (*GlFinishFenceNV) Class() binary.Class {
	return (*binaryClassGlFinishFenceNV)(nil)
}
func doEncodeGlFinishFenceNV(e binary.Encoder, o *GlFinishFenceNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Fence))
}
func doDecodeGlFinishFenceNV(d binary.Decoder, o *GlFinishFenceNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Fence = GLuint(d.Uint32())
}
func doDecodeRawGlFinishFenceNV(d binary.Decoder, o *GlFinishFenceNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Fence = GLuint(d.Uint32())
}
func (*binaryClassGlFinishFenceNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFinishFenceNV(e, obj.(*GlFinishFenceNV))
}
func (*binaryClassGlFinishFenceNV) New() binary.Object {
	return &GlFinishFenceNV{}
}
func (*binaryClassGlFinishFenceNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFinishFenceNV(d, obj.(*GlFinishFenceNV))
}
func (c *binaryClassGlFinishFenceNV) Schema() *binary.Entity {
	return &entities[ixǁGlFinishFenceNV]
}

type binaryClassGlFlush struct{}

func (*GlFlush) Class() binary.Class {
	return (*binaryClassGlFlush)(nil)
}
func doEncodeGlFlush(e binary.Encoder, o *GlFlush) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlFlush(d binary.Decoder, o *GlFlush) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlFlush(d binary.Decoder, o *GlFlush) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlFlush) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFlush(e, obj.(*GlFlush))
}
func (*binaryClassGlFlush) New() binary.Object {
	return &GlFlush{}
}
func (*binaryClassGlFlush) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFlush(d, obj.(*GlFlush))
}
func (c *binaryClassGlFlush) Schema() *binary.Entity {
	return &entities[ixǁGlFlush]
}

type binaryClassGlFlushMappedBufferRange struct{}

func (*GlFlushMappedBufferRange) Class() binary.Class {
	return (*binaryClassGlFlushMappedBufferRange)(nil)
}
func doEncodeGlFlushMappedBufferRange(e binary.Encoder, o *GlFlushMappedBufferRange) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Offset))
	e.Int32(int32(o.Length))
}
func doDecodeGlFlushMappedBufferRange(d binary.Decoder, o *GlFlushMappedBufferRange) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Length = GLsizeiptr(d.Int32())
}
func doDecodeRawGlFlushMappedBufferRange(d binary.Decoder, o *GlFlushMappedBufferRange) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Length = GLsizeiptr(d.Int32())
}
func (*binaryClassGlFlushMappedBufferRange) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFlushMappedBufferRange(e, obj.(*GlFlushMappedBufferRange))
}
func (*binaryClassGlFlushMappedBufferRange) New() binary.Object {
	return &GlFlushMappedBufferRange{}
}
func (*binaryClassGlFlushMappedBufferRange) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFlushMappedBufferRange(d, obj.(*GlFlushMappedBufferRange))
}
func (c *binaryClassGlFlushMappedBufferRange) Schema() *binary.Entity {
	return &entities[ixǁGlFlushMappedBufferRange]
}

type binaryClassGlFlushMappedBufferRangeEXT struct{}

func (*GlFlushMappedBufferRangeEXT) Class() binary.Class {
	return (*binaryClassGlFlushMappedBufferRangeEXT)(nil)
}
func doEncodeGlFlushMappedBufferRangeEXT(e binary.Encoder, o *GlFlushMappedBufferRangeEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Offset))
	e.Int32(int32(o.Length))
}
func doDecodeGlFlushMappedBufferRangeEXT(d binary.Decoder, o *GlFlushMappedBufferRangeEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Length = GLsizeiptr(d.Int32())
}
func doDecodeRawGlFlushMappedBufferRangeEXT(d binary.Decoder, o *GlFlushMappedBufferRangeEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Length = GLsizeiptr(d.Int32())
}
func (*binaryClassGlFlushMappedBufferRangeEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFlushMappedBufferRangeEXT(e, obj.(*GlFlushMappedBufferRangeEXT))
}
func (*binaryClassGlFlushMappedBufferRangeEXT) New() binary.Object {
	return &GlFlushMappedBufferRangeEXT{}
}
func (*binaryClassGlFlushMappedBufferRangeEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFlushMappedBufferRangeEXT(d, obj.(*GlFlushMappedBufferRangeEXT))
}
func (c *binaryClassGlFlushMappedBufferRangeEXT) Schema() *binary.Entity {
	return &entities[ixǁGlFlushMappedBufferRangeEXT]
}

type binaryClassGlFogf struct{}

func (*GlFogf) Class() binary.Class {
	return (*binaryClassGlFogf)(nil)
}
func doEncodeGlFogf(e binary.Encoder, o *GlFogf) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Float32(float32(o.Param))
}
func doDecodeGlFogf(d binary.Decoder, o *GlFogf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func doDecodeRawGlFogf(d binary.Decoder, o *GlFogf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func (*binaryClassGlFogf) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFogf(e, obj.(*GlFogf))
}
func (*binaryClassGlFogf) New() binary.Object {
	return &GlFogf{}
}
func (*binaryClassGlFogf) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFogf(d, obj.(*GlFogf))
}
func (c *binaryClassGlFogf) Schema() *binary.Entity {
	return &entities[ixǁGlFogf]
}

type binaryClassGlFogfv struct{}

func (*GlFogfv) Class() binary.Class {
	return (*binaryClassGlFogfv)(nil)
}
func doEncodeGlFogfv(e binary.Encoder, o *GlFogfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlFogfv(d binary.Decoder, o *GlFogfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlFogfv(d binary.Decoder, o *GlFogfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlFogfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFogfv(e, obj.(*GlFogfv))
}
func (*binaryClassGlFogfv) New() binary.Object {
	return &GlFogfv{}
}
func (*binaryClassGlFogfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFogfv(d, obj.(*GlFogfv))
}
func (c *binaryClassGlFogfv) Schema() *binary.Entity {
	return &entities[ixǁGlFogfv]
}

type binaryClassGlFogx struct{}

func (*GlFogx) Class() binary.Class {
	return (*binaryClassGlFogx)(nil)
}
func doEncodeGlFogx(e binary.Encoder, o *GlFogx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlFogx(d binary.Decoder, o *GlFogx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlFogx(d binary.Decoder, o *GlFogx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlFogx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFogx(e, obj.(*GlFogx))
}
func (*binaryClassGlFogx) New() binary.Object {
	return &GlFogx{}
}
func (*binaryClassGlFogx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFogx(d, obj.(*GlFogx))
}
func (c *binaryClassGlFogx) Schema() *binary.Entity {
	return &entities[ixǁGlFogx]
}

type binaryClassGlFogxOES struct{}

func (*GlFogxOES) Class() binary.Class {
	return (*binaryClassGlFogxOES)(nil)
}
func doEncodeGlFogxOES(e binary.Encoder, o *GlFogxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlFogxOES(d binary.Decoder, o *GlFogxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlFogxOES(d binary.Decoder, o *GlFogxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlFogxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFogxOES(e, obj.(*GlFogxOES))
}
func (*binaryClassGlFogxOES) New() binary.Object {
	return &GlFogxOES{}
}
func (*binaryClassGlFogxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFogxOES(d, obj.(*GlFogxOES))
}
func (c *binaryClassGlFogxOES) Schema() *binary.Entity {
	return &entities[ixǁGlFogxOES]
}

type binaryClassGlFogxv struct{}

func (*GlFogxv) Class() binary.Class {
	return (*binaryClassGlFogxv)(nil)
}
func doEncodeGlFogxv(e binary.Encoder, o *GlFogxv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlFogxv(d binary.Decoder, o *GlFogxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlFogxv(d binary.Decoder, o *GlFogxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlFogxv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFogxv(e, obj.(*GlFogxv))
}
func (*binaryClassGlFogxv) New() binary.Object {
	return &GlFogxv{}
}
func (*binaryClassGlFogxv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFogxv(d, obj.(*GlFogxv))
}
func (c *binaryClassGlFogxv) Schema() *binary.Entity {
	return &entities[ixǁGlFogxv]
}

type binaryClassGlFogxvOES struct{}

func (*GlFogxvOES) Class() binary.Class {
	return (*binaryClassGlFogxvOES)(nil)
}
func doEncodeGlFogxvOES(e binary.Encoder, o *GlFogxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlFogxvOES(d binary.Decoder, o *GlFogxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlFogxvOES(d binary.Decoder, o *GlFogxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlFogxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFogxvOES(e, obj.(*GlFogxvOES))
}
func (*binaryClassGlFogxvOES) New() binary.Object {
	return &GlFogxvOES{}
}
func (*binaryClassGlFogxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFogxvOES(d, obj.(*GlFogxvOES))
}
func (c *binaryClassGlFogxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlFogxvOES]
}

type binaryClassGlFragmentCoverageColorNV struct{}

func (*GlFragmentCoverageColorNV) Class() binary.Class {
	return (*binaryClassGlFragmentCoverageColorNV)(nil)
}
func doEncodeGlFragmentCoverageColorNV(e binary.Encoder, o *GlFragmentCoverageColorNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Color))
}
func doDecodeGlFragmentCoverageColorNV(d binary.Decoder, o *GlFragmentCoverageColorNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Color = GLuint(d.Uint32())
}
func doDecodeRawGlFragmentCoverageColorNV(d binary.Decoder, o *GlFragmentCoverageColorNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Color = GLuint(d.Uint32())
}
func (*binaryClassGlFragmentCoverageColorNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFragmentCoverageColorNV(e, obj.(*GlFragmentCoverageColorNV))
}
func (*binaryClassGlFragmentCoverageColorNV) New() binary.Object {
	return &GlFragmentCoverageColorNV{}
}
func (*binaryClassGlFragmentCoverageColorNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFragmentCoverageColorNV(d, obj.(*GlFragmentCoverageColorNV))
}
func (c *binaryClassGlFragmentCoverageColorNV) Schema() *binary.Entity {
	return &entities[ixǁGlFragmentCoverageColorNV]
}

type binaryClassGlFramebufferParameteri struct{}

func (*GlFramebufferParameteri) Class() binary.Class {
	return (*binaryClassGlFramebufferParameteri)(nil)
}
func doEncodeGlFramebufferParameteri(e binary.Encoder, o *GlFramebufferParameteri) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlFramebufferParameteri(d binary.Decoder, o *GlFramebufferParameteri) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLint(d.Int32())
}
func doDecodeRawGlFramebufferParameteri(d binary.Decoder, o *GlFramebufferParameteri) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLint(d.Int32())
}
func (*binaryClassGlFramebufferParameteri) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferParameteri(e, obj.(*GlFramebufferParameteri))
}
func (*binaryClassGlFramebufferParameteri) New() binary.Object {
	return &GlFramebufferParameteri{}
}
func (*binaryClassGlFramebufferParameteri) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferParameteri(d, obj.(*GlFramebufferParameteri))
}
func (c *binaryClassGlFramebufferParameteri) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferParameteri]
}

type binaryClassGlFramebufferRenderbuffer struct{}

func (*GlFramebufferRenderbuffer) Class() binary.Class {
	return (*binaryClassGlFramebufferRenderbuffer)(nil)
}
func doEncodeGlFramebufferRenderbuffer(e binary.Encoder, o *GlFramebufferRenderbuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.FramebufferTarget))
	e.Uint32(uint32(o.FramebufferAttachment))
	e.Uint32(uint32(o.RenderbufferTarget))
	e.Uint32(uint32(o.Renderbuffer))
}
func doDecodeGlFramebufferRenderbuffer(d binary.Decoder, o *GlFramebufferRenderbuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FramebufferTarget = GLenum(d.Uint32())
	o.FramebufferAttachment = GLenum(d.Uint32())
	o.RenderbufferTarget = GLenum(d.Uint32())
	o.Renderbuffer = RenderbufferId(d.Uint32())
}
func doDecodeRawGlFramebufferRenderbuffer(d binary.Decoder, o *GlFramebufferRenderbuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FramebufferTarget = GLenum(d.Uint32())
	o.FramebufferAttachment = GLenum(d.Uint32())
	o.RenderbufferTarget = GLenum(d.Uint32())
	o.Renderbuffer = RenderbufferId(d.Uint32())
}
func (*binaryClassGlFramebufferRenderbuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferRenderbuffer(e, obj.(*GlFramebufferRenderbuffer))
}
func (*binaryClassGlFramebufferRenderbuffer) New() binary.Object {
	return &GlFramebufferRenderbuffer{}
}
func (*binaryClassGlFramebufferRenderbuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferRenderbuffer(d, obj.(*GlFramebufferRenderbuffer))
}
func (c *binaryClassGlFramebufferRenderbuffer) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferRenderbuffer]
}

type binaryClassGlFramebufferRenderbufferOES struct{}

func (*GlFramebufferRenderbufferOES) Class() binary.Class {
	return (*binaryClassGlFramebufferRenderbufferOES)(nil)
}
func doEncodeGlFramebufferRenderbufferOES(e binary.Encoder, o *GlFramebufferRenderbufferOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Attachment))
	e.Uint32(uint32(o.Renderbuffertarget))
	e.Uint32(uint32(o.Renderbuffer))
}
func doDecodeGlFramebufferRenderbufferOES(d binary.Decoder, o *GlFramebufferRenderbufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Renderbuffertarget = GLenum(d.Uint32())
	o.Renderbuffer = GLuint(d.Uint32())
}
func doDecodeRawGlFramebufferRenderbufferOES(d binary.Decoder, o *GlFramebufferRenderbufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Renderbuffertarget = GLenum(d.Uint32())
	o.Renderbuffer = GLuint(d.Uint32())
}
func (*binaryClassGlFramebufferRenderbufferOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferRenderbufferOES(e, obj.(*GlFramebufferRenderbufferOES))
}
func (*binaryClassGlFramebufferRenderbufferOES) New() binary.Object {
	return &GlFramebufferRenderbufferOES{}
}
func (*binaryClassGlFramebufferRenderbufferOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferRenderbufferOES(d, obj.(*GlFramebufferRenderbufferOES))
}
func (c *binaryClassGlFramebufferRenderbufferOES) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferRenderbufferOES]
}

type binaryClassGlFramebufferSampleLocationsfvNV struct{}

func (*GlFramebufferSampleLocationsfvNV) Class() binary.Class {
	return (*binaryClassGlFramebufferSampleLocationsfvNV)(nil)
}
func doEncodeGlFramebufferSampleLocationsfvNV(e binary.Encoder, o *GlFramebufferSampleLocationsfvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Start))
	e.Int32(int32(o.Count))
	e.Simple(&o.V)
}
func doDecodeGlFramebufferSampleLocationsfvNV(d binary.Decoder, o *GlFramebufferSampleLocationsfvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Start = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func doDecodeRawGlFramebufferSampleLocationsfvNV(d binary.Decoder, o *GlFramebufferSampleLocationsfvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Start = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func (*binaryClassGlFramebufferSampleLocationsfvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferSampleLocationsfvNV(e, obj.(*GlFramebufferSampleLocationsfvNV))
}
func (*binaryClassGlFramebufferSampleLocationsfvNV) New() binary.Object {
	return &GlFramebufferSampleLocationsfvNV{}
}
func (*binaryClassGlFramebufferSampleLocationsfvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferSampleLocationsfvNV(d, obj.(*GlFramebufferSampleLocationsfvNV))
}
func (c *binaryClassGlFramebufferSampleLocationsfvNV) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferSampleLocationsfvNV]
}

type binaryClassGlFramebufferTexture struct{}

func (*GlFramebufferTexture) Class() binary.Class {
	return (*binaryClassGlFramebufferTexture)(nil)
}
func doEncodeGlFramebufferTexture(e binary.Encoder, o *GlFramebufferTexture) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Attachment))
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.Level))
}
func doDecodeGlFramebufferTexture(d binary.Decoder, o *GlFramebufferTexture) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
}
func doDecodeRawGlFramebufferTexture(d binary.Decoder, o *GlFramebufferTexture) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
}
func (*binaryClassGlFramebufferTexture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferTexture(e, obj.(*GlFramebufferTexture))
}
func (*binaryClassGlFramebufferTexture) New() binary.Object {
	return &GlFramebufferTexture{}
}
func (*binaryClassGlFramebufferTexture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferTexture(d, obj.(*GlFramebufferTexture))
}
func (c *binaryClassGlFramebufferTexture) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferTexture]
}

type binaryClassGlFramebufferTexture2D struct{}

func (*GlFramebufferTexture2D) Class() binary.Class {
	return (*binaryClassGlFramebufferTexture2D)(nil)
}
func doEncodeGlFramebufferTexture2D(e binary.Encoder, o *GlFramebufferTexture2D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.FramebufferTarget))
	e.Uint32(uint32(o.FramebufferAttachment))
	e.Uint32(uint32(o.TextureTarget))
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.Level))
}
func doDecodeGlFramebufferTexture2D(d binary.Decoder, o *GlFramebufferTexture2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FramebufferTarget = GLenum(d.Uint32())
	o.FramebufferAttachment = GLenum(d.Uint32())
	o.TextureTarget = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
}
func doDecodeRawGlFramebufferTexture2D(d binary.Decoder, o *GlFramebufferTexture2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FramebufferTarget = GLenum(d.Uint32())
	o.FramebufferAttachment = GLenum(d.Uint32())
	o.TextureTarget = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
}
func (*binaryClassGlFramebufferTexture2D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferTexture2D(e, obj.(*GlFramebufferTexture2D))
}
func (*binaryClassGlFramebufferTexture2D) New() binary.Object {
	return &GlFramebufferTexture2D{}
}
func (*binaryClassGlFramebufferTexture2D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferTexture2D(d, obj.(*GlFramebufferTexture2D))
}
func (c *binaryClassGlFramebufferTexture2D) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferTexture2D]
}

type binaryClassGlFramebufferTexture2DMultisampleEXT struct{}

func (*GlFramebufferTexture2DMultisampleEXT) Class() binary.Class {
	return (*binaryClassGlFramebufferTexture2DMultisampleEXT)(nil)
}
func doEncodeGlFramebufferTexture2DMultisampleEXT(e binary.Encoder, o *GlFramebufferTexture2DMultisampleEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Attachment))
	e.Uint32(uint32(o.Textarget))
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Samples))
}
func doDecodeGlFramebufferTexture2DMultisampleEXT(d binary.Decoder, o *GlFramebufferTexture2DMultisampleEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Textarget = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Samples = GLsizei(d.Int32())
}
func doDecodeRawGlFramebufferTexture2DMultisampleEXT(d binary.Decoder, o *GlFramebufferTexture2DMultisampleEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Textarget = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Samples = GLsizei(d.Int32())
}
func (*binaryClassGlFramebufferTexture2DMultisampleEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferTexture2DMultisampleEXT(e, obj.(*GlFramebufferTexture2DMultisampleEXT))
}
func (*binaryClassGlFramebufferTexture2DMultisampleEXT) New() binary.Object {
	return &GlFramebufferTexture2DMultisampleEXT{}
}
func (*binaryClassGlFramebufferTexture2DMultisampleEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferTexture2DMultisampleEXT(d, obj.(*GlFramebufferTexture2DMultisampleEXT))
}
func (c *binaryClassGlFramebufferTexture2DMultisampleEXT) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferTexture2DMultisampleEXT]
}

type binaryClassGlFramebufferTexture2DMultisampleIMG struct{}

func (*GlFramebufferTexture2DMultisampleIMG) Class() binary.Class {
	return (*binaryClassGlFramebufferTexture2DMultisampleIMG)(nil)
}
func doEncodeGlFramebufferTexture2DMultisampleIMG(e binary.Encoder, o *GlFramebufferTexture2DMultisampleIMG) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Attachment))
	e.Uint32(uint32(o.Textarget))
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Samples))
}
func doDecodeGlFramebufferTexture2DMultisampleIMG(d binary.Decoder, o *GlFramebufferTexture2DMultisampleIMG) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Textarget = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Samples = GLsizei(d.Int32())
}
func doDecodeRawGlFramebufferTexture2DMultisampleIMG(d binary.Decoder, o *GlFramebufferTexture2DMultisampleIMG) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Textarget = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Samples = GLsizei(d.Int32())
}
func (*binaryClassGlFramebufferTexture2DMultisampleIMG) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferTexture2DMultisampleIMG(e, obj.(*GlFramebufferTexture2DMultisampleIMG))
}
func (*binaryClassGlFramebufferTexture2DMultisampleIMG) New() binary.Object {
	return &GlFramebufferTexture2DMultisampleIMG{}
}
func (*binaryClassGlFramebufferTexture2DMultisampleIMG) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferTexture2DMultisampleIMG(d, obj.(*GlFramebufferTexture2DMultisampleIMG))
}
func (c *binaryClassGlFramebufferTexture2DMultisampleIMG) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferTexture2DMultisampleIMG]
}

type binaryClassGlFramebufferTexture2DOES struct{}

func (*GlFramebufferTexture2DOES) Class() binary.Class {
	return (*binaryClassGlFramebufferTexture2DOES)(nil)
}
func doEncodeGlFramebufferTexture2DOES(e binary.Encoder, o *GlFramebufferTexture2DOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Attachment))
	e.Uint32(uint32(o.Textarget))
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.Level))
}
func doDecodeGlFramebufferTexture2DOES(d binary.Decoder, o *GlFramebufferTexture2DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Textarget = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
}
func doDecodeRawGlFramebufferTexture2DOES(d binary.Decoder, o *GlFramebufferTexture2DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Textarget = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
}
func (*binaryClassGlFramebufferTexture2DOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferTexture2DOES(e, obj.(*GlFramebufferTexture2DOES))
}
func (*binaryClassGlFramebufferTexture2DOES) New() binary.Object {
	return &GlFramebufferTexture2DOES{}
}
func (*binaryClassGlFramebufferTexture2DOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferTexture2DOES(d, obj.(*GlFramebufferTexture2DOES))
}
func (c *binaryClassGlFramebufferTexture2DOES) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferTexture2DOES]
}

type binaryClassGlFramebufferTexture3DOES struct{}

func (*GlFramebufferTexture3DOES) Class() binary.Class {
	return (*binaryClassGlFramebufferTexture3DOES)(nil)
}
func doEncodeGlFramebufferTexture3DOES(e binary.Encoder, o *GlFramebufferTexture3DOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Attachment))
	e.Uint32(uint32(o.Textarget))
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Zoffset))
}
func doDecodeGlFramebufferTexture3DOES(d binary.Decoder, o *GlFramebufferTexture3DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Textarget = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
}
func doDecodeRawGlFramebufferTexture3DOES(d binary.Decoder, o *GlFramebufferTexture3DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Textarget = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
}
func (*binaryClassGlFramebufferTexture3DOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferTexture3DOES(e, obj.(*GlFramebufferTexture3DOES))
}
func (*binaryClassGlFramebufferTexture3DOES) New() binary.Object {
	return &GlFramebufferTexture3DOES{}
}
func (*binaryClassGlFramebufferTexture3DOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferTexture3DOES(d, obj.(*GlFramebufferTexture3DOES))
}
func (c *binaryClassGlFramebufferTexture3DOES) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferTexture3DOES]
}

type binaryClassGlFramebufferTextureEXT struct{}

func (*GlFramebufferTextureEXT) Class() binary.Class {
	return (*binaryClassGlFramebufferTextureEXT)(nil)
}
func doEncodeGlFramebufferTextureEXT(e binary.Encoder, o *GlFramebufferTextureEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Attachment))
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.Level))
}
func doDecodeGlFramebufferTextureEXT(d binary.Decoder, o *GlFramebufferTextureEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
}
func doDecodeRawGlFramebufferTextureEXT(d binary.Decoder, o *GlFramebufferTextureEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
}
func (*binaryClassGlFramebufferTextureEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferTextureEXT(e, obj.(*GlFramebufferTextureEXT))
}
func (*binaryClassGlFramebufferTextureEXT) New() binary.Object {
	return &GlFramebufferTextureEXT{}
}
func (*binaryClassGlFramebufferTextureEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferTextureEXT(d, obj.(*GlFramebufferTextureEXT))
}
func (c *binaryClassGlFramebufferTextureEXT) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferTextureEXT]
}

type binaryClassGlFramebufferTextureLayer struct{}

func (*GlFramebufferTextureLayer) Class() binary.Class {
	return (*binaryClassGlFramebufferTextureLayer)(nil)
}
func doEncodeGlFramebufferTextureLayer(e binary.Encoder, o *GlFramebufferTextureLayer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Attachment))
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Layer))
}
func doDecodeGlFramebufferTextureLayer(d binary.Decoder, o *GlFramebufferTextureLayer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Layer = GLint(d.Int32())
}
func doDecodeRawGlFramebufferTextureLayer(d binary.Decoder, o *GlFramebufferTextureLayer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Layer = GLint(d.Int32())
}
func (*binaryClassGlFramebufferTextureLayer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferTextureLayer(e, obj.(*GlFramebufferTextureLayer))
}
func (*binaryClassGlFramebufferTextureLayer) New() binary.Object {
	return &GlFramebufferTextureLayer{}
}
func (*binaryClassGlFramebufferTextureLayer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferTextureLayer(d, obj.(*GlFramebufferTextureLayer))
}
func (c *binaryClassGlFramebufferTextureLayer) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferTextureLayer]
}

type binaryClassGlFramebufferTextureMultiviewOVR struct{}

func (*GlFramebufferTextureMultiviewOVR) Class() binary.Class {
	return (*binaryClassGlFramebufferTextureMultiviewOVR)(nil)
}
func doEncodeGlFramebufferTextureMultiviewOVR(e binary.Encoder, o *GlFramebufferTextureMultiviewOVR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Attachment))
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.BaseViewIndex))
	e.Int32(int32(o.NumViews))
}
func doDecodeGlFramebufferTextureMultiviewOVR(d binary.Decoder, o *GlFramebufferTextureMultiviewOVR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.BaseViewIndex = GLint(d.Int32())
	o.NumViews = GLsizei(d.Int32())
}
func doDecodeRawGlFramebufferTextureMultiviewOVR(d binary.Decoder, o *GlFramebufferTextureMultiviewOVR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.BaseViewIndex = GLint(d.Int32())
	o.NumViews = GLsizei(d.Int32())
}
func (*binaryClassGlFramebufferTextureMultiviewOVR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferTextureMultiviewOVR(e, obj.(*GlFramebufferTextureMultiviewOVR))
}
func (*binaryClassGlFramebufferTextureMultiviewOVR) New() binary.Object {
	return &GlFramebufferTextureMultiviewOVR{}
}
func (*binaryClassGlFramebufferTextureMultiviewOVR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferTextureMultiviewOVR(d, obj.(*GlFramebufferTextureMultiviewOVR))
}
func (c *binaryClassGlFramebufferTextureMultiviewOVR) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferTextureMultiviewOVR]
}

type binaryClassGlFramebufferTextureOES struct{}

func (*GlFramebufferTextureOES) Class() binary.Class {
	return (*binaryClassGlFramebufferTextureOES)(nil)
}
func doEncodeGlFramebufferTextureOES(e binary.Encoder, o *GlFramebufferTextureOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Attachment))
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.Level))
}
func doDecodeGlFramebufferTextureOES(d binary.Decoder, o *GlFramebufferTextureOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
}
func doDecodeRawGlFramebufferTextureOES(d binary.Decoder, o *GlFramebufferTextureOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
}
func (*binaryClassGlFramebufferTextureOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFramebufferTextureOES(e, obj.(*GlFramebufferTextureOES))
}
func (*binaryClassGlFramebufferTextureOES) New() binary.Object {
	return &GlFramebufferTextureOES{}
}
func (*binaryClassGlFramebufferTextureOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFramebufferTextureOES(d, obj.(*GlFramebufferTextureOES))
}
func (c *binaryClassGlFramebufferTextureOES) Schema() *binary.Entity {
	return &entities[ixǁGlFramebufferTextureOES]
}

type binaryClassGlFrontFace struct{}

func (*GlFrontFace) Class() binary.Class {
	return (*binaryClassGlFrontFace)(nil)
}
func doEncodeGlFrontFace(e binary.Encoder, o *GlFrontFace) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Orientation))
}
func doDecodeGlFrontFace(d binary.Decoder, o *GlFrontFace) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Orientation = GLenum(d.Uint32())
}
func doDecodeRawGlFrontFace(d binary.Decoder, o *GlFrontFace) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Orientation = GLenum(d.Uint32())
}
func (*binaryClassGlFrontFace) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFrontFace(e, obj.(*GlFrontFace))
}
func (*binaryClassGlFrontFace) New() binary.Object {
	return &GlFrontFace{}
}
func (*binaryClassGlFrontFace) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFrontFace(d, obj.(*GlFrontFace))
}
func (c *binaryClassGlFrontFace) Schema() *binary.Entity {
	return &entities[ixǁGlFrontFace]
}

type binaryClassGlFrustumf struct{}

func (*GlFrustumf) Class() binary.Class {
	return (*binaryClassGlFrustumf)(nil)
}
func doEncodeGlFrustumf(e binary.Encoder, o *GlFrustumf) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.L))
	e.Float32(float32(o.R))
	e.Float32(float32(o.B))
	e.Float32(float32(o.T))
	e.Float32(float32(o.N))
	e.Float32(float32(o.F))
}
func doDecodeGlFrustumf(d binary.Decoder, o *GlFrustumf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfloat(d.Float32())
	o.R = GLfloat(d.Float32())
	o.B = GLfloat(d.Float32())
	o.T = GLfloat(d.Float32())
	o.N = GLfloat(d.Float32())
	o.F = GLfloat(d.Float32())
}
func doDecodeRawGlFrustumf(d binary.Decoder, o *GlFrustumf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfloat(d.Float32())
	o.R = GLfloat(d.Float32())
	o.B = GLfloat(d.Float32())
	o.T = GLfloat(d.Float32())
	o.N = GLfloat(d.Float32())
	o.F = GLfloat(d.Float32())
}
func (*binaryClassGlFrustumf) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFrustumf(e, obj.(*GlFrustumf))
}
func (*binaryClassGlFrustumf) New() binary.Object {
	return &GlFrustumf{}
}
func (*binaryClassGlFrustumf) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFrustumf(d, obj.(*GlFrustumf))
}
func (c *binaryClassGlFrustumf) Schema() *binary.Entity {
	return &entities[ixǁGlFrustumf]
}

type binaryClassGlFrustumfOES struct{}

func (*GlFrustumfOES) Class() binary.Class {
	return (*binaryClassGlFrustumfOES)(nil)
}
func doEncodeGlFrustumfOES(e binary.Encoder, o *GlFrustumfOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.L))
	e.Float32(float32(o.R))
	e.Float32(float32(o.B))
	e.Float32(float32(o.T))
	e.Float32(float32(o.N))
	e.Float32(float32(o.F))
}
func doDecodeGlFrustumfOES(d binary.Decoder, o *GlFrustumfOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfloat(d.Float32())
	o.R = GLfloat(d.Float32())
	o.B = GLfloat(d.Float32())
	o.T = GLfloat(d.Float32())
	o.N = GLfloat(d.Float32())
	o.F = GLfloat(d.Float32())
}
func doDecodeRawGlFrustumfOES(d binary.Decoder, o *GlFrustumfOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfloat(d.Float32())
	o.R = GLfloat(d.Float32())
	o.B = GLfloat(d.Float32())
	o.T = GLfloat(d.Float32())
	o.N = GLfloat(d.Float32())
	o.F = GLfloat(d.Float32())
}
func (*binaryClassGlFrustumfOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFrustumfOES(e, obj.(*GlFrustumfOES))
}
func (*binaryClassGlFrustumfOES) New() binary.Object {
	return &GlFrustumfOES{}
}
func (*binaryClassGlFrustumfOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFrustumfOES(d, obj.(*GlFrustumfOES))
}
func (c *binaryClassGlFrustumfOES) Schema() *binary.Entity {
	return &entities[ixǁGlFrustumfOES]
}

type binaryClassGlFrustumx struct{}

func (*GlFrustumx) Class() binary.Class {
	return (*binaryClassGlFrustumx)(nil)
}
func doEncodeGlFrustumx(e binary.Encoder, o *GlFrustumx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.L))
	e.Int32(int32(o.R))
	e.Int32(int32(o.B))
	e.Int32(int32(o.T))
	e.Int32(int32(o.N))
	e.Int32(int32(o.F))
}
func doDecodeGlFrustumx(d binary.Decoder, o *GlFrustumx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfixed(d.Int32())
	o.R = GLfixed(d.Int32())
	o.B = GLfixed(d.Int32())
	o.T = GLfixed(d.Int32())
	o.N = GLfixed(d.Int32())
	o.F = GLfixed(d.Int32())
}
func doDecodeRawGlFrustumx(d binary.Decoder, o *GlFrustumx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfixed(d.Int32())
	o.R = GLfixed(d.Int32())
	o.B = GLfixed(d.Int32())
	o.T = GLfixed(d.Int32())
	o.N = GLfixed(d.Int32())
	o.F = GLfixed(d.Int32())
}
func (*binaryClassGlFrustumx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFrustumx(e, obj.(*GlFrustumx))
}
func (*binaryClassGlFrustumx) New() binary.Object {
	return &GlFrustumx{}
}
func (*binaryClassGlFrustumx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFrustumx(d, obj.(*GlFrustumx))
}
func (c *binaryClassGlFrustumx) Schema() *binary.Entity {
	return &entities[ixǁGlFrustumx]
}

type binaryClassGlFrustumxOES struct{}

func (*GlFrustumxOES) Class() binary.Class {
	return (*binaryClassGlFrustumxOES)(nil)
}
func doEncodeGlFrustumxOES(e binary.Encoder, o *GlFrustumxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.L))
	e.Int32(int32(o.R))
	e.Int32(int32(o.B))
	e.Int32(int32(o.T))
	e.Int32(int32(o.N))
	e.Int32(int32(o.F))
}
func doDecodeGlFrustumxOES(d binary.Decoder, o *GlFrustumxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfixed(d.Int32())
	o.R = GLfixed(d.Int32())
	o.B = GLfixed(d.Int32())
	o.T = GLfixed(d.Int32())
	o.N = GLfixed(d.Int32())
	o.F = GLfixed(d.Int32())
}
func doDecodeRawGlFrustumxOES(d binary.Decoder, o *GlFrustumxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfixed(d.Int32())
	o.R = GLfixed(d.Int32())
	o.B = GLfixed(d.Int32())
	o.T = GLfixed(d.Int32())
	o.N = GLfixed(d.Int32())
	o.F = GLfixed(d.Int32())
}
func (*binaryClassGlFrustumxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlFrustumxOES(e, obj.(*GlFrustumxOES))
}
func (*binaryClassGlFrustumxOES) New() binary.Object {
	return &GlFrustumxOES{}
}
func (*binaryClassGlFrustumxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlFrustumxOES(d, obj.(*GlFrustumxOES))
}
func (c *binaryClassGlFrustumxOES) Schema() *binary.Entity {
	return &entities[ixǁGlFrustumxOES]
}

type binaryClassGlGenBuffers struct{}

func (*GlGenBuffers) Class() binary.Class {
	return (*binaryClassGlGenBuffers)(nil)
}
func doEncodeGlGenBuffers(e binary.Encoder, o *GlGenBuffers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Buffers)
}
func doDecodeGlGenBuffers(d binary.Decoder, o *GlGenBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Buffers)
}
func doDecodeRawGlGenBuffers(d binary.Decoder, o *GlGenBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Buffers)
}
func (*binaryClassGlGenBuffers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenBuffers(e, obj.(*GlGenBuffers))
}
func (*binaryClassGlGenBuffers) New() binary.Object {
	return &GlGenBuffers{}
}
func (*binaryClassGlGenBuffers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenBuffers(d, obj.(*GlGenBuffers))
}
func (c *binaryClassGlGenBuffers) Schema() *binary.Entity {
	return &entities[ixǁGlGenBuffers]
}

type binaryClassGlGenFencesNV struct{}

func (*GlGenFencesNV) Class() binary.Class {
	return (*binaryClassGlGenFencesNV)(nil)
}
func doEncodeGlGenFencesNV(e binary.Encoder, o *GlGenFencesNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Fences)
}
func doDecodeGlGenFencesNV(d binary.Decoder, o *GlGenFencesNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Fences)
}
func doDecodeRawGlGenFencesNV(d binary.Decoder, o *GlGenFencesNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Fences)
}
func (*binaryClassGlGenFencesNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenFencesNV(e, obj.(*GlGenFencesNV))
}
func (*binaryClassGlGenFencesNV) New() binary.Object {
	return &GlGenFencesNV{}
}
func (*binaryClassGlGenFencesNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenFencesNV(d, obj.(*GlGenFencesNV))
}
func (c *binaryClassGlGenFencesNV) Schema() *binary.Entity {
	return &entities[ixǁGlGenFencesNV]
}

type binaryClassGlGenFramebuffers struct{}

func (*GlGenFramebuffers) Class() binary.Class {
	return (*binaryClassGlGenFramebuffers)(nil)
}
func doEncodeGlGenFramebuffers(e binary.Encoder, o *GlGenFramebuffers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Framebuffers)
}
func doDecodeGlGenFramebuffers(d binary.Decoder, o *GlGenFramebuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Framebuffers)
}
func doDecodeRawGlGenFramebuffers(d binary.Decoder, o *GlGenFramebuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Framebuffers)
}
func (*binaryClassGlGenFramebuffers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenFramebuffers(e, obj.(*GlGenFramebuffers))
}
func (*binaryClassGlGenFramebuffers) New() binary.Object {
	return &GlGenFramebuffers{}
}
func (*binaryClassGlGenFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenFramebuffers(d, obj.(*GlGenFramebuffers))
}
func (c *binaryClassGlGenFramebuffers) Schema() *binary.Entity {
	return &entities[ixǁGlGenFramebuffers]
}

type binaryClassGlGenFramebuffersOES struct{}

func (*GlGenFramebuffersOES) Class() binary.Class {
	return (*binaryClassGlGenFramebuffersOES)(nil)
}
func doEncodeGlGenFramebuffersOES(e binary.Encoder, o *GlGenFramebuffersOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Framebuffers)
}
func doDecodeGlGenFramebuffersOES(d binary.Decoder, o *GlGenFramebuffersOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Framebuffers)
}
func doDecodeRawGlGenFramebuffersOES(d binary.Decoder, o *GlGenFramebuffersOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Framebuffers)
}
func (*binaryClassGlGenFramebuffersOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenFramebuffersOES(e, obj.(*GlGenFramebuffersOES))
}
func (*binaryClassGlGenFramebuffersOES) New() binary.Object {
	return &GlGenFramebuffersOES{}
}
func (*binaryClassGlGenFramebuffersOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenFramebuffersOES(d, obj.(*GlGenFramebuffersOES))
}
func (c *binaryClassGlGenFramebuffersOES) Schema() *binary.Entity {
	return &entities[ixǁGlGenFramebuffersOES]
}

type binaryClassGlGenPathsNV struct{}

func (*GlGenPathsNV) Class() binary.Class {
	return (*binaryClassGlGenPathsNV)(nil)
}
func doEncodeGlGenPathsNV(e binary.Encoder, o *GlGenPathsNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Range))
	e.Uint32(uint32(o.Result))
}
func doDecodeGlGenPathsNV(d binary.Decoder, o *GlGenPathsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Range = GLsizei(d.Int32())
	o.Result = GLuint(d.Uint32())
}
func doDecodeRawGlGenPathsNV(d binary.Decoder, o *GlGenPathsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Range = GLsizei(d.Int32())
	o.Result = GLuint(d.Uint32())
}
func (*binaryClassGlGenPathsNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenPathsNV(e, obj.(*GlGenPathsNV))
}
func (*binaryClassGlGenPathsNV) New() binary.Object {
	return &GlGenPathsNV{}
}
func (*binaryClassGlGenPathsNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenPathsNV(d, obj.(*GlGenPathsNV))
}
func (c *binaryClassGlGenPathsNV) Schema() *binary.Entity {
	return &entities[ixǁGlGenPathsNV]
}

type binaryClassGlGenPerfMonitorsAMD struct{}

func (*GlGenPerfMonitorsAMD) Class() binary.Class {
	return (*binaryClassGlGenPerfMonitorsAMD)(nil)
}
func doEncodeGlGenPerfMonitorsAMD(e binary.Encoder, o *GlGenPerfMonitorsAMD) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Monitors)
}
func doDecodeGlGenPerfMonitorsAMD(d binary.Decoder, o *GlGenPerfMonitorsAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Monitors)
}
func doDecodeRawGlGenPerfMonitorsAMD(d binary.Decoder, o *GlGenPerfMonitorsAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Monitors)
}
func (*binaryClassGlGenPerfMonitorsAMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenPerfMonitorsAMD(e, obj.(*GlGenPerfMonitorsAMD))
}
func (*binaryClassGlGenPerfMonitorsAMD) New() binary.Object {
	return &GlGenPerfMonitorsAMD{}
}
func (*binaryClassGlGenPerfMonitorsAMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenPerfMonitorsAMD(d, obj.(*GlGenPerfMonitorsAMD))
}
func (c *binaryClassGlGenPerfMonitorsAMD) Schema() *binary.Entity {
	return &entities[ixǁGlGenPerfMonitorsAMD]
}

type binaryClassPipelineIdᵖ struct{}

func (*PipelineIdᵖ) Class() binary.Class {
	return (*binaryClassPipelineIdᵖ)(nil)
}
func doEncodePipelineIdᵖ(e binary.Writer, o *PipelineIdᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodePipelineIdᵖ(d binary.Reader, o *PipelineIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawPipelineIdᵖ(d binary.Reader, o *PipelineIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassPipelineIdᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodePipelineIdᵖ(e, obj.(*PipelineIdᵖ))
}
func (*binaryClassPipelineIdᵖ) New() binary.Object {
	return &PipelineIdᵖ{}
}
func (*binaryClassPipelineIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodePipelineIdᵖ(d, obj.(*PipelineIdᵖ))
}
func (o *PipelineIdᵖ) WriteSimple(w binary.Writer) {
	doEncodePipelineIdᵖ(w, o)
}
func (o *PipelineIdᵖ) ReadSimple(r binary.Reader) {
	doDecodePipelineIdᵖ(r, o)
}
func (c *binaryClassPipelineIdᵖ) Schema() *binary.Entity {
	return &entities[ixǁPipelineIdᵖ]
}

type binaryClassGlGenProgramPipelines struct{}

func (*GlGenProgramPipelines) Class() binary.Class {
	return (*binaryClassGlGenProgramPipelines)(nil)
}
func doEncodeGlGenProgramPipelines(e binary.Encoder, o *GlGenProgramPipelines) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Pipelines)
}
func doDecodeGlGenProgramPipelines(d binary.Decoder, o *GlGenProgramPipelines) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Pipelines)
}
func doDecodeRawGlGenProgramPipelines(d binary.Decoder, o *GlGenProgramPipelines) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Pipelines)
}
func (*binaryClassGlGenProgramPipelines) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenProgramPipelines(e, obj.(*GlGenProgramPipelines))
}
func (*binaryClassGlGenProgramPipelines) New() binary.Object {
	return &GlGenProgramPipelines{}
}
func (*binaryClassGlGenProgramPipelines) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenProgramPipelines(d, obj.(*GlGenProgramPipelines))
}
func (c *binaryClassGlGenProgramPipelines) Schema() *binary.Entity {
	return &entities[ixǁGlGenProgramPipelines]
}

type binaryClassGlGenProgramPipelinesEXT struct{}

func (*GlGenProgramPipelinesEXT) Class() binary.Class {
	return (*binaryClassGlGenProgramPipelinesEXT)(nil)
}
func doEncodeGlGenProgramPipelinesEXT(e binary.Encoder, o *GlGenProgramPipelinesEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Pipelines)
}
func doDecodeGlGenProgramPipelinesEXT(d binary.Decoder, o *GlGenProgramPipelinesEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Pipelines)
}
func doDecodeRawGlGenProgramPipelinesEXT(d binary.Decoder, o *GlGenProgramPipelinesEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Pipelines)
}
func (*binaryClassGlGenProgramPipelinesEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenProgramPipelinesEXT(e, obj.(*GlGenProgramPipelinesEXT))
}
func (*binaryClassGlGenProgramPipelinesEXT) New() binary.Object {
	return &GlGenProgramPipelinesEXT{}
}
func (*binaryClassGlGenProgramPipelinesEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenProgramPipelinesEXT(d, obj.(*GlGenProgramPipelinesEXT))
}
func (c *binaryClassGlGenProgramPipelinesEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGenProgramPipelinesEXT]
}

type binaryClassQueryIdᵖ struct{}

func (*QueryIdᵖ) Class() binary.Class {
	return (*binaryClassQueryIdᵖ)(nil)
}
func doEncodeQueryIdᵖ(e binary.Writer, o *QueryIdᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeQueryIdᵖ(d binary.Reader, o *QueryIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawQueryIdᵖ(d binary.Reader, o *QueryIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassQueryIdᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeQueryIdᵖ(e, obj.(*QueryIdᵖ))
}
func (*binaryClassQueryIdᵖ) New() binary.Object {
	return &QueryIdᵖ{}
}
func (*binaryClassQueryIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeQueryIdᵖ(d, obj.(*QueryIdᵖ))
}
func (o *QueryIdᵖ) WriteSimple(w binary.Writer) {
	doEncodeQueryIdᵖ(w, o)
}
func (o *QueryIdᵖ) ReadSimple(r binary.Reader) {
	doDecodeQueryIdᵖ(r, o)
}
func (c *binaryClassQueryIdᵖ) Schema() *binary.Entity {
	return &entities[ixǁQueryIdᵖ]
}

type binaryClassGlGenQueries struct{}

func (*GlGenQueries) Class() binary.Class {
	return (*binaryClassGlGenQueries)(nil)
}
func doEncodeGlGenQueries(e binary.Encoder, o *GlGenQueries) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Queries)
}
func doDecodeGlGenQueries(d binary.Decoder, o *GlGenQueries) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Queries)
}
func doDecodeRawGlGenQueries(d binary.Decoder, o *GlGenQueries) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Queries)
}
func (*binaryClassGlGenQueries) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenQueries(e, obj.(*GlGenQueries))
}
func (*binaryClassGlGenQueries) New() binary.Object {
	return &GlGenQueries{}
}
func (*binaryClassGlGenQueries) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenQueries(d, obj.(*GlGenQueries))
}
func (c *binaryClassGlGenQueries) Schema() *binary.Entity {
	return &entities[ixǁGlGenQueries]
}

type binaryClassGlGenQueriesEXT struct{}

func (*GlGenQueriesEXT) Class() binary.Class {
	return (*binaryClassGlGenQueriesEXT)(nil)
}
func doEncodeGlGenQueriesEXT(e binary.Encoder, o *GlGenQueriesEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Queries)
}
func doDecodeGlGenQueriesEXT(d binary.Decoder, o *GlGenQueriesEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Queries)
}
func doDecodeRawGlGenQueriesEXT(d binary.Decoder, o *GlGenQueriesEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Queries)
}
func (*binaryClassGlGenQueriesEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenQueriesEXT(e, obj.(*GlGenQueriesEXT))
}
func (*binaryClassGlGenQueriesEXT) New() binary.Object {
	return &GlGenQueriesEXT{}
}
func (*binaryClassGlGenQueriesEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenQueriesEXT(d, obj.(*GlGenQueriesEXT))
}
func (c *binaryClassGlGenQueriesEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGenQueriesEXT]
}

type binaryClassGlGenRenderbuffers struct{}

func (*GlGenRenderbuffers) Class() binary.Class {
	return (*binaryClassGlGenRenderbuffers)(nil)
}
func doEncodeGlGenRenderbuffers(e binary.Encoder, o *GlGenRenderbuffers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Renderbuffers)
}
func doDecodeGlGenRenderbuffers(d binary.Decoder, o *GlGenRenderbuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Renderbuffers)
}
func doDecodeRawGlGenRenderbuffers(d binary.Decoder, o *GlGenRenderbuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Renderbuffers)
}
func (*binaryClassGlGenRenderbuffers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenRenderbuffers(e, obj.(*GlGenRenderbuffers))
}
func (*binaryClassGlGenRenderbuffers) New() binary.Object {
	return &GlGenRenderbuffers{}
}
func (*binaryClassGlGenRenderbuffers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenRenderbuffers(d, obj.(*GlGenRenderbuffers))
}
func (c *binaryClassGlGenRenderbuffers) Schema() *binary.Entity {
	return &entities[ixǁGlGenRenderbuffers]
}

type binaryClassGlGenRenderbuffersOES struct{}

func (*GlGenRenderbuffersOES) Class() binary.Class {
	return (*binaryClassGlGenRenderbuffersOES)(nil)
}
func doEncodeGlGenRenderbuffersOES(e binary.Encoder, o *GlGenRenderbuffersOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Renderbuffers)
}
func doDecodeGlGenRenderbuffersOES(d binary.Decoder, o *GlGenRenderbuffersOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Renderbuffers)
}
func doDecodeRawGlGenRenderbuffersOES(d binary.Decoder, o *GlGenRenderbuffersOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Renderbuffers)
}
func (*binaryClassGlGenRenderbuffersOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenRenderbuffersOES(e, obj.(*GlGenRenderbuffersOES))
}
func (*binaryClassGlGenRenderbuffersOES) New() binary.Object {
	return &GlGenRenderbuffersOES{}
}
func (*binaryClassGlGenRenderbuffersOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenRenderbuffersOES(d, obj.(*GlGenRenderbuffersOES))
}
func (c *binaryClassGlGenRenderbuffersOES) Schema() *binary.Entity {
	return &entities[ixǁGlGenRenderbuffersOES]
}

type binaryClassSamplerIdᵖ struct{}

func (*SamplerIdᵖ) Class() binary.Class {
	return (*binaryClassSamplerIdᵖ)(nil)
}
func doEncodeSamplerIdᵖ(e binary.Writer, o *SamplerIdᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeSamplerIdᵖ(d binary.Reader, o *SamplerIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawSamplerIdᵖ(d binary.Reader, o *SamplerIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassSamplerIdᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeSamplerIdᵖ(e, obj.(*SamplerIdᵖ))
}
func (*binaryClassSamplerIdᵖ) New() binary.Object {
	return &SamplerIdᵖ{}
}
func (*binaryClassSamplerIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeSamplerIdᵖ(d, obj.(*SamplerIdᵖ))
}
func (o *SamplerIdᵖ) WriteSimple(w binary.Writer) {
	doEncodeSamplerIdᵖ(w, o)
}
func (o *SamplerIdᵖ) ReadSimple(r binary.Reader) {
	doDecodeSamplerIdᵖ(r, o)
}
func (c *binaryClassSamplerIdᵖ) Schema() *binary.Entity {
	return &entities[ixǁSamplerIdᵖ]
}

type binaryClassGlGenSamplers struct{}

func (*GlGenSamplers) Class() binary.Class {
	return (*binaryClassGlGenSamplers)(nil)
}
func doEncodeGlGenSamplers(e binary.Encoder, o *GlGenSamplers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Samplers)
}
func doDecodeGlGenSamplers(d binary.Decoder, o *GlGenSamplers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Samplers)
}
func doDecodeRawGlGenSamplers(d binary.Decoder, o *GlGenSamplers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Samplers)
}
func (*binaryClassGlGenSamplers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenSamplers(e, obj.(*GlGenSamplers))
}
func (*binaryClassGlGenSamplers) New() binary.Object {
	return &GlGenSamplers{}
}
func (*binaryClassGlGenSamplers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenSamplers(d, obj.(*GlGenSamplers))
}
func (c *binaryClassGlGenSamplers) Schema() *binary.Entity {
	return &entities[ixǁGlGenSamplers]
}

type binaryClassGlGenTextures struct{}

func (*GlGenTextures) Class() binary.Class {
	return (*binaryClassGlGenTextures)(nil)
}
func doEncodeGlGenTextures(e binary.Encoder, o *GlGenTextures) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Textures)
}
func doDecodeGlGenTextures(d binary.Decoder, o *GlGenTextures) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Textures)
}
func doDecodeRawGlGenTextures(d binary.Decoder, o *GlGenTextures) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Textures)
}
func (*binaryClassGlGenTextures) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenTextures(e, obj.(*GlGenTextures))
}
func (*binaryClassGlGenTextures) New() binary.Object {
	return &GlGenTextures{}
}
func (*binaryClassGlGenTextures) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenTextures(d, obj.(*GlGenTextures))
}
func (c *binaryClassGlGenTextures) Schema() *binary.Entity {
	return &entities[ixǁGlGenTextures]
}

type binaryClassTransformFeedbackIdᵖ struct{}

func (*TransformFeedbackIdᵖ) Class() binary.Class {
	return (*binaryClassTransformFeedbackIdᵖ)(nil)
}
func doEncodeTransformFeedbackIdᵖ(e binary.Writer, o *TransformFeedbackIdᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeTransformFeedbackIdᵖ(d binary.Reader, o *TransformFeedbackIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawTransformFeedbackIdᵖ(d binary.Reader, o *TransformFeedbackIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassTransformFeedbackIdᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTransformFeedbackIdᵖ(e, obj.(*TransformFeedbackIdᵖ))
}
func (*binaryClassTransformFeedbackIdᵖ) New() binary.Object {
	return &TransformFeedbackIdᵖ{}
}
func (*binaryClassTransformFeedbackIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTransformFeedbackIdᵖ(d, obj.(*TransformFeedbackIdᵖ))
}
func (o *TransformFeedbackIdᵖ) WriteSimple(w binary.Writer) {
	doEncodeTransformFeedbackIdᵖ(w, o)
}
func (o *TransformFeedbackIdᵖ) ReadSimple(r binary.Reader) {
	doDecodeTransformFeedbackIdᵖ(r, o)
}
func (c *binaryClassTransformFeedbackIdᵖ) Schema() *binary.Entity {
	return &entities[ixǁTransformFeedbackIdᵖ]
}

type binaryClassGlGenTransformFeedbacks struct{}

func (*GlGenTransformFeedbacks) Class() binary.Class {
	return (*binaryClassGlGenTransformFeedbacks)(nil)
}
func doEncodeGlGenTransformFeedbacks(e binary.Encoder, o *GlGenTransformFeedbacks) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.N))
	e.Simple(&o.Ids)
}
func doDecodeGlGenTransformFeedbacks(d binary.Decoder, o *GlGenTransformFeedbacks) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Ids)
}
func doDecodeRawGlGenTransformFeedbacks(d binary.Decoder, o *GlGenTransformFeedbacks) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.N = GLsizei(d.Int32())
	d.Simple(&o.Ids)
}
func (*binaryClassGlGenTransformFeedbacks) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenTransformFeedbacks(e, obj.(*GlGenTransformFeedbacks))
}
func (*binaryClassGlGenTransformFeedbacks) New() binary.Object {
	return &GlGenTransformFeedbacks{}
}
func (*binaryClassGlGenTransformFeedbacks) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenTransformFeedbacks(d, obj.(*GlGenTransformFeedbacks))
}
func (c *binaryClassGlGenTransformFeedbacks) Schema() *binary.Entity {
	return &entities[ixǁGlGenTransformFeedbacks]
}

type binaryClassVertexArrayIdᵖ struct{}

func (*VertexArrayIdᵖ) Class() binary.Class {
	return (*binaryClassVertexArrayIdᵖ)(nil)
}
func doEncodeVertexArrayIdᵖ(e binary.Writer, o *VertexArrayIdᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVertexArrayIdᵖ(d binary.Reader, o *VertexArrayIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVertexArrayIdᵖ(d binary.Reader, o *VertexArrayIdᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVertexArrayIdᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVertexArrayIdᵖ(e, obj.(*VertexArrayIdᵖ))
}
func (*binaryClassVertexArrayIdᵖ) New() binary.Object {
	return &VertexArrayIdᵖ{}
}
func (*binaryClassVertexArrayIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVertexArrayIdᵖ(d, obj.(*VertexArrayIdᵖ))
}
func (o *VertexArrayIdᵖ) WriteSimple(w binary.Writer) {
	doEncodeVertexArrayIdᵖ(w, o)
}
func (o *VertexArrayIdᵖ) ReadSimple(r binary.Reader) {
	doDecodeVertexArrayIdᵖ(r, o)
}
func (c *binaryClassVertexArrayIdᵖ) Schema() *binary.Entity {
	return &entities[ixǁVertexArrayIdᵖ]
}

type binaryClassGlGenVertexArrays struct{}

func (*GlGenVertexArrays) Class() binary.Class {
	return (*binaryClassGlGenVertexArrays)(nil)
}
func doEncodeGlGenVertexArrays(e binary.Encoder, o *GlGenVertexArrays) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Arrays)
}
func doDecodeGlGenVertexArrays(d binary.Decoder, o *GlGenVertexArrays) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Arrays)
}
func doDecodeRawGlGenVertexArrays(d binary.Decoder, o *GlGenVertexArrays) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Arrays)
}
func (*binaryClassGlGenVertexArrays) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenVertexArrays(e, obj.(*GlGenVertexArrays))
}
func (*binaryClassGlGenVertexArrays) New() binary.Object {
	return &GlGenVertexArrays{}
}
func (*binaryClassGlGenVertexArrays) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenVertexArrays(d, obj.(*GlGenVertexArrays))
}
func (c *binaryClassGlGenVertexArrays) Schema() *binary.Entity {
	return &entities[ixǁGlGenVertexArrays]
}

type binaryClassGlGenVertexArraysOES struct{}

func (*GlGenVertexArraysOES) Class() binary.Class {
	return (*binaryClassGlGenVertexArraysOES)(nil)
}
func doEncodeGlGenVertexArraysOES(e binary.Encoder, o *GlGenVertexArraysOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Arrays)
}
func doDecodeGlGenVertexArraysOES(d binary.Decoder, o *GlGenVertexArraysOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Arrays)
}
func doDecodeRawGlGenVertexArraysOES(d binary.Decoder, o *GlGenVertexArraysOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Arrays)
}
func (*binaryClassGlGenVertexArraysOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenVertexArraysOES(e, obj.(*GlGenVertexArraysOES))
}
func (*binaryClassGlGenVertexArraysOES) New() binary.Object {
	return &GlGenVertexArraysOES{}
}
func (*binaryClassGlGenVertexArraysOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenVertexArraysOES(d, obj.(*GlGenVertexArraysOES))
}
func (c *binaryClassGlGenVertexArraysOES) Schema() *binary.Entity {
	return &entities[ixǁGlGenVertexArraysOES]
}

type binaryClassGlGenerateMipmap struct{}

func (*GlGenerateMipmap) Class() binary.Class {
	return (*binaryClassGlGenerateMipmap)(nil)
}
func doEncodeGlGenerateMipmap(e binary.Encoder, o *GlGenerateMipmap) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
}
func doDecodeGlGenerateMipmap(d binary.Decoder, o *GlGenerateMipmap) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
}
func doDecodeRawGlGenerateMipmap(d binary.Decoder, o *GlGenerateMipmap) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
}
func (*binaryClassGlGenerateMipmap) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenerateMipmap(e, obj.(*GlGenerateMipmap))
}
func (*binaryClassGlGenerateMipmap) New() binary.Object {
	return &GlGenerateMipmap{}
}
func (*binaryClassGlGenerateMipmap) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenerateMipmap(d, obj.(*GlGenerateMipmap))
}
func (c *binaryClassGlGenerateMipmap) Schema() *binary.Entity {
	return &entities[ixǁGlGenerateMipmap]
}

type binaryClassGlGenerateMipmapOES struct{}

func (*GlGenerateMipmapOES) Class() binary.Class {
	return (*binaryClassGlGenerateMipmapOES)(nil)
}
func doEncodeGlGenerateMipmapOES(e binary.Encoder, o *GlGenerateMipmapOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
}
func doDecodeGlGenerateMipmapOES(d binary.Decoder, o *GlGenerateMipmapOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
}
func doDecodeRawGlGenerateMipmapOES(d binary.Decoder, o *GlGenerateMipmapOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
}
func (*binaryClassGlGenerateMipmapOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGenerateMipmapOES(e, obj.(*GlGenerateMipmapOES))
}
func (*binaryClassGlGenerateMipmapOES) New() binary.Object {
	return &GlGenerateMipmapOES{}
}
func (*binaryClassGlGenerateMipmapOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGenerateMipmapOES(d, obj.(*GlGenerateMipmapOES))
}
func (c *binaryClassGlGenerateMipmapOES) Schema() *binary.Entity {
	return &entities[ixǁGlGenerateMipmapOES]
}

type binaryClassGlGetActiveAttrib struct{}

func (*GlGetActiveAttrib) Class() binary.Class {
	return (*binaryClassGlGetActiveAttrib)(nil)
}
func doEncodeGlGetActiveAttrib(e binary.Encoder, o *GlGetActiveAttrib) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.Index))
	e.Int32(int32(o.BufferSize))
	e.Simple(&o.BufferBytesWritten)
	e.Simple(&o.VectorCount)
	e.Simple(&o.Type)
	e.Simple(&o.Name)
}
func doDecodeGlGetActiveAttrib(d binary.Decoder, o *GlGetActiveAttrib) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Index = AttributeIndex(d.Uint32())
	o.BufferSize = GLsizei(d.Int32())
	d.Simple(&o.BufferBytesWritten)
	d.Simple(&o.VectorCount)
	d.Simple(&o.Type)
	d.Simple(&o.Name)
}
func doDecodeRawGlGetActiveAttrib(d binary.Decoder, o *GlGetActiveAttrib) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Index = AttributeIndex(d.Uint32())
	o.BufferSize = GLsizei(d.Int32())
	d.Simple(&o.BufferBytesWritten)
	d.Simple(&o.VectorCount)
	d.Simple(&o.Type)
	d.Simple(&o.Name)
}
func (*binaryClassGlGetActiveAttrib) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetActiveAttrib(e, obj.(*GlGetActiveAttrib))
}
func (*binaryClassGlGetActiveAttrib) New() binary.Object {
	return &GlGetActiveAttrib{}
}
func (*binaryClassGlGetActiveAttrib) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetActiveAttrib(d, obj.(*GlGetActiveAttrib))
}
func (c *binaryClassGlGetActiveAttrib) Schema() *binary.Entity {
	return &entities[ixǁGlGetActiveAttrib]
}

type binaryClassGlGetActiveUniform struct{}

func (*GlGetActiveUniform) Class() binary.Class {
	return (*binaryClassGlGetActiveUniform)(nil)
}
func doEncodeGlGetActiveUniform(e binary.Encoder, o *GlGetActiveUniform) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.Index))
	e.Int32(int32(o.BufferSize))
	e.Simple(&o.BufferBytesWritten)
	e.Simple(&o.VectorCount)
	e.Simple(&o.Type)
	e.Simple(&o.Name)
}
func doDecodeGlGetActiveUniform(d binary.Decoder, o *GlGetActiveUniform) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Index = UniformIndex(d.Uint32())
	o.BufferSize = GLsizei(d.Int32())
	d.Simple(&o.BufferBytesWritten)
	d.Simple(&o.VectorCount)
	d.Simple(&o.Type)
	d.Simple(&o.Name)
}
func doDecodeRawGlGetActiveUniform(d binary.Decoder, o *GlGetActiveUniform) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Index = UniformIndex(d.Uint32())
	o.BufferSize = GLsizei(d.Int32())
	d.Simple(&o.BufferBytesWritten)
	d.Simple(&o.VectorCount)
	d.Simple(&o.Type)
	d.Simple(&o.Name)
}
func (*binaryClassGlGetActiveUniform) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetActiveUniform(e, obj.(*GlGetActiveUniform))
}
func (*binaryClassGlGetActiveUniform) New() binary.Object {
	return &GlGetActiveUniform{}
}
func (*binaryClassGlGetActiveUniform) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetActiveUniform(d, obj.(*GlGetActiveUniform))
}
func (c *binaryClassGlGetActiveUniform) Schema() *binary.Entity {
	return &entities[ixǁGlGetActiveUniform]
}

type binaryClassGlGetActiveUniformBlockName struct{}

func (*GlGetActiveUniformBlockName) Class() binary.Class {
	return (*binaryClassGlGetActiveUniformBlockName)(nil)
}
func doEncodeGlGetActiveUniformBlockName(e binary.Encoder, o *GlGetActiveUniformBlockName) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.UniformBlockIndex))
	e.Int32(int32(o.BufferSize))
	e.Simple(&o.BufferBytesWritten)
	e.Simple(&o.Name)
}
func doDecodeGlGetActiveUniformBlockName(d binary.Decoder, o *GlGetActiveUniformBlockName) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.UniformBlockIndex = UniformBlockId(d.Uint32())
	o.BufferSize = GLsizei(d.Int32())
	d.Simple(&o.BufferBytesWritten)
	d.Simple(&o.Name)
}
func doDecodeRawGlGetActiveUniformBlockName(d binary.Decoder, o *GlGetActiveUniformBlockName) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.UniformBlockIndex = UniformBlockId(d.Uint32())
	o.BufferSize = GLsizei(d.Int32())
	d.Simple(&o.BufferBytesWritten)
	d.Simple(&o.Name)
}
func (*binaryClassGlGetActiveUniformBlockName) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetActiveUniformBlockName(e, obj.(*GlGetActiveUniformBlockName))
}
func (*binaryClassGlGetActiveUniformBlockName) New() binary.Object {
	return &GlGetActiveUniformBlockName{}
}
func (*binaryClassGlGetActiveUniformBlockName) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetActiveUniformBlockName(d, obj.(*GlGetActiveUniformBlockName))
}
func (c *binaryClassGlGetActiveUniformBlockName) Schema() *binary.Entity {
	return &entities[ixǁGlGetActiveUniformBlockName]
}

type binaryClassGlGetActiveUniformBlockiv struct{}

func (*GlGetActiveUniformBlockiv) Class() binary.Class {
	return (*binaryClassGlGetActiveUniformBlockiv)(nil)
}
func doEncodeGlGetActiveUniformBlockiv(e binary.Encoder, o *GlGetActiveUniformBlockiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.UniformBlockIndex))
	e.Uint32(uint32(o.ParameterName))
	e.Simple(&o.Parameters)
}
func doDecodeGlGetActiveUniformBlockiv(d binary.Decoder, o *GlGetActiveUniformBlockiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.UniformBlockIndex = UniformBlockId(d.Uint32())
	o.ParameterName = GLenum(d.Uint32())
	d.Simple(&o.Parameters)
}
func doDecodeRawGlGetActiveUniformBlockiv(d binary.Decoder, o *GlGetActiveUniformBlockiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.UniformBlockIndex = UniformBlockId(d.Uint32())
	o.ParameterName = GLenum(d.Uint32())
	d.Simple(&o.Parameters)
}
func (*binaryClassGlGetActiveUniformBlockiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetActiveUniformBlockiv(e, obj.(*GlGetActiveUniformBlockiv))
}
func (*binaryClassGlGetActiveUniformBlockiv) New() binary.Object {
	return &GlGetActiveUniformBlockiv{}
}
func (*binaryClassGlGetActiveUniformBlockiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetActiveUniformBlockiv(d, obj.(*GlGetActiveUniformBlockiv))
}
func (c *binaryClassGlGetActiveUniformBlockiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetActiveUniformBlockiv]
}

type binaryClassUniformIndexᶜᵖ struct{}

func (*UniformIndexᶜᵖ) Class() binary.Class {
	return (*binaryClassUniformIndexᶜᵖ)(nil)
}
func doEncodeUniformIndexᶜᵖ(e binary.Writer, o *UniformIndexᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeUniformIndexᶜᵖ(d binary.Reader, o *UniformIndexᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawUniformIndexᶜᵖ(d binary.Reader, o *UniformIndexᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassUniformIndexᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeUniformIndexᶜᵖ(e, obj.(*UniformIndexᶜᵖ))
}
func (*binaryClassUniformIndexᶜᵖ) New() binary.Object {
	return &UniformIndexᶜᵖ{}
}
func (*binaryClassUniformIndexᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeUniformIndexᶜᵖ(d, obj.(*UniformIndexᶜᵖ))
}
func (o *UniformIndexᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeUniformIndexᶜᵖ(w, o)
}
func (o *UniformIndexᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeUniformIndexᶜᵖ(r, o)
}
func (c *binaryClassUniformIndexᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁUniformIndexᶜᵖ]
}

type binaryClassGlGetActiveUniformsiv struct{}

func (*GlGetActiveUniformsiv) Class() binary.Class {
	return (*binaryClassGlGetActiveUniformsiv)(nil)
}
func doEncodeGlGetActiveUniformsiv(e binary.Encoder, o *GlGetActiveUniformsiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.UniformCount))
	e.Simple(&o.UniformIndices)
	e.Uint32(uint32(o.ParameterName))
	e.Simple(&o.Parameters)
}
func doDecodeGlGetActiveUniformsiv(d binary.Decoder, o *GlGetActiveUniformsiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.UniformCount = GLsizei(d.Int32())
	d.Simple(&o.UniformIndices)
	o.ParameterName = GLenum(d.Uint32())
	d.Simple(&o.Parameters)
}
func doDecodeRawGlGetActiveUniformsiv(d binary.Decoder, o *GlGetActiveUniformsiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.UniformCount = GLsizei(d.Int32())
	d.Simple(&o.UniformIndices)
	o.ParameterName = GLenum(d.Uint32())
	d.Simple(&o.Parameters)
}
func (*binaryClassGlGetActiveUniformsiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetActiveUniformsiv(e, obj.(*GlGetActiveUniformsiv))
}
func (*binaryClassGlGetActiveUniformsiv) New() binary.Object {
	return &GlGetActiveUniformsiv{}
}
func (*binaryClassGlGetActiveUniformsiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetActiveUniformsiv(d, obj.(*GlGetActiveUniformsiv))
}
func (c *binaryClassGlGetActiveUniformsiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetActiveUniformsiv]
}

type binaryClassGlGetAttachedShaders struct{}

func (*GlGetAttachedShaders) Class() binary.Class {
	return (*binaryClassGlGetAttachedShaders)(nil)
}
func doEncodeGlGetAttachedShaders(e binary.Encoder, o *GlGetAttachedShaders) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.BufferLength))
	e.Simple(&o.ShadersLengthWritten)
	e.Simple(&o.Shaders)
}
func doDecodeGlGetAttachedShaders(d binary.Decoder, o *GlGetAttachedShaders) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.BufferLength = GLsizei(d.Int32())
	d.Simple(&o.ShadersLengthWritten)
	d.Simple(&o.Shaders)
}
func doDecodeRawGlGetAttachedShaders(d binary.Decoder, o *GlGetAttachedShaders) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.BufferLength = GLsizei(d.Int32())
	d.Simple(&o.ShadersLengthWritten)
	d.Simple(&o.Shaders)
}
func (*binaryClassGlGetAttachedShaders) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetAttachedShaders(e, obj.(*GlGetAttachedShaders))
}
func (*binaryClassGlGetAttachedShaders) New() binary.Object {
	return &GlGetAttachedShaders{}
}
func (*binaryClassGlGetAttachedShaders) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetAttachedShaders(d, obj.(*GlGetAttachedShaders))
}
func (c *binaryClassGlGetAttachedShaders) Schema() *binary.Entity {
	return &entities[ixǁGlGetAttachedShaders]
}

type binaryClassGlGetAttribLocation struct{}

func (*GlGetAttribLocation) Class() binary.Class {
	return (*binaryClassGlGetAttribLocation)(nil)
}
func doEncodeGlGetAttribLocation(e binary.Encoder, o *GlGetAttribLocation) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.String(o.Name)
	e.Int32(int32(o.Result))
}
func doDecodeGlGetAttribLocation(d binary.Decoder, o *GlGetAttribLocation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Name = string(d.String())
	o.Result = GLint(d.Int32())
}
func doDecodeRawGlGetAttribLocation(d binary.Decoder, o *GlGetAttribLocation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Name = string(d.String())
	o.Result = GLint(d.Int32())
}
func (*binaryClassGlGetAttribLocation) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetAttribLocation(e, obj.(*GlGetAttribLocation))
}
func (*binaryClassGlGetAttribLocation) New() binary.Object {
	return &GlGetAttribLocation{}
}
func (*binaryClassGlGetAttribLocation) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetAttribLocation(d, obj.(*GlGetAttribLocation))
}
func (c *binaryClassGlGetAttribLocation) Schema() *binary.Entity {
	return &entities[ixǁGlGetAttribLocation]
}

type binaryClassGlGetBooleani_v struct{}

func (*GlGetBooleani_v) Class() binary.Class {
	return (*binaryClassGlGetBooleani_v)(nil)
}
func doEncodeGlGetBooleani_v(e binary.Encoder, o *GlGetBooleani_v) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Param))
	e.Uint32(uint32(o.Index))
	e.Simple(&o.Values)
}
func doDecodeGlGetBooleani_v(d binary.Decoder, o *GlGetBooleani_v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetBooleani_v(d binary.Decoder, o *GlGetBooleani_v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetBooleani_v) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetBooleani_v(e, obj.(*GlGetBooleani_v))
}
func (*binaryClassGlGetBooleani_v) New() binary.Object {
	return &GlGetBooleani_v{}
}
func (*binaryClassGlGetBooleani_v) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetBooleani_v(d, obj.(*GlGetBooleani_v))
}
func (c *binaryClassGlGetBooleani_v) Schema() *binary.Entity {
	return &entities[ixǁGlGetBooleani_v]
}

type binaryClassGlGetBooleanv struct{}

func (*GlGetBooleanv) Class() binary.Class {
	return (*binaryClassGlGetBooleanv)(nil)
}
func doEncodeGlGetBooleanv(e binary.Encoder, o *GlGetBooleanv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Param))
	e.Simple(&o.Values)
}
func doDecodeGlGetBooleanv(d binary.Decoder, o *GlGetBooleanv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetBooleanv(d binary.Decoder, o *GlGetBooleanv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetBooleanv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetBooleanv(e, obj.(*GlGetBooleanv))
}
func (*binaryClassGlGetBooleanv) New() binary.Object {
	return &GlGetBooleanv{}
}
func (*binaryClassGlGetBooleanv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetBooleanv(d, obj.(*GlGetBooleanv))
}
func (c *binaryClassGlGetBooleanv) Schema() *binary.Entity {
	return &entities[ixǁGlGetBooleanv]
}

type binaryClassGlGetBufferParameteri64v struct{}

func (*GlGetBufferParameteri64v) Class() binary.Class {
	return (*binaryClassGlGetBufferParameteri64v)(nil)
}
func doEncodeGlGetBufferParameteri64v(e binary.Encoder, o *GlGetBufferParameteri64v) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetBufferParameteri64v(d binary.Decoder, o *GlGetBufferParameteri64v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetBufferParameteri64v(d binary.Decoder, o *GlGetBufferParameteri64v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetBufferParameteri64v) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetBufferParameteri64v(e, obj.(*GlGetBufferParameteri64v))
}
func (*binaryClassGlGetBufferParameteri64v) New() binary.Object {
	return &GlGetBufferParameteri64v{}
}
func (*binaryClassGlGetBufferParameteri64v) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetBufferParameteri64v(d, obj.(*GlGetBufferParameteri64v))
}
func (c *binaryClassGlGetBufferParameteri64v) Schema() *binary.Entity {
	return &entities[ixǁGlGetBufferParameteri64v]
}

type binaryClassGlGetBufferParameteriv struct{}

func (*GlGetBufferParameteriv) Class() binary.Class {
	return (*binaryClassGlGetBufferParameteriv)(nil)
}
func doEncodeGlGetBufferParameteriv(e binary.Encoder, o *GlGetBufferParameteriv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetBufferParameteriv(d binary.Decoder, o *GlGetBufferParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetBufferParameteriv(d binary.Decoder, o *GlGetBufferParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetBufferParameteriv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetBufferParameteriv(e, obj.(*GlGetBufferParameteriv))
}
func (*binaryClassGlGetBufferParameteriv) New() binary.Object {
	return &GlGetBufferParameteriv{}
}
func (*binaryClassGlGetBufferParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetBufferParameteriv(d, obj.(*GlGetBufferParameteriv))
}
func (c *binaryClassGlGetBufferParameteriv) Schema() *binary.Entity {
	return &entities[ixǁGlGetBufferParameteriv]
}

type binaryClassGlGetBufferPointerv struct{}

func (*GlGetBufferPointerv) Class() binary.Class {
	return (*binaryClassGlGetBufferPointerv)(nil)
}
func doEncodeGlGetBufferPointerv(e binary.Encoder, o *GlGetBufferPointerv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetBufferPointerv(d binary.Decoder, o *GlGetBufferPointerv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetBufferPointerv(d binary.Decoder, o *GlGetBufferPointerv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetBufferPointerv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetBufferPointerv(e, obj.(*GlGetBufferPointerv))
}
func (*binaryClassGlGetBufferPointerv) New() binary.Object {
	return &GlGetBufferPointerv{}
}
func (*binaryClassGlGetBufferPointerv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetBufferPointerv(d, obj.(*GlGetBufferPointerv))
}
func (c *binaryClassGlGetBufferPointerv) Schema() *binary.Entity {
	return &entities[ixǁGlGetBufferPointerv]
}

type binaryClassGlGetBufferPointervOES struct{}

func (*GlGetBufferPointervOES) Class() binary.Class {
	return (*binaryClassGlGetBufferPointervOES)(nil)
}
func doEncodeGlGetBufferPointervOES(e binary.Encoder, o *GlGetBufferPointervOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetBufferPointervOES(d binary.Decoder, o *GlGetBufferPointervOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetBufferPointervOES(d binary.Decoder, o *GlGetBufferPointervOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetBufferPointervOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetBufferPointervOES(e, obj.(*GlGetBufferPointervOES))
}
func (*binaryClassGlGetBufferPointervOES) New() binary.Object {
	return &GlGetBufferPointervOES{}
}
func (*binaryClassGlGetBufferPointervOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetBufferPointervOES(d, obj.(*GlGetBufferPointervOES))
}
func (c *binaryClassGlGetBufferPointervOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetBufferPointervOES]
}

type binaryClassGlGetClipPlanef struct{}

func (*GlGetClipPlanef) Class() binary.Class {
	return (*binaryClassGlGetClipPlanef)(nil)
}
func doEncodeGlGetClipPlanef(e binary.Encoder, o *GlGetClipPlanef) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Plane))
	e.Simple(&o.Equation)
}
func doDecodeGlGetClipPlanef(d binary.Decoder, o *GlGetClipPlanef) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func doDecodeRawGlGetClipPlanef(d binary.Decoder, o *GlGetClipPlanef) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func (*binaryClassGlGetClipPlanef) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetClipPlanef(e, obj.(*GlGetClipPlanef))
}
func (*binaryClassGlGetClipPlanef) New() binary.Object {
	return &GlGetClipPlanef{}
}
func (*binaryClassGlGetClipPlanef) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetClipPlanef(d, obj.(*GlGetClipPlanef))
}
func (c *binaryClassGlGetClipPlanef) Schema() *binary.Entity {
	return &entities[ixǁGlGetClipPlanef]
}

type binaryClassGlGetClipPlanefOES struct{}

func (*GlGetClipPlanefOES) Class() binary.Class {
	return (*binaryClassGlGetClipPlanefOES)(nil)
}
func doEncodeGlGetClipPlanefOES(e binary.Encoder, o *GlGetClipPlanefOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Plane))
	e.Simple(&o.Equation)
}
func doDecodeGlGetClipPlanefOES(d binary.Decoder, o *GlGetClipPlanefOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func doDecodeRawGlGetClipPlanefOES(d binary.Decoder, o *GlGetClipPlanefOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func (*binaryClassGlGetClipPlanefOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetClipPlanefOES(e, obj.(*GlGetClipPlanefOES))
}
func (*binaryClassGlGetClipPlanefOES) New() binary.Object {
	return &GlGetClipPlanefOES{}
}
func (*binaryClassGlGetClipPlanefOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetClipPlanefOES(d, obj.(*GlGetClipPlanefOES))
}
func (c *binaryClassGlGetClipPlanefOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetClipPlanefOES]
}

type binaryClassGlGetClipPlanex struct{}

func (*GlGetClipPlanex) Class() binary.Class {
	return (*binaryClassGlGetClipPlanex)(nil)
}
func doEncodeGlGetClipPlanex(e binary.Encoder, o *GlGetClipPlanex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Plane))
	e.Simple(&o.Equation)
}
func doDecodeGlGetClipPlanex(d binary.Decoder, o *GlGetClipPlanex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func doDecodeRawGlGetClipPlanex(d binary.Decoder, o *GlGetClipPlanex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func (*binaryClassGlGetClipPlanex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetClipPlanex(e, obj.(*GlGetClipPlanex))
}
func (*binaryClassGlGetClipPlanex) New() binary.Object {
	return &GlGetClipPlanex{}
}
func (*binaryClassGlGetClipPlanex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetClipPlanex(d, obj.(*GlGetClipPlanex))
}
func (c *binaryClassGlGetClipPlanex) Schema() *binary.Entity {
	return &entities[ixǁGlGetClipPlanex]
}

type binaryClassGlGetClipPlanexOES struct{}

func (*GlGetClipPlanexOES) Class() binary.Class {
	return (*binaryClassGlGetClipPlanexOES)(nil)
}
func doEncodeGlGetClipPlanexOES(e binary.Encoder, o *GlGetClipPlanexOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Plane))
	e.Simple(&o.Equation)
}
func doDecodeGlGetClipPlanexOES(d binary.Decoder, o *GlGetClipPlanexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func doDecodeRawGlGetClipPlanexOES(d binary.Decoder, o *GlGetClipPlanexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Plane = GLenum(d.Uint32())
	d.Simple(&o.Equation)
}
func (*binaryClassGlGetClipPlanexOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetClipPlanexOES(e, obj.(*GlGetClipPlanexOES))
}
func (*binaryClassGlGetClipPlanexOES) New() binary.Object {
	return &GlGetClipPlanexOES{}
}
func (*binaryClassGlGetClipPlanexOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetClipPlanexOES(d, obj.(*GlGetClipPlanexOES))
}
func (c *binaryClassGlGetClipPlanexOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetClipPlanexOES]
}

type binaryClassGlGetCoverageModulationTableNV struct{}

func (*GlGetCoverageModulationTableNV) Class() binary.Class {
	return (*binaryClassGlGetCoverageModulationTableNV)(nil)
}
func doEncodeGlGetCoverageModulationTableNV(e binary.Encoder, o *GlGetCoverageModulationTableNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Bufsize))
	e.Simple(&o.V)
}
func doDecodeGlGetCoverageModulationTableNV(d binary.Decoder, o *GlGetCoverageModulationTableNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Bufsize = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func doDecodeRawGlGetCoverageModulationTableNV(d binary.Decoder, o *GlGetCoverageModulationTableNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Bufsize = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func (*binaryClassGlGetCoverageModulationTableNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetCoverageModulationTableNV(e, obj.(*GlGetCoverageModulationTableNV))
}
func (*binaryClassGlGetCoverageModulationTableNV) New() binary.Object {
	return &GlGetCoverageModulationTableNV{}
}
func (*binaryClassGlGetCoverageModulationTableNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetCoverageModulationTableNV(d, obj.(*GlGetCoverageModulationTableNV))
}
func (c *binaryClassGlGetCoverageModulationTableNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetCoverageModulationTableNV]
}

type binaryClassGlGetDebugMessageLog struct{}

func (*GlGetDebugMessageLog) Class() binary.Class {
	return (*binaryClassGlGetDebugMessageLog)(nil)
}
func doEncodeGlGetDebugMessageLog(e binary.Encoder, o *GlGetDebugMessageLog) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Count))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Sources)
	e.Simple(&o.Types)
	e.Simple(&o.Ids)
	e.Simple(&o.Severities)
	e.Simple(&o.Lengths)
	e.Simple(&o.MessageLog)
	e.Uint32(uint32(o.Result))
}
func doDecodeGlGetDebugMessageLog(d binary.Decoder, o *GlGetDebugMessageLog) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Sources)
	d.Simple(&o.Types)
	d.Simple(&o.Ids)
	d.Simple(&o.Severities)
	d.Simple(&o.Lengths)
	d.Simple(&o.MessageLog)
	o.Result = GLuint(d.Uint32())
}
func doDecodeRawGlGetDebugMessageLog(d binary.Decoder, o *GlGetDebugMessageLog) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Sources)
	d.Simple(&o.Types)
	d.Simple(&o.Ids)
	d.Simple(&o.Severities)
	d.Simple(&o.Lengths)
	d.Simple(&o.MessageLog)
	o.Result = GLuint(d.Uint32())
}
func (*binaryClassGlGetDebugMessageLog) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetDebugMessageLog(e, obj.(*GlGetDebugMessageLog))
}
func (*binaryClassGlGetDebugMessageLog) New() binary.Object {
	return &GlGetDebugMessageLog{}
}
func (*binaryClassGlGetDebugMessageLog) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetDebugMessageLog(d, obj.(*GlGetDebugMessageLog))
}
func (c *binaryClassGlGetDebugMessageLog) Schema() *binary.Entity {
	return &entities[ixǁGlGetDebugMessageLog]
}

type binaryClassGlGetDebugMessageLogKHR struct{}

func (*GlGetDebugMessageLogKHR) Class() binary.Class {
	return (*binaryClassGlGetDebugMessageLogKHR)(nil)
}
func doEncodeGlGetDebugMessageLogKHR(e binary.Encoder, o *GlGetDebugMessageLogKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Count))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Sources)
	e.Simple(&o.Types)
	e.Simple(&o.Ids)
	e.Simple(&o.Severities)
	e.Simple(&o.Lengths)
	e.Simple(&o.MessageLog)
	e.Uint32(uint32(o.Result))
}
func doDecodeGlGetDebugMessageLogKHR(d binary.Decoder, o *GlGetDebugMessageLogKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Sources)
	d.Simple(&o.Types)
	d.Simple(&o.Ids)
	d.Simple(&o.Severities)
	d.Simple(&o.Lengths)
	d.Simple(&o.MessageLog)
	o.Result = GLuint(d.Uint32())
}
func doDecodeRawGlGetDebugMessageLogKHR(d binary.Decoder, o *GlGetDebugMessageLogKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Sources)
	d.Simple(&o.Types)
	d.Simple(&o.Ids)
	d.Simple(&o.Severities)
	d.Simple(&o.Lengths)
	d.Simple(&o.MessageLog)
	o.Result = GLuint(d.Uint32())
}
func (*binaryClassGlGetDebugMessageLogKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetDebugMessageLogKHR(e, obj.(*GlGetDebugMessageLogKHR))
}
func (*binaryClassGlGetDebugMessageLogKHR) New() binary.Object {
	return &GlGetDebugMessageLogKHR{}
}
func (*binaryClassGlGetDebugMessageLogKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetDebugMessageLogKHR(d, obj.(*GlGetDebugMessageLogKHR))
}
func (c *binaryClassGlGetDebugMessageLogKHR) Schema() *binary.Entity {
	return &entities[ixǁGlGetDebugMessageLogKHR]
}

type binaryClassGlGetDriverControlStringQCOM struct{}

func (*GlGetDriverControlStringQCOM) Class() binary.Class {
	return (*binaryClassGlGetDriverControlStringQCOM)(nil)
}
func doEncodeGlGetDriverControlStringQCOM(e binary.Encoder, o *GlGetDriverControlStringQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.DriverControl))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.DriverControlString)
}
func doDecodeGlGetDriverControlStringQCOM(d binary.Decoder, o *GlGetDriverControlStringQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DriverControl = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.DriverControlString)
}
func doDecodeRawGlGetDriverControlStringQCOM(d binary.Decoder, o *GlGetDriverControlStringQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.DriverControl = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.DriverControlString)
}
func (*binaryClassGlGetDriverControlStringQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetDriverControlStringQCOM(e, obj.(*GlGetDriverControlStringQCOM))
}
func (*binaryClassGlGetDriverControlStringQCOM) New() binary.Object {
	return &GlGetDriverControlStringQCOM{}
}
func (*binaryClassGlGetDriverControlStringQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetDriverControlStringQCOM(d, obj.(*GlGetDriverControlStringQCOM))
}
func (c *binaryClassGlGetDriverControlStringQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlGetDriverControlStringQCOM]
}

type binaryClassGlGetDriverControlsQCOM struct{}

func (*GlGetDriverControlsQCOM) Class() binary.Class {
	return (*binaryClassGlGetDriverControlsQCOM)(nil)
}
func doEncodeGlGetDriverControlsQCOM(e binary.Encoder, o *GlGetDriverControlsQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Num)
	e.Int32(int32(o.Size))
	e.Simple(&o.DriverControls)
}
func doDecodeGlGetDriverControlsQCOM(d binary.Decoder, o *GlGetDriverControlsQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Num)
	o.Size = GLsizei(d.Int32())
	d.Simple(&o.DriverControls)
}
func doDecodeRawGlGetDriverControlsQCOM(d binary.Decoder, o *GlGetDriverControlsQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Num)
	o.Size = GLsizei(d.Int32())
	d.Simple(&o.DriverControls)
}
func (*binaryClassGlGetDriverControlsQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetDriverControlsQCOM(e, obj.(*GlGetDriverControlsQCOM))
}
func (*binaryClassGlGetDriverControlsQCOM) New() binary.Object {
	return &GlGetDriverControlsQCOM{}
}
func (*binaryClassGlGetDriverControlsQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetDriverControlsQCOM(d, obj.(*GlGetDriverControlsQCOM))
}
func (c *binaryClassGlGetDriverControlsQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlGetDriverControlsQCOM]
}

type binaryClassGlGetError struct{}

func (*GlGetError) Class() binary.Class {
	return (*binaryClassGlGetError)(nil)
}
func doEncodeGlGetError(e binary.Encoder, o *GlGetError) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Result))
}
func doDecodeGlGetError(d binary.Decoder, o *GlGetError) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = GLenum(d.Uint32())
}
func doDecodeRawGlGetError(d binary.Decoder, o *GlGetError) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = GLenum(d.Uint32())
}
func (*binaryClassGlGetError) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetError(e, obj.(*GlGetError))
}
func (*binaryClassGlGetError) New() binary.Object {
	return &GlGetError{}
}
func (*binaryClassGlGetError) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetError(d, obj.(*GlGetError))
}
func (c *binaryClassGlGetError) Schema() *binary.Entity {
	return &entities[ixǁGlGetError]
}

type binaryClassGlGetFenceivNV struct{}

func (*GlGetFenceivNV) Class() binary.Class {
	return (*binaryClassGlGetFenceivNV)(nil)
}
func doEncodeGlGetFenceivNV(e binary.Encoder, o *GlGetFenceivNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Fence))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetFenceivNV(d binary.Decoder, o *GlGetFenceivNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Fence = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetFenceivNV(d binary.Decoder, o *GlGetFenceivNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Fence = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetFenceivNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetFenceivNV(e, obj.(*GlGetFenceivNV))
}
func (*binaryClassGlGetFenceivNV) New() binary.Object {
	return &GlGetFenceivNV{}
}
func (*binaryClassGlGetFenceivNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetFenceivNV(d, obj.(*GlGetFenceivNV))
}
func (c *binaryClassGlGetFenceivNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetFenceivNV]
}

type binaryClassGlGetFirstPerfQueryIdINTEL struct{}

func (*GlGetFirstPerfQueryIdINTEL) Class() binary.Class {
	return (*binaryClassGlGetFirstPerfQueryIdINTEL)(nil)
}
func doEncodeGlGetFirstPerfQueryIdINTEL(e binary.Encoder, o *GlGetFirstPerfQueryIdINTEL) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.QueryId)
}
func doDecodeGlGetFirstPerfQueryIdINTEL(d binary.Decoder, o *GlGetFirstPerfQueryIdINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.QueryId)
}
func doDecodeRawGlGetFirstPerfQueryIdINTEL(d binary.Decoder, o *GlGetFirstPerfQueryIdINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.QueryId)
}
func (*binaryClassGlGetFirstPerfQueryIdINTEL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetFirstPerfQueryIdINTEL(e, obj.(*GlGetFirstPerfQueryIdINTEL))
}
func (*binaryClassGlGetFirstPerfQueryIdINTEL) New() binary.Object {
	return &GlGetFirstPerfQueryIdINTEL{}
}
func (*binaryClassGlGetFirstPerfQueryIdINTEL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetFirstPerfQueryIdINTEL(d, obj.(*GlGetFirstPerfQueryIdINTEL))
}
func (c *binaryClassGlGetFirstPerfQueryIdINTEL) Schema() *binary.Entity {
	return &entities[ixǁGlGetFirstPerfQueryIdINTEL]
}

type binaryClassGlGetFixedv struct{}

func (*GlGetFixedv) Class() binary.Class {
	return (*binaryClassGlGetFixedv)(nil)
}
func doEncodeGlGetFixedv(e binary.Encoder, o *GlGetFixedv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetFixedv(d binary.Decoder, o *GlGetFixedv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetFixedv(d binary.Decoder, o *GlGetFixedv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetFixedv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetFixedv(e, obj.(*GlGetFixedv))
}
func (*binaryClassGlGetFixedv) New() binary.Object {
	return &GlGetFixedv{}
}
func (*binaryClassGlGetFixedv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetFixedv(d, obj.(*GlGetFixedv))
}
func (c *binaryClassGlGetFixedv) Schema() *binary.Entity {
	return &entities[ixǁGlGetFixedv]
}

type binaryClassGlGetFixedvOES struct{}

func (*GlGetFixedvOES) Class() binary.Class {
	return (*binaryClassGlGetFixedvOES)(nil)
}
func doEncodeGlGetFixedvOES(e binary.Encoder, o *GlGetFixedvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetFixedvOES(d binary.Decoder, o *GlGetFixedvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetFixedvOES(d binary.Decoder, o *GlGetFixedvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetFixedvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetFixedvOES(e, obj.(*GlGetFixedvOES))
}
func (*binaryClassGlGetFixedvOES) New() binary.Object {
	return &GlGetFixedvOES{}
}
func (*binaryClassGlGetFixedvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetFixedvOES(d, obj.(*GlGetFixedvOES))
}
func (c *binaryClassGlGetFixedvOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetFixedvOES]
}

type binaryClassGlGetFloati_vNV struct{}

func (*GlGetFloati_vNV) Class() binary.Class {
	return (*binaryClassGlGetFloati_vNV)(nil)
}
func doEncodeGlGetFloati_vNV(e binary.Encoder, o *GlGetFloati_vNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
	e.Simple(&o.Data)
}
func doDecodeGlGetFloati_vNV(d binary.Decoder, o *GlGetFloati_vNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Data)
}
func doDecodeRawGlGetFloati_vNV(d binary.Decoder, o *GlGetFloati_vNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Data)
}
func (*binaryClassGlGetFloati_vNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetFloati_vNV(e, obj.(*GlGetFloati_vNV))
}
func (*binaryClassGlGetFloati_vNV) New() binary.Object {
	return &GlGetFloati_vNV{}
}
func (*binaryClassGlGetFloati_vNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetFloati_vNV(d, obj.(*GlGetFloati_vNV))
}
func (c *binaryClassGlGetFloati_vNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetFloati_vNV]
}

type binaryClassGlGetFloatv struct{}

func (*GlGetFloatv) Class() binary.Class {
	return (*binaryClassGlGetFloatv)(nil)
}
func doEncodeGlGetFloatv(e binary.Encoder, o *GlGetFloatv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Param))
	e.Simple(&o.Values)
}
func doDecodeGlGetFloatv(d binary.Decoder, o *GlGetFloatv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetFloatv(d binary.Decoder, o *GlGetFloatv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetFloatv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetFloatv(e, obj.(*GlGetFloatv))
}
func (*binaryClassGlGetFloatv) New() binary.Object {
	return &GlGetFloatv{}
}
func (*binaryClassGlGetFloatv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetFloatv(d, obj.(*GlGetFloatv))
}
func (c *binaryClassGlGetFloatv) Schema() *binary.Entity {
	return &entities[ixǁGlGetFloatv]
}

type binaryClassGlGetFragDataIndexEXT struct{}

func (*GlGetFragDataIndexEXT) Class() binary.Class {
	return (*binaryClassGlGetFragDataIndexEXT)(nil)
}
func doEncodeGlGetFragDataIndexEXT(e binary.Encoder, o *GlGetFragDataIndexEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.String(o.Name)
	e.Int32(int32(o.Result))
}
func doDecodeGlGetFragDataIndexEXT(d binary.Decoder, o *GlGetFragDataIndexEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Name = string(d.String())
	o.Result = GLint(d.Int32())
}
func doDecodeRawGlGetFragDataIndexEXT(d binary.Decoder, o *GlGetFragDataIndexEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Name = string(d.String())
	o.Result = GLint(d.Int32())
}
func (*binaryClassGlGetFragDataIndexEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetFragDataIndexEXT(e, obj.(*GlGetFragDataIndexEXT))
}
func (*binaryClassGlGetFragDataIndexEXT) New() binary.Object {
	return &GlGetFragDataIndexEXT{}
}
func (*binaryClassGlGetFragDataIndexEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetFragDataIndexEXT(d, obj.(*GlGetFragDataIndexEXT))
}
func (c *binaryClassGlGetFragDataIndexEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetFragDataIndexEXT]
}

type binaryClassGlGetFragDataLocation struct{}

func (*GlGetFragDataLocation) Class() binary.Class {
	return (*binaryClassGlGetFragDataLocation)(nil)
}
func doEncodeGlGetFragDataLocation(e binary.Encoder, o *GlGetFragDataLocation) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.String(o.Name)
	e.Int32(int32(o.Result))
}
func doDecodeGlGetFragDataLocation(d binary.Decoder, o *GlGetFragDataLocation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Name = string(d.String())
	o.Result = GLint(d.Int32())
}
func doDecodeRawGlGetFragDataLocation(d binary.Decoder, o *GlGetFragDataLocation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Name = string(d.String())
	o.Result = GLint(d.Int32())
}
func (*binaryClassGlGetFragDataLocation) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetFragDataLocation(e, obj.(*GlGetFragDataLocation))
}
func (*binaryClassGlGetFragDataLocation) New() binary.Object {
	return &GlGetFragDataLocation{}
}
func (*binaryClassGlGetFragDataLocation) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetFragDataLocation(d, obj.(*GlGetFragDataLocation))
}
func (c *binaryClassGlGetFragDataLocation) Schema() *binary.Entity {
	return &entities[ixǁGlGetFragDataLocation]
}

type binaryClassGlGetFramebufferAttachmentParameteriv struct{}

func (*GlGetFramebufferAttachmentParameteriv) Class() binary.Class {
	return (*binaryClassGlGetFramebufferAttachmentParameteriv)(nil)
}
func doEncodeGlGetFramebufferAttachmentParameteriv(e binary.Encoder, o *GlGetFramebufferAttachmentParameteriv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.FramebufferTarget))
	e.Uint32(uint32(o.Attachment))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetFramebufferAttachmentParameteriv(d binary.Decoder, o *GlGetFramebufferAttachmentParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FramebufferTarget = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetFramebufferAttachmentParameteriv(d binary.Decoder, o *GlGetFramebufferAttachmentParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FramebufferTarget = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetFramebufferAttachmentParameteriv(e, obj.(*GlGetFramebufferAttachmentParameteriv))
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) New() binary.Object {
	return &GlGetFramebufferAttachmentParameteriv{}
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetFramebufferAttachmentParameteriv(d, obj.(*GlGetFramebufferAttachmentParameteriv))
}
func (c *binaryClassGlGetFramebufferAttachmentParameteriv) Schema() *binary.Entity {
	return &entities[ixǁGlGetFramebufferAttachmentParameteriv]
}

type binaryClassGlGetFramebufferAttachmentParameterivOES struct{}

func (*GlGetFramebufferAttachmentParameterivOES) Class() binary.Class {
	return (*binaryClassGlGetFramebufferAttachmentParameterivOES)(nil)
}
func doEncodeGlGetFramebufferAttachmentParameterivOES(e binary.Encoder, o *GlGetFramebufferAttachmentParameterivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Attachment))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetFramebufferAttachmentParameterivOES(d binary.Decoder, o *GlGetFramebufferAttachmentParameterivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetFramebufferAttachmentParameterivOES(d binary.Decoder, o *GlGetFramebufferAttachmentParameterivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Attachment = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetFramebufferAttachmentParameterivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetFramebufferAttachmentParameterivOES(e, obj.(*GlGetFramebufferAttachmentParameterivOES))
}
func (*binaryClassGlGetFramebufferAttachmentParameterivOES) New() binary.Object {
	return &GlGetFramebufferAttachmentParameterivOES{}
}
func (*binaryClassGlGetFramebufferAttachmentParameterivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetFramebufferAttachmentParameterivOES(d, obj.(*GlGetFramebufferAttachmentParameterivOES))
}
func (c *binaryClassGlGetFramebufferAttachmentParameterivOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetFramebufferAttachmentParameterivOES]
}

type binaryClassGlGetFramebufferParameteriv struct{}

func (*GlGetFramebufferParameteriv) Class() binary.Class {
	return (*binaryClassGlGetFramebufferParameteriv)(nil)
}
func doEncodeGlGetFramebufferParameteriv(e binary.Encoder, o *GlGetFramebufferParameteriv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetFramebufferParameteriv(d binary.Decoder, o *GlGetFramebufferParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetFramebufferParameteriv(d binary.Decoder, o *GlGetFramebufferParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetFramebufferParameteriv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetFramebufferParameteriv(e, obj.(*GlGetFramebufferParameteriv))
}
func (*binaryClassGlGetFramebufferParameteriv) New() binary.Object {
	return &GlGetFramebufferParameteriv{}
}
func (*binaryClassGlGetFramebufferParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetFramebufferParameteriv(d, obj.(*GlGetFramebufferParameteriv))
}
func (c *binaryClassGlGetFramebufferParameteriv) Schema() *binary.Entity {
	return &entities[ixǁGlGetFramebufferParameteriv]
}

type binaryClassGlGetGraphicsResetStatus struct{}

func (*GlGetGraphicsResetStatus) Class() binary.Class {
	return (*binaryClassGlGetGraphicsResetStatus)(nil)
}
func doEncodeGlGetGraphicsResetStatus(e binary.Encoder, o *GlGetGraphicsResetStatus) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Result))
}
func doDecodeGlGetGraphicsResetStatus(d binary.Decoder, o *GlGetGraphicsResetStatus) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = GLenum(d.Uint32())
}
func doDecodeRawGlGetGraphicsResetStatus(d binary.Decoder, o *GlGetGraphicsResetStatus) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = GLenum(d.Uint32())
}
func (*binaryClassGlGetGraphicsResetStatus) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetGraphicsResetStatus(e, obj.(*GlGetGraphicsResetStatus))
}
func (*binaryClassGlGetGraphicsResetStatus) New() binary.Object {
	return &GlGetGraphicsResetStatus{}
}
func (*binaryClassGlGetGraphicsResetStatus) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetGraphicsResetStatus(d, obj.(*GlGetGraphicsResetStatus))
}
func (c *binaryClassGlGetGraphicsResetStatus) Schema() *binary.Entity {
	return &entities[ixǁGlGetGraphicsResetStatus]
}

type binaryClassGlGetGraphicsResetStatusEXT struct{}

func (*GlGetGraphicsResetStatusEXT) Class() binary.Class {
	return (*binaryClassGlGetGraphicsResetStatusEXT)(nil)
}
func doEncodeGlGetGraphicsResetStatusEXT(e binary.Encoder, o *GlGetGraphicsResetStatusEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Result))
}
func doDecodeGlGetGraphicsResetStatusEXT(d binary.Decoder, o *GlGetGraphicsResetStatusEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = GLenum(d.Uint32())
}
func doDecodeRawGlGetGraphicsResetStatusEXT(d binary.Decoder, o *GlGetGraphicsResetStatusEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = GLenum(d.Uint32())
}
func (*binaryClassGlGetGraphicsResetStatusEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetGraphicsResetStatusEXT(e, obj.(*GlGetGraphicsResetStatusEXT))
}
func (*binaryClassGlGetGraphicsResetStatusEXT) New() binary.Object {
	return &GlGetGraphicsResetStatusEXT{}
}
func (*binaryClassGlGetGraphicsResetStatusEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetGraphicsResetStatusEXT(d, obj.(*GlGetGraphicsResetStatusEXT))
}
func (c *binaryClassGlGetGraphicsResetStatusEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetGraphicsResetStatusEXT]
}

type binaryClassGlGetGraphicsResetStatusKHR struct{}

func (*GlGetGraphicsResetStatusKHR) Class() binary.Class {
	return (*binaryClassGlGetGraphicsResetStatusKHR)(nil)
}
func doEncodeGlGetGraphicsResetStatusKHR(e binary.Encoder, o *GlGetGraphicsResetStatusKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Result))
}
func doDecodeGlGetGraphicsResetStatusKHR(d binary.Decoder, o *GlGetGraphicsResetStatusKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = GLenum(d.Uint32())
}
func doDecodeRawGlGetGraphicsResetStatusKHR(d binary.Decoder, o *GlGetGraphicsResetStatusKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Result = GLenum(d.Uint32())
}
func (*binaryClassGlGetGraphicsResetStatusKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetGraphicsResetStatusKHR(e, obj.(*GlGetGraphicsResetStatusKHR))
}
func (*binaryClassGlGetGraphicsResetStatusKHR) New() binary.Object {
	return &GlGetGraphicsResetStatusKHR{}
}
func (*binaryClassGlGetGraphicsResetStatusKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetGraphicsResetStatusKHR(d, obj.(*GlGetGraphicsResetStatusKHR))
}
func (c *binaryClassGlGetGraphicsResetStatusKHR) Schema() *binary.Entity {
	return &entities[ixǁGlGetGraphicsResetStatusKHR]
}

type binaryClassGlGetImageHandleNV struct{}

func (*GlGetImageHandleNV) Class() binary.Class {
	return (*binaryClassGlGetImageHandleNV)(nil)
}
func doEncodeGlGetImageHandleNV(e binary.Encoder, o *GlGetImageHandleNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.Level))
	e.Uint8(uint8(o.Layered))
	e.Int32(int32(o.Layer))
	e.Uint32(uint32(o.Format))
	e.Uint64(uint64(o.Result))
}
func doDecodeGlGetImageHandleNV(d binary.Decoder, o *GlGetImageHandleNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Layered = GLboolean(d.Uint8())
	o.Layer = GLint(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Result = GLuint64(d.Uint64())
}
func doDecodeRawGlGetImageHandleNV(d binary.Decoder, o *GlGetImageHandleNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Layered = GLboolean(d.Uint8())
	o.Layer = GLint(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Result = GLuint64(d.Uint64())
}
func (*binaryClassGlGetImageHandleNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetImageHandleNV(e, obj.(*GlGetImageHandleNV))
}
func (*binaryClassGlGetImageHandleNV) New() binary.Object {
	return &GlGetImageHandleNV{}
}
func (*binaryClassGlGetImageHandleNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetImageHandleNV(d, obj.(*GlGetImageHandleNV))
}
func (c *binaryClassGlGetImageHandleNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetImageHandleNV]
}

type binaryClassGlGetInteger64i_v struct{}

func (*GlGetInteger64i_v) Class() binary.Class {
	return (*binaryClassGlGetInteger64i_v)(nil)
}
func doEncodeGlGetInteger64i_v(e binary.Encoder, o *GlGetInteger64i_v) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Param))
	e.Uint32(uint32(o.Index))
	e.Simple(&o.Values)
}
func doDecodeGlGetInteger64i_v(d binary.Decoder, o *GlGetInteger64i_v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetInteger64i_v(d binary.Decoder, o *GlGetInteger64i_v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetInteger64i_v) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetInteger64i_v(e, obj.(*GlGetInteger64i_v))
}
func (*binaryClassGlGetInteger64i_v) New() binary.Object {
	return &GlGetInteger64i_v{}
}
func (*binaryClassGlGetInteger64i_v) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetInteger64i_v(d, obj.(*GlGetInteger64i_v))
}
func (c *binaryClassGlGetInteger64i_v) Schema() *binary.Entity {
	return &entities[ixǁGlGetInteger64i_v]
}

type binaryClassGlGetInteger64v struct{}

func (*GlGetInteger64v) Class() binary.Class {
	return (*binaryClassGlGetInteger64v)(nil)
}
func doEncodeGlGetInteger64v(e binary.Encoder, o *GlGetInteger64v) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Param))
	e.Simple(&o.Values)
}
func doDecodeGlGetInteger64v(d binary.Decoder, o *GlGetInteger64v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetInteger64v(d binary.Decoder, o *GlGetInteger64v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetInteger64v) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetInteger64v(e, obj.(*GlGetInteger64v))
}
func (*binaryClassGlGetInteger64v) New() binary.Object {
	return &GlGetInteger64v{}
}
func (*binaryClassGlGetInteger64v) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetInteger64v(d, obj.(*GlGetInteger64v))
}
func (c *binaryClassGlGetInteger64v) Schema() *binary.Entity {
	return &entities[ixǁGlGetInteger64v]
}

type binaryClassGlGetInteger64vAPPLE struct{}

func (*GlGetInteger64vAPPLE) Class() binary.Class {
	return (*binaryClassGlGetInteger64vAPPLE)(nil)
}
func doEncodeGlGetInteger64vAPPLE(e binary.Encoder, o *GlGetInteger64vAPPLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetInteger64vAPPLE(d binary.Decoder, o *GlGetInteger64vAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetInteger64vAPPLE(d binary.Decoder, o *GlGetInteger64vAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetInteger64vAPPLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetInteger64vAPPLE(e, obj.(*GlGetInteger64vAPPLE))
}
func (*binaryClassGlGetInteger64vAPPLE) New() binary.Object {
	return &GlGetInteger64vAPPLE{}
}
func (*binaryClassGlGetInteger64vAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetInteger64vAPPLE(d, obj.(*GlGetInteger64vAPPLE))
}
func (c *binaryClassGlGetInteger64vAPPLE) Schema() *binary.Entity {
	return &entities[ixǁGlGetInteger64vAPPLE]
}

type binaryClassGlGetIntegeri_v struct{}

func (*GlGetIntegeri_v) Class() binary.Class {
	return (*binaryClassGlGetIntegeri_v)(nil)
}
func doEncodeGlGetIntegeri_v(e binary.Encoder, o *GlGetIntegeri_v) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Param))
	e.Uint32(uint32(o.Index))
	e.Simple(&o.Values)
}
func doDecodeGlGetIntegeri_v(d binary.Decoder, o *GlGetIntegeri_v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetIntegeri_v(d binary.Decoder, o *GlGetIntegeri_v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetIntegeri_v) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetIntegeri_v(e, obj.(*GlGetIntegeri_v))
}
func (*binaryClassGlGetIntegeri_v) New() binary.Object {
	return &GlGetIntegeri_v{}
}
func (*binaryClassGlGetIntegeri_v) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetIntegeri_v(d, obj.(*GlGetIntegeri_v))
}
func (c *binaryClassGlGetIntegeri_v) Schema() *binary.Entity {
	return &entities[ixǁGlGetIntegeri_v]
}

type binaryClassGlGetIntegeri_vEXT struct{}

func (*GlGetIntegeri_vEXT) Class() binary.Class {
	return (*binaryClassGlGetIntegeri_vEXT)(nil)
}
func doEncodeGlGetIntegeri_vEXT(e binary.Encoder, o *GlGetIntegeri_vEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
	e.Simple(&o.Data)
}
func doDecodeGlGetIntegeri_vEXT(d binary.Decoder, o *GlGetIntegeri_vEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Data)
}
func doDecodeRawGlGetIntegeri_vEXT(d binary.Decoder, o *GlGetIntegeri_vEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Data)
}
func (*binaryClassGlGetIntegeri_vEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetIntegeri_vEXT(e, obj.(*GlGetIntegeri_vEXT))
}
func (*binaryClassGlGetIntegeri_vEXT) New() binary.Object {
	return &GlGetIntegeri_vEXT{}
}
func (*binaryClassGlGetIntegeri_vEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetIntegeri_vEXT(d, obj.(*GlGetIntegeri_vEXT))
}
func (c *binaryClassGlGetIntegeri_vEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetIntegeri_vEXT]
}

type binaryClassGlGetIntegerv struct{}

func (*GlGetIntegerv) Class() binary.Class {
	return (*binaryClassGlGetIntegerv)(nil)
}
func doEncodeGlGetIntegerv(e binary.Encoder, o *GlGetIntegerv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Param))
	e.Simple(&o.Values)
}
func doDecodeGlGetIntegerv(d binary.Decoder, o *GlGetIntegerv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetIntegerv(d binary.Decoder, o *GlGetIntegerv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetIntegerv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetIntegerv(e, obj.(*GlGetIntegerv))
}
func (*binaryClassGlGetIntegerv) New() binary.Object {
	return &GlGetIntegerv{}
}
func (*binaryClassGlGetIntegerv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetIntegerv(d, obj.(*GlGetIntegerv))
}
func (c *binaryClassGlGetIntegerv) Schema() *binary.Entity {
	return &entities[ixǁGlGetIntegerv]
}

type binaryClassGlGetInternalformatSampleivNV struct{}

func (*GlGetInternalformatSampleivNV) Class() binary.Class {
	return (*binaryClassGlGetInternalformatSampleivNV)(nil)
}
func doEncodeGlGetInternalformatSampleivNV(e binary.Encoder, o *GlGetInternalformatSampleivNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Samples))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Params)
}
func doDecodeGlGetInternalformatSampleivNV(d binary.Decoder, o *GlGetInternalformatSampleivNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Pname = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetInternalformatSampleivNV(d binary.Decoder, o *GlGetInternalformatSampleivNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Pname = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetInternalformatSampleivNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetInternalformatSampleivNV(e, obj.(*GlGetInternalformatSampleivNV))
}
func (*binaryClassGlGetInternalformatSampleivNV) New() binary.Object {
	return &GlGetInternalformatSampleivNV{}
}
func (*binaryClassGlGetInternalformatSampleivNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetInternalformatSampleivNV(d, obj.(*GlGetInternalformatSampleivNV))
}
func (c *binaryClassGlGetInternalformatSampleivNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetInternalformatSampleivNV]
}

type binaryClassGlGetInternalformativ struct{}

func (*GlGetInternalformativ) Class() binary.Class {
	return (*binaryClassGlGetInternalformativ)(nil)
}
func doEncodeGlGetInternalformativ(e binary.Encoder, o *GlGetInternalformativ) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Internalformat))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Params)
}
func doDecodeGlGetInternalformativ(d binary.Decoder, o *GlGetInternalformativ) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetInternalformativ(d binary.Decoder, o *GlGetInternalformativ) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetInternalformativ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetInternalformativ(e, obj.(*GlGetInternalformativ))
}
func (*binaryClassGlGetInternalformativ) New() binary.Object {
	return &GlGetInternalformativ{}
}
func (*binaryClassGlGetInternalformativ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetInternalformativ(d, obj.(*GlGetInternalformativ))
}
func (c *binaryClassGlGetInternalformativ) Schema() *binary.Entity {
	return &entities[ixǁGlGetInternalformativ]
}

type binaryClassGlGetLightfv struct{}

func (*GlGetLightfv) Class() binary.Class {
	return (*binaryClassGlGetLightfv)(nil)
}
func doEncodeGlGetLightfv(e binary.Encoder, o *GlGetLightfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Light))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetLightfv(d binary.Decoder, o *GlGetLightfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetLightfv(d binary.Decoder, o *GlGetLightfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetLightfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetLightfv(e, obj.(*GlGetLightfv))
}
func (*binaryClassGlGetLightfv) New() binary.Object {
	return &GlGetLightfv{}
}
func (*binaryClassGlGetLightfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetLightfv(d, obj.(*GlGetLightfv))
}
func (c *binaryClassGlGetLightfv) Schema() *binary.Entity {
	return &entities[ixǁGlGetLightfv]
}

type binaryClassGlGetLightxv struct{}

func (*GlGetLightxv) Class() binary.Class {
	return (*binaryClassGlGetLightxv)(nil)
}
func doEncodeGlGetLightxv(e binary.Encoder, o *GlGetLightxv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Light))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetLightxv(d binary.Decoder, o *GlGetLightxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetLightxv(d binary.Decoder, o *GlGetLightxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetLightxv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetLightxv(e, obj.(*GlGetLightxv))
}
func (*binaryClassGlGetLightxv) New() binary.Object {
	return &GlGetLightxv{}
}
func (*binaryClassGlGetLightxv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetLightxv(d, obj.(*GlGetLightxv))
}
func (c *binaryClassGlGetLightxv) Schema() *binary.Entity {
	return &entities[ixǁGlGetLightxv]
}

type binaryClassGlGetLightxvOES struct{}

func (*GlGetLightxvOES) Class() binary.Class {
	return (*binaryClassGlGetLightxvOES)(nil)
}
func doEncodeGlGetLightxvOES(e binary.Encoder, o *GlGetLightxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Light))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetLightxvOES(d binary.Decoder, o *GlGetLightxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetLightxvOES(d binary.Decoder, o *GlGetLightxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetLightxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetLightxvOES(e, obj.(*GlGetLightxvOES))
}
func (*binaryClassGlGetLightxvOES) New() binary.Object {
	return &GlGetLightxvOES{}
}
func (*binaryClassGlGetLightxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetLightxvOES(d, obj.(*GlGetLightxvOES))
}
func (c *binaryClassGlGetLightxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetLightxvOES]
}

type binaryClassGlGetMaterialfv struct{}

func (*GlGetMaterialfv) Class() binary.Class {
	return (*binaryClassGlGetMaterialfv)(nil)
}
func doEncodeGlGetMaterialfv(e binary.Encoder, o *GlGetMaterialfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetMaterialfv(d binary.Decoder, o *GlGetMaterialfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetMaterialfv(d binary.Decoder, o *GlGetMaterialfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetMaterialfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetMaterialfv(e, obj.(*GlGetMaterialfv))
}
func (*binaryClassGlGetMaterialfv) New() binary.Object {
	return &GlGetMaterialfv{}
}
func (*binaryClassGlGetMaterialfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetMaterialfv(d, obj.(*GlGetMaterialfv))
}
func (c *binaryClassGlGetMaterialfv) Schema() *binary.Entity {
	return &entities[ixǁGlGetMaterialfv]
}

type binaryClassGlGetMaterialxv struct{}

func (*GlGetMaterialxv) Class() binary.Class {
	return (*binaryClassGlGetMaterialxv)(nil)
}
func doEncodeGlGetMaterialxv(e binary.Encoder, o *GlGetMaterialxv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetMaterialxv(d binary.Decoder, o *GlGetMaterialxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetMaterialxv(d binary.Decoder, o *GlGetMaterialxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetMaterialxv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetMaterialxv(e, obj.(*GlGetMaterialxv))
}
func (*binaryClassGlGetMaterialxv) New() binary.Object {
	return &GlGetMaterialxv{}
}
func (*binaryClassGlGetMaterialxv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetMaterialxv(d, obj.(*GlGetMaterialxv))
}
func (c *binaryClassGlGetMaterialxv) Schema() *binary.Entity {
	return &entities[ixǁGlGetMaterialxv]
}

type binaryClassGlGetMaterialxvOES struct{}

func (*GlGetMaterialxvOES) Class() binary.Class {
	return (*binaryClassGlGetMaterialxvOES)(nil)
}
func doEncodeGlGetMaterialxvOES(e binary.Encoder, o *GlGetMaterialxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetMaterialxvOES(d binary.Decoder, o *GlGetMaterialxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetMaterialxvOES(d binary.Decoder, o *GlGetMaterialxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetMaterialxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetMaterialxvOES(e, obj.(*GlGetMaterialxvOES))
}
func (*binaryClassGlGetMaterialxvOES) New() binary.Object {
	return &GlGetMaterialxvOES{}
}
func (*binaryClassGlGetMaterialxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetMaterialxvOES(d, obj.(*GlGetMaterialxvOES))
}
func (c *binaryClassGlGetMaterialxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetMaterialxvOES]
}

type binaryClassGlGetMultisamplefv struct{}

func (*GlGetMultisamplefv) Class() binary.Class {
	return (*binaryClassGlGetMultisamplefv)(nil)
}
func doEncodeGlGetMultisamplefv(e binary.Encoder, o *GlGetMultisamplefv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Uint32(uint32(o.Index))
	e.Simple(&o.Val)
}
func doDecodeGlGetMultisamplefv(d binary.Decoder, o *GlGetMultisamplefv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Val)
}
func doDecodeRawGlGetMultisamplefv(d binary.Decoder, o *GlGetMultisamplefv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Val)
}
func (*binaryClassGlGetMultisamplefv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetMultisamplefv(e, obj.(*GlGetMultisamplefv))
}
func (*binaryClassGlGetMultisamplefv) New() binary.Object {
	return &GlGetMultisamplefv{}
}
func (*binaryClassGlGetMultisamplefv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetMultisamplefv(d, obj.(*GlGetMultisamplefv))
}
func (c *binaryClassGlGetMultisamplefv) Schema() *binary.Entity {
	return &entities[ixǁGlGetMultisamplefv]
}

type binaryClassGlGetNextPerfQueryIdINTEL struct{}

func (*GlGetNextPerfQueryIdINTEL) Class() binary.Class {
	return (*binaryClassGlGetNextPerfQueryIdINTEL)(nil)
}
func doEncodeGlGetNextPerfQueryIdINTEL(e binary.Encoder, o *GlGetNextPerfQueryIdINTEL) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.QueryId))
	e.Simple(&o.NextQueryId)
}
func doDecodeGlGetNextPerfQueryIdINTEL(d binary.Decoder, o *GlGetNextPerfQueryIdINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryId = GLuint(d.Uint32())
	d.Simple(&o.NextQueryId)
}
func doDecodeRawGlGetNextPerfQueryIdINTEL(d binary.Decoder, o *GlGetNextPerfQueryIdINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryId = GLuint(d.Uint32())
	d.Simple(&o.NextQueryId)
}
func (*binaryClassGlGetNextPerfQueryIdINTEL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetNextPerfQueryIdINTEL(e, obj.(*GlGetNextPerfQueryIdINTEL))
}
func (*binaryClassGlGetNextPerfQueryIdINTEL) New() binary.Object {
	return &GlGetNextPerfQueryIdINTEL{}
}
func (*binaryClassGlGetNextPerfQueryIdINTEL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetNextPerfQueryIdINTEL(d, obj.(*GlGetNextPerfQueryIdINTEL))
}
func (c *binaryClassGlGetNextPerfQueryIdINTEL) Schema() *binary.Entity {
	return &entities[ixǁGlGetNextPerfQueryIdINTEL]
}

type binaryClassGlGetObjectLabel struct{}

func (*GlGetObjectLabel) Class() binary.Class {
	return (*binaryClassGlGetObjectLabel)(nil)
}
func doEncodeGlGetObjectLabel(e binary.Encoder, o *GlGetObjectLabel) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Identifier))
	e.Uint32(uint32(o.Name))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.Label)
}
func doDecodeGlGetObjectLabel(d binary.Decoder, o *GlGetObjectLabel) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Identifier = GLenum(d.Uint32())
	o.Name = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Label)
}
func doDecodeRawGlGetObjectLabel(d binary.Decoder, o *GlGetObjectLabel) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Identifier = GLenum(d.Uint32())
	o.Name = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Label)
}
func (*binaryClassGlGetObjectLabel) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetObjectLabel(e, obj.(*GlGetObjectLabel))
}
func (*binaryClassGlGetObjectLabel) New() binary.Object {
	return &GlGetObjectLabel{}
}
func (*binaryClassGlGetObjectLabel) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetObjectLabel(d, obj.(*GlGetObjectLabel))
}
func (c *binaryClassGlGetObjectLabel) Schema() *binary.Entity {
	return &entities[ixǁGlGetObjectLabel]
}

type binaryClassGlGetObjectLabelEXT struct{}

func (*GlGetObjectLabelEXT) Class() binary.Class {
	return (*binaryClassGlGetObjectLabelEXT)(nil)
}
func doEncodeGlGetObjectLabelEXT(e binary.Encoder, o *GlGetObjectLabelEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Type))
	e.Uint32(uint32(o.Object))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.Label)
}
func doDecodeGlGetObjectLabelEXT(d binary.Decoder, o *GlGetObjectLabelEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Object = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Label)
}
func doDecodeRawGlGetObjectLabelEXT(d binary.Decoder, o *GlGetObjectLabelEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Object = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Label)
}
func (*binaryClassGlGetObjectLabelEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetObjectLabelEXT(e, obj.(*GlGetObjectLabelEXT))
}
func (*binaryClassGlGetObjectLabelEXT) New() binary.Object {
	return &GlGetObjectLabelEXT{}
}
func (*binaryClassGlGetObjectLabelEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetObjectLabelEXT(d, obj.(*GlGetObjectLabelEXT))
}
func (c *binaryClassGlGetObjectLabelEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetObjectLabelEXT]
}

type binaryClassGlGetObjectLabelKHR struct{}

func (*GlGetObjectLabelKHR) Class() binary.Class {
	return (*binaryClassGlGetObjectLabelKHR)(nil)
}
func doEncodeGlGetObjectLabelKHR(e binary.Encoder, o *GlGetObjectLabelKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Identifier))
	e.Uint32(uint32(o.Name))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.Label)
}
func doDecodeGlGetObjectLabelKHR(d binary.Decoder, o *GlGetObjectLabelKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Identifier = GLenum(d.Uint32())
	o.Name = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Label)
}
func doDecodeRawGlGetObjectLabelKHR(d binary.Decoder, o *GlGetObjectLabelKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Identifier = GLenum(d.Uint32())
	o.Name = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Label)
}
func (*binaryClassGlGetObjectLabelKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetObjectLabelKHR(e, obj.(*GlGetObjectLabelKHR))
}
func (*binaryClassGlGetObjectLabelKHR) New() binary.Object {
	return &GlGetObjectLabelKHR{}
}
func (*binaryClassGlGetObjectLabelKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetObjectLabelKHR(d, obj.(*GlGetObjectLabelKHR))
}
func (c *binaryClassGlGetObjectLabelKHR) Schema() *binary.Entity {
	return &entities[ixǁGlGetObjectLabelKHR]
}

type binaryClassGlGetObjectPtrLabel struct{}

func (*GlGetObjectPtrLabel) Class() binary.Class {
	return (*binaryClassGlGetObjectPtrLabel)(nil)
}
func doEncodeGlGetObjectPtrLabel(e binary.Encoder, o *GlGetObjectPtrLabel) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Ptr)
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.Label)
}
func doDecodeGlGetObjectPtrLabel(d binary.Decoder, o *GlGetObjectPtrLabel) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ptr)
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Label)
}
func doDecodeRawGlGetObjectPtrLabel(d binary.Decoder, o *GlGetObjectPtrLabel) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ptr)
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Label)
}
func (*binaryClassGlGetObjectPtrLabel) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetObjectPtrLabel(e, obj.(*GlGetObjectPtrLabel))
}
func (*binaryClassGlGetObjectPtrLabel) New() binary.Object {
	return &GlGetObjectPtrLabel{}
}
func (*binaryClassGlGetObjectPtrLabel) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetObjectPtrLabel(d, obj.(*GlGetObjectPtrLabel))
}
func (c *binaryClassGlGetObjectPtrLabel) Schema() *binary.Entity {
	return &entities[ixǁGlGetObjectPtrLabel]
}

type binaryClassGlGetObjectPtrLabelKHR struct{}

func (*GlGetObjectPtrLabelKHR) Class() binary.Class {
	return (*binaryClassGlGetObjectPtrLabelKHR)(nil)
}
func doEncodeGlGetObjectPtrLabelKHR(e binary.Encoder, o *GlGetObjectPtrLabelKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Ptr)
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.Label)
}
func doDecodeGlGetObjectPtrLabelKHR(d binary.Decoder, o *GlGetObjectPtrLabelKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ptr)
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Label)
}
func doDecodeRawGlGetObjectPtrLabelKHR(d binary.Decoder, o *GlGetObjectPtrLabelKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ptr)
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Label)
}
func (*binaryClassGlGetObjectPtrLabelKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetObjectPtrLabelKHR(e, obj.(*GlGetObjectPtrLabelKHR))
}
func (*binaryClassGlGetObjectPtrLabelKHR) New() binary.Object {
	return &GlGetObjectPtrLabelKHR{}
}
func (*binaryClassGlGetObjectPtrLabelKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetObjectPtrLabelKHR(d, obj.(*GlGetObjectPtrLabelKHR))
}
func (c *binaryClassGlGetObjectPtrLabelKHR) Schema() *binary.Entity {
	return &entities[ixǁGlGetObjectPtrLabelKHR]
}

type binaryClassGlGetPathCommandsNV struct{}

func (*GlGetPathCommandsNV) Class() binary.Class {
	return (*binaryClassGlGetPathCommandsNV)(nil)
}
func doEncodeGlGetPathCommandsNV(e binary.Encoder, o *GlGetPathCommandsNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Simple(&o.Commands)
}
func doDecodeGlGetPathCommandsNV(d binary.Decoder, o *GlGetPathCommandsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	d.Simple(&o.Commands)
}
func doDecodeRawGlGetPathCommandsNV(d binary.Decoder, o *GlGetPathCommandsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	d.Simple(&o.Commands)
}
func (*binaryClassGlGetPathCommandsNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPathCommandsNV(e, obj.(*GlGetPathCommandsNV))
}
func (*binaryClassGlGetPathCommandsNV) New() binary.Object {
	return &GlGetPathCommandsNV{}
}
func (*binaryClassGlGetPathCommandsNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPathCommandsNV(d, obj.(*GlGetPathCommandsNV))
}
func (c *binaryClassGlGetPathCommandsNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetPathCommandsNV]
}

type binaryClassGlGetPathCoordsNV struct{}

func (*GlGetPathCoordsNV) Class() binary.Class {
	return (*binaryClassGlGetPathCoordsNV)(nil)
}
func doEncodeGlGetPathCoordsNV(e binary.Encoder, o *GlGetPathCoordsNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Simple(&o.Coords)
}
func doDecodeGlGetPathCoordsNV(d binary.Decoder, o *GlGetPathCoordsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	d.Simple(&o.Coords)
}
func doDecodeRawGlGetPathCoordsNV(d binary.Decoder, o *GlGetPathCoordsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	d.Simple(&o.Coords)
}
func (*binaryClassGlGetPathCoordsNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPathCoordsNV(e, obj.(*GlGetPathCoordsNV))
}
func (*binaryClassGlGetPathCoordsNV) New() binary.Object {
	return &GlGetPathCoordsNV{}
}
func (*binaryClassGlGetPathCoordsNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPathCoordsNV(d, obj.(*GlGetPathCoordsNV))
}
func (c *binaryClassGlGetPathCoordsNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetPathCoordsNV]
}

type binaryClassGlGetPathDashArrayNV struct{}

func (*GlGetPathDashArrayNV) Class() binary.Class {
	return (*binaryClassGlGetPathDashArrayNV)(nil)
}
func doEncodeGlGetPathDashArrayNV(e binary.Encoder, o *GlGetPathDashArrayNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Simple(&o.DashArray)
}
func doDecodeGlGetPathDashArrayNV(d binary.Decoder, o *GlGetPathDashArrayNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	d.Simple(&o.DashArray)
}
func doDecodeRawGlGetPathDashArrayNV(d binary.Decoder, o *GlGetPathDashArrayNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	d.Simple(&o.DashArray)
}
func (*binaryClassGlGetPathDashArrayNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPathDashArrayNV(e, obj.(*GlGetPathDashArrayNV))
}
func (*binaryClassGlGetPathDashArrayNV) New() binary.Object {
	return &GlGetPathDashArrayNV{}
}
func (*binaryClassGlGetPathDashArrayNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPathDashArrayNV(d, obj.(*GlGetPathDashArrayNV))
}
func (c *binaryClassGlGetPathDashArrayNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetPathDashArrayNV]
}

type binaryClassGlGetPathLengthNV struct{}

func (*GlGetPathLengthNV) Class() binary.Class {
	return (*binaryClassGlGetPathLengthNV)(nil)
}
func doEncodeGlGetPathLengthNV(e binary.Encoder, o *GlGetPathLengthNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Int32(int32(o.StartSegment))
	e.Int32(int32(o.NumSegments))
	e.Float32(float32(o.Result))
}
func doDecodeGlGetPathLengthNV(d binary.Decoder, o *GlGetPathLengthNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.StartSegment = GLsizei(d.Int32())
	o.NumSegments = GLsizei(d.Int32())
	o.Result = GLfloat(d.Float32())
}
func doDecodeRawGlGetPathLengthNV(d binary.Decoder, o *GlGetPathLengthNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.StartSegment = GLsizei(d.Int32())
	o.NumSegments = GLsizei(d.Int32())
	o.Result = GLfloat(d.Float32())
}
func (*binaryClassGlGetPathLengthNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPathLengthNV(e, obj.(*GlGetPathLengthNV))
}
func (*binaryClassGlGetPathLengthNV) New() binary.Object {
	return &GlGetPathLengthNV{}
}
func (*binaryClassGlGetPathLengthNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPathLengthNV(d, obj.(*GlGetPathLengthNV))
}
func (c *binaryClassGlGetPathLengthNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetPathLengthNV]
}

type binaryClassGlGetPathMetricRangeNV struct{}

func (*GlGetPathMetricRangeNV) Class() binary.Class {
	return (*binaryClassGlGetPathMetricRangeNV)(nil)
}
func doEncodeGlGetPathMetricRangeNV(e binary.Encoder, o *GlGetPathMetricRangeNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.MetricQueryMask))
	e.Uint32(uint32(o.FirstPathName))
	e.Int32(int32(o.NumPaths))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Metrics)
}
func doDecodeGlGetPathMetricRangeNV(d binary.Decoder, o *GlGetPathMetricRangeNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MetricQueryMask = GLbitfield(d.Uint32())
	o.FirstPathName = GLuint(d.Uint32())
	o.NumPaths = GLsizei(d.Int32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Metrics)
}
func doDecodeRawGlGetPathMetricRangeNV(d binary.Decoder, o *GlGetPathMetricRangeNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MetricQueryMask = GLbitfield(d.Uint32())
	o.FirstPathName = GLuint(d.Uint32())
	o.NumPaths = GLsizei(d.Int32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Metrics)
}
func (*binaryClassGlGetPathMetricRangeNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPathMetricRangeNV(e, obj.(*GlGetPathMetricRangeNV))
}
func (*binaryClassGlGetPathMetricRangeNV) New() binary.Object {
	return &GlGetPathMetricRangeNV{}
}
func (*binaryClassGlGetPathMetricRangeNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPathMetricRangeNV(d, obj.(*GlGetPathMetricRangeNV))
}
func (c *binaryClassGlGetPathMetricRangeNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetPathMetricRangeNV]
}

type binaryClassGlGetPathMetricsNV struct{}

func (*GlGetPathMetricsNV) Class() binary.Class {
	return (*binaryClassGlGetPathMetricsNV)(nil)
}
func doEncodeGlGetPathMetricsNV(e binary.Encoder, o *GlGetPathMetricsNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.MetricQueryMask))
	e.Int32(int32(o.NumPaths))
	e.Uint32(uint32(o.PathNameType))
	e.Simple(&o.Paths)
	e.Uint32(uint32(o.PathBase))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Metrics)
}
func doDecodeGlGetPathMetricsNV(d binary.Decoder, o *GlGetPathMetricsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MetricQueryMask = GLbitfield(d.Uint32())
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Metrics)
}
func doDecodeRawGlGetPathMetricsNV(d binary.Decoder, o *GlGetPathMetricsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MetricQueryMask = GLbitfield(d.Uint32())
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Metrics)
}
func (*binaryClassGlGetPathMetricsNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPathMetricsNV(e, obj.(*GlGetPathMetricsNV))
}
func (*binaryClassGlGetPathMetricsNV) New() binary.Object {
	return &GlGetPathMetricsNV{}
}
func (*binaryClassGlGetPathMetricsNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPathMetricsNV(d, obj.(*GlGetPathMetricsNV))
}
func (c *binaryClassGlGetPathMetricsNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetPathMetricsNV]
}

type binaryClassGlGetPathParameterfvNV struct{}

func (*GlGetPathParameterfvNV) Class() binary.Class {
	return (*binaryClassGlGetPathParameterfvNV)(nil)
}
func doEncodeGlGetPathParameterfvNV(e binary.Encoder, o *GlGetPathParameterfvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Value)
}
func doDecodeGlGetPathParameterfvNV(d binary.Decoder, o *GlGetPathParameterfvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetPathParameterfvNV(d binary.Decoder, o *GlGetPathParameterfvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetPathParameterfvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPathParameterfvNV(e, obj.(*GlGetPathParameterfvNV))
}
func (*binaryClassGlGetPathParameterfvNV) New() binary.Object {
	return &GlGetPathParameterfvNV{}
}
func (*binaryClassGlGetPathParameterfvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPathParameterfvNV(d, obj.(*GlGetPathParameterfvNV))
}
func (c *binaryClassGlGetPathParameterfvNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetPathParameterfvNV]
}

type binaryClassGlGetPathParameterivNV struct{}

func (*GlGetPathParameterivNV) Class() binary.Class {
	return (*binaryClassGlGetPathParameterivNV)(nil)
}
func doEncodeGlGetPathParameterivNV(e binary.Encoder, o *GlGetPathParameterivNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Value)
}
func doDecodeGlGetPathParameterivNV(d binary.Decoder, o *GlGetPathParameterivNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetPathParameterivNV(d binary.Decoder, o *GlGetPathParameterivNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetPathParameterivNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPathParameterivNV(e, obj.(*GlGetPathParameterivNV))
}
func (*binaryClassGlGetPathParameterivNV) New() binary.Object {
	return &GlGetPathParameterivNV{}
}
func (*binaryClassGlGetPathParameterivNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPathParameterivNV(d, obj.(*GlGetPathParameterivNV))
}
func (c *binaryClassGlGetPathParameterivNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetPathParameterivNV]
}

type binaryClassGlGetPathSpacingNV struct{}

func (*GlGetPathSpacingNV) Class() binary.Class {
	return (*binaryClassGlGetPathSpacingNV)(nil)
}
func doEncodeGlGetPathSpacingNV(e binary.Encoder, o *GlGetPathSpacingNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.PathListMode))
	e.Int32(int32(o.NumPaths))
	e.Uint32(uint32(o.PathNameType))
	e.Simple(&o.Paths)
	e.Uint32(uint32(o.PathBase))
	e.Float32(float32(o.AdvanceScale))
	e.Float32(float32(o.KerningScale))
	e.Uint32(uint32(o.TransformType))
	e.Simple(&o.ReturnedSpacing)
}
func doDecodeGlGetPathSpacingNV(d binary.Decoder, o *GlGetPathSpacingNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.PathListMode = GLenum(d.Uint32())
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.AdvanceScale = GLfloat(d.Float32())
	o.KerningScale = GLfloat(d.Float32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.ReturnedSpacing)
}
func doDecodeRawGlGetPathSpacingNV(d binary.Decoder, o *GlGetPathSpacingNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.PathListMode = GLenum(d.Uint32())
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.AdvanceScale = GLfloat(d.Float32())
	o.KerningScale = GLfloat(d.Float32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.ReturnedSpacing)
}
func (*binaryClassGlGetPathSpacingNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPathSpacingNV(e, obj.(*GlGetPathSpacingNV))
}
func (*binaryClassGlGetPathSpacingNV) New() binary.Object {
	return &GlGetPathSpacingNV{}
}
func (*binaryClassGlGetPathSpacingNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPathSpacingNV(d, obj.(*GlGetPathSpacingNV))
}
func (c *binaryClassGlGetPathSpacingNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetPathSpacingNV]
}

type binaryClassGlGetPerfCounterInfoINTEL struct{}

func (*GlGetPerfCounterInfoINTEL) Class() binary.Class {
	return (*binaryClassGlGetPerfCounterInfoINTEL)(nil)
}
func doEncodeGlGetPerfCounterInfoINTEL(e binary.Encoder, o *GlGetPerfCounterInfoINTEL) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.QueryId))
	e.Uint32(uint32(o.CounterId))
	e.Uint32(uint32(o.CounterNameLength))
	e.Simple(&o.CounterName)
	e.Uint32(uint32(o.CounterDescLength))
	e.Simple(&o.CounterDesc)
	e.Simple(&o.CounterOffset)
	e.Simple(&o.CounterDataSize)
	e.Simple(&o.CounterTypeEnum)
	e.Simple(&o.CounterDataTypeEnum)
	e.Simple(&o.RawCounterMaxValue)
}
func doDecodeGlGetPerfCounterInfoINTEL(d binary.Decoder, o *GlGetPerfCounterInfoINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryId = GLuint(d.Uint32())
	o.CounterId = GLuint(d.Uint32())
	o.CounterNameLength = GLuint(d.Uint32())
	d.Simple(&o.CounterName)
	o.CounterDescLength = GLuint(d.Uint32())
	d.Simple(&o.CounterDesc)
	d.Simple(&o.CounterOffset)
	d.Simple(&o.CounterDataSize)
	d.Simple(&o.CounterTypeEnum)
	d.Simple(&o.CounterDataTypeEnum)
	d.Simple(&o.RawCounterMaxValue)
}
func doDecodeRawGlGetPerfCounterInfoINTEL(d binary.Decoder, o *GlGetPerfCounterInfoINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryId = GLuint(d.Uint32())
	o.CounterId = GLuint(d.Uint32())
	o.CounterNameLength = GLuint(d.Uint32())
	d.Simple(&o.CounterName)
	o.CounterDescLength = GLuint(d.Uint32())
	d.Simple(&o.CounterDesc)
	d.Simple(&o.CounterOffset)
	d.Simple(&o.CounterDataSize)
	d.Simple(&o.CounterTypeEnum)
	d.Simple(&o.CounterDataTypeEnum)
	d.Simple(&o.RawCounterMaxValue)
}
func (*binaryClassGlGetPerfCounterInfoINTEL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPerfCounterInfoINTEL(e, obj.(*GlGetPerfCounterInfoINTEL))
}
func (*binaryClassGlGetPerfCounterInfoINTEL) New() binary.Object {
	return &GlGetPerfCounterInfoINTEL{}
}
func (*binaryClassGlGetPerfCounterInfoINTEL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPerfCounterInfoINTEL(d, obj.(*GlGetPerfCounterInfoINTEL))
}
func (c *binaryClassGlGetPerfCounterInfoINTEL) Schema() *binary.Entity {
	return &entities[ixǁGlGetPerfCounterInfoINTEL]
}

type binaryClassGlGetPerfMonitorCounterDataAMD struct{}

func (*GlGetPerfMonitorCounterDataAMD) Class() binary.Class {
	return (*binaryClassGlGetPerfMonitorCounterDataAMD)(nil)
}
func doEncodeGlGetPerfMonitorCounterDataAMD(e binary.Encoder, o *GlGetPerfMonitorCounterDataAMD) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Monitor))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.DataSize))
	e.Simple(&o.Data)
	e.Simple(&o.BytesWritten)
}
func doDecodeGlGetPerfMonitorCounterDataAMD(d binary.Decoder, o *GlGetPerfMonitorCounterDataAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Monitor = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.DataSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
	d.Simple(&o.BytesWritten)
}
func doDecodeRawGlGetPerfMonitorCounterDataAMD(d binary.Decoder, o *GlGetPerfMonitorCounterDataAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Monitor = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.DataSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
	d.Simple(&o.BytesWritten)
}
func (*binaryClassGlGetPerfMonitorCounterDataAMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPerfMonitorCounterDataAMD(e, obj.(*GlGetPerfMonitorCounterDataAMD))
}
func (*binaryClassGlGetPerfMonitorCounterDataAMD) New() binary.Object {
	return &GlGetPerfMonitorCounterDataAMD{}
}
func (*binaryClassGlGetPerfMonitorCounterDataAMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPerfMonitorCounterDataAMD(d, obj.(*GlGetPerfMonitorCounterDataAMD))
}
func (c *binaryClassGlGetPerfMonitorCounterDataAMD) Schema() *binary.Entity {
	return &entities[ixǁGlGetPerfMonitorCounterDataAMD]
}

type binaryClassGlGetPerfMonitorCounterInfoAMD struct{}

func (*GlGetPerfMonitorCounterInfoAMD) Class() binary.Class {
	return (*binaryClassGlGetPerfMonitorCounterInfoAMD)(nil)
}
func doEncodeGlGetPerfMonitorCounterInfoAMD(e binary.Encoder, o *GlGetPerfMonitorCounterInfoAMD) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Group))
	e.Uint32(uint32(o.Counter))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Data)
}
func doDecodeGlGetPerfMonitorCounterInfoAMD(d binary.Decoder, o *GlGetPerfMonitorCounterInfoAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Group = GLuint(d.Uint32())
	o.Counter = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Data)
}
func doDecodeRawGlGetPerfMonitorCounterInfoAMD(d binary.Decoder, o *GlGetPerfMonitorCounterInfoAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Group = GLuint(d.Uint32())
	o.Counter = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Data)
}
func (*binaryClassGlGetPerfMonitorCounterInfoAMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPerfMonitorCounterInfoAMD(e, obj.(*GlGetPerfMonitorCounterInfoAMD))
}
func (*binaryClassGlGetPerfMonitorCounterInfoAMD) New() binary.Object {
	return &GlGetPerfMonitorCounterInfoAMD{}
}
func (*binaryClassGlGetPerfMonitorCounterInfoAMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPerfMonitorCounterInfoAMD(d, obj.(*GlGetPerfMonitorCounterInfoAMD))
}
func (c *binaryClassGlGetPerfMonitorCounterInfoAMD) Schema() *binary.Entity {
	return &entities[ixǁGlGetPerfMonitorCounterInfoAMD]
}

type binaryClassGlGetPerfMonitorCounterStringAMD struct{}

func (*GlGetPerfMonitorCounterStringAMD) Class() binary.Class {
	return (*binaryClassGlGetPerfMonitorCounterStringAMD)(nil)
}
func doEncodeGlGetPerfMonitorCounterStringAMD(e binary.Encoder, o *GlGetPerfMonitorCounterStringAMD) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Group))
	e.Uint32(uint32(o.Counter))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.CounterString)
}
func doDecodeGlGetPerfMonitorCounterStringAMD(d binary.Decoder, o *GlGetPerfMonitorCounterStringAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Group = GLuint(d.Uint32())
	o.Counter = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.CounterString)
}
func doDecodeRawGlGetPerfMonitorCounterStringAMD(d binary.Decoder, o *GlGetPerfMonitorCounterStringAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Group = GLuint(d.Uint32())
	o.Counter = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.CounterString)
}
func (*binaryClassGlGetPerfMonitorCounterStringAMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPerfMonitorCounterStringAMD(e, obj.(*GlGetPerfMonitorCounterStringAMD))
}
func (*binaryClassGlGetPerfMonitorCounterStringAMD) New() binary.Object {
	return &GlGetPerfMonitorCounterStringAMD{}
}
func (*binaryClassGlGetPerfMonitorCounterStringAMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPerfMonitorCounterStringAMD(d, obj.(*GlGetPerfMonitorCounterStringAMD))
}
func (c *binaryClassGlGetPerfMonitorCounterStringAMD) Schema() *binary.Entity {
	return &entities[ixǁGlGetPerfMonitorCounterStringAMD]
}

type binaryClassGlGetPerfMonitorCountersAMD struct{}

func (*GlGetPerfMonitorCountersAMD) Class() binary.Class {
	return (*binaryClassGlGetPerfMonitorCountersAMD)(nil)
}
func doEncodeGlGetPerfMonitorCountersAMD(e binary.Encoder, o *GlGetPerfMonitorCountersAMD) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Group))
	e.Simple(&o.NumCounters)
	e.Simple(&o.MaxActiveCounters)
	e.Int32(int32(o.CounterSize))
	e.Simple(&o.Counters)
}
func doDecodeGlGetPerfMonitorCountersAMD(d binary.Decoder, o *GlGetPerfMonitorCountersAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Group = GLuint(d.Uint32())
	d.Simple(&o.NumCounters)
	d.Simple(&o.MaxActiveCounters)
	o.CounterSize = GLsizei(d.Int32())
	d.Simple(&o.Counters)
}
func doDecodeRawGlGetPerfMonitorCountersAMD(d binary.Decoder, o *GlGetPerfMonitorCountersAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Group = GLuint(d.Uint32())
	d.Simple(&o.NumCounters)
	d.Simple(&o.MaxActiveCounters)
	o.CounterSize = GLsizei(d.Int32())
	d.Simple(&o.Counters)
}
func (*binaryClassGlGetPerfMonitorCountersAMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPerfMonitorCountersAMD(e, obj.(*GlGetPerfMonitorCountersAMD))
}
func (*binaryClassGlGetPerfMonitorCountersAMD) New() binary.Object {
	return &GlGetPerfMonitorCountersAMD{}
}
func (*binaryClassGlGetPerfMonitorCountersAMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPerfMonitorCountersAMD(d, obj.(*GlGetPerfMonitorCountersAMD))
}
func (c *binaryClassGlGetPerfMonitorCountersAMD) Schema() *binary.Entity {
	return &entities[ixǁGlGetPerfMonitorCountersAMD]
}

type binaryClassGlGetPerfMonitorGroupStringAMD struct{}

func (*GlGetPerfMonitorGroupStringAMD) Class() binary.Class {
	return (*binaryClassGlGetPerfMonitorGroupStringAMD)(nil)
}
func doEncodeGlGetPerfMonitorGroupStringAMD(e binary.Encoder, o *GlGetPerfMonitorGroupStringAMD) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Group))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.GroupString)
}
func doDecodeGlGetPerfMonitorGroupStringAMD(d binary.Decoder, o *GlGetPerfMonitorGroupStringAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Group = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.GroupString)
}
func doDecodeRawGlGetPerfMonitorGroupStringAMD(d binary.Decoder, o *GlGetPerfMonitorGroupStringAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Group = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.GroupString)
}
func (*binaryClassGlGetPerfMonitorGroupStringAMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPerfMonitorGroupStringAMD(e, obj.(*GlGetPerfMonitorGroupStringAMD))
}
func (*binaryClassGlGetPerfMonitorGroupStringAMD) New() binary.Object {
	return &GlGetPerfMonitorGroupStringAMD{}
}
func (*binaryClassGlGetPerfMonitorGroupStringAMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPerfMonitorGroupStringAMD(d, obj.(*GlGetPerfMonitorGroupStringAMD))
}
func (c *binaryClassGlGetPerfMonitorGroupStringAMD) Schema() *binary.Entity {
	return &entities[ixǁGlGetPerfMonitorGroupStringAMD]
}

type binaryClassGlGetPerfMonitorGroupsAMD struct{}

func (*GlGetPerfMonitorGroupsAMD) Class() binary.Class {
	return (*binaryClassGlGetPerfMonitorGroupsAMD)(nil)
}
func doEncodeGlGetPerfMonitorGroupsAMD(e binary.Encoder, o *GlGetPerfMonitorGroupsAMD) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.NumGroups)
	e.Int32(int32(o.GroupsSize))
	e.Simple(&o.Groups)
}
func doDecodeGlGetPerfMonitorGroupsAMD(d binary.Decoder, o *GlGetPerfMonitorGroupsAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.NumGroups)
	o.GroupsSize = GLsizei(d.Int32())
	d.Simple(&o.Groups)
}
func doDecodeRawGlGetPerfMonitorGroupsAMD(d binary.Decoder, o *GlGetPerfMonitorGroupsAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.NumGroups)
	o.GroupsSize = GLsizei(d.Int32())
	d.Simple(&o.Groups)
}
func (*binaryClassGlGetPerfMonitorGroupsAMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPerfMonitorGroupsAMD(e, obj.(*GlGetPerfMonitorGroupsAMD))
}
func (*binaryClassGlGetPerfMonitorGroupsAMD) New() binary.Object {
	return &GlGetPerfMonitorGroupsAMD{}
}
func (*binaryClassGlGetPerfMonitorGroupsAMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPerfMonitorGroupsAMD(d, obj.(*GlGetPerfMonitorGroupsAMD))
}
func (c *binaryClassGlGetPerfMonitorGroupsAMD) Schema() *binary.Entity {
	return &entities[ixǁGlGetPerfMonitorGroupsAMD]
}

type binaryClassGlGetPerfQueryDataINTEL struct{}

func (*GlGetPerfQueryDataINTEL) Class() binary.Class {
	return (*binaryClassGlGetPerfQueryDataINTEL)(nil)
}
func doEncodeGlGetPerfQueryDataINTEL(e binary.Encoder, o *GlGetPerfQueryDataINTEL) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.QueryHandle))
	e.Uint32(uint32(o.Flag))
	e.Int32(int32(o.DataSize))
	e.Simple(&o.Data)
	e.Simple(&o.BytesWritten)
}
func doDecodeGlGetPerfQueryDataINTEL(d binary.Decoder, o *GlGetPerfQueryDataINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryHandle = GLuint(d.Uint32())
	o.Flag = GLuint(d.Uint32())
	o.DataSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
	d.Simple(&o.BytesWritten)
}
func doDecodeRawGlGetPerfQueryDataINTEL(d binary.Decoder, o *GlGetPerfQueryDataINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryHandle = GLuint(d.Uint32())
	o.Flag = GLuint(d.Uint32())
	o.DataSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
	d.Simple(&o.BytesWritten)
}
func (*binaryClassGlGetPerfQueryDataINTEL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPerfQueryDataINTEL(e, obj.(*GlGetPerfQueryDataINTEL))
}
func (*binaryClassGlGetPerfQueryDataINTEL) New() binary.Object {
	return &GlGetPerfQueryDataINTEL{}
}
func (*binaryClassGlGetPerfQueryDataINTEL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPerfQueryDataINTEL(d, obj.(*GlGetPerfQueryDataINTEL))
}
func (c *binaryClassGlGetPerfQueryDataINTEL) Schema() *binary.Entity {
	return &entities[ixǁGlGetPerfQueryDataINTEL]
}

type binaryClassGlGetPerfQueryIdByNameINTEL struct{}

func (*GlGetPerfQueryIdByNameINTEL) Class() binary.Class {
	return (*binaryClassGlGetPerfQueryIdByNameINTEL)(nil)
}
func doEncodeGlGetPerfQueryIdByNameINTEL(e binary.Encoder, o *GlGetPerfQueryIdByNameINTEL) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.QueryName)
	e.Simple(&o.QueryId)
}
func doDecodeGlGetPerfQueryIdByNameINTEL(d binary.Decoder, o *GlGetPerfQueryIdByNameINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.QueryName)
	d.Simple(&o.QueryId)
}
func doDecodeRawGlGetPerfQueryIdByNameINTEL(d binary.Decoder, o *GlGetPerfQueryIdByNameINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.QueryName)
	d.Simple(&o.QueryId)
}
func (*binaryClassGlGetPerfQueryIdByNameINTEL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPerfQueryIdByNameINTEL(e, obj.(*GlGetPerfQueryIdByNameINTEL))
}
func (*binaryClassGlGetPerfQueryIdByNameINTEL) New() binary.Object {
	return &GlGetPerfQueryIdByNameINTEL{}
}
func (*binaryClassGlGetPerfQueryIdByNameINTEL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPerfQueryIdByNameINTEL(d, obj.(*GlGetPerfQueryIdByNameINTEL))
}
func (c *binaryClassGlGetPerfQueryIdByNameINTEL) Schema() *binary.Entity {
	return &entities[ixǁGlGetPerfQueryIdByNameINTEL]
}

type binaryClassGlGetPerfQueryInfoINTEL struct{}

func (*GlGetPerfQueryInfoINTEL) Class() binary.Class {
	return (*binaryClassGlGetPerfQueryInfoINTEL)(nil)
}
func doEncodeGlGetPerfQueryInfoINTEL(e binary.Encoder, o *GlGetPerfQueryInfoINTEL) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.QueryId))
	e.Uint32(uint32(o.QueryNameLength))
	e.Simple(&o.QueryName)
	e.Simple(&o.DataSize)
	e.Simple(&o.NoCounters)
	e.Simple(&o.NoInstances)
	e.Simple(&o.CapsMask)
}
func doDecodeGlGetPerfQueryInfoINTEL(d binary.Decoder, o *GlGetPerfQueryInfoINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryId = GLuint(d.Uint32())
	o.QueryNameLength = GLuint(d.Uint32())
	d.Simple(&o.QueryName)
	d.Simple(&o.DataSize)
	d.Simple(&o.NoCounters)
	d.Simple(&o.NoInstances)
	d.Simple(&o.CapsMask)
}
func doDecodeRawGlGetPerfQueryInfoINTEL(d binary.Decoder, o *GlGetPerfQueryInfoINTEL) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.QueryId = GLuint(d.Uint32())
	o.QueryNameLength = GLuint(d.Uint32())
	d.Simple(&o.QueryName)
	d.Simple(&o.DataSize)
	d.Simple(&o.NoCounters)
	d.Simple(&o.NoInstances)
	d.Simple(&o.CapsMask)
}
func (*binaryClassGlGetPerfQueryInfoINTEL) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPerfQueryInfoINTEL(e, obj.(*GlGetPerfQueryInfoINTEL))
}
func (*binaryClassGlGetPerfQueryInfoINTEL) New() binary.Object {
	return &GlGetPerfQueryInfoINTEL{}
}
func (*binaryClassGlGetPerfQueryInfoINTEL) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPerfQueryInfoINTEL(d, obj.(*GlGetPerfQueryInfoINTEL))
}
func (c *binaryClassGlGetPerfQueryInfoINTEL) Schema() *binary.Entity {
	return &entities[ixǁGlGetPerfQueryInfoINTEL]
}

type binaryClassGlGetPointerv struct{}

func (*GlGetPointerv) Class() binary.Class {
	return (*binaryClassGlGetPointerv)(nil)
}
func doEncodeGlGetPointerv(e binary.Encoder, o *GlGetPointerv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetPointerv(d binary.Decoder, o *GlGetPointerv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetPointerv(d binary.Decoder, o *GlGetPointerv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetPointerv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPointerv(e, obj.(*GlGetPointerv))
}
func (*binaryClassGlGetPointerv) New() binary.Object {
	return &GlGetPointerv{}
}
func (*binaryClassGlGetPointerv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPointerv(d, obj.(*GlGetPointerv))
}
func (c *binaryClassGlGetPointerv) Schema() *binary.Entity {
	return &entities[ixǁGlGetPointerv]
}

type binaryClassGlGetPointervKHR struct{}

func (*GlGetPointervKHR) Class() binary.Class {
	return (*binaryClassGlGetPointervKHR)(nil)
}
func doEncodeGlGetPointervKHR(e binary.Encoder, o *GlGetPointervKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetPointervKHR(d binary.Decoder, o *GlGetPointervKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetPointervKHR(d binary.Decoder, o *GlGetPointervKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetPointervKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetPointervKHR(e, obj.(*GlGetPointervKHR))
}
func (*binaryClassGlGetPointervKHR) New() binary.Object {
	return &GlGetPointervKHR{}
}
func (*binaryClassGlGetPointervKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetPointervKHR(d, obj.(*GlGetPointervKHR))
}
func (c *binaryClassGlGetPointervKHR) Schema() *binary.Entity {
	return &entities[ixǁGlGetPointervKHR]
}

type binaryClassGlGetProgramBinary struct{}

func (*GlGetProgramBinary) Class() binary.Class {
	return (*binaryClassGlGetProgramBinary)(nil)
}
func doEncodeGlGetProgramBinary(e binary.Encoder, o *GlGetProgramBinary) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.BinaryFormat)
	e.Simple(&o.Binary)
}
func doDecodeGlGetProgramBinary(d binary.Decoder, o *GlGetProgramBinary) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.BinaryFormat)
	d.Simple(&o.Binary)
}
func doDecodeRawGlGetProgramBinary(d binary.Decoder, o *GlGetProgramBinary) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.BinaryFormat)
	d.Simple(&o.Binary)
}
func (*binaryClassGlGetProgramBinary) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramBinary(e, obj.(*GlGetProgramBinary))
}
func (*binaryClassGlGetProgramBinary) New() binary.Object {
	return &GlGetProgramBinary{}
}
func (*binaryClassGlGetProgramBinary) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramBinary(d, obj.(*GlGetProgramBinary))
}
func (c *binaryClassGlGetProgramBinary) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramBinary]
}

type binaryClassGlGetProgramBinaryOES struct{}

func (*GlGetProgramBinaryOES) Class() binary.Class {
	return (*binaryClassGlGetProgramBinaryOES)(nil)
}
func doEncodeGlGetProgramBinaryOES(e binary.Encoder, o *GlGetProgramBinaryOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.BufferSize))
	e.Simple(&o.BytesWritten)
	e.Simple(&o.BinaryFormat)
	e.Simple(&o.Binary)
}
func doDecodeGlGetProgramBinaryOES(d binary.Decoder, o *GlGetProgramBinaryOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.BufferSize = GLsizei(d.Int32())
	d.Simple(&o.BytesWritten)
	d.Simple(&o.BinaryFormat)
	d.Simple(&o.Binary)
}
func doDecodeRawGlGetProgramBinaryOES(d binary.Decoder, o *GlGetProgramBinaryOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.BufferSize = GLsizei(d.Int32())
	d.Simple(&o.BytesWritten)
	d.Simple(&o.BinaryFormat)
	d.Simple(&o.Binary)
}
func (*binaryClassGlGetProgramBinaryOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramBinaryOES(e, obj.(*GlGetProgramBinaryOES))
}
func (*binaryClassGlGetProgramBinaryOES) New() binary.Object {
	return &GlGetProgramBinaryOES{}
}
func (*binaryClassGlGetProgramBinaryOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramBinaryOES(d, obj.(*GlGetProgramBinaryOES))
}
func (c *binaryClassGlGetProgramBinaryOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramBinaryOES]
}

type binaryClassGlGetProgramInfoLog struct{}

func (*GlGetProgramInfoLog) Class() binary.Class {
	return (*binaryClassGlGetProgramInfoLog)(nil)
}
func doEncodeGlGetProgramInfoLog(e binary.Encoder, o *GlGetProgramInfoLog) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.BufferLength))
	e.Simple(&o.StringLengthWritten)
	e.Simple(&o.Info)
}
func doDecodeGlGetProgramInfoLog(d binary.Decoder, o *GlGetProgramInfoLog) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.BufferLength = GLsizei(d.Int32())
	d.Simple(&o.StringLengthWritten)
	d.Simple(&o.Info)
}
func doDecodeRawGlGetProgramInfoLog(d binary.Decoder, o *GlGetProgramInfoLog) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.BufferLength = GLsizei(d.Int32())
	d.Simple(&o.StringLengthWritten)
	d.Simple(&o.Info)
}
func (*binaryClassGlGetProgramInfoLog) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramInfoLog(e, obj.(*GlGetProgramInfoLog))
}
func (*binaryClassGlGetProgramInfoLog) New() binary.Object {
	return &GlGetProgramInfoLog{}
}
func (*binaryClassGlGetProgramInfoLog) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramInfoLog(d, obj.(*GlGetProgramInfoLog))
}
func (c *binaryClassGlGetProgramInfoLog) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramInfoLog]
}

type binaryClassGlGetProgramInterfaceiv struct{}

func (*GlGetProgramInterfaceiv) Class() binary.Class {
	return (*binaryClassGlGetProgramInterfaceiv)(nil)
}
func doEncodeGlGetProgramInterfaceiv(e binary.Encoder, o *GlGetProgramInterfaceiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.ProgramInterface))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetProgramInterfaceiv(d binary.Decoder, o *GlGetProgramInterfaceiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetProgramInterfaceiv(d binary.Decoder, o *GlGetProgramInterfaceiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetProgramInterfaceiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramInterfaceiv(e, obj.(*GlGetProgramInterfaceiv))
}
func (*binaryClassGlGetProgramInterfaceiv) New() binary.Object {
	return &GlGetProgramInterfaceiv{}
}
func (*binaryClassGlGetProgramInterfaceiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramInterfaceiv(d, obj.(*GlGetProgramInterfaceiv))
}
func (c *binaryClassGlGetProgramInterfaceiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramInterfaceiv]
}

type binaryClassGlGetProgramPipelineInfoLog struct{}

func (*GlGetProgramPipelineInfoLog) Class() binary.Class {
	return (*binaryClassGlGetProgramPipelineInfoLog)(nil)
}
func doEncodeGlGetProgramPipelineInfoLog(e binary.Encoder, o *GlGetProgramPipelineInfoLog) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.InfoLog)
}
func doDecodeGlGetProgramPipelineInfoLog(d binary.Decoder, o *GlGetProgramPipelineInfoLog) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.InfoLog)
}
func doDecodeRawGlGetProgramPipelineInfoLog(d binary.Decoder, o *GlGetProgramPipelineInfoLog) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.InfoLog)
}
func (*binaryClassGlGetProgramPipelineInfoLog) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramPipelineInfoLog(e, obj.(*GlGetProgramPipelineInfoLog))
}
func (*binaryClassGlGetProgramPipelineInfoLog) New() binary.Object {
	return &GlGetProgramPipelineInfoLog{}
}
func (*binaryClassGlGetProgramPipelineInfoLog) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramPipelineInfoLog(d, obj.(*GlGetProgramPipelineInfoLog))
}
func (c *binaryClassGlGetProgramPipelineInfoLog) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramPipelineInfoLog]
}

type binaryClassGlGetProgramPipelineInfoLogEXT struct{}

func (*GlGetProgramPipelineInfoLogEXT) Class() binary.Class {
	return (*binaryClassGlGetProgramPipelineInfoLogEXT)(nil)
}
func doEncodeGlGetProgramPipelineInfoLogEXT(e binary.Encoder, o *GlGetProgramPipelineInfoLogEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.InfoLog)
}
func doDecodeGlGetProgramPipelineInfoLogEXT(d binary.Decoder, o *GlGetProgramPipelineInfoLogEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.InfoLog)
}
func doDecodeRawGlGetProgramPipelineInfoLogEXT(d binary.Decoder, o *GlGetProgramPipelineInfoLogEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.InfoLog)
}
func (*binaryClassGlGetProgramPipelineInfoLogEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramPipelineInfoLogEXT(e, obj.(*GlGetProgramPipelineInfoLogEXT))
}
func (*binaryClassGlGetProgramPipelineInfoLogEXT) New() binary.Object {
	return &GlGetProgramPipelineInfoLogEXT{}
}
func (*binaryClassGlGetProgramPipelineInfoLogEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramPipelineInfoLogEXT(d, obj.(*GlGetProgramPipelineInfoLogEXT))
}
func (c *binaryClassGlGetProgramPipelineInfoLogEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramPipelineInfoLogEXT]
}

type binaryClassGlGetProgramPipelineiv struct{}

func (*GlGetProgramPipelineiv) Class() binary.Class {
	return (*binaryClassGlGetProgramPipelineiv)(nil)
}
func doEncodeGlGetProgramPipelineiv(e binary.Encoder, o *GlGetProgramPipelineiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetProgramPipelineiv(d binary.Decoder, o *GlGetProgramPipelineiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetProgramPipelineiv(d binary.Decoder, o *GlGetProgramPipelineiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetProgramPipelineiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramPipelineiv(e, obj.(*GlGetProgramPipelineiv))
}
func (*binaryClassGlGetProgramPipelineiv) New() binary.Object {
	return &GlGetProgramPipelineiv{}
}
func (*binaryClassGlGetProgramPipelineiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramPipelineiv(d, obj.(*GlGetProgramPipelineiv))
}
func (c *binaryClassGlGetProgramPipelineiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramPipelineiv]
}

type binaryClassGlGetProgramPipelineivEXT struct{}

func (*GlGetProgramPipelineivEXT) Class() binary.Class {
	return (*binaryClassGlGetProgramPipelineivEXT)(nil)
}
func doEncodeGlGetProgramPipelineivEXT(e binary.Encoder, o *GlGetProgramPipelineivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetProgramPipelineivEXT(d binary.Decoder, o *GlGetProgramPipelineivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetProgramPipelineivEXT(d binary.Decoder, o *GlGetProgramPipelineivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetProgramPipelineivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramPipelineivEXT(e, obj.(*GlGetProgramPipelineivEXT))
}
func (*binaryClassGlGetProgramPipelineivEXT) New() binary.Object {
	return &GlGetProgramPipelineivEXT{}
}
func (*binaryClassGlGetProgramPipelineivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramPipelineivEXT(d, obj.(*GlGetProgramPipelineivEXT))
}
func (c *binaryClassGlGetProgramPipelineivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramPipelineivEXT]
}

type binaryClassGlGetProgramResourceIndex struct{}

func (*GlGetProgramResourceIndex) Class() binary.Class {
	return (*binaryClassGlGetProgramResourceIndex)(nil)
}
func doEncodeGlGetProgramResourceIndex(e binary.Encoder, o *GlGetProgramResourceIndex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.ProgramInterface))
	e.String(o.Name)
	e.Uint32(uint32(o.Result))
}
func doDecodeGlGetProgramResourceIndex(d binary.Decoder, o *GlGetProgramResourceIndex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Name = string(d.String())
	o.Result = GLuint(d.Uint32())
}
func doDecodeRawGlGetProgramResourceIndex(d binary.Decoder, o *GlGetProgramResourceIndex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Name = string(d.String())
	o.Result = GLuint(d.Uint32())
}
func (*binaryClassGlGetProgramResourceIndex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramResourceIndex(e, obj.(*GlGetProgramResourceIndex))
}
func (*binaryClassGlGetProgramResourceIndex) New() binary.Object {
	return &GlGetProgramResourceIndex{}
}
func (*binaryClassGlGetProgramResourceIndex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramResourceIndex(d, obj.(*GlGetProgramResourceIndex))
}
func (c *binaryClassGlGetProgramResourceIndex) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramResourceIndex]
}

type binaryClassGlGetProgramResourceLocation struct{}

func (*GlGetProgramResourceLocation) Class() binary.Class {
	return (*binaryClassGlGetProgramResourceLocation)(nil)
}
func doEncodeGlGetProgramResourceLocation(e binary.Encoder, o *GlGetProgramResourceLocation) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.ProgramInterface))
	e.String(o.Name)
	e.Int32(int32(o.Result))
}
func doDecodeGlGetProgramResourceLocation(d binary.Decoder, o *GlGetProgramResourceLocation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Name = string(d.String())
	o.Result = GLint(d.Int32())
}
func doDecodeRawGlGetProgramResourceLocation(d binary.Decoder, o *GlGetProgramResourceLocation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Name = string(d.String())
	o.Result = GLint(d.Int32())
}
func (*binaryClassGlGetProgramResourceLocation) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramResourceLocation(e, obj.(*GlGetProgramResourceLocation))
}
func (*binaryClassGlGetProgramResourceLocation) New() binary.Object {
	return &GlGetProgramResourceLocation{}
}
func (*binaryClassGlGetProgramResourceLocation) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramResourceLocation(d, obj.(*GlGetProgramResourceLocation))
}
func (c *binaryClassGlGetProgramResourceLocation) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramResourceLocation]
}

type binaryClassGlGetProgramResourceLocationIndexEXT struct{}

func (*GlGetProgramResourceLocationIndexEXT) Class() binary.Class {
	return (*binaryClassGlGetProgramResourceLocationIndexEXT)(nil)
}
func doEncodeGlGetProgramResourceLocationIndexEXT(e binary.Encoder, o *GlGetProgramResourceLocationIndexEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.ProgramInterface))
	e.String(o.Name)
	e.Int32(int32(o.Result))
}
func doDecodeGlGetProgramResourceLocationIndexEXT(d binary.Decoder, o *GlGetProgramResourceLocationIndexEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Name = string(d.String())
	o.Result = GLint(d.Int32())
}
func doDecodeRawGlGetProgramResourceLocationIndexEXT(d binary.Decoder, o *GlGetProgramResourceLocationIndexEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Name = string(d.String())
	o.Result = GLint(d.Int32())
}
func (*binaryClassGlGetProgramResourceLocationIndexEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramResourceLocationIndexEXT(e, obj.(*GlGetProgramResourceLocationIndexEXT))
}
func (*binaryClassGlGetProgramResourceLocationIndexEXT) New() binary.Object {
	return &GlGetProgramResourceLocationIndexEXT{}
}
func (*binaryClassGlGetProgramResourceLocationIndexEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramResourceLocationIndexEXT(d, obj.(*GlGetProgramResourceLocationIndexEXT))
}
func (c *binaryClassGlGetProgramResourceLocationIndexEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramResourceLocationIndexEXT]
}

type binaryClassGlGetProgramResourceName struct{}

func (*GlGetProgramResourceName) Class() binary.Class {
	return (*binaryClassGlGetProgramResourceName)(nil)
}
func doEncodeGlGetProgramResourceName(e binary.Encoder, o *GlGetProgramResourceName) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.ProgramInterface))
	e.Uint32(uint32(o.Index))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.Name)
}
func doDecodeGlGetProgramResourceName(d binary.Decoder, o *GlGetProgramResourceName) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Name)
}
func doDecodeRawGlGetProgramResourceName(d binary.Decoder, o *GlGetProgramResourceName) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Name)
}
func (*binaryClassGlGetProgramResourceName) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramResourceName(e, obj.(*GlGetProgramResourceName))
}
func (*binaryClassGlGetProgramResourceName) New() binary.Object {
	return &GlGetProgramResourceName{}
}
func (*binaryClassGlGetProgramResourceName) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramResourceName(d, obj.(*GlGetProgramResourceName))
}
func (c *binaryClassGlGetProgramResourceName) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramResourceName]
}

type binaryClassGlGetProgramResourcefvNV struct{}

func (*GlGetProgramResourcefvNV) Class() binary.Class {
	return (*binaryClassGlGetProgramResourcefvNV)(nil)
}
func doEncodeGlGetProgramResourcefvNV(e binary.Encoder, o *GlGetProgramResourcefvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.ProgramInterface))
	e.Uint32(uint32(o.Index))
	e.Int32(int32(o.PropCount))
	e.Simple(&o.Props)
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.Params)
}
func doDecodeGlGetProgramResourcefvNV(d binary.Decoder, o *GlGetProgramResourcefvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.PropCount = GLsizei(d.Int32())
	d.Simple(&o.Props)
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Params)
}
func doDecodeRawGlGetProgramResourcefvNV(d binary.Decoder, o *GlGetProgramResourcefvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.PropCount = GLsizei(d.Int32())
	d.Simple(&o.Props)
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Params)
}
func (*binaryClassGlGetProgramResourcefvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramResourcefvNV(e, obj.(*GlGetProgramResourcefvNV))
}
func (*binaryClassGlGetProgramResourcefvNV) New() binary.Object {
	return &GlGetProgramResourcefvNV{}
}
func (*binaryClassGlGetProgramResourcefvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramResourcefvNV(d, obj.(*GlGetProgramResourcefvNV))
}
func (c *binaryClassGlGetProgramResourcefvNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramResourcefvNV]
}

type binaryClassGlGetProgramResourceiv struct{}

func (*GlGetProgramResourceiv) Class() binary.Class {
	return (*binaryClassGlGetProgramResourceiv)(nil)
}
func doEncodeGlGetProgramResourceiv(e binary.Encoder, o *GlGetProgramResourceiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.ProgramInterface))
	e.Uint32(uint32(o.Index))
	e.Int32(int32(o.PropCount))
	e.Simple(&o.Props)
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.Params)
}
func doDecodeGlGetProgramResourceiv(d binary.Decoder, o *GlGetProgramResourceiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.PropCount = GLsizei(d.Int32())
	d.Simple(&o.Props)
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Params)
}
func doDecodeRawGlGetProgramResourceiv(d binary.Decoder, o *GlGetProgramResourceiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.ProgramInterface = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.PropCount = GLsizei(d.Int32())
	d.Simple(&o.Props)
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Params)
}
func (*binaryClassGlGetProgramResourceiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramResourceiv(e, obj.(*GlGetProgramResourceiv))
}
func (*binaryClassGlGetProgramResourceiv) New() binary.Object {
	return &GlGetProgramResourceiv{}
}
func (*binaryClassGlGetProgramResourceiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramResourceiv(d, obj.(*GlGetProgramResourceiv))
}
func (c *binaryClassGlGetProgramResourceiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramResourceiv]
}

type binaryClassGlGetProgramiv struct{}

func (*GlGetProgramiv) Class() binary.Class {
	return (*binaryClassGlGetProgramiv)(nil)
}
func doEncodeGlGetProgramiv(e binary.Encoder, o *GlGetProgramiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetProgramiv(d binary.Decoder, o *GlGetProgramiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetProgramiv(d binary.Decoder, o *GlGetProgramiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetProgramiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetProgramiv(e, obj.(*GlGetProgramiv))
}
func (*binaryClassGlGetProgramiv) New() binary.Object {
	return &GlGetProgramiv{}
}
func (*binaryClassGlGetProgramiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetProgramiv(d, obj.(*GlGetProgramiv))
}
func (c *binaryClassGlGetProgramiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetProgramiv]
}

type binaryClassS64ᵖ struct{}

func (*S64ᵖ) Class() binary.Class {
	return (*binaryClassS64ᵖ)(nil)
}
func doEncodeS64ᵖ(e binary.Writer, o *S64ᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeS64ᵖ(d binary.Reader, o *S64ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawS64ᵖ(d binary.Reader, o *S64ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassS64ᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeS64ᵖ(e, obj.(*S64ᵖ))
}
func (*binaryClassS64ᵖ) New() binary.Object {
	return &S64ᵖ{}
}
func (*binaryClassS64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeS64ᵖ(d, obj.(*S64ᵖ))
}
func (o *S64ᵖ) WriteSimple(w binary.Writer) {
	doEncodeS64ᵖ(w, o)
}
func (o *S64ᵖ) ReadSimple(r binary.Reader) {
	doDecodeS64ᵖ(r, o)
}
func (c *binaryClassS64ᵖ) Schema() *binary.Entity {
	return &entities[ixǁS64ᵖ]
}

type binaryClassGlGetQueryObjecti64v struct{}

func (*GlGetQueryObjecti64v) Class() binary.Class {
	return (*binaryClassGlGetQueryObjecti64v)(nil)
}
func doEncodeGlGetQueryObjecti64v(e binary.Encoder, o *GlGetQueryObjecti64v) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Query))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetQueryObjecti64v(d binary.Decoder, o *GlGetQueryObjecti64v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetQueryObjecti64v(d binary.Decoder, o *GlGetQueryObjecti64v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetQueryObjecti64v) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetQueryObjecti64v(e, obj.(*GlGetQueryObjecti64v))
}
func (*binaryClassGlGetQueryObjecti64v) New() binary.Object {
	return &GlGetQueryObjecti64v{}
}
func (*binaryClassGlGetQueryObjecti64v) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetQueryObjecti64v(d, obj.(*GlGetQueryObjecti64v))
}
func (c *binaryClassGlGetQueryObjecti64v) Schema() *binary.Entity {
	return &entities[ixǁGlGetQueryObjecti64v]
}

type binaryClassGlGetQueryObjecti64vEXT struct{}

func (*GlGetQueryObjecti64vEXT) Class() binary.Class {
	return (*binaryClassGlGetQueryObjecti64vEXT)(nil)
}
func doEncodeGlGetQueryObjecti64vEXT(e binary.Encoder, o *GlGetQueryObjecti64vEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Query))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetQueryObjecti64vEXT(d binary.Decoder, o *GlGetQueryObjecti64vEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetQueryObjecti64vEXT(d binary.Decoder, o *GlGetQueryObjecti64vEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetQueryObjecti64vEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetQueryObjecti64vEXT(e, obj.(*GlGetQueryObjecti64vEXT))
}
func (*binaryClassGlGetQueryObjecti64vEXT) New() binary.Object {
	return &GlGetQueryObjecti64vEXT{}
}
func (*binaryClassGlGetQueryObjecti64vEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetQueryObjecti64vEXT(d, obj.(*GlGetQueryObjecti64vEXT))
}
func (c *binaryClassGlGetQueryObjecti64vEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetQueryObjecti64vEXT]
}

type binaryClassGlGetQueryObjectivEXT struct{}

func (*GlGetQueryObjectivEXT) Class() binary.Class {
	return (*binaryClassGlGetQueryObjectivEXT)(nil)
}
func doEncodeGlGetQueryObjectivEXT(e binary.Encoder, o *GlGetQueryObjectivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Query))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetQueryObjectivEXT(d binary.Decoder, o *GlGetQueryObjectivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetQueryObjectivEXT(d binary.Decoder, o *GlGetQueryObjectivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetQueryObjectivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetQueryObjectivEXT(e, obj.(*GlGetQueryObjectivEXT))
}
func (*binaryClassGlGetQueryObjectivEXT) New() binary.Object {
	return &GlGetQueryObjectivEXT{}
}
func (*binaryClassGlGetQueryObjectivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetQueryObjectivEXT(d, obj.(*GlGetQueryObjectivEXT))
}
func (c *binaryClassGlGetQueryObjectivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetQueryObjectivEXT]
}

type binaryClassU64ᵖ struct{}

func (*U64ᵖ) Class() binary.Class {
	return (*binaryClassU64ᵖ)(nil)
}
func doEncodeU64ᵖ(e binary.Writer, o *U64ᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeU64ᵖ(d binary.Reader, o *U64ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawU64ᵖ(d binary.Reader, o *U64ᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassU64ᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeU64ᵖ(e, obj.(*U64ᵖ))
}
func (*binaryClassU64ᵖ) New() binary.Object {
	return &U64ᵖ{}
}
func (*binaryClassU64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeU64ᵖ(d, obj.(*U64ᵖ))
}
func (o *U64ᵖ) WriteSimple(w binary.Writer) {
	doEncodeU64ᵖ(w, o)
}
func (o *U64ᵖ) ReadSimple(r binary.Reader) {
	doDecodeU64ᵖ(r, o)
}
func (c *binaryClassU64ᵖ) Schema() *binary.Entity {
	return &entities[ixǁU64ᵖ]
}

type binaryClassGlGetQueryObjectui64v struct{}

func (*GlGetQueryObjectui64v) Class() binary.Class {
	return (*binaryClassGlGetQueryObjectui64v)(nil)
}
func doEncodeGlGetQueryObjectui64v(e binary.Encoder, o *GlGetQueryObjectui64v) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Query))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetQueryObjectui64v(d binary.Decoder, o *GlGetQueryObjectui64v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetQueryObjectui64v(d binary.Decoder, o *GlGetQueryObjectui64v) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetQueryObjectui64v) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetQueryObjectui64v(e, obj.(*GlGetQueryObjectui64v))
}
func (*binaryClassGlGetQueryObjectui64v) New() binary.Object {
	return &GlGetQueryObjectui64v{}
}
func (*binaryClassGlGetQueryObjectui64v) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetQueryObjectui64v(d, obj.(*GlGetQueryObjectui64v))
}
func (c *binaryClassGlGetQueryObjectui64v) Schema() *binary.Entity {
	return &entities[ixǁGlGetQueryObjectui64v]
}

type binaryClassGlGetQueryObjectui64vEXT struct{}

func (*GlGetQueryObjectui64vEXT) Class() binary.Class {
	return (*binaryClassGlGetQueryObjectui64vEXT)(nil)
}
func doEncodeGlGetQueryObjectui64vEXT(e binary.Encoder, o *GlGetQueryObjectui64vEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Query))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetQueryObjectui64vEXT(d binary.Decoder, o *GlGetQueryObjectui64vEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetQueryObjectui64vEXT(d binary.Decoder, o *GlGetQueryObjectui64vEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetQueryObjectui64vEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetQueryObjectui64vEXT(e, obj.(*GlGetQueryObjectui64vEXT))
}
func (*binaryClassGlGetQueryObjectui64vEXT) New() binary.Object {
	return &GlGetQueryObjectui64vEXT{}
}
func (*binaryClassGlGetQueryObjectui64vEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetQueryObjectui64vEXT(d, obj.(*GlGetQueryObjectui64vEXT))
}
func (c *binaryClassGlGetQueryObjectui64vEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetQueryObjectui64vEXT]
}

type binaryClassGlGetQueryObjectuiv struct{}

func (*GlGetQueryObjectuiv) Class() binary.Class {
	return (*binaryClassGlGetQueryObjectuiv)(nil)
}
func doEncodeGlGetQueryObjectuiv(e binary.Encoder, o *GlGetQueryObjectuiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Query))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetQueryObjectuiv(d binary.Decoder, o *GlGetQueryObjectuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetQueryObjectuiv(d binary.Decoder, o *GlGetQueryObjectuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetQueryObjectuiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetQueryObjectuiv(e, obj.(*GlGetQueryObjectuiv))
}
func (*binaryClassGlGetQueryObjectuiv) New() binary.Object {
	return &GlGetQueryObjectuiv{}
}
func (*binaryClassGlGetQueryObjectuiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetQueryObjectuiv(d, obj.(*GlGetQueryObjectuiv))
}
func (c *binaryClassGlGetQueryObjectuiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetQueryObjectuiv]
}

type binaryClassGlGetQueryObjectuivEXT struct{}

func (*GlGetQueryObjectuivEXT) Class() binary.Class {
	return (*binaryClassGlGetQueryObjectuivEXT)(nil)
}
func doEncodeGlGetQueryObjectuivEXT(e binary.Encoder, o *GlGetQueryObjectuivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Query))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetQueryObjectuivEXT(d binary.Decoder, o *GlGetQueryObjectuivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetQueryObjectuivEXT(d binary.Decoder, o *GlGetQueryObjectuivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetQueryObjectuivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetQueryObjectuivEXT(e, obj.(*GlGetQueryObjectuivEXT))
}
func (*binaryClassGlGetQueryObjectuivEXT) New() binary.Object {
	return &GlGetQueryObjectuivEXT{}
}
func (*binaryClassGlGetQueryObjectuivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetQueryObjectuivEXT(d, obj.(*GlGetQueryObjectuivEXT))
}
func (c *binaryClassGlGetQueryObjectuivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetQueryObjectuivEXT]
}

type binaryClassGlGetQueryiv struct{}

func (*GlGetQueryiv) Class() binary.Class {
	return (*binaryClassGlGetQueryiv)(nil)
}
func doEncodeGlGetQueryiv(e binary.Encoder, o *GlGetQueryiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetQueryiv(d binary.Decoder, o *GlGetQueryiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetQueryiv(d binary.Decoder, o *GlGetQueryiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetQueryiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetQueryiv(e, obj.(*GlGetQueryiv))
}
func (*binaryClassGlGetQueryiv) New() binary.Object {
	return &GlGetQueryiv{}
}
func (*binaryClassGlGetQueryiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetQueryiv(d, obj.(*GlGetQueryiv))
}
func (c *binaryClassGlGetQueryiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetQueryiv]
}

type binaryClassGlGetQueryivEXT struct{}

func (*GlGetQueryivEXT) Class() binary.Class {
	return (*binaryClassGlGetQueryivEXT)(nil)
}
func doEncodeGlGetQueryivEXT(e binary.Encoder, o *GlGetQueryivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetQueryivEXT(d binary.Decoder, o *GlGetQueryivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetQueryivEXT(d binary.Decoder, o *GlGetQueryivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetQueryivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetQueryivEXT(e, obj.(*GlGetQueryivEXT))
}
func (*binaryClassGlGetQueryivEXT) New() binary.Object {
	return &GlGetQueryivEXT{}
}
func (*binaryClassGlGetQueryivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetQueryivEXT(d, obj.(*GlGetQueryivEXT))
}
func (c *binaryClassGlGetQueryivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetQueryivEXT]
}

type binaryClassGlGetRenderbufferParameteriv struct{}

func (*GlGetRenderbufferParameteriv) Class() binary.Class {
	return (*binaryClassGlGetRenderbufferParameteriv)(nil)
}
func doEncodeGlGetRenderbufferParameteriv(e binary.Encoder, o *GlGetRenderbufferParameteriv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Values)
}
func doDecodeGlGetRenderbufferParameteriv(d binary.Decoder, o *GlGetRenderbufferParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetRenderbufferParameteriv(d binary.Decoder, o *GlGetRenderbufferParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetRenderbufferParameteriv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetRenderbufferParameteriv(e, obj.(*GlGetRenderbufferParameteriv))
}
func (*binaryClassGlGetRenderbufferParameteriv) New() binary.Object {
	return &GlGetRenderbufferParameteriv{}
}
func (*binaryClassGlGetRenderbufferParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetRenderbufferParameteriv(d, obj.(*GlGetRenderbufferParameteriv))
}
func (c *binaryClassGlGetRenderbufferParameteriv) Schema() *binary.Entity {
	return &entities[ixǁGlGetRenderbufferParameteriv]
}

type binaryClassGlGetRenderbufferParameterivOES struct{}

func (*GlGetRenderbufferParameterivOES) Class() binary.Class {
	return (*binaryClassGlGetRenderbufferParameterivOES)(nil)
}
func doEncodeGlGetRenderbufferParameterivOES(e binary.Encoder, o *GlGetRenderbufferParameterivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetRenderbufferParameterivOES(d binary.Decoder, o *GlGetRenderbufferParameterivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetRenderbufferParameterivOES(d binary.Decoder, o *GlGetRenderbufferParameterivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetRenderbufferParameterivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetRenderbufferParameterivOES(e, obj.(*GlGetRenderbufferParameterivOES))
}
func (*binaryClassGlGetRenderbufferParameterivOES) New() binary.Object {
	return &GlGetRenderbufferParameterivOES{}
}
func (*binaryClassGlGetRenderbufferParameterivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetRenderbufferParameterivOES(d, obj.(*GlGetRenderbufferParameterivOES))
}
func (c *binaryClassGlGetRenderbufferParameterivOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetRenderbufferParameterivOES]
}

type binaryClassGlGetSamplerParameterIiv struct{}

func (*GlGetSamplerParameterIiv) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameterIiv)(nil)
}
func doEncodeGlGetSamplerParameterIiv(e binary.Encoder, o *GlGetSamplerParameterIiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetSamplerParameterIiv(d binary.Decoder, o *GlGetSamplerParameterIiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetSamplerParameterIiv(d binary.Decoder, o *GlGetSamplerParameterIiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetSamplerParameterIiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetSamplerParameterIiv(e, obj.(*GlGetSamplerParameterIiv))
}
func (*binaryClassGlGetSamplerParameterIiv) New() binary.Object {
	return &GlGetSamplerParameterIiv{}
}
func (*binaryClassGlGetSamplerParameterIiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetSamplerParameterIiv(d, obj.(*GlGetSamplerParameterIiv))
}
func (c *binaryClassGlGetSamplerParameterIiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetSamplerParameterIiv]
}

type binaryClassGlGetSamplerParameterIivEXT struct{}

func (*GlGetSamplerParameterIivEXT) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameterIivEXT)(nil)
}
func doEncodeGlGetSamplerParameterIivEXT(e binary.Encoder, o *GlGetSamplerParameterIivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetSamplerParameterIivEXT(d binary.Decoder, o *GlGetSamplerParameterIivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetSamplerParameterIivEXT(d binary.Decoder, o *GlGetSamplerParameterIivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetSamplerParameterIivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetSamplerParameterIivEXT(e, obj.(*GlGetSamplerParameterIivEXT))
}
func (*binaryClassGlGetSamplerParameterIivEXT) New() binary.Object {
	return &GlGetSamplerParameterIivEXT{}
}
func (*binaryClassGlGetSamplerParameterIivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetSamplerParameterIivEXT(d, obj.(*GlGetSamplerParameterIivEXT))
}
func (c *binaryClassGlGetSamplerParameterIivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetSamplerParameterIivEXT]
}

type binaryClassGlGetSamplerParameterIivOES struct{}

func (*GlGetSamplerParameterIivOES) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameterIivOES)(nil)
}
func doEncodeGlGetSamplerParameterIivOES(e binary.Encoder, o *GlGetSamplerParameterIivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetSamplerParameterIivOES(d binary.Decoder, o *GlGetSamplerParameterIivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetSamplerParameterIivOES(d binary.Decoder, o *GlGetSamplerParameterIivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetSamplerParameterIivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetSamplerParameterIivOES(e, obj.(*GlGetSamplerParameterIivOES))
}
func (*binaryClassGlGetSamplerParameterIivOES) New() binary.Object {
	return &GlGetSamplerParameterIivOES{}
}
func (*binaryClassGlGetSamplerParameterIivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetSamplerParameterIivOES(d, obj.(*GlGetSamplerParameterIivOES))
}
func (c *binaryClassGlGetSamplerParameterIivOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetSamplerParameterIivOES]
}

type binaryClassGlGetSamplerParameterIuiv struct{}

func (*GlGetSamplerParameterIuiv) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameterIuiv)(nil)
}
func doEncodeGlGetSamplerParameterIuiv(e binary.Encoder, o *GlGetSamplerParameterIuiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetSamplerParameterIuiv(d binary.Decoder, o *GlGetSamplerParameterIuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetSamplerParameterIuiv(d binary.Decoder, o *GlGetSamplerParameterIuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetSamplerParameterIuiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetSamplerParameterIuiv(e, obj.(*GlGetSamplerParameterIuiv))
}
func (*binaryClassGlGetSamplerParameterIuiv) New() binary.Object {
	return &GlGetSamplerParameterIuiv{}
}
func (*binaryClassGlGetSamplerParameterIuiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetSamplerParameterIuiv(d, obj.(*GlGetSamplerParameterIuiv))
}
func (c *binaryClassGlGetSamplerParameterIuiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetSamplerParameterIuiv]
}

type binaryClassGlGetSamplerParameterIuivEXT struct{}

func (*GlGetSamplerParameterIuivEXT) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameterIuivEXT)(nil)
}
func doEncodeGlGetSamplerParameterIuivEXT(e binary.Encoder, o *GlGetSamplerParameterIuivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetSamplerParameterIuivEXT(d binary.Decoder, o *GlGetSamplerParameterIuivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetSamplerParameterIuivEXT(d binary.Decoder, o *GlGetSamplerParameterIuivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetSamplerParameterIuivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetSamplerParameterIuivEXT(e, obj.(*GlGetSamplerParameterIuivEXT))
}
func (*binaryClassGlGetSamplerParameterIuivEXT) New() binary.Object {
	return &GlGetSamplerParameterIuivEXT{}
}
func (*binaryClassGlGetSamplerParameterIuivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetSamplerParameterIuivEXT(d, obj.(*GlGetSamplerParameterIuivEXT))
}
func (c *binaryClassGlGetSamplerParameterIuivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetSamplerParameterIuivEXT]
}

type binaryClassGlGetSamplerParameterIuivOES struct{}

func (*GlGetSamplerParameterIuivOES) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameterIuivOES)(nil)
}
func doEncodeGlGetSamplerParameterIuivOES(e binary.Encoder, o *GlGetSamplerParameterIuivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetSamplerParameterIuivOES(d binary.Decoder, o *GlGetSamplerParameterIuivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetSamplerParameterIuivOES(d binary.Decoder, o *GlGetSamplerParameterIuivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetSamplerParameterIuivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetSamplerParameterIuivOES(e, obj.(*GlGetSamplerParameterIuivOES))
}
func (*binaryClassGlGetSamplerParameterIuivOES) New() binary.Object {
	return &GlGetSamplerParameterIuivOES{}
}
func (*binaryClassGlGetSamplerParameterIuivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetSamplerParameterIuivOES(d, obj.(*GlGetSamplerParameterIuivOES))
}
func (c *binaryClassGlGetSamplerParameterIuivOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetSamplerParameterIuivOES]
}

type binaryClassGlGetSamplerParameterfv struct{}

func (*GlGetSamplerParameterfv) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameterfv)(nil)
}
func doEncodeGlGetSamplerParameterfv(e binary.Encoder, o *GlGetSamplerParameterfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetSamplerParameterfv(d binary.Decoder, o *GlGetSamplerParameterfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetSamplerParameterfv(d binary.Decoder, o *GlGetSamplerParameterfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetSamplerParameterfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetSamplerParameterfv(e, obj.(*GlGetSamplerParameterfv))
}
func (*binaryClassGlGetSamplerParameterfv) New() binary.Object {
	return &GlGetSamplerParameterfv{}
}
func (*binaryClassGlGetSamplerParameterfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetSamplerParameterfv(d, obj.(*GlGetSamplerParameterfv))
}
func (c *binaryClassGlGetSamplerParameterfv) Schema() *binary.Entity {
	return &entities[ixǁGlGetSamplerParameterfv]
}

type binaryClassGlGetSamplerParameteriv struct{}

func (*GlGetSamplerParameteriv) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameteriv)(nil)
}
func doEncodeGlGetSamplerParameteriv(e binary.Encoder, o *GlGetSamplerParameteriv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetSamplerParameteriv(d binary.Decoder, o *GlGetSamplerParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetSamplerParameteriv(d binary.Decoder, o *GlGetSamplerParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetSamplerParameteriv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetSamplerParameteriv(e, obj.(*GlGetSamplerParameteriv))
}
func (*binaryClassGlGetSamplerParameteriv) New() binary.Object {
	return &GlGetSamplerParameteriv{}
}
func (*binaryClassGlGetSamplerParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetSamplerParameteriv(d, obj.(*GlGetSamplerParameteriv))
}
func (c *binaryClassGlGetSamplerParameteriv) Schema() *binary.Entity {
	return &entities[ixǁGlGetSamplerParameteriv]
}

type binaryClassGlGetShaderInfoLog struct{}

func (*GlGetShaderInfoLog) Class() binary.Class {
	return (*binaryClassGlGetShaderInfoLog)(nil)
}
func doEncodeGlGetShaderInfoLog(e binary.Encoder, o *GlGetShaderInfoLog) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Shader))
	e.Int32(int32(o.BufferLength))
	e.Simple(&o.StringLengthWritten)
	e.Simple(&o.Info)
}
func doDecodeGlGetShaderInfoLog(d binary.Decoder, o *GlGetShaderInfoLog) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
	o.BufferLength = GLsizei(d.Int32())
	d.Simple(&o.StringLengthWritten)
	d.Simple(&o.Info)
}
func doDecodeRawGlGetShaderInfoLog(d binary.Decoder, o *GlGetShaderInfoLog) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
	o.BufferLength = GLsizei(d.Int32())
	d.Simple(&o.StringLengthWritten)
	d.Simple(&o.Info)
}
func (*binaryClassGlGetShaderInfoLog) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetShaderInfoLog(e, obj.(*GlGetShaderInfoLog))
}
func (*binaryClassGlGetShaderInfoLog) New() binary.Object {
	return &GlGetShaderInfoLog{}
}
func (*binaryClassGlGetShaderInfoLog) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetShaderInfoLog(d, obj.(*GlGetShaderInfoLog))
}
func (c *binaryClassGlGetShaderInfoLog) Schema() *binary.Entity {
	return &entities[ixǁGlGetShaderInfoLog]
}

type binaryClassGlGetShaderPrecisionFormat struct{}

func (*GlGetShaderPrecisionFormat) Class() binary.Class {
	return (*binaryClassGlGetShaderPrecisionFormat)(nil)
}
func doEncodeGlGetShaderPrecisionFormat(e binary.Encoder, o *GlGetShaderPrecisionFormat) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.ShaderType))
	e.Uint32(uint32(o.PrecisionType))
	e.Simple(&o.Range)
	e.Simple(&o.Precision)
}
func doDecodeGlGetShaderPrecisionFormat(d binary.Decoder, o *GlGetShaderPrecisionFormat) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ShaderType = GLenum(d.Uint32())
	o.PrecisionType = GLenum(d.Uint32())
	d.Simple(&o.Range)
	d.Simple(&o.Precision)
}
func doDecodeRawGlGetShaderPrecisionFormat(d binary.Decoder, o *GlGetShaderPrecisionFormat) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ShaderType = GLenum(d.Uint32())
	o.PrecisionType = GLenum(d.Uint32())
	d.Simple(&o.Range)
	d.Simple(&o.Precision)
}
func (*binaryClassGlGetShaderPrecisionFormat) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetShaderPrecisionFormat(e, obj.(*GlGetShaderPrecisionFormat))
}
func (*binaryClassGlGetShaderPrecisionFormat) New() binary.Object {
	return &GlGetShaderPrecisionFormat{}
}
func (*binaryClassGlGetShaderPrecisionFormat) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetShaderPrecisionFormat(d, obj.(*GlGetShaderPrecisionFormat))
}
func (c *binaryClassGlGetShaderPrecisionFormat) Schema() *binary.Entity {
	return &entities[ixǁGlGetShaderPrecisionFormat]
}

type binaryClassGlGetShaderSource struct{}

func (*GlGetShaderSource) Class() binary.Class {
	return (*binaryClassGlGetShaderSource)(nil)
}
func doEncodeGlGetShaderSource(e binary.Encoder, o *GlGetShaderSource) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Shader))
	e.Int32(int32(o.BufferLength))
	e.Simple(&o.StringLengthWritten)
	e.Simple(&o.Source)
}
func doDecodeGlGetShaderSource(d binary.Decoder, o *GlGetShaderSource) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
	o.BufferLength = GLsizei(d.Int32())
	d.Simple(&o.StringLengthWritten)
	d.Simple(&o.Source)
}
func doDecodeRawGlGetShaderSource(d binary.Decoder, o *GlGetShaderSource) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
	o.BufferLength = GLsizei(d.Int32())
	d.Simple(&o.StringLengthWritten)
	d.Simple(&o.Source)
}
func (*binaryClassGlGetShaderSource) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetShaderSource(e, obj.(*GlGetShaderSource))
}
func (*binaryClassGlGetShaderSource) New() binary.Object {
	return &GlGetShaderSource{}
}
func (*binaryClassGlGetShaderSource) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetShaderSource(d, obj.(*GlGetShaderSource))
}
func (c *binaryClassGlGetShaderSource) Schema() *binary.Entity {
	return &entities[ixǁGlGetShaderSource]
}

type binaryClassGlGetShaderiv struct{}

func (*GlGetShaderiv) Class() binary.Class {
	return (*binaryClassGlGetShaderiv)(nil)
}
func doEncodeGlGetShaderiv(e binary.Encoder, o *GlGetShaderiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Shader))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Value)
}
func doDecodeGlGetShaderiv(d binary.Decoder, o *GlGetShaderiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlGetShaderiv(d binary.Decoder, o *GlGetShaderiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlGetShaderiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetShaderiv(e, obj.(*GlGetShaderiv))
}
func (*binaryClassGlGetShaderiv) New() binary.Object {
	return &GlGetShaderiv{}
}
func (*binaryClassGlGetShaderiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetShaderiv(d, obj.(*GlGetShaderiv))
}
func (c *binaryClassGlGetShaderiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetShaderiv]
}

type binaryClassGlGetString struct{}

func (*GlGetString) Class() binary.Class {
	return (*binaryClassGlGetString)(nil)
}
func doEncodeGlGetString(e binary.Encoder, o *GlGetString) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Param))
	e.Simple(&o.Result)
}
func doDecodeGlGetString(d binary.Decoder, o *GlGetString) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	d.Simple(&o.Result)
}
func doDecodeRawGlGetString(d binary.Decoder, o *GlGetString) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Param = GLenum(d.Uint32())
	d.Simple(&o.Result)
}
func (*binaryClassGlGetString) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetString(e, obj.(*GlGetString))
}
func (*binaryClassGlGetString) New() binary.Object {
	return &GlGetString{}
}
func (*binaryClassGlGetString) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetString(d, obj.(*GlGetString))
}
func (c *binaryClassGlGetString) Schema() *binary.Entity {
	return &entities[ixǁGlGetString]
}

type binaryClassGlGetStringi struct{}

func (*GlGetStringi) Class() binary.Class {
	return (*binaryClassGlGetStringi)(nil)
}
func doEncodeGlGetStringi(e binary.Encoder, o *GlGetStringi) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Name))
	e.Uint32(uint32(o.Index))
	e.Simple(&o.Result)
}
func doDecodeGlGetStringi(d binary.Decoder, o *GlGetStringi) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Name = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Result)
}
func doDecodeRawGlGetStringi(d binary.Decoder, o *GlGetStringi) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Name = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.Result)
}
func (*binaryClassGlGetStringi) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetStringi(e, obj.(*GlGetStringi))
}
func (*binaryClassGlGetStringi) New() binary.Object {
	return &GlGetStringi{}
}
func (*binaryClassGlGetStringi) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetStringi(d, obj.(*GlGetStringi))
}
func (c *binaryClassGlGetStringi) Schema() *binary.Entity {
	return &entities[ixǁGlGetStringi]
}

type binaryClassGlGetSynciv struct{}

func (*GlGetSynciv) Class() binary.Class {
	return (*binaryClassGlGetSynciv)(nil)
}
func doEncodeGlGetSynciv(e binary.Encoder, o *GlGetSynciv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Sync)
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.Values)
}
func doDecodeGlGetSynciv(d binary.Decoder, o *GlGetSynciv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.Pname = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Values)
}
func doDecodeRawGlGetSynciv(d binary.Decoder, o *GlGetSynciv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.Pname = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Values)
}
func (*binaryClassGlGetSynciv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetSynciv(e, obj.(*GlGetSynciv))
}
func (*binaryClassGlGetSynciv) New() binary.Object {
	return &GlGetSynciv{}
}
func (*binaryClassGlGetSynciv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetSynciv(d, obj.(*GlGetSynciv))
}
func (c *binaryClassGlGetSynciv) Schema() *binary.Entity {
	return &entities[ixǁGlGetSynciv]
}

type binaryClassGlGetSyncivAPPLE struct{}

func (*GlGetSyncivAPPLE) Class() binary.Class {
	return (*binaryClassGlGetSyncivAPPLE)(nil)
}
func doEncodeGlGetSyncivAPPLE(e binary.Encoder, o *GlGetSyncivAPPLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Sync)
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.Values)
}
func doDecodeGlGetSyncivAPPLE(d binary.Decoder, o *GlGetSyncivAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.Pname = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Values)
}
func doDecodeRawGlGetSyncivAPPLE(d binary.Decoder, o *GlGetSyncivAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.Pname = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Values)
}
func (*binaryClassGlGetSyncivAPPLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetSyncivAPPLE(e, obj.(*GlGetSyncivAPPLE))
}
func (*binaryClassGlGetSyncivAPPLE) New() binary.Object {
	return &GlGetSyncivAPPLE{}
}
func (*binaryClassGlGetSyncivAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetSyncivAPPLE(d, obj.(*GlGetSyncivAPPLE))
}
func (c *binaryClassGlGetSyncivAPPLE) Schema() *binary.Entity {
	return &entities[ixǁGlGetSyncivAPPLE]
}

type binaryClassGlGetTexEnvfv struct{}

func (*GlGetTexEnvfv) Class() binary.Class {
	return (*binaryClassGlGetTexEnvfv)(nil)
}
func doEncodeGlGetTexEnvfv(e binary.Encoder, o *GlGetTexEnvfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexEnvfv(d binary.Decoder, o *GlGetTexEnvfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexEnvfv(d binary.Decoder, o *GlGetTexEnvfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexEnvfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexEnvfv(e, obj.(*GlGetTexEnvfv))
}
func (*binaryClassGlGetTexEnvfv) New() binary.Object {
	return &GlGetTexEnvfv{}
}
func (*binaryClassGlGetTexEnvfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexEnvfv(d, obj.(*GlGetTexEnvfv))
}
func (c *binaryClassGlGetTexEnvfv) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexEnvfv]
}

type binaryClassGlGetTexEnviv struct{}

func (*GlGetTexEnviv) Class() binary.Class {
	return (*binaryClassGlGetTexEnviv)(nil)
}
func doEncodeGlGetTexEnviv(e binary.Encoder, o *GlGetTexEnviv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexEnviv(d binary.Decoder, o *GlGetTexEnviv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexEnviv(d binary.Decoder, o *GlGetTexEnviv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexEnviv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexEnviv(e, obj.(*GlGetTexEnviv))
}
func (*binaryClassGlGetTexEnviv) New() binary.Object {
	return &GlGetTexEnviv{}
}
func (*binaryClassGlGetTexEnviv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexEnviv(d, obj.(*GlGetTexEnviv))
}
func (c *binaryClassGlGetTexEnviv) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexEnviv]
}

type binaryClassGlGetTexEnvxv struct{}

func (*GlGetTexEnvxv) Class() binary.Class {
	return (*binaryClassGlGetTexEnvxv)(nil)
}
func doEncodeGlGetTexEnvxv(e binary.Encoder, o *GlGetTexEnvxv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexEnvxv(d binary.Decoder, o *GlGetTexEnvxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexEnvxv(d binary.Decoder, o *GlGetTexEnvxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexEnvxv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexEnvxv(e, obj.(*GlGetTexEnvxv))
}
func (*binaryClassGlGetTexEnvxv) New() binary.Object {
	return &GlGetTexEnvxv{}
}
func (*binaryClassGlGetTexEnvxv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexEnvxv(d, obj.(*GlGetTexEnvxv))
}
func (c *binaryClassGlGetTexEnvxv) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexEnvxv]
}

type binaryClassGlGetTexEnvxvOES struct{}

func (*GlGetTexEnvxvOES) Class() binary.Class {
	return (*binaryClassGlGetTexEnvxvOES)(nil)
}
func doEncodeGlGetTexEnvxvOES(e binary.Encoder, o *GlGetTexEnvxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexEnvxvOES(d binary.Decoder, o *GlGetTexEnvxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexEnvxvOES(d binary.Decoder, o *GlGetTexEnvxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexEnvxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexEnvxvOES(e, obj.(*GlGetTexEnvxvOES))
}
func (*binaryClassGlGetTexEnvxvOES) New() binary.Object {
	return &GlGetTexEnvxvOES{}
}
func (*binaryClassGlGetTexEnvxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexEnvxvOES(d, obj.(*GlGetTexEnvxvOES))
}
func (c *binaryClassGlGetTexEnvxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexEnvxvOES]
}

type binaryClassGlGetTexGenfvOES struct{}

func (*GlGetTexGenfvOES) Class() binary.Class {
	return (*binaryClassGlGetTexGenfvOES)(nil)
}
func doEncodeGlGetTexGenfvOES(e binary.Encoder, o *GlGetTexGenfvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Coord))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexGenfvOES(d binary.Decoder, o *GlGetTexGenfvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexGenfvOES(d binary.Decoder, o *GlGetTexGenfvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexGenfvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexGenfvOES(e, obj.(*GlGetTexGenfvOES))
}
func (*binaryClassGlGetTexGenfvOES) New() binary.Object {
	return &GlGetTexGenfvOES{}
}
func (*binaryClassGlGetTexGenfvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexGenfvOES(d, obj.(*GlGetTexGenfvOES))
}
func (c *binaryClassGlGetTexGenfvOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexGenfvOES]
}

type binaryClassGlGetTexGenivOES struct{}

func (*GlGetTexGenivOES) Class() binary.Class {
	return (*binaryClassGlGetTexGenivOES)(nil)
}
func doEncodeGlGetTexGenivOES(e binary.Encoder, o *GlGetTexGenivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Coord))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexGenivOES(d binary.Decoder, o *GlGetTexGenivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexGenivOES(d binary.Decoder, o *GlGetTexGenivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexGenivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexGenivOES(e, obj.(*GlGetTexGenivOES))
}
func (*binaryClassGlGetTexGenivOES) New() binary.Object {
	return &GlGetTexGenivOES{}
}
func (*binaryClassGlGetTexGenivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexGenivOES(d, obj.(*GlGetTexGenivOES))
}
func (c *binaryClassGlGetTexGenivOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexGenivOES]
}

type binaryClassGlGetTexGenxvOES struct{}

func (*GlGetTexGenxvOES) Class() binary.Class {
	return (*binaryClassGlGetTexGenxvOES)(nil)
}
func doEncodeGlGetTexGenxvOES(e binary.Encoder, o *GlGetTexGenxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Coord))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexGenxvOES(d binary.Decoder, o *GlGetTexGenxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexGenxvOES(d binary.Decoder, o *GlGetTexGenxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexGenxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexGenxvOES(e, obj.(*GlGetTexGenxvOES))
}
func (*binaryClassGlGetTexGenxvOES) New() binary.Object {
	return &GlGetTexGenxvOES{}
}
func (*binaryClassGlGetTexGenxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexGenxvOES(d, obj.(*GlGetTexGenxvOES))
}
func (c *binaryClassGlGetTexGenxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexGenxvOES]
}

type binaryClassGlGetTexLevelParameterfv struct{}

func (*GlGetTexLevelParameterfv) Class() binary.Class {
	return (*binaryClassGlGetTexLevelParameterfv)(nil)
}
func doEncodeGlGetTexLevelParameterfv(e binary.Encoder, o *GlGetTexLevelParameterfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexLevelParameterfv(d binary.Decoder, o *GlGetTexLevelParameterfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexLevelParameterfv(d binary.Decoder, o *GlGetTexLevelParameterfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexLevelParameterfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexLevelParameterfv(e, obj.(*GlGetTexLevelParameterfv))
}
func (*binaryClassGlGetTexLevelParameterfv) New() binary.Object {
	return &GlGetTexLevelParameterfv{}
}
func (*binaryClassGlGetTexLevelParameterfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexLevelParameterfv(d, obj.(*GlGetTexLevelParameterfv))
}
func (c *binaryClassGlGetTexLevelParameterfv) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexLevelParameterfv]
}

type binaryClassGlGetTexLevelParameteriv struct{}

func (*GlGetTexLevelParameteriv) Class() binary.Class {
	return (*binaryClassGlGetTexLevelParameteriv)(nil)
}
func doEncodeGlGetTexLevelParameteriv(e binary.Encoder, o *GlGetTexLevelParameteriv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexLevelParameteriv(d binary.Decoder, o *GlGetTexLevelParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexLevelParameteriv(d binary.Decoder, o *GlGetTexLevelParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexLevelParameteriv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexLevelParameteriv(e, obj.(*GlGetTexLevelParameteriv))
}
func (*binaryClassGlGetTexLevelParameteriv) New() binary.Object {
	return &GlGetTexLevelParameteriv{}
}
func (*binaryClassGlGetTexLevelParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexLevelParameteriv(d, obj.(*GlGetTexLevelParameteriv))
}
func (c *binaryClassGlGetTexLevelParameteriv) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexLevelParameteriv]
}

type binaryClassGlGetTexParameterIiv struct{}

func (*GlGetTexParameterIiv) Class() binary.Class {
	return (*binaryClassGlGetTexParameterIiv)(nil)
}
func doEncodeGlGetTexParameterIiv(e binary.Encoder, o *GlGetTexParameterIiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexParameterIiv(d binary.Decoder, o *GlGetTexParameterIiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexParameterIiv(d binary.Decoder, o *GlGetTexParameterIiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexParameterIiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexParameterIiv(e, obj.(*GlGetTexParameterIiv))
}
func (*binaryClassGlGetTexParameterIiv) New() binary.Object {
	return &GlGetTexParameterIiv{}
}
func (*binaryClassGlGetTexParameterIiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexParameterIiv(d, obj.(*GlGetTexParameterIiv))
}
func (c *binaryClassGlGetTexParameterIiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexParameterIiv]
}

type binaryClassGlGetTexParameterIivEXT struct{}

func (*GlGetTexParameterIivEXT) Class() binary.Class {
	return (*binaryClassGlGetTexParameterIivEXT)(nil)
}
func doEncodeGlGetTexParameterIivEXT(e binary.Encoder, o *GlGetTexParameterIivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexParameterIivEXT(d binary.Decoder, o *GlGetTexParameterIivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexParameterIivEXT(d binary.Decoder, o *GlGetTexParameterIivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexParameterIivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexParameterIivEXT(e, obj.(*GlGetTexParameterIivEXT))
}
func (*binaryClassGlGetTexParameterIivEXT) New() binary.Object {
	return &GlGetTexParameterIivEXT{}
}
func (*binaryClassGlGetTexParameterIivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexParameterIivEXT(d, obj.(*GlGetTexParameterIivEXT))
}
func (c *binaryClassGlGetTexParameterIivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexParameterIivEXT]
}

type binaryClassGlGetTexParameterIivOES struct{}

func (*GlGetTexParameterIivOES) Class() binary.Class {
	return (*binaryClassGlGetTexParameterIivOES)(nil)
}
func doEncodeGlGetTexParameterIivOES(e binary.Encoder, o *GlGetTexParameterIivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexParameterIivOES(d binary.Decoder, o *GlGetTexParameterIivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexParameterIivOES(d binary.Decoder, o *GlGetTexParameterIivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexParameterIivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexParameterIivOES(e, obj.(*GlGetTexParameterIivOES))
}
func (*binaryClassGlGetTexParameterIivOES) New() binary.Object {
	return &GlGetTexParameterIivOES{}
}
func (*binaryClassGlGetTexParameterIivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexParameterIivOES(d, obj.(*GlGetTexParameterIivOES))
}
func (c *binaryClassGlGetTexParameterIivOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexParameterIivOES]
}

type binaryClassGlGetTexParameterIuiv struct{}

func (*GlGetTexParameterIuiv) Class() binary.Class {
	return (*binaryClassGlGetTexParameterIuiv)(nil)
}
func doEncodeGlGetTexParameterIuiv(e binary.Encoder, o *GlGetTexParameterIuiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexParameterIuiv(d binary.Decoder, o *GlGetTexParameterIuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexParameterIuiv(d binary.Decoder, o *GlGetTexParameterIuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexParameterIuiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexParameterIuiv(e, obj.(*GlGetTexParameterIuiv))
}
func (*binaryClassGlGetTexParameterIuiv) New() binary.Object {
	return &GlGetTexParameterIuiv{}
}
func (*binaryClassGlGetTexParameterIuiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexParameterIuiv(d, obj.(*GlGetTexParameterIuiv))
}
func (c *binaryClassGlGetTexParameterIuiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexParameterIuiv]
}

type binaryClassGlGetTexParameterIuivEXT struct{}

func (*GlGetTexParameterIuivEXT) Class() binary.Class {
	return (*binaryClassGlGetTexParameterIuivEXT)(nil)
}
func doEncodeGlGetTexParameterIuivEXT(e binary.Encoder, o *GlGetTexParameterIuivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexParameterIuivEXT(d binary.Decoder, o *GlGetTexParameterIuivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexParameterIuivEXT(d binary.Decoder, o *GlGetTexParameterIuivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexParameterIuivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexParameterIuivEXT(e, obj.(*GlGetTexParameterIuivEXT))
}
func (*binaryClassGlGetTexParameterIuivEXT) New() binary.Object {
	return &GlGetTexParameterIuivEXT{}
}
func (*binaryClassGlGetTexParameterIuivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexParameterIuivEXT(d, obj.(*GlGetTexParameterIuivEXT))
}
func (c *binaryClassGlGetTexParameterIuivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexParameterIuivEXT]
}

type binaryClassGlGetTexParameterIuivOES struct{}

func (*GlGetTexParameterIuivOES) Class() binary.Class {
	return (*binaryClassGlGetTexParameterIuivOES)(nil)
}
func doEncodeGlGetTexParameterIuivOES(e binary.Encoder, o *GlGetTexParameterIuivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexParameterIuivOES(d binary.Decoder, o *GlGetTexParameterIuivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexParameterIuivOES(d binary.Decoder, o *GlGetTexParameterIuivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexParameterIuivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexParameterIuivOES(e, obj.(*GlGetTexParameterIuivOES))
}
func (*binaryClassGlGetTexParameterIuivOES) New() binary.Object {
	return &GlGetTexParameterIuivOES{}
}
func (*binaryClassGlGetTexParameterIuivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexParameterIuivOES(d, obj.(*GlGetTexParameterIuivOES))
}
func (c *binaryClassGlGetTexParameterIuivOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexParameterIuivOES]
}

type binaryClassGlGetTexParameterfv struct{}

func (*GlGetTexParameterfv) Class() binary.Class {
	return (*binaryClassGlGetTexParameterfv)(nil)
}
func doEncodeGlGetTexParameterfv(e binary.Encoder, o *GlGetTexParameterfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Values)
}
func doDecodeGlGetTexParameterfv(d binary.Decoder, o *GlGetTexParameterfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetTexParameterfv(d binary.Decoder, o *GlGetTexParameterfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetTexParameterfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexParameterfv(e, obj.(*GlGetTexParameterfv))
}
func (*binaryClassGlGetTexParameterfv) New() binary.Object {
	return &GlGetTexParameterfv{}
}
func (*binaryClassGlGetTexParameterfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexParameterfv(d, obj.(*GlGetTexParameterfv))
}
func (c *binaryClassGlGetTexParameterfv) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexParameterfv]
}

type binaryClassGlGetTexParameteriv struct{}

func (*GlGetTexParameteriv) Class() binary.Class {
	return (*binaryClassGlGetTexParameteriv)(nil)
}
func doEncodeGlGetTexParameteriv(e binary.Encoder, o *GlGetTexParameteriv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Parameter))
	e.Simple(&o.Values)
}
func doDecodeGlGetTexParameteriv(d binary.Decoder, o *GlGetTexParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetTexParameteriv(d binary.Decoder, o *GlGetTexParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetTexParameteriv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexParameteriv(e, obj.(*GlGetTexParameteriv))
}
func (*binaryClassGlGetTexParameteriv) New() binary.Object {
	return &GlGetTexParameteriv{}
}
func (*binaryClassGlGetTexParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexParameteriv(d, obj.(*GlGetTexParameteriv))
}
func (c *binaryClassGlGetTexParameteriv) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexParameteriv]
}

type binaryClassGlGetTexParameterxv struct{}

func (*GlGetTexParameterxv) Class() binary.Class {
	return (*binaryClassGlGetTexParameterxv)(nil)
}
func doEncodeGlGetTexParameterxv(e binary.Encoder, o *GlGetTexParameterxv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexParameterxv(d binary.Decoder, o *GlGetTexParameterxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexParameterxv(d binary.Decoder, o *GlGetTexParameterxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexParameterxv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexParameterxv(e, obj.(*GlGetTexParameterxv))
}
func (*binaryClassGlGetTexParameterxv) New() binary.Object {
	return &GlGetTexParameterxv{}
}
func (*binaryClassGlGetTexParameterxv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexParameterxv(d, obj.(*GlGetTexParameterxv))
}
func (c *binaryClassGlGetTexParameterxv) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexParameterxv]
}

type binaryClassGlGetTexParameterxvOES struct{}

func (*GlGetTexParameterxvOES) Class() binary.Class {
	return (*binaryClassGlGetTexParameterxvOES)(nil)
}
func doEncodeGlGetTexParameterxvOES(e binary.Encoder, o *GlGetTexParameterxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetTexParameterxvOES(d binary.Decoder, o *GlGetTexParameterxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetTexParameterxvOES(d binary.Decoder, o *GlGetTexParameterxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetTexParameterxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTexParameterxvOES(e, obj.(*GlGetTexParameterxvOES))
}
func (*binaryClassGlGetTexParameterxvOES) New() binary.Object {
	return &GlGetTexParameterxvOES{}
}
func (*binaryClassGlGetTexParameterxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTexParameterxvOES(d, obj.(*GlGetTexParameterxvOES))
}
func (c *binaryClassGlGetTexParameterxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlGetTexParameterxvOES]
}

type binaryClassGlGetTextureHandleNV struct{}

func (*GlGetTextureHandleNV) Class() binary.Class {
	return (*binaryClassGlGetTextureHandleNV)(nil)
}
func doEncodeGlGetTextureHandleNV(e binary.Encoder, o *GlGetTextureHandleNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
	e.Uint64(uint64(o.Result))
}
func doDecodeGlGetTextureHandleNV(d binary.Decoder, o *GlGetTextureHandleNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Result = GLuint64(d.Uint64())
}
func doDecodeRawGlGetTextureHandleNV(d binary.Decoder, o *GlGetTextureHandleNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Result = GLuint64(d.Uint64())
}
func (*binaryClassGlGetTextureHandleNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTextureHandleNV(e, obj.(*GlGetTextureHandleNV))
}
func (*binaryClassGlGetTextureHandleNV) New() binary.Object {
	return &GlGetTextureHandleNV{}
}
func (*binaryClassGlGetTextureHandleNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTextureHandleNV(d, obj.(*GlGetTextureHandleNV))
}
func (c *binaryClassGlGetTextureHandleNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetTextureHandleNV]
}

type binaryClassGlGetTextureSamplerHandleNV struct{}

func (*GlGetTextureSamplerHandleNV) Class() binary.Class {
	return (*binaryClassGlGetTextureSamplerHandleNV)(nil)
}
func doEncodeGlGetTextureSamplerHandleNV(e binary.Encoder, o *GlGetTextureSamplerHandleNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
	e.Uint32(uint32(o.Sampler))
	e.Uint64(uint64(o.Result))
}
func doDecodeGlGetTextureSamplerHandleNV(d binary.Decoder, o *GlGetTextureSamplerHandleNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Sampler = SamplerId(d.Uint32())
	o.Result = GLuint64(d.Uint64())
}
func doDecodeRawGlGetTextureSamplerHandleNV(d binary.Decoder, o *GlGetTextureSamplerHandleNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Sampler = SamplerId(d.Uint32())
	o.Result = GLuint64(d.Uint64())
}
func (*binaryClassGlGetTextureSamplerHandleNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTextureSamplerHandleNV(e, obj.(*GlGetTextureSamplerHandleNV))
}
func (*binaryClassGlGetTextureSamplerHandleNV) New() binary.Object {
	return &GlGetTextureSamplerHandleNV{}
}
func (*binaryClassGlGetTextureSamplerHandleNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTextureSamplerHandleNV(d, obj.(*GlGetTextureSamplerHandleNV))
}
func (c *binaryClassGlGetTextureSamplerHandleNV) Schema() *binary.Entity {
	return &entities[ixǁGlGetTextureSamplerHandleNV]
}

type binaryClassGlGetTransformFeedbackVarying struct{}

func (*GlGetTransformFeedbackVarying) Class() binary.Class {
	return (*binaryClassGlGetTransformFeedbackVarying)(nil)
}
func doEncodeGlGetTransformFeedbackVarying(e binary.Encoder, o *GlGetTransformFeedbackVarying) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.Index))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Length)
	e.Simple(&o.Size)
	e.Simple(&o.Type)
	e.Simple(&o.Name)
}
func doDecodeGlGetTransformFeedbackVarying(d binary.Decoder, o *GlGetTransformFeedbackVarying) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Size)
	d.Simple(&o.Type)
	d.Simple(&o.Name)
}
func doDecodeRawGlGetTransformFeedbackVarying(d binary.Decoder, o *GlGetTransformFeedbackVarying) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Size)
	d.Simple(&o.Type)
	d.Simple(&o.Name)
}
func (*binaryClassGlGetTransformFeedbackVarying) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTransformFeedbackVarying(e, obj.(*GlGetTransformFeedbackVarying))
}
func (*binaryClassGlGetTransformFeedbackVarying) New() binary.Object {
	return &GlGetTransformFeedbackVarying{}
}
func (*binaryClassGlGetTransformFeedbackVarying) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTransformFeedbackVarying(d, obj.(*GlGetTransformFeedbackVarying))
}
func (c *binaryClassGlGetTransformFeedbackVarying) Schema() *binary.Entity {
	return &entities[ixǁGlGetTransformFeedbackVarying]
}

type binaryClassGlGetTranslatedShaderSourceANGLE struct{}

func (*GlGetTranslatedShaderSourceANGLE) Class() binary.Class {
	return (*binaryClassGlGetTranslatedShaderSourceANGLE)(nil)
}
func doEncodeGlGetTranslatedShaderSourceANGLE(e binary.Encoder, o *GlGetTranslatedShaderSourceANGLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Shader))
	e.Int32(int32(o.Bufsize))
	e.Simple(&o.Length)
	e.Simple(&o.Source)
}
func doDecodeGlGetTranslatedShaderSourceANGLE(d binary.Decoder, o *GlGetTranslatedShaderSourceANGLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
	o.Bufsize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Source)
}
func doDecodeRawGlGetTranslatedShaderSourceANGLE(d binary.Decoder, o *GlGetTranslatedShaderSourceANGLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
	o.Bufsize = GLsizei(d.Int32())
	d.Simple(&o.Length)
	d.Simple(&o.Source)
}
func (*binaryClassGlGetTranslatedShaderSourceANGLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetTranslatedShaderSourceANGLE(e, obj.(*GlGetTranslatedShaderSourceANGLE))
}
func (*binaryClassGlGetTranslatedShaderSourceANGLE) New() binary.Object {
	return &GlGetTranslatedShaderSourceANGLE{}
}
func (*binaryClassGlGetTranslatedShaderSourceANGLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetTranslatedShaderSourceANGLE(d, obj.(*GlGetTranslatedShaderSourceANGLE))
}
func (c *binaryClassGlGetTranslatedShaderSourceANGLE) Schema() *binary.Entity {
	return &entities[ixǁGlGetTranslatedShaderSourceANGLE]
}

type binaryClassGlGetUniformBlockIndex struct{}

func (*GlGetUniformBlockIndex) Class() binary.Class {
	return (*binaryClassGlGetUniformBlockIndex)(nil)
}
func doEncodeGlGetUniformBlockIndex(e binary.Encoder, o *GlGetUniformBlockIndex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.String(o.UniformBlockName)
	e.Uint32(uint32(o.Result))
}
func doDecodeGlGetUniformBlockIndex(d binary.Decoder, o *GlGetUniformBlockIndex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.UniformBlockName = string(d.String())
	o.Result = UniformBlockId(d.Uint32())
}
func doDecodeRawGlGetUniformBlockIndex(d binary.Decoder, o *GlGetUniformBlockIndex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.UniformBlockName = string(d.String())
	o.Result = UniformBlockId(d.Uint32())
}
func (*binaryClassGlGetUniformBlockIndex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetUniformBlockIndex(e, obj.(*GlGetUniformBlockIndex))
}
func (*binaryClassGlGetUniformBlockIndex) New() binary.Object {
	return &GlGetUniformBlockIndex{}
}
func (*binaryClassGlGetUniformBlockIndex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetUniformBlockIndex(d, obj.(*GlGetUniformBlockIndex))
}
func (c *binaryClassGlGetUniformBlockIndex) Schema() *binary.Entity {
	return &entities[ixǁGlGetUniformBlockIndex]
}

type binaryClassUniformIndexᵖ struct{}

func (*UniformIndexᵖ) Class() binary.Class {
	return (*binaryClassUniformIndexᵖ)(nil)
}
func doEncodeUniformIndexᵖ(e binary.Writer, o *UniformIndexᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeUniformIndexᵖ(d binary.Reader, o *UniformIndexᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawUniformIndexᵖ(d binary.Reader, o *UniformIndexᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassUniformIndexᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeUniformIndexᵖ(e, obj.(*UniformIndexᵖ))
}
func (*binaryClassUniformIndexᵖ) New() binary.Object {
	return &UniformIndexᵖ{}
}
func (*binaryClassUniformIndexᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeUniformIndexᵖ(d, obj.(*UniformIndexᵖ))
}
func (o *UniformIndexᵖ) WriteSimple(w binary.Writer) {
	doEncodeUniformIndexᵖ(w, o)
}
func (o *UniformIndexᵖ) ReadSimple(r binary.Reader) {
	doDecodeUniformIndexᵖ(r, o)
}
func (c *binaryClassUniformIndexᵖ) Schema() *binary.Entity {
	return &entities[ixǁUniformIndexᵖ]
}

type binaryClassGlGetUniformIndices struct{}

func (*GlGetUniformIndices) Class() binary.Class {
	return (*binaryClassGlGetUniformIndices)(nil)
}
func doEncodeGlGetUniformIndices(e binary.Encoder, o *GlGetUniformIndices) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.UniformCount))
	e.Simple(&o.UniformNames)
	e.Simple(&o.UniformIndices)
}
func doDecodeGlGetUniformIndices(d binary.Decoder, o *GlGetUniformIndices) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.UniformCount = GLsizei(d.Int32())
	d.Simple(&o.UniformNames)
	d.Simple(&o.UniformIndices)
}
func doDecodeRawGlGetUniformIndices(d binary.Decoder, o *GlGetUniformIndices) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.UniformCount = GLsizei(d.Int32())
	d.Simple(&o.UniformNames)
	d.Simple(&o.UniformIndices)
}
func (*binaryClassGlGetUniformIndices) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetUniformIndices(e, obj.(*GlGetUniformIndices))
}
func (*binaryClassGlGetUniformIndices) New() binary.Object {
	return &GlGetUniformIndices{}
}
func (*binaryClassGlGetUniformIndices) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetUniformIndices(d, obj.(*GlGetUniformIndices))
}
func (c *binaryClassGlGetUniformIndices) Schema() *binary.Entity {
	return &entities[ixǁGlGetUniformIndices]
}

type binaryClassGlGetUniformLocation struct{}

func (*GlGetUniformLocation) Class() binary.Class {
	return (*binaryClassGlGetUniformLocation)(nil)
}
func doEncodeGlGetUniformLocation(e binary.Encoder, o *GlGetUniformLocation) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.String(o.Name)
	e.Int32(int32(o.Result))
}
func doDecodeGlGetUniformLocation(d binary.Decoder, o *GlGetUniformLocation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Name = string(d.String())
	o.Result = UniformLocation(d.Int32())
}
func doDecodeRawGlGetUniformLocation(d binary.Decoder, o *GlGetUniformLocation) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Name = string(d.String())
	o.Result = UniformLocation(d.Int32())
}
func (*binaryClassGlGetUniformLocation) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetUniformLocation(e, obj.(*GlGetUniformLocation))
}
func (*binaryClassGlGetUniformLocation) New() binary.Object {
	return &GlGetUniformLocation{}
}
func (*binaryClassGlGetUniformLocation) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetUniformLocation(d, obj.(*GlGetUniformLocation))
}
func (c *binaryClassGlGetUniformLocation) Schema() *binary.Entity {
	return &entities[ixǁGlGetUniformLocation]
}

type binaryClassGlGetUniformfv struct{}

func (*GlGetUniformfv) Class() binary.Class {
	return (*binaryClassGlGetUniformfv)(nil)
}
func doEncodeGlGetUniformfv(e binary.Encoder, o *GlGetUniformfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Simple(&o.Values)
}
func doDecodeGlGetUniformfv(d binary.Decoder, o *GlGetUniformfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetUniformfv(d binary.Decoder, o *GlGetUniformfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetUniformfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetUniformfv(e, obj.(*GlGetUniformfv))
}
func (*binaryClassGlGetUniformfv) New() binary.Object {
	return &GlGetUniformfv{}
}
func (*binaryClassGlGetUniformfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetUniformfv(d, obj.(*GlGetUniformfv))
}
func (c *binaryClassGlGetUniformfv) Schema() *binary.Entity {
	return &entities[ixǁGlGetUniformfv]
}

type binaryClassGlGetUniformiv struct{}

func (*GlGetUniformiv) Class() binary.Class {
	return (*binaryClassGlGetUniformiv)(nil)
}
func doEncodeGlGetUniformiv(e binary.Encoder, o *GlGetUniformiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Simple(&o.Values)
}
func doDecodeGlGetUniformiv(d binary.Decoder, o *GlGetUniformiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetUniformiv(d binary.Decoder, o *GlGetUniformiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetUniformiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetUniformiv(e, obj.(*GlGetUniformiv))
}
func (*binaryClassGlGetUniformiv) New() binary.Object {
	return &GlGetUniformiv{}
}
func (*binaryClassGlGetUniformiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetUniformiv(d, obj.(*GlGetUniformiv))
}
func (c *binaryClassGlGetUniformiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetUniformiv]
}

type binaryClassGlGetUniformuiv struct{}

func (*GlGetUniformuiv) Class() binary.Class {
	return (*binaryClassGlGetUniformuiv)(nil)
}
func doEncodeGlGetUniformuiv(e binary.Encoder, o *GlGetUniformuiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Simple(&o.Values)
}
func doDecodeGlGetUniformuiv(d binary.Decoder, o *GlGetUniformuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetUniformuiv(d binary.Decoder, o *GlGetUniformuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetUniformuiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetUniformuiv(e, obj.(*GlGetUniformuiv))
}
func (*binaryClassGlGetUniformuiv) New() binary.Object {
	return &GlGetUniformuiv{}
}
func (*binaryClassGlGetUniformuiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetUniformuiv(d, obj.(*GlGetUniformuiv))
}
func (c *binaryClassGlGetUniformuiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetUniformuiv]
}

type binaryClassGlGetVertexAttribIiv struct{}

func (*GlGetVertexAttribIiv) Class() binary.Class {
	return (*binaryClassGlGetVertexAttribIiv)(nil)
}
func doEncodeGlGetVertexAttribIiv(e binary.Encoder, o *GlGetVertexAttribIiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetVertexAttribIiv(d binary.Decoder, o *GlGetVertexAttribIiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetVertexAttribIiv(d binary.Decoder, o *GlGetVertexAttribIiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetVertexAttribIiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetVertexAttribIiv(e, obj.(*GlGetVertexAttribIiv))
}
func (*binaryClassGlGetVertexAttribIiv) New() binary.Object {
	return &GlGetVertexAttribIiv{}
}
func (*binaryClassGlGetVertexAttribIiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetVertexAttribIiv(d, obj.(*GlGetVertexAttribIiv))
}
func (c *binaryClassGlGetVertexAttribIiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetVertexAttribIiv]
}

type binaryClassGlGetVertexAttribIuiv struct{}

func (*GlGetVertexAttribIuiv) Class() binary.Class {
	return (*binaryClassGlGetVertexAttribIuiv)(nil)
}
func doEncodeGlGetVertexAttribIuiv(e binary.Encoder, o *GlGetVertexAttribIuiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetVertexAttribIuiv(d binary.Decoder, o *GlGetVertexAttribIuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetVertexAttribIuiv(d binary.Decoder, o *GlGetVertexAttribIuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetVertexAttribIuiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetVertexAttribIuiv(e, obj.(*GlGetVertexAttribIuiv))
}
func (*binaryClassGlGetVertexAttribIuiv) New() binary.Object {
	return &GlGetVertexAttribIuiv{}
}
func (*binaryClassGlGetVertexAttribIuiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetVertexAttribIuiv(d, obj.(*GlGetVertexAttribIuiv))
}
func (c *binaryClassGlGetVertexAttribIuiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetVertexAttribIuiv]
}

type binaryClassGlGetVertexAttribPointerv struct{}

func (*GlGetVertexAttribPointerv) Class() binary.Class {
	return (*binaryClassGlGetVertexAttribPointerv)(nil)
}
func doEncodeGlGetVertexAttribPointerv(e binary.Encoder, o *GlGetVertexAttribPointerv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Pointer)
}
func doDecodeGlGetVertexAttribPointerv(d binary.Decoder, o *GlGetVertexAttribPointerv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Pointer)
}
func doDecodeRawGlGetVertexAttribPointerv(d binary.Decoder, o *GlGetVertexAttribPointerv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Pointer)
}
func (*binaryClassGlGetVertexAttribPointerv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetVertexAttribPointerv(e, obj.(*GlGetVertexAttribPointerv))
}
func (*binaryClassGlGetVertexAttribPointerv) New() binary.Object {
	return &GlGetVertexAttribPointerv{}
}
func (*binaryClassGlGetVertexAttribPointerv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetVertexAttribPointerv(d, obj.(*GlGetVertexAttribPointerv))
}
func (c *binaryClassGlGetVertexAttribPointerv) Schema() *binary.Entity {
	return &entities[ixǁGlGetVertexAttribPointerv]
}

type binaryClassGlGetVertexAttribfv struct{}

func (*GlGetVertexAttribfv) Class() binary.Class {
	return (*binaryClassGlGetVertexAttribfv)(nil)
}
func doEncodeGlGetVertexAttribfv(e binary.Encoder, o *GlGetVertexAttribfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetVertexAttribfv(d binary.Decoder, o *GlGetVertexAttribfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetVertexAttribfv(d binary.Decoder, o *GlGetVertexAttribfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetVertexAttribfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetVertexAttribfv(e, obj.(*GlGetVertexAttribfv))
}
func (*binaryClassGlGetVertexAttribfv) New() binary.Object {
	return &GlGetVertexAttribfv{}
}
func (*binaryClassGlGetVertexAttribfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetVertexAttribfv(d, obj.(*GlGetVertexAttribfv))
}
func (c *binaryClassGlGetVertexAttribfv) Schema() *binary.Entity {
	return &entities[ixǁGlGetVertexAttribfv]
}

type binaryClassGlGetVertexAttribiv struct{}

func (*GlGetVertexAttribiv) Class() binary.Class {
	return (*binaryClassGlGetVertexAttribiv)(nil)
}
func doEncodeGlGetVertexAttribiv(e binary.Encoder, o *GlGetVertexAttribiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlGetVertexAttribiv(d binary.Decoder, o *GlGetVertexAttribiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetVertexAttribiv(d binary.Decoder, o *GlGetVertexAttribiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetVertexAttribiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetVertexAttribiv(e, obj.(*GlGetVertexAttribiv))
}
func (*binaryClassGlGetVertexAttribiv) New() binary.Object {
	return &GlGetVertexAttribiv{}
}
func (*binaryClassGlGetVertexAttribiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetVertexAttribiv(d, obj.(*GlGetVertexAttribiv))
}
func (c *binaryClassGlGetVertexAttribiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetVertexAttribiv]
}

type binaryClassGlGetnUniformfv struct{}

func (*GlGetnUniformfv) Class() binary.Class {
	return (*binaryClassGlGetnUniformfv)(nil)
}
func doEncodeGlGetnUniformfv(e binary.Encoder, o *GlGetnUniformfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Values)
}
func doDecodeGlGetnUniformfv(d binary.Decoder, o *GlGetnUniformfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetnUniformfv(d binary.Decoder, o *GlGetnUniformfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetnUniformfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetnUniformfv(e, obj.(*GlGetnUniformfv))
}
func (*binaryClassGlGetnUniformfv) New() binary.Object {
	return &GlGetnUniformfv{}
}
func (*binaryClassGlGetnUniformfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetnUniformfv(d, obj.(*GlGetnUniformfv))
}
func (c *binaryClassGlGetnUniformfv) Schema() *binary.Entity {
	return &entities[ixǁGlGetnUniformfv]
}

type binaryClassGlGetnUniformfvEXT struct{}

func (*GlGetnUniformfvEXT) Class() binary.Class {
	return (*binaryClassGlGetnUniformfvEXT)(nil)
}
func doEncodeGlGetnUniformfvEXT(e binary.Encoder, o *GlGetnUniformfvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Params)
}
func doDecodeGlGetnUniformfvEXT(d binary.Decoder, o *GlGetnUniformfvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetnUniformfvEXT(d binary.Decoder, o *GlGetnUniformfvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetnUniformfvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetnUniformfvEXT(e, obj.(*GlGetnUniformfvEXT))
}
func (*binaryClassGlGetnUniformfvEXT) New() binary.Object {
	return &GlGetnUniformfvEXT{}
}
func (*binaryClassGlGetnUniformfvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetnUniformfvEXT(d, obj.(*GlGetnUniformfvEXT))
}
func (c *binaryClassGlGetnUniformfvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetnUniformfvEXT]
}

type binaryClassGlGetnUniformfvKHR struct{}

func (*GlGetnUniformfvKHR) Class() binary.Class {
	return (*binaryClassGlGetnUniformfvKHR)(nil)
}
func doEncodeGlGetnUniformfvKHR(e binary.Encoder, o *GlGetnUniformfvKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Params)
}
func doDecodeGlGetnUniformfvKHR(d binary.Decoder, o *GlGetnUniformfvKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetnUniformfvKHR(d binary.Decoder, o *GlGetnUniformfvKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetnUniformfvKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetnUniformfvKHR(e, obj.(*GlGetnUniformfvKHR))
}
func (*binaryClassGlGetnUniformfvKHR) New() binary.Object {
	return &GlGetnUniformfvKHR{}
}
func (*binaryClassGlGetnUniformfvKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetnUniformfvKHR(d, obj.(*GlGetnUniformfvKHR))
}
func (c *binaryClassGlGetnUniformfvKHR) Schema() *binary.Entity {
	return &entities[ixǁGlGetnUniformfvKHR]
}

type binaryClassGlGetnUniformiv struct{}

func (*GlGetnUniformiv) Class() binary.Class {
	return (*binaryClassGlGetnUniformiv)(nil)
}
func doEncodeGlGetnUniformiv(e binary.Encoder, o *GlGetnUniformiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Values)
}
func doDecodeGlGetnUniformiv(d binary.Decoder, o *GlGetnUniformiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetnUniformiv(d binary.Decoder, o *GlGetnUniformiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetnUniformiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetnUniformiv(e, obj.(*GlGetnUniformiv))
}
func (*binaryClassGlGetnUniformiv) New() binary.Object {
	return &GlGetnUniformiv{}
}
func (*binaryClassGlGetnUniformiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetnUniformiv(d, obj.(*GlGetnUniformiv))
}
func (c *binaryClassGlGetnUniformiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetnUniformiv]
}

type binaryClassGlGetnUniformivEXT struct{}

func (*GlGetnUniformivEXT) Class() binary.Class {
	return (*binaryClassGlGetnUniformivEXT)(nil)
}
func doEncodeGlGetnUniformivEXT(e binary.Encoder, o *GlGetnUniformivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Params)
}
func doDecodeGlGetnUniformivEXT(d binary.Decoder, o *GlGetnUniformivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetnUniformivEXT(d binary.Decoder, o *GlGetnUniformivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetnUniformivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetnUniformivEXT(e, obj.(*GlGetnUniformivEXT))
}
func (*binaryClassGlGetnUniformivEXT) New() binary.Object {
	return &GlGetnUniformivEXT{}
}
func (*binaryClassGlGetnUniformivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetnUniformivEXT(d, obj.(*GlGetnUniformivEXT))
}
func (c *binaryClassGlGetnUniformivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlGetnUniformivEXT]
}

type binaryClassGlGetnUniformivKHR struct{}

func (*GlGetnUniformivKHR) Class() binary.Class {
	return (*binaryClassGlGetnUniformivKHR)(nil)
}
func doEncodeGlGetnUniformivKHR(e binary.Encoder, o *GlGetnUniformivKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Params)
}
func doDecodeGlGetnUniformivKHR(d binary.Decoder, o *GlGetnUniformivKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetnUniformivKHR(d binary.Decoder, o *GlGetnUniformivKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetnUniformivKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetnUniformivKHR(e, obj.(*GlGetnUniformivKHR))
}
func (*binaryClassGlGetnUniformivKHR) New() binary.Object {
	return &GlGetnUniformivKHR{}
}
func (*binaryClassGlGetnUniformivKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetnUniformivKHR(d, obj.(*GlGetnUniformivKHR))
}
func (c *binaryClassGlGetnUniformivKHR) Schema() *binary.Entity {
	return &entities[ixǁGlGetnUniformivKHR]
}

type binaryClassGlGetnUniformuiv struct{}

func (*GlGetnUniformuiv) Class() binary.Class {
	return (*binaryClassGlGetnUniformuiv)(nil)
}
func doEncodeGlGetnUniformuiv(e binary.Encoder, o *GlGetnUniformuiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Values)
}
func doDecodeGlGetnUniformuiv(d binary.Decoder, o *GlGetnUniformuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlGetnUniformuiv(d binary.Decoder, o *GlGetnUniformuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlGetnUniformuiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetnUniformuiv(e, obj.(*GlGetnUniformuiv))
}
func (*binaryClassGlGetnUniformuiv) New() binary.Object {
	return &GlGetnUniformuiv{}
}
func (*binaryClassGlGetnUniformuiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetnUniformuiv(d, obj.(*GlGetnUniformuiv))
}
func (c *binaryClassGlGetnUniformuiv) Schema() *binary.Entity {
	return &entities[ixǁGlGetnUniformuiv]
}

type binaryClassGlGetnUniformuivKHR struct{}

func (*GlGetnUniformuivKHR) Class() binary.Class {
	return (*binaryClassGlGetnUniformuivKHR)(nil)
}
func doEncodeGlGetnUniformuivKHR(e binary.Encoder, o *GlGetnUniformuivKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Params)
}
func doDecodeGlGetnUniformuivKHR(d binary.Decoder, o *GlGetnUniformuivKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func doDecodeRawGlGetnUniformuivKHR(d binary.Decoder, o *GlGetnUniformuivKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Params)
}
func (*binaryClassGlGetnUniformuivKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlGetnUniformuivKHR(e, obj.(*GlGetnUniformuivKHR))
}
func (*binaryClassGlGetnUniformuivKHR) New() binary.Object {
	return &GlGetnUniformuivKHR{}
}
func (*binaryClassGlGetnUniformuivKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlGetnUniformuivKHR(d, obj.(*GlGetnUniformuivKHR))
}
func (c *binaryClassGlGetnUniformuivKHR) Schema() *binary.Entity {
	return &entities[ixǁGlGetnUniformuivKHR]
}

type binaryClassGlHint struct{}

func (*GlHint) Class() binary.Class {
	return (*binaryClassGlHint)(nil)
}
func doEncodeGlHint(e binary.Encoder, o *GlHint) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Mode))
}
func doDecodeGlHint(d binary.Decoder, o *GlHint) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Mode = GLenum(d.Uint32())
}
func doDecodeRawGlHint(d binary.Decoder, o *GlHint) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Mode = GLenum(d.Uint32())
}
func (*binaryClassGlHint) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlHint(e, obj.(*GlHint))
}
func (*binaryClassGlHint) New() binary.Object {
	return &GlHint{}
}
func (*binaryClassGlHint) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlHint(d, obj.(*GlHint))
}
func (c *binaryClassGlHint) Schema() *binary.Entity {
	return &entities[ixǁGlHint]
}

type binaryClassGlInsertEventMarkerEXT struct{}

func (*GlInsertEventMarkerEXT) Class() binary.Class {
	return (*binaryClassGlInsertEventMarkerEXT)(nil)
}
func doEncodeGlInsertEventMarkerEXT(e binary.Encoder, o *GlInsertEventMarkerEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Length))
	e.Simple(&o.Marker)
}
func doDecodeGlInsertEventMarkerEXT(d binary.Decoder, o *GlInsertEventMarkerEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Marker)
}
func doDecodeRawGlInsertEventMarkerEXT(d binary.Decoder, o *GlInsertEventMarkerEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Marker)
}
func (*binaryClassGlInsertEventMarkerEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlInsertEventMarkerEXT(e, obj.(*GlInsertEventMarkerEXT))
}
func (*binaryClassGlInsertEventMarkerEXT) New() binary.Object {
	return &GlInsertEventMarkerEXT{}
}
func (*binaryClassGlInsertEventMarkerEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlInsertEventMarkerEXT(d, obj.(*GlInsertEventMarkerEXT))
}
func (c *binaryClassGlInsertEventMarkerEXT) Schema() *binary.Entity {
	return &entities[ixǁGlInsertEventMarkerEXT]
}

type binaryClassGlInterpolatePathsNV struct{}

func (*GlInterpolatePathsNV) Class() binary.Class {
	return (*binaryClassGlInterpolatePathsNV)(nil)
}
func doEncodeGlInterpolatePathsNV(e binary.Encoder, o *GlInterpolatePathsNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.ResultPath))
	e.Uint32(uint32(o.PathA))
	e.Uint32(uint32(o.PathB))
	e.Float32(float32(o.Weight))
}
func doDecodeGlInterpolatePathsNV(d binary.Decoder, o *GlInterpolatePathsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ResultPath = GLuint(d.Uint32())
	o.PathA = GLuint(d.Uint32())
	o.PathB = GLuint(d.Uint32())
	o.Weight = GLfloat(d.Float32())
}
func doDecodeRawGlInterpolatePathsNV(d binary.Decoder, o *GlInterpolatePathsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ResultPath = GLuint(d.Uint32())
	o.PathA = GLuint(d.Uint32())
	o.PathB = GLuint(d.Uint32())
	o.Weight = GLfloat(d.Float32())
}
func (*binaryClassGlInterpolatePathsNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlInterpolatePathsNV(e, obj.(*GlInterpolatePathsNV))
}
func (*binaryClassGlInterpolatePathsNV) New() binary.Object {
	return &GlInterpolatePathsNV{}
}
func (*binaryClassGlInterpolatePathsNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlInterpolatePathsNV(d, obj.(*GlInterpolatePathsNV))
}
func (c *binaryClassGlInterpolatePathsNV) Schema() *binary.Entity {
	return &entities[ixǁGlInterpolatePathsNV]
}

type binaryClassGlInvalidateFramebuffer struct{}

func (*GlInvalidateFramebuffer) Class() binary.Class {
	return (*binaryClassGlInvalidateFramebuffer)(nil)
}
func doEncodeGlInvalidateFramebuffer(e binary.Encoder, o *GlInvalidateFramebuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Count))
	e.Simple(&o.Attachments)
}
func doDecodeGlInvalidateFramebuffer(d binary.Decoder, o *GlInvalidateFramebuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Attachments)
}
func doDecodeRawGlInvalidateFramebuffer(d binary.Decoder, o *GlInvalidateFramebuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Attachments)
}
func (*binaryClassGlInvalidateFramebuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlInvalidateFramebuffer(e, obj.(*GlInvalidateFramebuffer))
}
func (*binaryClassGlInvalidateFramebuffer) New() binary.Object {
	return &GlInvalidateFramebuffer{}
}
func (*binaryClassGlInvalidateFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlInvalidateFramebuffer(d, obj.(*GlInvalidateFramebuffer))
}
func (c *binaryClassGlInvalidateFramebuffer) Schema() *binary.Entity {
	return &entities[ixǁGlInvalidateFramebuffer]
}

type binaryClassGlInvalidateSubFramebuffer struct{}

func (*GlInvalidateSubFramebuffer) Class() binary.Class {
	return (*binaryClassGlInvalidateSubFramebuffer)(nil)
}
func doEncodeGlInvalidateSubFramebuffer(e binary.Encoder, o *GlInvalidateSubFramebuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.NumAttachments))
	e.Simple(&o.Attachments)
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlInvalidateSubFramebuffer(d binary.Decoder, o *GlInvalidateSubFramebuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.NumAttachments = GLsizei(d.Int32())
	d.Simple(&o.Attachments)
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlInvalidateSubFramebuffer(d binary.Decoder, o *GlInvalidateSubFramebuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.NumAttachments = GLsizei(d.Int32())
	d.Simple(&o.Attachments)
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlInvalidateSubFramebuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlInvalidateSubFramebuffer(e, obj.(*GlInvalidateSubFramebuffer))
}
func (*binaryClassGlInvalidateSubFramebuffer) New() binary.Object {
	return &GlInvalidateSubFramebuffer{}
}
func (*binaryClassGlInvalidateSubFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlInvalidateSubFramebuffer(d, obj.(*GlInvalidateSubFramebuffer))
}
func (c *binaryClassGlInvalidateSubFramebuffer) Schema() *binary.Entity {
	return &entities[ixǁGlInvalidateSubFramebuffer]
}

type binaryClassGlIsBuffer struct{}

func (*GlIsBuffer) Class() binary.Class {
	return (*binaryClassGlIsBuffer)(nil)
}
func doEncodeGlIsBuffer(e binary.Encoder, o *GlIsBuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Buffer))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsBuffer(d binary.Decoder, o *GlIsBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buffer = BufferId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsBuffer(d binary.Decoder, o *GlIsBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Buffer = BufferId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsBuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsBuffer(e, obj.(*GlIsBuffer))
}
func (*binaryClassGlIsBuffer) New() binary.Object {
	return &GlIsBuffer{}
}
func (*binaryClassGlIsBuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsBuffer(d, obj.(*GlIsBuffer))
}
func (c *binaryClassGlIsBuffer) Schema() *binary.Entity {
	return &entities[ixǁGlIsBuffer]
}

type binaryClassGlIsEnabled struct{}

func (*GlIsEnabled) Class() binary.Class {
	return (*binaryClassGlIsEnabled)(nil)
}
func doEncodeGlIsEnabled(e binary.Encoder, o *GlIsEnabled) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Capability))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsEnabled(d binary.Decoder, o *GlIsEnabled) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Capability = GLenum(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsEnabled(d binary.Decoder, o *GlIsEnabled) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Capability = GLenum(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsEnabled) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsEnabled(e, obj.(*GlIsEnabled))
}
func (*binaryClassGlIsEnabled) New() binary.Object {
	return &GlIsEnabled{}
}
func (*binaryClassGlIsEnabled) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsEnabled(d, obj.(*GlIsEnabled))
}
func (c *binaryClassGlIsEnabled) Schema() *binary.Entity {
	return &entities[ixǁGlIsEnabled]
}

type binaryClassGlIsEnabledi struct{}

func (*GlIsEnabledi) Class() binary.Class {
	return (*binaryClassGlIsEnabledi)(nil)
}
func doEncodeGlIsEnabledi(e binary.Encoder, o *GlIsEnabledi) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Capability))
	e.Uint32(uint32(o.Index))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsEnabledi(d binary.Decoder, o *GlIsEnabledi) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Capability = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsEnabledi(d binary.Decoder, o *GlIsEnabledi) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Capability = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsEnabledi) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsEnabledi(e, obj.(*GlIsEnabledi))
}
func (*binaryClassGlIsEnabledi) New() binary.Object {
	return &GlIsEnabledi{}
}
func (*binaryClassGlIsEnabledi) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsEnabledi(d, obj.(*GlIsEnabledi))
}
func (c *binaryClassGlIsEnabledi) Schema() *binary.Entity {
	return &entities[ixǁGlIsEnabledi]
}

type binaryClassGlIsEnablediEXT struct{}

func (*GlIsEnablediEXT) Class() binary.Class {
	return (*binaryClassGlIsEnablediEXT)(nil)
}
func doEncodeGlIsEnablediEXT(e binary.Encoder, o *GlIsEnablediEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsEnablediEXT(d binary.Decoder, o *GlIsEnablediEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsEnablediEXT(d binary.Decoder, o *GlIsEnablediEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsEnablediEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsEnablediEXT(e, obj.(*GlIsEnablediEXT))
}
func (*binaryClassGlIsEnablediEXT) New() binary.Object {
	return &GlIsEnablediEXT{}
}
func (*binaryClassGlIsEnablediEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsEnablediEXT(d, obj.(*GlIsEnablediEXT))
}
func (c *binaryClassGlIsEnablediEXT) Schema() *binary.Entity {
	return &entities[ixǁGlIsEnablediEXT]
}

type binaryClassGlIsEnablediNV struct{}

func (*GlIsEnablediNV) Class() binary.Class {
	return (*binaryClassGlIsEnablediNV)(nil)
}
func doEncodeGlIsEnablediNV(e binary.Encoder, o *GlIsEnablediNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsEnablediNV(d binary.Decoder, o *GlIsEnablediNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsEnablediNV(d binary.Decoder, o *GlIsEnablediNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsEnablediNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsEnablediNV(e, obj.(*GlIsEnablediNV))
}
func (*binaryClassGlIsEnablediNV) New() binary.Object {
	return &GlIsEnablediNV{}
}
func (*binaryClassGlIsEnablediNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsEnablediNV(d, obj.(*GlIsEnablediNV))
}
func (c *binaryClassGlIsEnablediNV) Schema() *binary.Entity {
	return &entities[ixǁGlIsEnablediNV]
}

type binaryClassGlIsEnablediOES struct{}

func (*GlIsEnablediOES) Class() binary.Class {
	return (*binaryClassGlIsEnablediOES)(nil)
}
func doEncodeGlIsEnablediOES(e binary.Encoder, o *GlIsEnablediOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Index))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsEnablediOES(d binary.Decoder, o *GlIsEnablediOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsEnablediOES(d binary.Decoder, o *GlIsEnablediOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Index = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsEnablediOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsEnablediOES(e, obj.(*GlIsEnablediOES))
}
func (*binaryClassGlIsEnablediOES) New() binary.Object {
	return &GlIsEnablediOES{}
}
func (*binaryClassGlIsEnablediOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsEnablediOES(d, obj.(*GlIsEnablediOES))
}
func (c *binaryClassGlIsEnablediOES) Schema() *binary.Entity {
	return &entities[ixǁGlIsEnablediOES]
}

type binaryClassGlIsFenceNV struct{}

func (*GlIsFenceNV) Class() binary.Class {
	return (*binaryClassGlIsFenceNV)(nil)
}
func doEncodeGlIsFenceNV(e binary.Encoder, o *GlIsFenceNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Fence))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsFenceNV(d binary.Decoder, o *GlIsFenceNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Fence = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsFenceNV(d binary.Decoder, o *GlIsFenceNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Fence = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsFenceNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsFenceNV(e, obj.(*GlIsFenceNV))
}
func (*binaryClassGlIsFenceNV) New() binary.Object {
	return &GlIsFenceNV{}
}
func (*binaryClassGlIsFenceNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsFenceNV(d, obj.(*GlIsFenceNV))
}
func (c *binaryClassGlIsFenceNV) Schema() *binary.Entity {
	return &entities[ixǁGlIsFenceNV]
}

type binaryClassGlIsFramebuffer struct{}

func (*GlIsFramebuffer) Class() binary.Class {
	return (*binaryClassGlIsFramebuffer)(nil)
}
func doEncodeGlIsFramebuffer(e binary.Encoder, o *GlIsFramebuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Framebuffer))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsFramebuffer(d binary.Decoder, o *GlIsFramebuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Framebuffer = FramebufferId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsFramebuffer(d binary.Decoder, o *GlIsFramebuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Framebuffer = FramebufferId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsFramebuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsFramebuffer(e, obj.(*GlIsFramebuffer))
}
func (*binaryClassGlIsFramebuffer) New() binary.Object {
	return &GlIsFramebuffer{}
}
func (*binaryClassGlIsFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsFramebuffer(d, obj.(*GlIsFramebuffer))
}
func (c *binaryClassGlIsFramebuffer) Schema() *binary.Entity {
	return &entities[ixǁGlIsFramebuffer]
}

type binaryClassGlIsFramebufferOES struct{}

func (*GlIsFramebufferOES) Class() binary.Class {
	return (*binaryClassGlIsFramebufferOES)(nil)
}
func doEncodeGlIsFramebufferOES(e binary.Encoder, o *GlIsFramebufferOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Framebuffer))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsFramebufferOES(d binary.Decoder, o *GlIsFramebufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Framebuffer = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsFramebufferOES(d binary.Decoder, o *GlIsFramebufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Framebuffer = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsFramebufferOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsFramebufferOES(e, obj.(*GlIsFramebufferOES))
}
func (*binaryClassGlIsFramebufferOES) New() binary.Object {
	return &GlIsFramebufferOES{}
}
func (*binaryClassGlIsFramebufferOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsFramebufferOES(d, obj.(*GlIsFramebufferOES))
}
func (c *binaryClassGlIsFramebufferOES) Schema() *binary.Entity {
	return &entities[ixǁGlIsFramebufferOES]
}

type binaryClassGlIsImageHandleResidentNV struct{}

func (*GlIsImageHandleResidentNV) Class() binary.Class {
	return (*binaryClassGlIsImageHandleResidentNV)(nil)
}
func doEncodeGlIsImageHandleResidentNV(e binary.Encoder, o *GlIsImageHandleResidentNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint64(uint64(o.Handle))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsImageHandleResidentNV(d binary.Decoder, o *GlIsImageHandleResidentNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Handle = GLuint64(d.Uint64())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsImageHandleResidentNV(d binary.Decoder, o *GlIsImageHandleResidentNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Handle = GLuint64(d.Uint64())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsImageHandleResidentNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsImageHandleResidentNV(e, obj.(*GlIsImageHandleResidentNV))
}
func (*binaryClassGlIsImageHandleResidentNV) New() binary.Object {
	return &GlIsImageHandleResidentNV{}
}
func (*binaryClassGlIsImageHandleResidentNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsImageHandleResidentNV(d, obj.(*GlIsImageHandleResidentNV))
}
func (c *binaryClassGlIsImageHandleResidentNV) Schema() *binary.Entity {
	return &entities[ixǁGlIsImageHandleResidentNV]
}

type binaryClassGlIsPathNV struct{}

func (*GlIsPathNV) Class() binary.Class {
	return (*binaryClassGlIsPathNV)(nil)
}
func doEncodeGlIsPathNV(e binary.Encoder, o *GlIsPathNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsPathNV(d binary.Decoder, o *GlIsPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsPathNV(d binary.Decoder, o *GlIsPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsPathNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsPathNV(e, obj.(*GlIsPathNV))
}
func (*binaryClassGlIsPathNV) New() binary.Object {
	return &GlIsPathNV{}
}
func (*binaryClassGlIsPathNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsPathNV(d, obj.(*GlIsPathNV))
}
func (c *binaryClassGlIsPathNV) Schema() *binary.Entity {
	return &entities[ixǁGlIsPathNV]
}

type binaryClassGlIsPointInFillPathNV struct{}

func (*GlIsPointInFillPathNV) Class() binary.Class {
	return (*binaryClassGlIsPointInFillPathNV)(nil)
}
func doEncodeGlIsPointInFillPathNV(e binary.Encoder, o *GlIsPointInFillPathNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint32(uint32(o.Mask))
	e.Float32(float32(o.X))
	e.Float32(float32(o.Y))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsPointInFillPathNV(d binary.Decoder, o *GlIsPointInFillPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Mask = GLuint(d.Uint32())
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsPointInFillPathNV(d binary.Decoder, o *GlIsPointInFillPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Mask = GLuint(d.Uint32())
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsPointInFillPathNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsPointInFillPathNV(e, obj.(*GlIsPointInFillPathNV))
}
func (*binaryClassGlIsPointInFillPathNV) New() binary.Object {
	return &GlIsPointInFillPathNV{}
}
func (*binaryClassGlIsPointInFillPathNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsPointInFillPathNV(d, obj.(*GlIsPointInFillPathNV))
}
func (c *binaryClassGlIsPointInFillPathNV) Schema() *binary.Entity {
	return &entities[ixǁGlIsPointInFillPathNV]
}

type binaryClassGlIsPointInStrokePathNV struct{}

func (*GlIsPointInStrokePathNV) Class() binary.Class {
	return (*binaryClassGlIsPointInStrokePathNV)(nil)
}
func doEncodeGlIsPointInStrokePathNV(e binary.Encoder, o *GlIsPointInStrokePathNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Float32(float32(o.X))
	e.Float32(float32(o.Y))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsPointInStrokePathNV(d binary.Decoder, o *GlIsPointInStrokePathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsPointInStrokePathNV(d binary.Decoder, o *GlIsPointInStrokePathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsPointInStrokePathNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsPointInStrokePathNV(e, obj.(*GlIsPointInStrokePathNV))
}
func (*binaryClassGlIsPointInStrokePathNV) New() binary.Object {
	return &GlIsPointInStrokePathNV{}
}
func (*binaryClassGlIsPointInStrokePathNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsPointInStrokePathNV(d, obj.(*GlIsPointInStrokePathNV))
}
func (c *binaryClassGlIsPointInStrokePathNV) Schema() *binary.Entity {
	return &entities[ixǁGlIsPointInStrokePathNV]
}

type binaryClassGlIsProgram struct{}

func (*GlIsProgram) Class() binary.Class {
	return (*binaryClassGlIsProgram)(nil)
}
func doEncodeGlIsProgram(e binary.Encoder, o *GlIsProgram) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsProgram(d binary.Decoder, o *GlIsProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsProgram(d binary.Decoder, o *GlIsProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsProgram) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsProgram(e, obj.(*GlIsProgram))
}
func (*binaryClassGlIsProgram) New() binary.Object {
	return &GlIsProgram{}
}
func (*binaryClassGlIsProgram) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsProgram(d, obj.(*GlIsProgram))
}
func (c *binaryClassGlIsProgram) Schema() *binary.Entity {
	return &entities[ixǁGlIsProgram]
}

type binaryClassGlIsProgramPipeline struct{}

func (*GlIsProgramPipeline) Class() binary.Class {
	return (*binaryClassGlIsProgramPipeline)(nil)
}
func doEncodeGlIsProgramPipeline(e binary.Encoder, o *GlIsProgramPipeline) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsProgramPipeline(d binary.Decoder, o *GlIsProgramPipeline) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsProgramPipeline(d binary.Decoder, o *GlIsProgramPipeline) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsProgramPipeline) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsProgramPipeline(e, obj.(*GlIsProgramPipeline))
}
func (*binaryClassGlIsProgramPipeline) New() binary.Object {
	return &GlIsProgramPipeline{}
}
func (*binaryClassGlIsProgramPipeline) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsProgramPipeline(d, obj.(*GlIsProgramPipeline))
}
func (c *binaryClassGlIsProgramPipeline) Schema() *binary.Entity {
	return &entities[ixǁGlIsProgramPipeline]
}

type binaryClassGlIsProgramPipelineEXT struct{}

func (*GlIsProgramPipelineEXT) Class() binary.Class {
	return (*binaryClassGlIsProgramPipelineEXT)(nil)
}
func doEncodeGlIsProgramPipelineEXT(e binary.Encoder, o *GlIsProgramPipelineEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsProgramPipelineEXT(d binary.Decoder, o *GlIsProgramPipelineEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsProgramPipelineEXT(d binary.Decoder, o *GlIsProgramPipelineEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsProgramPipelineEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsProgramPipelineEXT(e, obj.(*GlIsProgramPipelineEXT))
}
func (*binaryClassGlIsProgramPipelineEXT) New() binary.Object {
	return &GlIsProgramPipelineEXT{}
}
func (*binaryClassGlIsProgramPipelineEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsProgramPipelineEXT(d, obj.(*GlIsProgramPipelineEXT))
}
func (c *binaryClassGlIsProgramPipelineEXT) Schema() *binary.Entity {
	return &entities[ixǁGlIsProgramPipelineEXT]
}

type binaryClassGlIsQuery struct{}

func (*GlIsQuery) Class() binary.Class {
	return (*binaryClassGlIsQuery)(nil)
}
func doEncodeGlIsQuery(e binary.Encoder, o *GlIsQuery) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Query))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsQuery(d binary.Decoder, o *GlIsQuery) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsQuery(d binary.Decoder, o *GlIsQuery) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsQuery) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsQuery(e, obj.(*GlIsQuery))
}
func (*binaryClassGlIsQuery) New() binary.Object {
	return &GlIsQuery{}
}
func (*binaryClassGlIsQuery) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsQuery(d, obj.(*GlIsQuery))
}
func (c *binaryClassGlIsQuery) Schema() *binary.Entity {
	return &entities[ixǁGlIsQuery]
}

type binaryClassGlIsQueryEXT struct{}

func (*GlIsQueryEXT) Class() binary.Class {
	return (*binaryClassGlIsQueryEXT)(nil)
}
func doEncodeGlIsQueryEXT(e binary.Encoder, o *GlIsQueryEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Query))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsQueryEXT(d binary.Decoder, o *GlIsQueryEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsQueryEXT(d binary.Decoder, o *GlIsQueryEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsQueryEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsQueryEXT(e, obj.(*GlIsQueryEXT))
}
func (*binaryClassGlIsQueryEXT) New() binary.Object {
	return &GlIsQueryEXT{}
}
func (*binaryClassGlIsQueryEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsQueryEXT(d, obj.(*GlIsQueryEXT))
}
func (c *binaryClassGlIsQueryEXT) Schema() *binary.Entity {
	return &entities[ixǁGlIsQueryEXT]
}

type binaryClassGlIsRenderbuffer struct{}

func (*GlIsRenderbuffer) Class() binary.Class {
	return (*binaryClassGlIsRenderbuffer)(nil)
}
func doEncodeGlIsRenderbuffer(e binary.Encoder, o *GlIsRenderbuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Renderbuffer))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsRenderbuffer(d binary.Decoder, o *GlIsRenderbuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Renderbuffer = RenderbufferId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsRenderbuffer(d binary.Decoder, o *GlIsRenderbuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Renderbuffer = RenderbufferId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsRenderbuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsRenderbuffer(e, obj.(*GlIsRenderbuffer))
}
func (*binaryClassGlIsRenderbuffer) New() binary.Object {
	return &GlIsRenderbuffer{}
}
func (*binaryClassGlIsRenderbuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsRenderbuffer(d, obj.(*GlIsRenderbuffer))
}
func (c *binaryClassGlIsRenderbuffer) Schema() *binary.Entity {
	return &entities[ixǁGlIsRenderbuffer]
}

type binaryClassGlIsRenderbufferOES struct{}

func (*GlIsRenderbufferOES) Class() binary.Class {
	return (*binaryClassGlIsRenderbufferOES)(nil)
}
func doEncodeGlIsRenderbufferOES(e binary.Encoder, o *GlIsRenderbufferOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Renderbuffer))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsRenderbufferOES(d binary.Decoder, o *GlIsRenderbufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Renderbuffer = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsRenderbufferOES(d binary.Decoder, o *GlIsRenderbufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Renderbuffer = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsRenderbufferOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsRenderbufferOES(e, obj.(*GlIsRenderbufferOES))
}
func (*binaryClassGlIsRenderbufferOES) New() binary.Object {
	return &GlIsRenderbufferOES{}
}
func (*binaryClassGlIsRenderbufferOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsRenderbufferOES(d, obj.(*GlIsRenderbufferOES))
}
func (c *binaryClassGlIsRenderbufferOES) Schema() *binary.Entity {
	return &entities[ixǁGlIsRenderbufferOES]
}

type binaryClassGlIsSampler struct{}

func (*GlIsSampler) Class() binary.Class {
	return (*binaryClassGlIsSampler)(nil)
}
func doEncodeGlIsSampler(e binary.Encoder, o *GlIsSampler) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsSampler(d binary.Decoder, o *GlIsSampler) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsSampler(d binary.Decoder, o *GlIsSampler) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsSampler) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsSampler(e, obj.(*GlIsSampler))
}
func (*binaryClassGlIsSampler) New() binary.Object {
	return &GlIsSampler{}
}
func (*binaryClassGlIsSampler) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsSampler(d, obj.(*GlIsSampler))
}
func (c *binaryClassGlIsSampler) Schema() *binary.Entity {
	return &entities[ixǁGlIsSampler]
}

type binaryClassGlIsShader struct{}

func (*GlIsShader) Class() binary.Class {
	return (*binaryClassGlIsShader)(nil)
}
func doEncodeGlIsShader(e binary.Encoder, o *GlIsShader) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Shader))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsShader(d binary.Decoder, o *GlIsShader) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsShader(d binary.Decoder, o *GlIsShader) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsShader) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsShader(e, obj.(*GlIsShader))
}
func (*binaryClassGlIsShader) New() binary.Object {
	return &GlIsShader{}
}
func (*binaryClassGlIsShader) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsShader(d, obj.(*GlIsShader))
}
func (c *binaryClassGlIsShader) Schema() *binary.Entity {
	return &entities[ixǁGlIsShader]
}

type binaryClassGlIsSync struct{}

func (*GlIsSync) Class() binary.Class {
	return (*binaryClassGlIsSync)(nil)
}
func doEncodeGlIsSync(e binary.Encoder, o *GlIsSync) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Sync)
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsSync(d binary.Decoder, o *GlIsSync) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsSync(d binary.Decoder, o *GlIsSync) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsSync) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsSync(e, obj.(*GlIsSync))
}
func (*binaryClassGlIsSync) New() binary.Object {
	return &GlIsSync{}
}
func (*binaryClassGlIsSync) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsSync(d, obj.(*GlIsSync))
}
func (c *binaryClassGlIsSync) Schema() *binary.Entity {
	return &entities[ixǁGlIsSync]
}

type binaryClassGlIsSyncAPPLE struct{}

func (*GlIsSyncAPPLE) Class() binary.Class {
	return (*binaryClassGlIsSyncAPPLE)(nil)
}
func doEncodeGlIsSyncAPPLE(e binary.Encoder, o *GlIsSyncAPPLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Sync)
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsSyncAPPLE(d binary.Decoder, o *GlIsSyncAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsSyncAPPLE(d binary.Decoder, o *GlIsSyncAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsSyncAPPLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsSyncAPPLE(e, obj.(*GlIsSyncAPPLE))
}
func (*binaryClassGlIsSyncAPPLE) New() binary.Object {
	return &GlIsSyncAPPLE{}
}
func (*binaryClassGlIsSyncAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsSyncAPPLE(d, obj.(*GlIsSyncAPPLE))
}
func (c *binaryClassGlIsSyncAPPLE) Schema() *binary.Entity {
	return &entities[ixǁGlIsSyncAPPLE]
}

type binaryClassGlIsTexture struct{}

func (*GlIsTexture) Class() binary.Class {
	return (*binaryClassGlIsTexture)(nil)
}
func doEncodeGlIsTexture(e binary.Encoder, o *GlIsTexture) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsTexture(d binary.Decoder, o *GlIsTexture) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsTexture(d binary.Decoder, o *GlIsTexture) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsTexture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsTexture(e, obj.(*GlIsTexture))
}
func (*binaryClassGlIsTexture) New() binary.Object {
	return &GlIsTexture{}
}
func (*binaryClassGlIsTexture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsTexture(d, obj.(*GlIsTexture))
}
func (c *binaryClassGlIsTexture) Schema() *binary.Entity {
	return &entities[ixǁGlIsTexture]
}

type binaryClassGlIsTextureHandleResidentNV struct{}

func (*GlIsTextureHandleResidentNV) Class() binary.Class {
	return (*binaryClassGlIsTextureHandleResidentNV)(nil)
}
func doEncodeGlIsTextureHandleResidentNV(e binary.Encoder, o *GlIsTextureHandleResidentNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint64(uint64(o.Handle))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsTextureHandleResidentNV(d binary.Decoder, o *GlIsTextureHandleResidentNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Handle = GLuint64(d.Uint64())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsTextureHandleResidentNV(d binary.Decoder, o *GlIsTextureHandleResidentNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Handle = GLuint64(d.Uint64())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsTextureHandleResidentNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsTextureHandleResidentNV(e, obj.(*GlIsTextureHandleResidentNV))
}
func (*binaryClassGlIsTextureHandleResidentNV) New() binary.Object {
	return &GlIsTextureHandleResidentNV{}
}
func (*binaryClassGlIsTextureHandleResidentNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsTextureHandleResidentNV(d, obj.(*GlIsTextureHandleResidentNV))
}
func (c *binaryClassGlIsTextureHandleResidentNV) Schema() *binary.Entity {
	return &entities[ixǁGlIsTextureHandleResidentNV]
}

type binaryClassGlIsTransformFeedback struct{}

func (*GlIsTransformFeedback) Class() binary.Class {
	return (*binaryClassGlIsTransformFeedback)(nil)
}
func doEncodeGlIsTransformFeedback(e binary.Encoder, o *GlIsTransformFeedback) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Id))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsTransformFeedback(d binary.Decoder, o *GlIsTransformFeedback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Id = TransformFeedbackId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsTransformFeedback(d binary.Decoder, o *GlIsTransformFeedback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Id = TransformFeedbackId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsTransformFeedback) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsTransformFeedback(e, obj.(*GlIsTransformFeedback))
}
func (*binaryClassGlIsTransformFeedback) New() binary.Object {
	return &GlIsTransformFeedback{}
}
func (*binaryClassGlIsTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsTransformFeedback(d, obj.(*GlIsTransformFeedback))
}
func (c *binaryClassGlIsTransformFeedback) Schema() *binary.Entity {
	return &entities[ixǁGlIsTransformFeedback]
}

type binaryClassGlIsVertexArray struct{}

func (*GlIsVertexArray) Class() binary.Class {
	return (*binaryClassGlIsVertexArray)(nil)
}
func doEncodeGlIsVertexArray(e binary.Encoder, o *GlIsVertexArray) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Array))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsVertexArray(d binary.Decoder, o *GlIsVertexArray) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Array = VertexArrayId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsVertexArray(d binary.Decoder, o *GlIsVertexArray) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Array = VertexArrayId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsVertexArray) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsVertexArray(e, obj.(*GlIsVertexArray))
}
func (*binaryClassGlIsVertexArray) New() binary.Object {
	return &GlIsVertexArray{}
}
func (*binaryClassGlIsVertexArray) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsVertexArray(d, obj.(*GlIsVertexArray))
}
func (c *binaryClassGlIsVertexArray) Schema() *binary.Entity {
	return &entities[ixǁGlIsVertexArray]
}

type binaryClassGlIsVertexArrayOES struct{}

func (*GlIsVertexArrayOES) Class() binary.Class {
	return (*binaryClassGlIsVertexArrayOES)(nil)
}
func doEncodeGlIsVertexArrayOES(e binary.Encoder, o *GlIsVertexArrayOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Array))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlIsVertexArrayOES(d binary.Decoder, o *GlIsVertexArrayOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Array = VertexArrayId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlIsVertexArrayOES(d binary.Decoder, o *GlIsVertexArrayOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Array = VertexArrayId(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlIsVertexArrayOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlIsVertexArrayOES(e, obj.(*GlIsVertexArrayOES))
}
func (*binaryClassGlIsVertexArrayOES) New() binary.Object {
	return &GlIsVertexArrayOES{}
}
func (*binaryClassGlIsVertexArrayOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlIsVertexArrayOES(d, obj.(*GlIsVertexArrayOES))
}
func (c *binaryClassGlIsVertexArrayOES) Schema() *binary.Entity {
	return &entities[ixǁGlIsVertexArrayOES]
}

type binaryClassGlLabelObjectEXT struct{}

func (*GlLabelObjectEXT) Class() binary.Class {
	return (*binaryClassGlLabelObjectEXT)(nil)
}
func doEncodeGlLabelObjectEXT(e binary.Encoder, o *GlLabelObjectEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Type))
	e.Uint32(uint32(o.Object))
	e.Int32(int32(o.Length))
	e.Simple(&o.Label)
}
func doDecodeGlLabelObjectEXT(d binary.Decoder, o *GlLabelObjectEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Object = GLuint(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Label)
}
func doDecodeRawGlLabelObjectEXT(d binary.Decoder, o *GlLabelObjectEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Object = GLuint(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Label)
}
func (*binaryClassGlLabelObjectEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLabelObjectEXT(e, obj.(*GlLabelObjectEXT))
}
func (*binaryClassGlLabelObjectEXT) New() binary.Object {
	return &GlLabelObjectEXT{}
}
func (*binaryClassGlLabelObjectEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLabelObjectEXT(d, obj.(*GlLabelObjectEXT))
}
func (c *binaryClassGlLabelObjectEXT) Schema() *binary.Entity {
	return &entities[ixǁGlLabelObjectEXT]
}

type binaryClassGlLightModelf struct{}

func (*GlLightModelf) Class() binary.Class {
	return (*binaryClassGlLightModelf)(nil)
}
func doEncodeGlLightModelf(e binary.Encoder, o *GlLightModelf) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Float32(float32(o.Param))
}
func doDecodeGlLightModelf(d binary.Decoder, o *GlLightModelf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func doDecodeRawGlLightModelf(d binary.Decoder, o *GlLightModelf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func (*binaryClassGlLightModelf) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLightModelf(e, obj.(*GlLightModelf))
}
func (*binaryClassGlLightModelf) New() binary.Object {
	return &GlLightModelf{}
}
func (*binaryClassGlLightModelf) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLightModelf(d, obj.(*GlLightModelf))
}
func (c *binaryClassGlLightModelf) Schema() *binary.Entity {
	return &entities[ixǁGlLightModelf]
}

type binaryClassGlLightModelfv struct{}

func (*GlLightModelfv) Class() binary.Class {
	return (*binaryClassGlLightModelfv)(nil)
}
func doEncodeGlLightModelfv(e binary.Encoder, o *GlLightModelfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlLightModelfv(d binary.Decoder, o *GlLightModelfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlLightModelfv(d binary.Decoder, o *GlLightModelfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlLightModelfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLightModelfv(e, obj.(*GlLightModelfv))
}
func (*binaryClassGlLightModelfv) New() binary.Object {
	return &GlLightModelfv{}
}
func (*binaryClassGlLightModelfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLightModelfv(d, obj.(*GlLightModelfv))
}
func (c *binaryClassGlLightModelfv) Schema() *binary.Entity {
	return &entities[ixǁGlLightModelfv]
}

type binaryClassGlLightModelx struct{}

func (*GlLightModelx) Class() binary.Class {
	return (*binaryClassGlLightModelx)(nil)
}
func doEncodeGlLightModelx(e binary.Encoder, o *GlLightModelx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlLightModelx(d binary.Decoder, o *GlLightModelx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlLightModelx(d binary.Decoder, o *GlLightModelx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlLightModelx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLightModelx(e, obj.(*GlLightModelx))
}
func (*binaryClassGlLightModelx) New() binary.Object {
	return &GlLightModelx{}
}
func (*binaryClassGlLightModelx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLightModelx(d, obj.(*GlLightModelx))
}
func (c *binaryClassGlLightModelx) Schema() *binary.Entity {
	return &entities[ixǁGlLightModelx]
}

type binaryClassGlLightModelxOES struct{}

func (*GlLightModelxOES) Class() binary.Class {
	return (*binaryClassGlLightModelxOES)(nil)
}
func doEncodeGlLightModelxOES(e binary.Encoder, o *GlLightModelxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlLightModelxOES(d binary.Decoder, o *GlLightModelxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlLightModelxOES(d binary.Decoder, o *GlLightModelxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlLightModelxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLightModelxOES(e, obj.(*GlLightModelxOES))
}
func (*binaryClassGlLightModelxOES) New() binary.Object {
	return &GlLightModelxOES{}
}
func (*binaryClassGlLightModelxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLightModelxOES(d, obj.(*GlLightModelxOES))
}
func (c *binaryClassGlLightModelxOES) Schema() *binary.Entity {
	return &entities[ixǁGlLightModelxOES]
}

type binaryClassGlLightModelxv struct{}

func (*GlLightModelxv) Class() binary.Class {
	return (*binaryClassGlLightModelxv)(nil)
}
func doEncodeGlLightModelxv(e binary.Encoder, o *GlLightModelxv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlLightModelxv(d binary.Decoder, o *GlLightModelxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlLightModelxv(d binary.Decoder, o *GlLightModelxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlLightModelxv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLightModelxv(e, obj.(*GlLightModelxv))
}
func (*binaryClassGlLightModelxv) New() binary.Object {
	return &GlLightModelxv{}
}
func (*binaryClassGlLightModelxv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLightModelxv(d, obj.(*GlLightModelxv))
}
func (c *binaryClassGlLightModelxv) Schema() *binary.Entity {
	return &entities[ixǁGlLightModelxv]
}

type binaryClassGlLightModelxvOES struct{}

func (*GlLightModelxvOES) Class() binary.Class {
	return (*binaryClassGlLightModelxvOES)(nil)
}
func doEncodeGlLightModelxvOES(e binary.Encoder, o *GlLightModelxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlLightModelxvOES(d binary.Decoder, o *GlLightModelxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlLightModelxvOES(d binary.Decoder, o *GlLightModelxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlLightModelxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLightModelxvOES(e, obj.(*GlLightModelxvOES))
}
func (*binaryClassGlLightModelxvOES) New() binary.Object {
	return &GlLightModelxvOES{}
}
func (*binaryClassGlLightModelxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLightModelxvOES(d, obj.(*GlLightModelxvOES))
}
func (c *binaryClassGlLightModelxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlLightModelxvOES]
}

type binaryClassGlLightf struct{}

func (*GlLightf) Class() binary.Class {
	return (*binaryClassGlLightf)(nil)
}
func doEncodeGlLightf(e binary.Encoder, o *GlLightf) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Light))
	e.Uint32(uint32(o.Pname))
	e.Float32(float32(o.Param))
}
func doDecodeGlLightf(d binary.Decoder, o *GlLightf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func doDecodeRawGlLightf(d binary.Decoder, o *GlLightf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func (*binaryClassGlLightf) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLightf(e, obj.(*GlLightf))
}
func (*binaryClassGlLightf) New() binary.Object {
	return &GlLightf{}
}
func (*binaryClassGlLightf) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLightf(d, obj.(*GlLightf))
}
func (c *binaryClassGlLightf) Schema() *binary.Entity {
	return &entities[ixǁGlLightf]
}

type binaryClassGlLightfv struct{}

func (*GlLightfv) Class() binary.Class {
	return (*binaryClassGlLightfv)(nil)
}
func doEncodeGlLightfv(e binary.Encoder, o *GlLightfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Light))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlLightfv(d binary.Decoder, o *GlLightfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlLightfv(d binary.Decoder, o *GlLightfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlLightfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLightfv(e, obj.(*GlLightfv))
}
func (*binaryClassGlLightfv) New() binary.Object {
	return &GlLightfv{}
}
func (*binaryClassGlLightfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLightfv(d, obj.(*GlLightfv))
}
func (c *binaryClassGlLightfv) Schema() *binary.Entity {
	return &entities[ixǁGlLightfv]
}

type binaryClassGlLightx struct{}

func (*GlLightx) Class() binary.Class {
	return (*binaryClassGlLightx)(nil)
}
func doEncodeGlLightx(e binary.Encoder, o *GlLightx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Light))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlLightx(d binary.Decoder, o *GlLightx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlLightx(d binary.Decoder, o *GlLightx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlLightx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLightx(e, obj.(*GlLightx))
}
func (*binaryClassGlLightx) New() binary.Object {
	return &GlLightx{}
}
func (*binaryClassGlLightx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLightx(d, obj.(*GlLightx))
}
func (c *binaryClassGlLightx) Schema() *binary.Entity {
	return &entities[ixǁGlLightx]
}

type binaryClassGlLightxOES struct{}

func (*GlLightxOES) Class() binary.Class {
	return (*binaryClassGlLightxOES)(nil)
}
func doEncodeGlLightxOES(e binary.Encoder, o *GlLightxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Light))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlLightxOES(d binary.Decoder, o *GlLightxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlLightxOES(d binary.Decoder, o *GlLightxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlLightxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLightxOES(e, obj.(*GlLightxOES))
}
func (*binaryClassGlLightxOES) New() binary.Object {
	return &GlLightxOES{}
}
func (*binaryClassGlLightxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLightxOES(d, obj.(*GlLightxOES))
}
func (c *binaryClassGlLightxOES) Schema() *binary.Entity {
	return &entities[ixǁGlLightxOES]
}

type binaryClassGlLightxv struct{}

func (*GlLightxv) Class() binary.Class {
	return (*binaryClassGlLightxv)(nil)
}
func doEncodeGlLightxv(e binary.Encoder, o *GlLightxv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Light))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlLightxv(d binary.Decoder, o *GlLightxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlLightxv(d binary.Decoder, o *GlLightxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlLightxv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLightxv(e, obj.(*GlLightxv))
}
func (*binaryClassGlLightxv) New() binary.Object {
	return &GlLightxv{}
}
func (*binaryClassGlLightxv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLightxv(d, obj.(*GlLightxv))
}
func (c *binaryClassGlLightxv) Schema() *binary.Entity {
	return &entities[ixǁGlLightxv]
}

type binaryClassGlLightxvOES struct{}

func (*GlLightxvOES) Class() binary.Class {
	return (*binaryClassGlLightxvOES)(nil)
}
func doEncodeGlLightxvOES(e binary.Encoder, o *GlLightxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Light))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlLightxvOES(d binary.Decoder, o *GlLightxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlLightxvOES(d binary.Decoder, o *GlLightxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Light = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlLightxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLightxvOES(e, obj.(*GlLightxvOES))
}
func (*binaryClassGlLightxvOES) New() binary.Object {
	return &GlLightxvOES{}
}
func (*binaryClassGlLightxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLightxvOES(d, obj.(*GlLightxvOES))
}
func (c *binaryClassGlLightxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlLightxvOES]
}

type binaryClassGlLineWidth struct{}

func (*GlLineWidth) Class() binary.Class {
	return (*binaryClassGlLineWidth)(nil)
}
func doEncodeGlLineWidth(e binary.Encoder, o *GlLineWidth) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Width))
}
func doDecodeGlLineWidth(d binary.Decoder, o *GlLineWidth) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Width = GLfloat(d.Float32())
}
func doDecodeRawGlLineWidth(d binary.Decoder, o *GlLineWidth) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Width = GLfloat(d.Float32())
}
func (*binaryClassGlLineWidth) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLineWidth(e, obj.(*GlLineWidth))
}
func (*binaryClassGlLineWidth) New() binary.Object {
	return &GlLineWidth{}
}
func (*binaryClassGlLineWidth) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLineWidth(d, obj.(*GlLineWidth))
}
func (c *binaryClassGlLineWidth) Schema() *binary.Entity {
	return &entities[ixǁGlLineWidth]
}

type binaryClassGlLineWidthx struct{}

func (*GlLineWidthx) Class() binary.Class {
	return (*binaryClassGlLineWidthx)(nil)
}
func doEncodeGlLineWidthx(e binary.Encoder, o *GlLineWidthx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Width))
}
func doDecodeGlLineWidthx(d binary.Decoder, o *GlLineWidthx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Width = GLfixed(d.Int32())
}
func doDecodeRawGlLineWidthx(d binary.Decoder, o *GlLineWidthx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Width = GLfixed(d.Int32())
}
func (*binaryClassGlLineWidthx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLineWidthx(e, obj.(*GlLineWidthx))
}
func (*binaryClassGlLineWidthx) New() binary.Object {
	return &GlLineWidthx{}
}
func (*binaryClassGlLineWidthx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLineWidthx(d, obj.(*GlLineWidthx))
}
func (c *binaryClassGlLineWidthx) Schema() *binary.Entity {
	return &entities[ixǁGlLineWidthx]
}

type binaryClassGlLineWidthxOES struct{}

func (*GlLineWidthxOES) Class() binary.Class {
	return (*binaryClassGlLineWidthxOES)(nil)
}
func doEncodeGlLineWidthxOES(e binary.Encoder, o *GlLineWidthxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Width))
}
func doDecodeGlLineWidthxOES(d binary.Decoder, o *GlLineWidthxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Width = GLfixed(d.Int32())
}
func doDecodeRawGlLineWidthxOES(d binary.Decoder, o *GlLineWidthxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Width = GLfixed(d.Int32())
}
func (*binaryClassGlLineWidthxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLineWidthxOES(e, obj.(*GlLineWidthxOES))
}
func (*binaryClassGlLineWidthxOES) New() binary.Object {
	return &GlLineWidthxOES{}
}
func (*binaryClassGlLineWidthxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLineWidthxOES(d, obj.(*GlLineWidthxOES))
}
func (c *binaryClassGlLineWidthxOES) Schema() *binary.Entity {
	return &entities[ixǁGlLineWidthxOES]
}

type binaryClassGlLinkProgram struct{}

func (*GlLinkProgram) Class() binary.Class {
	return (*binaryClassGlLinkProgram)(nil)
}
func doEncodeGlLinkProgram(e binary.Encoder, o *GlLinkProgram) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
}
func doDecodeGlLinkProgram(d binary.Decoder, o *GlLinkProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
}
func doDecodeRawGlLinkProgram(d binary.Decoder, o *GlLinkProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
}
func (*binaryClassGlLinkProgram) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLinkProgram(e, obj.(*GlLinkProgram))
}
func (*binaryClassGlLinkProgram) New() binary.Object {
	return &GlLinkProgram{}
}
func (*binaryClassGlLinkProgram) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLinkProgram(d, obj.(*GlLinkProgram))
}
func (c *binaryClassGlLinkProgram) Schema() *binary.Entity {
	return &entities[ixǁGlLinkProgram]
}

type binaryClassGlLoadIdentity struct{}

func (*GlLoadIdentity) Class() binary.Class {
	return (*binaryClassGlLoadIdentity)(nil)
}
func doEncodeGlLoadIdentity(e binary.Encoder, o *GlLoadIdentity) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlLoadIdentity(d binary.Decoder, o *GlLoadIdentity) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlLoadIdentity(d binary.Decoder, o *GlLoadIdentity) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlLoadIdentity) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLoadIdentity(e, obj.(*GlLoadIdentity))
}
func (*binaryClassGlLoadIdentity) New() binary.Object {
	return &GlLoadIdentity{}
}
func (*binaryClassGlLoadIdentity) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLoadIdentity(d, obj.(*GlLoadIdentity))
}
func (c *binaryClassGlLoadIdentity) Schema() *binary.Entity {
	return &entities[ixǁGlLoadIdentity]
}

type binaryClassGlLoadMatrixf struct{}

func (*GlLoadMatrixf) Class() binary.Class {
	return (*binaryClassGlLoadMatrixf)(nil)
}
func doEncodeGlLoadMatrixf(e binary.Encoder, o *GlLoadMatrixf) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.M)
}
func doDecodeGlLoadMatrixf(d binary.Decoder, o *GlLoadMatrixf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.M)
}
func doDecodeRawGlLoadMatrixf(d binary.Decoder, o *GlLoadMatrixf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.M)
}
func (*binaryClassGlLoadMatrixf) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLoadMatrixf(e, obj.(*GlLoadMatrixf))
}
func (*binaryClassGlLoadMatrixf) New() binary.Object {
	return &GlLoadMatrixf{}
}
func (*binaryClassGlLoadMatrixf) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLoadMatrixf(d, obj.(*GlLoadMatrixf))
}
func (c *binaryClassGlLoadMatrixf) Schema() *binary.Entity {
	return &entities[ixǁGlLoadMatrixf]
}

type binaryClassGlLoadMatrixx struct{}

func (*GlLoadMatrixx) Class() binary.Class {
	return (*binaryClassGlLoadMatrixx)(nil)
}
func doEncodeGlLoadMatrixx(e binary.Encoder, o *GlLoadMatrixx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.M)
}
func doDecodeGlLoadMatrixx(d binary.Decoder, o *GlLoadMatrixx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.M)
}
func doDecodeRawGlLoadMatrixx(d binary.Decoder, o *GlLoadMatrixx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.M)
}
func (*binaryClassGlLoadMatrixx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLoadMatrixx(e, obj.(*GlLoadMatrixx))
}
func (*binaryClassGlLoadMatrixx) New() binary.Object {
	return &GlLoadMatrixx{}
}
func (*binaryClassGlLoadMatrixx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLoadMatrixx(d, obj.(*GlLoadMatrixx))
}
func (c *binaryClassGlLoadMatrixx) Schema() *binary.Entity {
	return &entities[ixǁGlLoadMatrixx]
}

type binaryClassGlLoadMatrixxOES struct{}

func (*GlLoadMatrixxOES) Class() binary.Class {
	return (*binaryClassGlLoadMatrixxOES)(nil)
}
func doEncodeGlLoadMatrixxOES(e binary.Encoder, o *GlLoadMatrixxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.M)
}
func doDecodeGlLoadMatrixxOES(d binary.Decoder, o *GlLoadMatrixxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.M)
}
func doDecodeRawGlLoadMatrixxOES(d binary.Decoder, o *GlLoadMatrixxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.M)
}
func (*binaryClassGlLoadMatrixxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLoadMatrixxOES(e, obj.(*GlLoadMatrixxOES))
}
func (*binaryClassGlLoadMatrixxOES) New() binary.Object {
	return &GlLoadMatrixxOES{}
}
func (*binaryClassGlLoadMatrixxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLoadMatrixxOES(d, obj.(*GlLoadMatrixxOES))
}
func (c *binaryClassGlLoadMatrixxOES) Schema() *binary.Entity {
	return &entities[ixǁGlLoadMatrixxOES]
}

type binaryClassGlLoadPaletteFromModelViewMatrixOES struct{}

func (*GlLoadPaletteFromModelViewMatrixOES) Class() binary.Class {
	return (*binaryClassGlLoadPaletteFromModelViewMatrixOES)(nil)
}
func doEncodeGlLoadPaletteFromModelViewMatrixOES(e binary.Encoder, o *GlLoadPaletteFromModelViewMatrixOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlLoadPaletteFromModelViewMatrixOES(d binary.Decoder, o *GlLoadPaletteFromModelViewMatrixOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlLoadPaletteFromModelViewMatrixOES(d binary.Decoder, o *GlLoadPaletteFromModelViewMatrixOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlLoadPaletteFromModelViewMatrixOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLoadPaletteFromModelViewMatrixOES(e, obj.(*GlLoadPaletteFromModelViewMatrixOES))
}
func (*binaryClassGlLoadPaletteFromModelViewMatrixOES) New() binary.Object {
	return &GlLoadPaletteFromModelViewMatrixOES{}
}
func (*binaryClassGlLoadPaletteFromModelViewMatrixOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLoadPaletteFromModelViewMatrixOES(d, obj.(*GlLoadPaletteFromModelViewMatrixOES))
}
func (c *binaryClassGlLoadPaletteFromModelViewMatrixOES) Schema() *binary.Entity {
	return &entities[ixǁGlLoadPaletteFromModelViewMatrixOES]
}

type binaryClassGlLogicOp struct{}

func (*GlLogicOp) Class() binary.Class {
	return (*binaryClassGlLogicOp)(nil)
}
func doEncodeGlLogicOp(e binary.Encoder, o *GlLogicOp) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Opcode))
}
func doDecodeGlLogicOp(d binary.Decoder, o *GlLogicOp) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Opcode = GLenum(d.Uint32())
}
func doDecodeRawGlLogicOp(d binary.Decoder, o *GlLogicOp) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Opcode = GLenum(d.Uint32())
}
func (*binaryClassGlLogicOp) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlLogicOp(e, obj.(*GlLogicOp))
}
func (*binaryClassGlLogicOp) New() binary.Object {
	return &GlLogicOp{}
}
func (*binaryClassGlLogicOp) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlLogicOp(d, obj.(*GlLogicOp))
}
func (c *binaryClassGlLogicOp) Schema() *binary.Entity {
	return &entities[ixǁGlLogicOp]
}

type binaryClassGlMakeImageHandleNonResidentNV struct{}

func (*GlMakeImageHandleNonResidentNV) Class() binary.Class {
	return (*binaryClassGlMakeImageHandleNonResidentNV)(nil)
}
func doEncodeGlMakeImageHandleNonResidentNV(e binary.Encoder, o *GlMakeImageHandleNonResidentNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint64(uint64(o.Handle))
}
func doDecodeGlMakeImageHandleNonResidentNV(d binary.Decoder, o *GlMakeImageHandleNonResidentNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Handle = GLuint64(d.Uint64())
}
func doDecodeRawGlMakeImageHandleNonResidentNV(d binary.Decoder, o *GlMakeImageHandleNonResidentNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Handle = GLuint64(d.Uint64())
}
func (*binaryClassGlMakeImageHandleNonResidentNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMakeImageHandleNonResidentNV(e, obj.(*GlMakeImageHandleNonResidentNV))
}
func (*binaryClassGlMakeImageHandleNonResidentNV) New() binary.Object {
	return &GlMakeImageHandleNonResidentNV{}
}
func (*binaryClassGlMakeImageHandleNonResidentNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMakeImageHandleNonResidentNV(d, obj.(*GlMakeImageHandleNonResidentNV))
}
func (c *binaryClassGlMakeImageHandleNonResidentNV) Schema() *binary.Entity {
	return &entities[ixǁGlMakeImageHandleNonResidentNV]
}

type binaryClassGlMakeImageHandleResidentNV struct{}

func (*GlMakeImageHandleResidentNV) Class() binary.Class {
	return (*binaryClassGlMakeImageHandleResidentNV)(nil)
}
func doEncodeGlMakeImageHandleResidentNV(e binary.Encoder, o *GlMakeImageHandleResidentNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint64(uint64(o.Handle))
	e.Uint32(uint32(o.Access))
}
func doDecodeGlMakeImageHandleResidentNV(d binary.Decoder, o *GlMakeImageHandleResidentNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Handle = GLuint64(d.Uint64())
	o.Access = GLenum(d.Uint32())
}
func doDecodeRawGlMakeImageHandleResidentNV(d binary.Decoder, o *GlMakeImageHandleResidentNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Handle = GLuint64(d.Uint64())
	o.Access = GLenum(d.Uint32())
}
func (*binaryClassGlMakeImageHandleResidentNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMakeImageHandleResidentNV(e, obj.(*GlMakeImageHandleResidentNV))
}
func (*binaryClassGlMakeImageHandleResidentNV) New() binary.Object {
	return &GlMakeImageHandleResidentNV{}
}
func (*binaryClassGlMakeImageHandleResidentNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMakeImageHandleResidentNV(d, obj.(*GlMakeImageHandleResidentNV))
}
func (c *binaryClassGlMakeImageHandleResidentNV) Schema() *binary.Entity {
	return &entities[ixǁGlMakeImageHandleResidentNV]
}

type binaryClassGlMakeTextureHandleNonResidentNV struct{}

func (*GlMakeTextureHandleNonResidentNV) Class() binary.Class {
	return (*binaryClassGlMakeTextureHandleNonResidentNV)(nil)
}
func doEncodeGlMakeTextureHandleNonResidentNV(e binary.Encoder, o *GlMakeTextureHandleNonResidentNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint64(uint64(o.Handle))
}
func doDecodeGlMakeTextureHandleNonResidentNV(d binary.Decoder, o *GlMakeTextureHandleNonResidentNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Handle = GLuint64(d.Uint64())
}
func doDecodeRawGlMakeTextureHandleNonResidentNV(d binary.Decoder, o *GlMakeTextureHandleNonResidentNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Handle = GLuint64(d.Uint64())
}
func (*binaryClassGlMakeTextureHandleNonResidentNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMakeTextureHandleNonResidentNV(e, obj.(*GlMakeTextureHandleNonResidentNV))
}
func (*binaryClassGlMakeTextureHandleNonResidentNV) New() binary.Object {
	return &GlMakeTextureHandleNonResidentNV{}
}
func (*binaryClassGlMakeTextureHandleNonResidentNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMakeTextureHandleNonResidentNV(d, obj.(*GlMakeTextureHandleNonResidentNV))
}
func (c *binaryClassGlMakeTextureHandleNonResidentNV) Schema() *binary.Entity {
	return &entities[ixǁGlMakeTextureHandleNonResidentNV]
}

type binaryClassGlMakeTextureHandleResidentNV struct{}

func (*GlMakeTextureHandleResidentNV) Class() binary.Class {
	return (*binaryClassGlMakeTextureHandleResidentNV)(nil)
}
func doEncodeGlMakeTextureHandleResidentNV(e binary.Encoder, o *GlMakeTextureHandleResidentNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint64(uint64(o.Handle))
}
func doDecodeGlMakeTextureHandleResidentNV(d binary.Decoder, o *GlMakeTextureHandleResidentNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Handle = GLuint64(d.Uint64())
}
func doDecodeRawGlMakeTextureHandleResidentNV(d binary.Decoder, o *GlMakeTextureHandleResidentNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Handle = GLuint64(d.Uint64())
}
func (*binaryClassGlMakeTextureHandleResidentNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMakeTextureHandleResidentNV(e, obj.(*GlMakeTextureHandleResidentNV))
}
func (*binaryClassGlMakeTextureHandleResidentNV) New() binary.Object {
	return &GlMakeTextureHandleResidentNV{}
}
func (*binaryClassGlMakeTextureHandleResidentNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMakeTextureHandleResidentNV(d, obj.(*GlMakeTextureHandleResidentNV))
}
func (c *binaryClassGlMakeTextureHandleResidentNV) Schema() *binary.Entity {
	return &entities[ixǁGlMakeTextureHandleResidentNV]
}

type binaryClassGlMapBuffer struct{}

func (*GlMapBuffer) Class() binary.Class {
	return (*binaryClassGlMapBuffer)(nil)
}
func doEncodeGlMapBuffer(e binary.Encoder, o *GlMapBuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Access))
	e.Simple(&o.Result)
}
func doDecodeGlMapBuffer(d binary.Decoder, o *GlMapBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Access = GLenum(d.Uint32())
	d.Simple(&o.Result)
}
func doDecodeRawGlMapBuffer(d binary.Decoder, o *GlMapBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Access = GLenum(d.Uint32())
	d.Simple(&o.Result)
}
func (*binaryClassGlMapBuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMapBuffer(e, obj.(*GlMapBuffer))
}
func (*binaryClassGlMapBuffer) New() binary.Object {
	return &GlMapBuffer{}
}
func (*binaryClassGlMapBuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMapBuffer(d, obj.(*GlMapBuffer))
}
func (c *binaryClassGlMapBuffer) Schema() *binary.Entity {
	return &entities[ixǁGlMapBuffer]
}

type binaryClassGlMapBufferOES struct{}

func (*GlMapBufferOES) Class() binary.Class {
	return (*binaryClassGlMapBufferOES)(nil)
}
func doEncodeGlMapBufferOES(e binary.Encoder, o *GlMapBufferOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Access))
	e.Simple(&o.Result)
}
func doDecodeGlMapBufferOES(d binary.Decoder, o *GlMapBufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Access = GLenum(d.Uint32())
	d.Simple(&o.Result)
}
func doDecodeRawGlMapBufferOES(d binary.Decoder, o *GlMapBufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Access = GLenum(d.Uint32())
	d.Simple(&o.Result)
}
func (*binaryClassGlMapBufferOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMapBufferOES(e, obj.(*GlMapBufferOES))
}
func (*binaryClassGlMapBufferOES) New() binary.Object {
	return &GlMapBufferOES{}
}
func (*binaryClassGlMapBufferOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMapBufferOES(d, obj.(*GlMapBufferOES))
}
func (c *binaryClassGlMapBufferOES) Schema() *binary.Entity {
	return &entities[ixǁGlMapBufferOES]
}

type binaryClassGlMapBufferRange struct{}

func (*GlMapBufferRange) Class() binary.Class {
	return (*binaryClassGlMapBufferRange)(nil)
}
func doEncodeGlMapBufferRange(e binary.Encoder, o *GlMapBufferRange) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Offset))
	e.Int32(int32(o.Length))
	e.Uint32(uint32(o.Access))
	e.Simple(&o.Result)
}
func doDecodeGlMapBufferRange(d binary.Decoder, o *GlMapBufferRange) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Length = GLsizeiptr(d.Int32())
	o.Access = GLbitfield(d.Uint32())
	d.Simple(&o.Result)
}
func doDecodeRawGlMapBufferRange(d binary.Decoder, o *GlMapBufferRange) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Length = GLsizeiptr(d.Int32())
	o.Access = GLbitfield(d.Uint32())
	d.Simple(&o.Result)
}
func (*binaryClassGlMapBufferRange) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMapBufferRange(e, obj.(*GlMapBufferRange))
}
func (*binaryClassGlMapBufferRange) New() binary.Object {
	return &GlMapBufferRange{}
}
func (*binaryClassGlMapBufferRange) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMapBufferRange(d, obj.(*GlMapBufferRange))
}
func (c *binaryClassGlMapBufferRange) Schema() *binary.Entity {
	return &entities[ixǁGlMapBufferRange]
}

type binaryClassGlMapBufferRangeEXT struct{}

func (*GlMapBufferRangeEXT) Class() binary.Class {
	return (*binaryClassGlMapBufferRangeEXT)(nil)
}
func doEncodeGlMapBufferRangeEXT(e binary.Encoder, o *GlMapBufferRangeEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Offset))
	e.Int32(int32(o.Length))
	e.Uint32(uint32(o.Access))
	e.Simple(&o.Result)
}
func doDecodeGlMapBufferRangeEXT(d binary.Decoder, o *GlMapBufferRangeEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Length = GLsizeiptr(d.Int32())
	o.Access = GLbitfield(d.Uint32())
	d.Simple(&o.Result)
}
func doDecodeRawGlMapBufferRangeEXT(d binary.Decoder, o *GlMapBufferRangeEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Length = GLsizeiptr(d.Int32())
	o.Access = GLbitfield(d.Uint32())
	d.Simple(&o.Result)
}
func (*binaryClassGlMapBufferRangeEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMapBufferRangeEXT(e, obj.(*GlMapBufferRangeEXT))
}
func (*binaryClassGlMapBufferRangeEXT) New() binary.Object {
	return &GlMapBufferRangeEXT{}
}
func (*binaryClassGlMapBufferRangeEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMapBufferRangeEXT(d, obj.(*GlMapBufferRangeEXT))
}
func (c *binaryClassGlMapBufferRangeEXT) Schema() *binary.Entity {
	return &entities[ixǁGlMapBufferRangeEXT]
}

type binaryClassGlMaterialf struct{}

func (*GlMaterialf) Class() binary.Class {
	return (*binaryClassGlMaterialf)(nil)
}
func doEncodeGlMaterialf(e binary.Encoder, o *GlMaterialf) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.Pname))
	e.Float32(float32(o.Param))
}
func doDecodeGlMaterialf(d binary.Decoder, o *GlMaterialf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func doDecodeRawGlMaterialf(d binary.Decoder, o *GlMaterialf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func (*binaryClassGlMaterialf) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMaterialf(e, obj.(*GlMaterialf))
}
func (*binaryClassGlMaterialf) New() binary.Object {
	return &GlMaterialf{}
}
func (*binaryClassGlMaterialf) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMaterialf(d, obj.(*GlMaterialf))
}
func (c *binaryClassGlMaterialf) Schema() *binary.Entity {
	return &entities[ixǁGlMaterialf]
}

type binaryClassGlMaterialfv struct{}

func (*GlMaterialfv) Class() binary.Class {
	return (*binaryClassGlMaterialfv)(nil)
}
func doEncodeGlMaterialfv(e binary.Encoder, o *GlMaterialfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlMaterialfv(d binary.Decoder, o *GlMaterialfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlMaterialfv(d binary.Decoder, o *GlMaterialfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlMaterialfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMaterialfv(e, obj.(*GlMaterialfv))
}
func (*binaryClassGlMaterialfv) New() binary.Object {
	return &GlMaterialfv{}
}
func (*binaryClassGlMaterialfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMaterialfv(d, obj.(*GlMaterialfv))
}
func (c *binaryClassGlMaterialfv) Schema() *binary.Entity {
	return &entities[ixǁGlMaterialfv]
}

type binaryClassGlMaterialx struct{}

func (*GlMaterialx) Class() binary.Class {
	return (*binaryClassGlMaterialx)(nil)
}
func doEncodeGlMaterialx(e binary.Encoder, o *GlMaterialx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlMaterialx(d binary.Decoder, o *GlMaterialx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlMaterialx(d binary.Decoder, o *GlMaterialx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlMaterialx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMaterialx(e, obj.(*GlMaterialx))
}
func (*binaryClassGlMaterialx) New() binary.Object {
	return &GlMaterialx{}
}
func (*binaryClassGlMaterialx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMaterialx(d, obj.(*GlMaterialx))
}
func (c *binaryClassGlMaterialx) Schema() *binary.Entity {
	return &entities[ixǁGlMaterialx]
}

type binaryClassGlMaterialxOES struct{}

func (*GlMaterialxOES) Class() binary.Class {
	return (*binaryClassGlMaterialxOES)(nil)
}
func doEncodeGlMaterialxOES(e binary.Encoder, o *GlMaterialxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlMaterialxOES(d binary.Decoder, o *GlMaterialxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlMaterialxOES(d binary.Decoder, o *GlMaterialxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlMaterialxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMaterialxOES(e, obj.(*GlMaterialxOES))
}
func (*binaryClassGlMaterialxOES) New() binary.Object {
	return &GlMaterialxOES{}
}
func (*binaryClassGlMaterialxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMaterialxOES(d, obj.(*GlMaterialxOES))
}
func (c *binaryClassGlMaterialxOES) Schema() *binary.Entity {
	return &entities[ixǁGlMaterialxOES]
}

type binaryClassGlMaterialxv struct{}

func (*GlMaterialxv) Class() binary.Class {
	return (*binaryClassGlMaterialxv)(nil)
}
func doEncodeGlMaterialxv(e binary.Encoder, o *GlMaterialxv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlMaterialxv(d binary.Decoder, o *GlMaterialxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlMaterialxv(d binary.Decoder, o *GlMaterialxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlMaterialxv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMaterialxv(e, obj.(*GlMaterialxv))
}
func (*binaryClassGlMaterialxv) New() binary.Object {
	return &GlMaterialxv{}
}
func (*binaryClassGlMaterialxv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMaterialxv(d, obj.(*GlMaterialxv))
}
func (c *binaryClassGlMaterialxv) Schema() *binary.Entity {
	return &entities[ixǁGlMaterialxv]
}

type binaryClassGlMaterialxvOES struct{}

func (*GlMaterialxvOES) Class() binary.Class {
	return (*binaryClassGlMaterialxvOES)(nil)
}
func doEncodeGlMaterialxvOES(e binary.Encoder, o *GlMaterialxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlMaterialxvOES(d binary.Decoder, o *GlMaterialxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlMaterialxvOES(d binary.Decoder, o *GlMaterialxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlMaterialxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMaterialxvOES(e, obj.(*GlMaterialxvOES))
}
func (*binaryClassGlMaterialxvOES) New() binary.Object {
	return &GlMaterialxvOES{}
}
func (*binaryClassGlMaterialxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMaterialxvOES(d, obj.(*GlMaterialxvOES))
}
func (c *binaryClassGlMaterialxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlMaterialxvOES]
}

type binaryClassGlMatrixIndexPointerOES struct{}

func (*GlMatrixIndexPointerOES) Class() binary.Class {
	return (*binaryClassGlMatrixIndexPointerOES)(nil)
}
func doEncodeGlMatrixIndexPointerOES(e binary.Encoder, o *GlMatrixIndexPointerOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
}
func doDecodeGlMatrixIndexPointerOES(d binary.Decoder, o *GlMatrixIndexPointerOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func doDecodeRawGlMatrixIndexPointerOES(d binary.Decoder, o *GlMatrixIndexPointerOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func (*binaryClassGlMatrixIndexPointerOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMatrixIndexPointerOES(e, obj.(*GlMatrixIndexPointerOES))
}
func (*binaryClassGlMatrixIndexPointerOES) New() binary.Object {
	return &GlMatrixIndexPointerOES{}
}
func (*binaryClassGlMatrixIndexPointerOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMatrixIndexPointerOES(d, obj.(*GlMatrixIndexPointerOES))
}
func (c *binaryClassGlMatrixIndexPointerOES) Schema() *binary.Entity {
	return &entities[ixǁGlMatrixIndexPointerOES]
}

type binaryClassGlMatrixIndexPointerOESBounds struct{}

func (*GlMatrixIndexPointerOESBounds) Class() binary.Class {
	return (*binaryClassGlMatrixIndexPointerOESBounds)(nil)
}
func doEncodeGlMatrixIndexPointerOESBounds(e binary.Encoder, o *GlMatrixIndexPointerOESBounds) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
	e.Int32(int32(o.Count))
}
func doDecodeGlMatrixIndexPointerOESBounds(d binary.Decoder, o *GlMatrixIndexPointerOESBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func doDecodeRawGlMatrixIndexPointerOESBounds(d binary.Decoder, o *GlMatrixIndexPointerOESBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func (*binaryClassGlMatrixIndexPointerOESBounds) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMatrixIndexPointerOESBounds(e, obj.(*GlMatrixIndexPointerOESBounds))
}
func (*binaryClassGlMatrixIndexPointerOESBounds) New() binary.Object {
	return &GlMatrixIndexPointerOESBounds{}
}
func (*binaryClassGlMatrixIndexPointerOESBounds) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMatrixIndexPointerOESBounds(d, obj.(*GlMatrixIndexPointerOESBounds))
}
func (c *binaryClassGlMatrixIndexPointerOESBounds) Schema() *binary.Entity {
	return &entities[ixǁGlMatrixIndexPointerOESBounds]
}

type binaryClassGlMatrixLoad3x2fNV struct{}

func (*GlMatrixLoad3x2fNV) Class() binary.Class {
	return (*binaryClassGlMatrixLoad3x2fNV)(nil)
}
func doEncodeGlMatrixLoad3x2fNV(e binary.Encoder, o *GlMatrixLoad3x2fNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.MatrixMode))
	e.Simple(&o.M)
}
func doDecodeGlMatrixLoad3x2fNV(d binary.Decoder, o *GlMatrixLoad3x2fNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MatrixMode = GLenum(d.Uint32())
	d.Simple(&o.M)
}
func doDecodeRawGlMatrixLoad3x2fNV(d binary.Decoder, o *GlMatrixLoad3x2fNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MatrixMode = GLenum(d.Uint32())
	d.Simple(&o.M)
}
func (*binaryClassGlMatrixLoad3x2fNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMatrixLoad3x2fNV(e, obj.(*GlMatrixLoad3x2fNV))
}
func (*binaryClassGlMatrixLoad3x2fNV) New() binary.Object {
	return &GlMatrixLoad3x2fNV{}
}
func (*binaryClassGlMatrixLoad3x2fNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMatrixLoad3x2fNV(d, obj.(*GlMatrixLoad3x2fNV))
}
func (c *binaryClassGlMatrixLoad3x2fNV) Schema() *binary.Entity {
	return &entities[ixǁGlMatrixLoad3x2fNV]
}

type binaryClassGlMatrixLoad3x3fNV struct{}

func (*GlMatrixLoad3x3fNV) Class() binary.Class {
	return (*binaryClassGlMatrixLoad3x3fNV)(nil)
}
func doEncodeGlMatrixLoad3x3fNV(e binary.Encoder, o *GlMatrixLoad3x3fNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.MatrixMode))
	e.Simple(&o.M)
}
func doDecodeGlMatrixLoad3x3fNV(d binary.Decoder, o *GlMatrixLoad3x3fNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MatrixMode = GLenum(d.Uint32())
	d.Simple(&o.M)
}
func doDecodeRawGlMatrixLoad3x3fNV(d binary.Decoder, o *GlMatrixLoad3x3fNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MatrixMode = GLenum(d.Uint32())
	d.Simple(&o.M)
}
func (*binaryClassGlMatrixLoad3x3fNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMatrixLoad3x3fNV(e, obj.(*GlMatrixLoad3x3fNV))
}
func (*binaryClassGlMatrixLoad3x3fNV) New() binary.Object {
	return &GlMatrixLoad3x3fNV{}
}
func (*binaryClassGlMatrixLoad3x3fNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMatrixLoad3x3fNV(d, obj.(*GlMatrixLoad3x3fNV))
}
func (c *binaryClassGlMatrixLoad3x3fNV) Schema() *binary.Entity {
	return &entities[ixǁGlMatrixLoad3x3fNV]
}

type binaryClassGlMatrixLoadTranspose3x3fNV struct{}

func (*GlMatrixLoadTranspose3x3fNV) Class() binary.Class {
	return (*binaryClassGlMatrixLoadTranspose3x3fNV)(nil)
}
func doEncodeGlMatrixLoadTranspose3x3fNV(e binary.Encoder, o *GlMatrixLoadTranspose3x3fNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.MatrixMode))
	e.Simple(&o.M)
}
func doDecodeGlMatrixLoadTranspose3x3fNV(d binary.Decoder, o *GlMatrixLoadTranspose3x3fNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MatrixMode = GLenum(d.Uint32())
	d.Simple(&o.M)
}
func doDecodeRawGlMatrixLoadTranspose3x3fNV(d binary.Decoder, o *GlMatrixLoadTranspose3x3fNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MatrixMode = GLenum(d.Uint32())
	d.Simple(&o.M)
}
func (*binaryClassGlMatrixLoadTranspose3x3fNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMatrixLoadTranspose3x3fNV(e, obj.(*GlMatrixLoadTranspose3x3fNV))
}
func (*binaryClassGlMatrixLoadTranspose3x3fNV) New() binary.Object {
	return &GlMatrixLoadTranspose3x3fNV{}
}
func (*binaryClassGlMatrixLoadTranspose3x3fNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMatrixLoadTranspose3x3fNV(d, obj.(*GlMatrixLoadTranspose3x3fNV))
}
func (c *binaryClassGlMatrixLoadTranspose3x3fNV) Schema() *binary.Entity {
	return &entities[ixǁGlMatrixLoadTranspose3x3fNV]
}

type binaryClassGlMatrixMode struct{}

func (*GlMatrixMode) Class() binary.Class {
	return (*binaryClassGlMatrixMode)(nil)
}
func doEncodeGlMatrixMode(e binary.Encoder, o *GlMatrixMode) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
}
func doDecodeGlMatrixMode(d binary.Decoder, o *GlMatrixMode) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
}
func doDecodeRawGlMatrixMode(d binary.Decoder, o *GlMatrixMode) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
}
func (*binaryClassGlMatrixMode) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMatrixMode(e, obj.(*GlMatrixMode))
}
func (*binaryClassGlMatrixMode) New() binary.Object {
	return &GlMatrixMode{}
}
func (*binaryClassGlMatrixMode) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMatrixMode(d, obj.(*GlMatrixMode))
}
func (c *binaryClassGlMatrixMode) Schema() *binary.Entity {
	return &entities[ixǁGlMatrixMode]
}

type binaryClassGlMatrixMult3x2fNV struct{}

func (*GlMatrixMult3x2fNV) Class() binary.Class {
	return (*binaryClassGlMatrixMult3x2fNV)(nil)
}
func doEncodeGlMatrixMult3x2fNV(e binary.Encoder, o *GlMatrixMult3x2fNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.MatrixMode))
	e.Simple(&o.M)
}
func doDecodeGlMatrixMult3x2fNV(d binary.Decoder, o *GlMatrixMult3x2fNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MatrixMode = GLenum(d.Uint32())
	d.Simple(&o.M)
}
func doDecodeRawGlMatrixMult3x2fNV(d binary.Decoder, o *GlMatrixMult3x2fNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MatrixMode = GLenum(d.Uint32())
	d.Simple(&o.M)
}
func (*binaryClassGlMatrixMult3x2fNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMatrixMult3x2fNV(e, obj.(*GlMatrixMult3x2fNV))
}
func (*binaryClassGlMatrixMult3x2fNV) New() binary.Object {
	return &GlMatrixMult3x2fNV{}
}
func (*binaryClassGlMatrixMult3x2fNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMatrixMult3x2fNV(d, obj.(*GlMatrixMult3x2fNV))
}
func (c *binaryClassGlMatrixMult3x2fNV) Schema() *binary.Entity {
	return &entities[ixǁGlMatrixMult3x2fNV]
}

type binaryClassGlMatrixMult3x3fNV struct{}

func (*GlMatrixMult3x3fNV) Class() binary.Class {
	return (*binaryClassGlMatrixMult3x3fNV)(nil)
}
func doEncodeGlMatrixMult3x3fNV(e binary.Encoder, o *GlMatrixMult3x3fNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.MatrixMode))
	e.Simple(&o.M)
}
func doDecodeGlMatrixMult3x3fNV(d binary.Decoder, o *GlMatrixMult3x3fNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MatrixMode = GLenum(d.Uint32())
	d.Simple(&o.M)
}
func doDecodeRawGlMatrixMult3x3fNV(d binary.Decoder, o *GlMatrixMult3x3fNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MatrixMode = GLenum(d.Uint32())
	d.Simple(&o.M)
}
func (*binaryClassGlMatrixMult3x3fNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMatrixMult3x3fNV(e, obj.(*GlMatrixMult3x3fNV))
}
func (*binaryClassGlMatrixMult3x3fNV) New() binary.Object {
	return &GlMatrixMult3x3fNV{}
}
func (*binaryClassGlMatrixMult3x3fNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMatrixMult3x3fNV(d, obj.(*GlMatrixMult3x3fNV))
}
func (c *binaryClassGlMatrixMult3x3fNV) Schema() *binary.Entity {
	return &entities[ixǁGlMatrixMult3x3fNV]
}

type binaryClassGlMatrixMultTranspose3x3fNV struct{}

func (*GlMatrixMultTranspose3x3fNV) Class() binary.Class {
	return (*binaryClassGlMatrixMultTranspose3x3fNV)(nil)
}
func doEncodeGlMatrixMultTranspose3x3fNV(e binary.Encoder, o *GlMatrixMultTranspose3x3fNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.MatrixMode))
	e.Simple(&o.M)
}
func doDecodeGlMatrixMultTranspose3x3fNV(d binary.Decoder, o *GlMatrixMultTranspose3x3fNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MatrixMode = GLenum(d.Uint32())
	d.Simple(&o.M)
}
func doDecodeRawGlMatrixMultTranspose3x3fNV(d binary.Decoder, o *GlMatrixMultTranspose3x3fNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MatrixMode = GLenum(d.Uint32())
	d.Simple(&o.M)
}
func (*binaryClassGlMatrixMultTranspose3x3fNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMatrixMultTranspose3x3fNV(e, obj.(*GlMatrixMultTranspose3x3fNV))
}
func (*binaryClassGlMatrixMultTranspose3x3fNV) New() binary.Object {
	return &GlMatrixMultTranspose3x3fNV{}
}
func (*binaryClassGlMatrixMultTranspose3x3fNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMatrixMultTranspose3x3fNV(d, obj.(*GlMatrixMultTranspose3x3fNV))
}
func (c *binaryClassGlMatrixMultTranspose3x3fNV) Schema() *binary.Entity {
	return &entities[ixǁGlMatrixMultTranspose3x3fNV]
}

type binaryClassGlMemoryBarrier struct{}

func (*GlMemoryBarrier) Class() binary.Class {
	return (*binaryClassGlMemoryBarrier)(nil)
}
func doEncodeGlMemoryBarrier(e binary.Encoder, o *GlMemoryBarrier) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Barriers))
}
func doDecodeGlMemoryBarrier(d binary.Decoder, o *GlMemoryBarrier) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Barriers = GLbitfield(d.Uint32())
}
func doDecodeRawGlMemoryBarrier(d binary.Decoder, o *GlMemoryBarrier) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Barriers = GLbitfield(d.Uint32())
}
func (*binaryClassGlMemoryBarrier) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMemoryBarrier(e, obj.(*GlMemoryBarrier))
}
func (*binaryClassGlMemoryBarrier) New() binary.Object {
	return &GlMemoryBarrier{}
}
func (*binaryClassGlMemoryBarrier) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMemoryBarrier(d, obj.(*GlMemoryBarrier))
}
func (c *binaryClassGlMemoryBarrier) Schema() *binary.Entity {
	return &entities[ixǁGlMemoryBarrier]
}

type binaryClassGlMemoryBarrierByRegion struct{}

func (*GlMemoryBarrierByRegion) Class() binary.Class {
	return (*binaryClassGlMemoryBarrierByRegion)(nil)
}
func doEncodeGlMemoryBarrierByRegion(e binary.Encoder, o *GlMemoryBarrierByRegion) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Barriers))
}
func doDecodeGlMemoryBarrierByRegion(d binary.Decoder, o *GlMemoryBarrierByRegion) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Barriers = GLbitfield(d.Uint32())
}
func doDecodeRawGlMemoryBarrierByRegion(d binary.Decoder, o *GlMemoryBarrierByRegion) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Barriers = GLbitfield(d.Uint32())
}
func (*binaryClassGlMemoryBarrierByRegion) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMemoryBarrierByRegion(e, obj.(*GlMemoryBarrierByRegion))
}
func (*binaryClassGlMemoryBarrierByRegion) New() binary.Object {
	return &GlMemoryBarrierByRegion{}
}
func (*binaryClassGlMemoryBarrierByRegion) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMemoryBarrierByRegion(d, obj.(*GlMemoryBarrierByRegion))
}
func (c *binaryClassGlMemoryBarrierByRegion) Schema() *binary.Entity {
	return &entities[ixǁGlMemoryBarrierByRegion]
}

type binaryClassGlMinSampleShading struct{}

func (*GlMinSampleShading) Class() binary.Class {
	return (*binaryClassGlMinSampleShading)(nil)
}
func doEncodeGlMinSampleShading(e binary.Encoder, o *GlMinSampleShading) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Value))
}
func doDecodeGlMinSampleShading(d binary.Decoder, o *GlMinSampleShading) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Value = GLfloat(d.Float32())
}
func doDecodeRawGlMinSampleShading(d binary.Decoder, o *GlMinSampleShading) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Value = GLfloat(d.Float32())
}
func (*binaryClassGlMinSampleShading) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMinSampleShading(e, obj.(*GlMinSampleShading))
}
func (*binaryClassGlMinSampleShading) New() binary.Object {
	return &GlMinSampleShading{}
}
func (*binaryClassGlMinSampleShading) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMinSampleShading(d, obj.(*GlMinSampleShading))
}
func (c *binaryClassGlMinSampleShading) Schema() *binary.Entity {
	return &entities[ixǁGlMinSampleShading]
}

type binaryClassGlMinSampleShadingOES struct{}

func (*GlMinSampleShadingOES) Class() binary.Class {
	return (*binaryClassGlMinSampleShadingOES)(nil)
}
func doEncodeGlMinSampleShadingOES(e binary.Encoder, o *GlMinSampleShadingOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Value))
}
func doDecodeGlMinSampleShadingOES(d binary.Decoder, o *GlMinSampleShadingOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Value = GLfloat(d.Float32())
}
func doDecodeRawGlMinSampleShadingOES(d binary.Decoder, o *GlMinSampleShadingOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Value = GLfloat(d.Float32())
}
func (*binaryClassGlMinSampleShadingOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMinSampleShadingOES(e, obj.(*GlMinSampleShadingOES))
}
func (*binaryClassGlMinSampleShadingOES) New() binary.Object {
	return &GlMinSampleShadingOES{}
}
func (*binaryClassGlMinSampleShadingOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMinSampleShadingOES(d, obj.(*GlMinSampleShadingOES))
}
func (c *binaryClassGlMinSampleShadingOES) Schema() *binary.Entity {
	return &entities[ixǁGlMinSampleShadingOES]
}

type binaryClassGlMultMatrixf struct{}

func (*GlMultMatrixf) Class() binary.Class {
	return (*binaryClassGlMultMatrixf)(nil)
}
func doEncodeGlMultMatrixf(e binary.Encoder, o *GlMultMatrixf) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.M)
}
func doDecodeGlMultMatrixf(d binary.Decoder, o *GlMultMatrixf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.M)
}
func doDecodeRawGlMultMatrixf(d binary.Decoder, o *GlMultMatrixf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.M)
}
func (*binaryClassGlMultMatrixf) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMultMatrixf(e, obj.(*GlMultMatrixf))
}
func (*binaryClassGlMultMatrixf) New() binary.Object {
	return &GlMultMatrixf{}
}
func (*binaryClassGlMultMatrixf) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMultMatrixf(d, obj.(*GlMultMatrixf))
}
func (c *binaryClassGlMultMatrixf) Schema() *binary.Entity {
	return &entities[ixǁGlMultMatrixf]
}

type binaryClassGlMultMatrixx struct{}

func (*GlMultMatrixx) Class() binary.Class {
	return (*binaryClassGlMultMatrixx)(nil)
}
func doEncodeGlMultMatrixx(e binary.Encoder, o *GlMultMatrixx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.M)
}
func doDecodeGlMultMatrixx(d binary.Decoder, o *GlMultMatrixx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.M)
}
func doDecodeRawGlMultMatrixx(d binary.Decoder, o *GlMultMatrixx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.M)
}
func (*binaryClassGlMultMatrixx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMultMatrixx(e, obj.(*GlMultMatrixx))
}
func (*binaryClassGlMultMatrixx) New() binary.Object {
	return &GlMultMatrixx{}
}
func (*binaryClassGlMultMatrixx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMultMatrixx(d, obj.(*GlMultMatrixx))
}
func (c *binaryClassGlMultMatrixx) Schema() *binary.Entity {
	return &entities[ixǁGlMultMatrixx]
}

type binaryClassGlMultMatrixxOES struct{}

func (*GlMultMatrixxOES) Class() binary.Class {
	return (*binaryClassGlMultMatrixxOES)(nil)
}
func doEncodeGlMultMatrixxOES(e binary.Encoder, o *GlMultMatrixxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.M)
}
func doDecodeGlMultMatrixxOES(d binary.Decoder, o *GlMultMatrixxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.M)
}
func doDecodeRawGlMultMatrixxOES(d binary.Decoder, o *GlMultMatrixxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.M)
}
func (*binaryClassGlMultMatrixxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMultMatrixxOES(e, obj.(*GlMultMatrixxOES))
}
func (*binaryClassGlMultMatrixxOES) New() binary.Object {
	return &GlMultMatrixxOES{}
}
func (*binaryClassGlMultMatrixxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMultMatrixxOES(d, obj.(*GlMultMatrixxOES))
}
func (c *binaryClassGlMultMatrixxOES) Schema() *binary.Entity {
	return &entities[ixǁGlMultMatrixxOES]
}

type binaryClassGlMultiDrawArraysEXT struct{}

func (*GlMultiDrawArraysEXT) Class() binary.Class {
	return (*binaryClassGlMultiDrawArraysEXT)(nil)
}
func doEncodeGlMultiDrawArraysEXT(e binary.Encoder, o *GlMultiDrawArraysEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Simple(&o.First)
	e.Simple(&o.Count)
	e.Int32(int32(o.Primcount))
}
func doDecodeGlMultiDrawArraysEXT(d binary.Decoder, o *GlMultiDrawArraysEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	d.Simple(&o.First)
	d.Simple(&o.Count)
	o.Primcount = GLsizei(d.Int32())
}
func doDecodeRawGlMultiDrawArraysEXT(d binary.Decoder, o *GlMultiDrawArraysEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	d.Simple(&o.First)
	d.Simple(&o.Count)
	o.Primcount = GLsizei(d.Int32())
}
func (*binaryClassGlMultiDrawArraysEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMultiDrawArraysEXT(e, obj.(*GlMultiDrawArraysEXT))
}
func (*binaryClassGlMultiDrawArraysEXT) New() binary.Object {
	return &GlMultiDrawArraysEXT{}
}
func (*binaryClassGlMultiDrawArraysEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMultiDrawArraysEXT(d, obj.(*GlMultiDrawArraysEXT))
}
func (c *binaryClassGlMultiDrawArraysEXT) Schema() *binary.Entity {
	return &entities[ixǁGlMultiDrawArraysEXT]
}

type binaryClassGlMultiDrawArraysIndirectEXT struct{}

func (*GlMultiDrawArraysIndirectEXT) Class() binary.Class {
	return (*binaryClassGlMultiDrawArraysIndirectEXT)(nil)
}
func doEncodeGlMultiDrawArraysIndirectEXT(e binary.Encoder, o *GlMultiDrawArraysIndirectEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Simple(&o.Indirect)
	e.Int32(int32(o.Drawcount))
	e.Int32(int32(o.Stride))
}
func doDecodeGlMultiDrawArraysIndirectEXT(d binary.Decoder, o *GlMultiDrawArraysIndirectEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	d.Simple(&o.Indirect)
	o.Drawcount = GLsizei(d.Int32())
	o.Stride = GLsizei(d.Int32())
}
func doDecodeRawGlMultiDrawArraysIndirectEXT(d binary.Decoder, o *GlMultiDrawArraysIndirectEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	d.Simple(&o.Indirect)
	o.Drawcount = GLsizei(d.Int32())
	o.Stride = GLsizei(d.Int32())
}
func (*binaryClassGlMultiDrawArraysIndirectEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMultiDrawArraysIndirectEXT(e, obj.(*GlMultiDrawArraysIndirectEXT))
}
func (*binaryClassGlMultiDrawArraysIndirectEXT) New() binary.Object {
	return &GlMultiDrawArraysIndirectEXT{}
}
func (*binaryClassGlMultiDrawArraysIndirectEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMultiDrawArraysIndirectEXT(d, obj.(*GlMultiDrawArraysIndirectEXT))
}
func (c *binaryClassGlMultiDrawArraysIndirectEXT) Schema() *binary.Entity {
	return &entities[ixǁGlMultiDrawArraysIndirectEXT]
}

type binaryClassVoidᶜᵖᶜᵖ struct{}

func (*Voidᶜᵖᶜᵖ) Class() binary.Class {
	return (*binaryClassVoidᶜᵖᶜᵖ)(nil)
}
func doEncodeVoidᶜᵖᶜᵖ(e binary.Writer, o *Voidᶜᵖᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVoidᶜᵖᶜᵖ(d binary.Reader, o *Voidᶜᵖᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVoidᶜᵖᶜᵖ(d binary.Reader, o *Voidᶜᵖᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVoidᶜᵖᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVoidᶜᵖᶜᵖ(e, obj.(*Voidᶜᵖᶜᵖ))
}
func (*binaryClassVoidᶜᵖᶜᵖ) New() binary.Object {
	return &Voidᶜᵖᶜᵖ{}
}
func (*binaryClassVoidᶜᵖᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVoidᶜᵖᶜᵖ(d, obj.(*Voidᶜᵖᶜᵖ))
}
func (o *Voidᶜᵖᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeVoidᶜᵖᶜᵖ(w, o)
}
func (o *Voidᶜᵖᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeVoidᶜᵖᶜᵖ(r, o)
}
func (c *binaryClassVoidᶜᵖᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁVoidᶜᵖᶜᵖ]
}

type binaryClassGlMultiDrawElementsBaseVertexEXT struct{}

func (*GlMultiDrawElementsBaseVertexEXT) Class() binary.Class {
	return (*binaryClassGlMultiDrawElementsBaseVertexEXT)(nil)
}
func doEncodeGlMultiDrawElementsBaseVertexEXT(e binary.Encoder, o *GlMultiDrawElementsBaseVertexEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Simple(&o.Count)
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Primcount))
	e.Simple(&o.Basevertex)
}
func doDecodeGlMultiDrawElementsBaseVertexEXT(d binary.Decoder, o *GlMultiDrawElementsBaseVertexEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	d.Simple(&o.Count)
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Primcount = GLsizei(d.Int32())
	d.Simple(&o.Basevertex)
}
func doDecodeRawGlMultiDrawElementsBaseVertexEXT(d binary.Decoder, o *GlMultiDrawElementsBaseVertexEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	d.Simple(&o.Count)
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Primcount = GLsizei(d.Int32())
	d.Simple(&o.Basevertex)
}
func (*binaryClassGlMultiDrawElementsBaseVertexEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMultiDrawElementsBaseVertexEXT(e, obj.(*GlMultiDrawElementsBaseVertexEXT))
}
func (*binaryClassGlMultiDrawElementsBaseVertexEXT) New() binary.Object {
	return &GlMultiDrawElementsBaseVertexEXT{}
}
func (*binaryClassGlMultiDrawElementsBaseVertexEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMultiDrawElementsBaseVertexEXT(d, obj.(*GlMultiDrawElementsBaseVertexEXT))
}
func (c *binaryClassGlMultiDrawElementsBaseVertexEXT) Schema() *binary.Entity {
	return &entities[ixǁGlMultiDrawElementsBaseVertexEXT]
}

type binaryClassGlMultiDrawElementsBaseVertexOES struct{}

func (*GlMultiDrawElementsBaseVertexOES) Class() binary.Class {
	return (*binaryClassGlMultiDrawElementsBaseVertexOES)(nil)
}
func doEncodeGlMultiDrawElementsBaseVertexOES(e binary.Encoder, o *GlMultiDrawElementsBaseVertexOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Simple(&o.Count)
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Primcount))
	e.Simple(&o.Basevertex)
}
func doDecodeGlMultiDrawElementsBaseVertexOES(d binary.Decoder, o *GlMultiDrawElementsBaseVertexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	d.Simple(&o.Count)
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Primcount = GLsizei(d.Int32())
	d.Simple(&o.Basevertex)
}
func doDecodeRawGlMultiDrawElementsBaseVertexOES(d binary.Decoder, o *GlMultiDrawElementsBaseVertexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	d.Simple(&o.Count)
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Primcount = GLsizei(d.Int32())
	d.Simple(&o.Basevertex)
}
func (*binaryClassGlMultiDrawElementsBaseVertexOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMultiDrawElementsBaseVertexOES(e, obj.(*GlMultiDrawElementsBaseVertexOES))
}
func (*binaryClassGlMultiDrawElementsBaseVertexOES) New() binary.Object {
	return &GlMultiDrawElementsBaseVertexOES{}
}
func (*binaryClassGlMultiDrawElementsBaseVertexOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMultiDrawElementsBaseVertexOES(d, obj.(*GlMultiDrawElementsBaseVertexOES))
}
func (c *binaryClassGlMultiDrawElementsBaseVertexOES) Schema() *binary.Entity {
	return &entities[ixǁGlMultiDrawElementsBaseVertexOES]
}

type binaryClassGlMultiDrawElementsEXT struct{}

func (*GlMultiDrawElementsEXT) Class() binary.Class {
	return (*binaryClassGlMultiDrawElementsEXT)(nil)
}
func doEncodeGlMultiDrawElementsEXT(e binary.Encoder, o *GlMultiDrawElementsEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Simple(&o.Count)
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indices)
	e.Int32(int32(o.Primcount))
}
func doDecodeGlMultiDrawElementsEXT(d binary.Decoder, o *GlMultiDrawElementsEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	d.Simple(&o.Count)
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Primcount = GLsizei(d.Int32())
}
func doDecodeRawGlMultiDrawElementsEXT(d binary.Decoder, o *GlMultiDrawElementsEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	d.Simple(&o.Count)
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indices)
	o.Primcount = GLsizei(d.Int32())
}
func (*binaryClassGlMultiDrawElementsEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMultiDrawElementsEXT(e, obj.(*GlMultiDrawElementsEXT))
}
func (*binaryClassGlMultiDrawElementsEXT) New() binary.Object {
	return &GlMultiDrawElementsEXT{}
}
func (*binaryClassGlMultiDrawElementsEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMultiDrawElementsEXT(d, obj.(*GlMultiDrawElementsEXT))
}
func (c *binaryClassGlMultiDrawElementsEXT) Schema() *binary.Entity {
	return &entities[ixǁGlMultiDrawElementsEXT]
}

type binaryClassGlMultiDrawElementsIndirectEXT struct{}

func (*GlMultiDrawElementsIndirectEXT) Class() binary.Class {
	return (*binaryClassGlMultiDrawElementsIndirectEXT)(nil)
}
func doEncodeGlMultiDrawElementsIndirectEXT(e binary.Encoder, o *GlMultiDrawElementsIndirectEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Indirect)
	e.Int32(int32(o.Drawcount))
	e.Int32(int32(o.Stride))
}
func doDecodeGlMultiDrawElementsIndirectEXT(d binary.Decoder, o *GlMultiDrawElementsIndirectEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indirect)
	o.Drawcount = GLsizei(d.Int32())
	o.Stride = GLsizei(d.Int32())
}
func doDecodeRawGlMultiDrawElementsIndirectEXT(d binary.Decoder, o *GlMultiDrawElementsIndirectEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Indirect)
	o.Drawcount = GLsizei(d.Int32())
	o.Stride = GLsizei(d.Int32())
}
func (*binaryClassGlMultiDrawElementsIndirectEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMultiDrawElementsIndirectEXT(e, obj.(*GlMultiDrawElementsIndirectEXT))
}
func (*binaryClassGlMultiDrawElementsIndirectEXT) New() binary.Object {
	return &GlMultiDrawElementsIndirectEXT{}
}
func (*binaryClassGlMultiDrawElementsIndirectEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMultiDrawElementsIndirectEXT(d, obj.(*GlMultiDrawElementsIndirectEXT))
}
func (c *binaryClassGlMultiDrawElementsIndirectEXT) Schema() *binary.Entity {
	return &entities[ixǁGlMultiDrawElementsIndirectEXT]
}

type binaryClassGlMultiTexCoord4f struct{}

func (*GlMultiTexCoord4f) Class() binary.Class {
	return (*binaryClassGlMultiTexCoord4f)(nil)
}
func doEncodeGlMultiTexCoord4f(e binary.Encoder, o *GlMultiTexCoord4f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Float32(float32(o.V0))
	e.Float32(float32(o.V1))
	e.Float32(float32(o.V2))
	e.Float32(float32(o.V3))
}
func doDecodeGlMultiTexCoord4f(d binary.Decoder, o *GlMultiTexCoord4f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.V0 = GLfloat(d.Float32())
	o.V1 = GLfloat(d.Float32())
	o.V2 = GLfloat(d.Float32())
	o.V3 = GLfloat(d.Float32())
}
func doDecodeRawGlMultiTexCoord4f(d binary.Decoder, o *GlMultiTexCoord4f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.V0 = GLfloat(d.Float32())
	o.V1 = GLfloat(d.Float32())
	o.V2 = GLfloat(d.Float32())
	o.V3 = GLfloat(d.Float32())
}
func (*binaryClassGlMultiTexCoord4f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMultiTexCoord4f(e, obj.(*GlMultiTexCoord4f))
}
func (*binaryClassGlMultiTexCoord4f) New() binary.Object {
	return &GlMultiTexCoord4f{}
}
func (*binaryClassGlMultiTexCoord4f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMultiTexCoord4f(d, obj.(*GlMultiTexCoord4f))
}
func (c *binaryClassGlMultiTexCoord4f) Schema() *binary.Entity {
	return &entities[ixǁGlMultiTexCoord4f]
}

type binaryClassGlMultiTexCoord4x struct{}

func (*GlMultiTexCoord4x) Class() binary.Class {
	return (*binaryClassGlMultiTexCoord4x)(nil)
}
func doEncodeGlMultiTexCoord4x(e binary.Encoder, o *GlMultiTexCoord4x) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.V0))
	e.Int32(int32(o.V1))
	e.Int32(int32(o.V2))
	e.Int32(int32(o.V3))
}
func doDecodeGlMultiTexCoord4x(d binary.Decoder, o *GlMultiTexCoord4x) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = GLenum(d.Uint32())
	o.V0 = GLfixed(d.Int32())
	o.V1 = GLfixed(d.Int32())
	o.V2 = GLfixed(d.Int32())
	o.V3 = GLfixed(d.Int32())
}
func doDecodeRawGlMultiTexCoord4x(d binary.Decoder, o *GlMultiTexCoord4x) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = GLenum(d.Uint32())
	o.V0 = GLfixed(d.Int32())
	o.V1 = GLfixed(d.Int32())
	o.V2 = GLfixed(d.Int32())
	o.V3 = GLfixed(d.Int32())
}
func (*binaryClassGlMultiTexCoord4x) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMultiTexCoord4x(e, obj.(*GlMultiTexCoord4x))
}
func (*binaryClassGlMultiTexCoord4x) New() binary.Object {
	return &GlMultiTexCoord4x{}
}
func (*binaryClassGlMultiTexCoord4x) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMultiTexCoord4x(d, obj.(*GlMultiTexCoord4x))
}
func (c *binaryClassGlMultiTexCoord4x) Schema() *binary.Entity {
	return &entities[ixǁGlMultiTexCoord4x]
}

type binaryClassGlMultiTexCoord4xOES struct{}

func (*GlMultiTexCoord4xOES) Class() binary.Class {
	return (*binaryClassGlMultiTexCoord4xOES)(nil)
}
func doEncodeGlMultiTexCoord4xOES(e binary.Encoder, o *GlMultiTexCoord4xOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
	e.Int32(int32(o.V0))
	e.Int32(int32(o.V1))
	e.Int32(int32(o.V2))
	e.Int32(int32(o.V3))
}
func doDecodeGlMultiTexCoord4xOES(d binary.Decoder, o *GlMultiTexCoord4xOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = GLenum(d.Uint32())
	o.V0 = GLfixed(d.Int32())
	o.V1 = GLfixed(d.Int32())
	o.V2 = GLfixed(d.Int32())
	o.V3 = GLfixed(d.Int32())
}
func doDecodeRawGlMultiTexCoord4xOES(d binary.Decoder, o *GlMultiTexCoord4xOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = GLenum(d.Uint32())
	o.V0 = GLfixed(d.Int32())
	o.V1 = GLfixed(d.Int32())
	o.V2 = GLfixed(d.Int32())
	o.V3 = GLfixed(d.Int32())
}
func (*binaryClassGlMultiTexCoord4xOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlMultiTexCoord4xOES(e, obj.(*GlMultiTexCoord4xOES))
}
func (*binaryClassGlMultiTexCoord4xOES) New() binary.Object {
	return &GlMultiTexCoord4xOES{}
}
func (*binaryClassGlMultiTexCoord4xOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlMultiTexCoord4xOES(d, obj.(*GlMultiTexCoord4xOES))
}
func (c *binaryClassGlMultiTexCoord4xOES) Schema() *binary.Entity {
	return &entities[ixǁGlMultiTexCoord4xOES]
}

type binaryClassGlNamedFramebufferSampleLocationsfvNV struct{}

func (*GlNamedFramebufferSampleLocationsfvNV) Class() binary.Class {
	return (*binaryClassGlNamedFramebufferSampleLocationsfvNV)(nil)
}
func doEncodeGlNamedFramebufferSampleLocationsfvNV(e binary.Encoder, o *GlNamedFramebufferSampleLocationsfvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Framebuffer))
	e.Uint32(uint32(o.Start))
	e.Int32(int32(o.Count))
	e.Simple(&o.V)
}
func doDecodeGlNamedFramebufferSampleLocationsfvNV(d binary.Decoder, o *GlNamedFramebufferSampleLocationsfvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Framebuffer = FramebufferId(d.Uint32())
	o.Start = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func doDecodeRawGlNamedFramebufferSampleLocationsfvNV(d binary.Decoder, o *GlNamedFramebufferSampleLocationsfvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Framebuffer = FramebufferId(d.Uint32())
	o.Start = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func (*binaryClassGlNamedFramebufferSampleLocationsfvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlNamedFramebufferSampleLocationsfvNV(e, obj.(*GlNamedFramebufferSampleLocationsfvNV))
}
func (*binaryClassGlNamedFramebufferSampleLocationsfvNV) New() binary.Object {
	return &GlNamedFramebufferSampleLocationsfvNV{}
}
func (*binaryClassGlNamedFramebufferSampleLocationsfvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlNamedFramebufferSampleLocationsfvNV(d, obj.(*GlNamedFramebufferSampleLocationsfvNV))
}
func (c *binaryClassGlNamedFramebufferSampleLocationsfvNV) Schema() *binary.Entity {
	return &entities[ixǁGlNamedFramebufferSampleLocationsfvNV]
}

type binaryClassGlNormal3f struct{}

func (*GlNormal3f) Class() binary.Class {
	return (*binaryClassGlNormal3f)(nil)
}
func doEncodeGlNormal3f(e binary.Encoder, o *GlNormal3f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Nx))
	e.Float32(float32(o.Ny))
	e.Float32(float32(o.Nz))
}
func doDecodeGlNormal3f(d binary.Decoder, o *GlNormal3f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Nx = GLfloat(d.Float32())
	o.Ny = GLfloat(d.Float32())
	o.Nz = GLfloat(d.Float32())
}
func doDecodeRawGlNormal3f(d binary.Decoder, o *GlNormal3f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Nx = GLfloat(d.Float32())
	o.Ny = GLfloat(d.Float32())
	o.Nz = GLfloat(d.Float32())
}
func (*binaryClassGlNormal3f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlNormal3f(e, obj.(*GlNormal3f))
}
func (*binaryClassGlNormal3f) New() binary.Object {
	return &GlNormal3f{}
}
func (*binaryClassGlNormal3f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlNormal3f(d, obj.(*GlNormal3f))
}
func (c *binaryClassGlNormal3f) Schema() *binary.Entity {
	return &entities[ixǁGlNormal3f]
}

type binaryClassGlNormal3x struct{}

func (*GlNormal3x) Class() binary.Class {
	return (*binaryClassGlNormal3x)(nil)
}
func doEncodeGlNormal3x(e binary.Encoder, o *GlNormal3x) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Nx))
	e.Int32(int32(o.Ny))
	e.Int32(int32(o.Nz))
}
func doDecodeGlNormal3x(d binary.Decoder, o *GlNormal3x) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Nx = GLfixed(d.Int32())
	o.Ny = GLfixed(d.Int32())
	o.Nz = GLfixed(d.Int32())
}
func doDecodeRawGlNormal3x(d binary.Decoder, o *GlNormal3x) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Nx = GLfixed(d.Int32())
	o.Ny = GLfixed(d.Int32())
	o.Nz = GLfixed(d.Int32())
}
func (*binaryClassGlNormal3x) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlNormal3x(e, obj.(*GlNormal3x))
}
func (*binaryClassGlNormal3x) New() binary.Object {
	return &GlNormal3x{}
}
func (*binaryClassGlNormal3x) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlNormal3x(d, obj.(*GlNormal3x))
}
func (c *binaryClassGlNormal3x) Schema() *binary.Entity {
	return &entities[ixǁGlNormal3x]
}

type binaryClassGlNormal3xOES struct{}

func (*GlNormal3xOES) Class() binary.Class {
	return (*binaryClassGlNormal3xOES)(nil)
}
func doEncodeGlNormal3xOES(e binary.Encoder, o *GlNormal3xOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Nx))
	e.Int32(int32(o.Ny))
	e.Int32(int32(o.Nz))
}
func doDecodeGlNormal3xOES(d binary.Decoder, o *GlNormal3xOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Nx = GLfixed(d.Int32())
	o.Ny = GLfixed(d.Int32())
	o.Nz = GLfixed(d.Int32())
}
func doDecodeRawGlNormal3xOES(d binary.Decoder, o *GlNormal3xOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Nx = GLfixed(d.Int32())
	o.Ny = GLfixed(d.Int32())
	o.Nz = GLfixed(d.Int32())
}
func (*binaryClassGlNormal3xOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlNormal3xOES(e, obj.(*GlNormal3xOES))
}
func (*binaryClassGlNormal3xOES) New() binary.Object {
	return &GlNormal3xOES{}
}
func (*binaryClassGlNormal3xOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlNormal3xOES(d, obj.(*GlNormal3xOES))
}
func (c *binaryClassGlNormal3xOES) Schema() *binary.Entity {
	return &entities[ixǁGlNormal3xOES]
}

type binaryClassGlNormalPointer struct{}

func (*GlNormalPointer) Class() binary.Class {
	return (*binaryClassGlNormalPointer)(nil)
}
func doEncodeGlNormalPointer(e binary.Encoder, o *GlNormalPointer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
}
func doDecodeGlNormalPointer(d binary.Decoder, o *GlNormalPointer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func doDecodeRawGlNormalPointer(d binary.Decoder, o *GlNormalPointer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func (*binaryClassGlNormalPointer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlNormalPointer(e, obj.(*GlNormalPointer))
}
func (*binaryClassGlNormalPointer) New() binary.Object {
	return &GlNormalPointer{}
}
func (*binaryClassGlNormalPointer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlNormalPointer(d, obj.(*GlNormalPointer))
}
func (c *binaryClassGlNormalPointer) Schema() *binary.Entity {
	return &entities[ixǁGlNormalPointer]
}

type binaryClassGlNormalPointerBounds struct{}

func (*GlNormalPointerBounds) Class() binary.Class {
	return (*binaryClassGlNormalPointerBounds)(nil)
}
func doEncodeGlNormalPointerBounds(e binary.Encoder, o *GlNormalPointerBounds) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
	e.Int32(int32(o.Count))
}
func doDecodeGlNormalPointerBounds(d binary.Decoder, o *GlNormalPointerBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func doDecodeRawGlNormalPointerBounds(d binary.Decoder, o *GlNormalPointerBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func (*binaryClassGlNormalPointerBounds) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlNormalPointerBounds(e, obj.(*GlNormalPointerBounds))
}
func (*binaryClassGlNormalPointerBounds) New() binary.Object {
	return &GlNormalPointerBounds{}
}
func (*binaryClassGlNormalPointerBounds) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlNormalPointerBounds(d, obj.(*GlNormalPointerBounds))
}
func (c *binaryClassGlNormalPointerBounds) Schema() *binary.Entity {
	return &entities[ixǁGlNormalPointerBounds]
}

type binaryClassGlObjectLabel struct{}

func (*GlObjectLabel) Class() binary.Class {
	return (*binaryClassGlObjectLabel)(nil)
}
func doEncodeGlObjectLabel(e binary.Encoder, o *GlObjectLabel) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Identifier))
	e.Uint32(uint32(o.Name))
	e.Int32(int32(o.Length))
	e.Simple(&o.Label)
}
func doDecodeGlObjectLabel(d binary.Decoder, o *GlObjectLabel) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Identifier = GLenum(d.Uint32())
	o.Name = GLuint(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Label)
}
func doDecodeRawGlObjectLabel(d binary.Decoder, o *GlObjectLabel) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Identifier = GLenum(d.Uint32())
	o.Name = GLuint(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Label)
}
func (*binaryClassGlObjectLabel) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlObjectLabel(e, obj.(*GlObjectLabel))
}
func (*binaryClassGlObjectLabel) New() binary.Object {
	return &GlObjectLabel{}
}
func (*binaryClassGlObjectLabel) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlObjectLabel(d, obj.(*GlObjectLabel))
}
func (c *binaryClassGlObjectLabel) Schema() *binary.Entity {
	return &entities[ixǁGlObjectLabel]
}

type binaryClassGlObjectLabelKHR struct{}

func (*GlObjectLabelKHR) Class() binary.Class {
	return (*binaryClassGlObjectLabelKHR)(nil)
}
func doEncodeGlObjectLabelKHR(e binary.Encoder, o *GlObjectLabelKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Identifier))
	e.Uint32(uint32(o.Name))
	e.Int32(int32(o.Length))
	e.Simple(&o.Label)
}
func doDecodeGlObjectLabelKHR(d binary.Decoder, o *GlObjectLabelKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Identifier = GLenum(d.Uint32())
	o.Name = GLuint(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Label)
}
func doDecodeRawGlObjectLabelKHR(d binary.Decoder, o *GlObjectLabelKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Identifier = GLenum(d.Uint32())
	o.Name = GLuint(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Label)
}
func (*binaryClassGlObjectLabelKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlObjectLabelKHR(e, obj.(*GlObjectLabelKHR))
}
func (*binaryClassGlObjectLabelKHR) New() binary.Object {
	return &GlObjectLabelKHR{}
}
func (*binaryClassGlObjectLabelKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlObjectLabelKHR(d, obj.(*GlObjectLabelKHR))
}
func (c *binaryClassGlObjectLabelKHR) Schema() *binary.Entity {
	return &entities[ixǁGlObjectLabelKHR]
}

type binaryClassGlObjectPtrLabel struct{}

func (*GlObjectPtrLabel) Class() binary.Class {
	return (*binaryClassGlObjectPtrLabel)(nil)
}
func doEncodeGlObjectPtrLabel(e binary.Encoder, o *GlObjectPtrLabel) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Ptr)
	e.Int32(int32(o.Length))
	e.Simple(&o.Label)
}
func doDecodeGlObjectPtrLabel(d binary.Decoder, o *GlObjectPtrLabel) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ptr)
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Label)
}
func doDecodeRawGlObjectPtrLabel(d binary.Decoder, o *GlObjectPtrLabel) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ptr)
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Label)
}
func (*binaryClassGlObjectPtrLabel) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlObjectPtrLabel(e, obj.(*GlObjectPtrLabel))
}
func (*binaryClassGlObjectPtrLabel) New() binary.Object {
	return &GlObjectPtrLabel{}
}
func (*binaryClassGlObjectPtrLabel) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlObjectPtrLabel(d, obj.(*GlObjectPtrLabel))
}
func (c *binaryClassGlObjectPtrLabel) Schema() *binary.Entity {
	return &entities[ixǁGlObjectPtrLabel]
}

type binaryClassGlObjectPtrLabelKHR struct{}

func (*GlObjectPtrLabelKHR) Class() binary.Class {
	return (*binaryClassGlObjectPtrLabelKHR)(nil)
}
func doEncodeGlObjectPtrLabelKHR(e binary.Encoder, o *GlObjectPtrLabelKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Ptr)
	e.Int32(int32(o.Length))
	e.Simple(&o.Label)
}
func doDecodeGlObjectPtrLabelKHR(d binary.Decoder, o *GlObjectPtrLabelKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ptr)
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Label)
}
func doDecodeRawGlObjectPtrLabelKHR(d binary.Decoder, o *GlObjectPtrLabelKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Ptr)
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Label)
}
func (*binaryClassGlObjectPtrLabelKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlObjectPtrLabelKHR(e, obj.(*GlObjectPtrLabelKHR))
}
func (*binaryClassGlObjectPtrLabelKHR) New() binary.Object {
	return &GlObjectPtrLabelKHR{}
}
func (*binaryClassGlObjectPtrLabelKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlObjectPtrLabelKHR(d, obj.(*GlObjectPtrLabelKHR))
}
func (c *binaryClassGlObjectPtrLabelKHR) Schema() *binary.Entity {
	return &entities[ixǁGlObjectPtrLabelKHR]
}

type binaryClassGlOrthof struct{}

func (*GlOrthof) Class() binary.Class {
	return (*binaryClassGlOrthof)(nil)
}
func doEncodeGlOrthof(e binary.Encoder, o *GlOrthof) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.L))
	e.Float32(float32(o.R))
	e.Float32(float32(o.B))
	e.Float32(float32(o.T))
	e.Float32(float32(o.N))
	e.Float32(float32(o.F))
}
func doDecodeGlOrthof(d binary.Decoder, o *GlOrthof) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfloat(d.Float32())
	o.R = GLfloat(d.Float32())
	o.B = GLfloat(d.Float32())
	o.T = GLfloat(d.Float32())
	o.N = GLfloat(d.Float32())
	o.F = GLfloat(d.Float32())
}
func doDecodeRawGlOrthof(d binary.Decoder, o *GlOrthof) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfloat(d.Float32())
	o.R = GLfloat(d.Float32())
	o.B = GLfloat(d.Float32())
	o.T = GLfloat(d.Float32())
	o.N = GLfloat(d.Float32())
	o.F = GLfloat(d.Float32())
}
func (*binaryClassGlOrthof) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlOrthof(e, obj.(*GlOrthof))
}
func (*binaryClassGlOrthof) New() binary.Object {
	return &GlOrthof{}
}
func (*binaryClassGlOrthof) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlOrthof(d, obj.(*GlOrthof))
}
func (c *binaryClassGlOrthof) Schema() *binary.Entity {
	return &entities[ixǁGlOrthof]
}

type binaryClassGlOrthofOES struct{}

func (*GlOrthofOES) Class() binary.Class {
	return (*binaryClassGlOrthofOES)(nil)
}
func doEncodeGlOrthofOES(e binary.Encoder, o *GlOrthofOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.L))
	e.Float32(float32(o.R))
	e.Float32(float32(o.B))
	e.Float32(float32(o.T))
	e.Float32(float32(o.N))
	e.Float32(float32(o.F))
}
func doDecodeGlOrthofOES(d binary.Decoder, o *GlOrthofOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfloat(d.Float32())
	o.R = GLfloat(d.Float32())
	o.B = GLfloat(d.Float32())
	o.T = GLfloat(d.Float32())
	o.N = GLfloat(d.Float32())
	o.F = GLfloat(d.Float32())
}
func doDecodeRawGlOrthofOES(d binary.Decoder, o *GlOrthofOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfloat(d.Float32())
	o.R = GLfloat(d.Float32())
	o.B = GLfloat(d.Float32())
	o.T = GLfloat(d.Float32())
	o.N = GLfloat(d.Float32())
	o.F = GLfloat(d.Float32())
}
func (*binaryClassGlOrthofOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlOrthofOES(e, obj.(*GlOrthofOES))
}
func (*binaryClassGlOrthofOES) New() binary.Object {
	return &GlOrthofOES{}
}
func (*binaryClassGlOrthofOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlOrthofOES(d, obj.(*GlOrthofOES))
}
func (c *binaryClassGlOrthofOES) Schema() *binary.Entity {
	return &entities[ixǁGlOrthofOES]
}

type binaryClassGlOrthox struct{}

func (*GlOrthox) Class() binary.Class {
	return (*binaryClassGlOrthox)(nil)
}
func doEncodeGlOrthox(e binary.Encoder, o *GlOrthox) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.L))
	e.Int32(int32(o.R))
	e.Int32(int32(o.B))
	e.Int32(int32(o.T))
	e.Int32(int32(o.N))
	e.Int32(int32(o.F))
}
func doDecodeGlOrthox(d binary.Decoder, o *GlOrthox) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfixed(d.Int32())
	o.R = GLfixed(d.Int32())
	o.B = GLfixed(d.Int32())
	o.T = GLfixed(d.Int32())
	o.N = GLfixed(d.Int32())
	o.F = GLfixed(d.Int32())
}
func doDecodeRawGlOrthox(d binary.Decoder, o *GlOrthox) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfixed(d.Int32())
	o.R = GLfixed(d.Int32())
	o.B = GLfixed(d.Int32())
	o.T = GLfixed(d.Int32())
	o.N = GLfixed(d.Int32())
	o.F = GLfixed(d.Int32())
}
func (*binaryClassGlOrthox) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlOrthox(e, obj.(*GlOrthox))
}
func (*binaryClassGlOrthox) New() binary.Object {
	return &GlOrthox{}
}
func (*binaryClassGlOrthox) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlOrthox(d, obj.(*GlOrthox))
}
func (c *binaryClassGlOrthox) Schema() *binary.Entity {
	return &entities[ixǁGlOrthox]
}

type binaryClassGlOrthoxOES struct{}

func (*GlOrthoxOES) Class() binary.Class {
	return (*binaryClassGlOrthoxOES)(nil)
}
func doEncodeGlOrthoxOES(e binary.Encoder, o *GlOrthoxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.L))
	e.Int32(int32(o.R))
	e.Int32(int32(o.B))
	e.Int32(int32(o.T))
	e.Int32(int32(o.N))
	e.Int32(int32(o.F))
}
func doDecodeGlOrthoxOES(d binary.Decoder, o *GlOrthoxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfixed(d.Int32())
	o.R = GLfixed(d.Int32())
	o.B = GLfixed(d.Int32())
	o.T = GLfixed(d.Int32())
	o.N = GLfixed(d.Int32())
	o.F = GLfixed(d.Int32())
}
func doDecodeRawGlOrthoxOES(d binary.Decoder, o *GlOrthoxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.L = GLfixed(d.Int32())
	o.R = GLfixed(d.Int32())
	o.B = GLfixed(d.Int32())
	o.T = GLfixed(d.Int32())
	o.N = GLfixed(d.Int32())
	o.F = GLfixed(d.Int32())
}
func (*binaryClassGlOrthoxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlOrthoxOES(e, obj.(*GlOrthoxOES))
}
func (*binaryClassGlOrthoxOES) New() binary.Object {
	return &GlOrthoxOES{}
}
func (*binaryClassGlOrthoxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlOrthoxOES(d, obj.(*GlOrthoxOES))
}
func (c *binaryClassGlOrthoxOES) Schema() *binary.Entity {
	return &entities[ixǁGlOrthoxOES]
}

type binaryClassGlPatchParameteri struct{}

func (*GlPatchParameteri) Class() binary.Class {
	return (*binaryClassGlPatchParameteri)(nil)
}
func doEncodeGlPatchParameteri(e binary.Encoder, o *GlPatchParameteri) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Value))
}
func doDecodeGlPatchParameteri(d binary.Decoder, o *GlPatchParameteri) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func doDecodeRawGlPatchParameteri(d binary.Decoder, o *GlPatchParameteri) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func (*binaryClassGlPatchParameteri) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPatchParameteri(e, obj.(*GlPatchParameteri))
}
func (*binaryClassGlPatchParameteri) New() binary.Object {
	return &GlPatchParameteri{}
}
func (*binaryClassGlPatchParameteri) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPatchParameteri(d, obj.(*GlPatchParameteri))
}
func (c *binaryClassGlPatchParameteri) Schema() *binary.Entity {
	return &entities[ixǁGlPatchParameteri]
}

type binaryClassGlPatchParameteriEXT struct{}

func (*GlPatchParameteriEXT) Class() binary.Class {
	return (*binaryClassGlPatchParameteriEXT)(nil)
}
func doEncodeGlPatchParameteriEXT(e binary.Encoder, o *GlPatchParameteriEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Value))
}
func doDecodeGlPatchParameteriEXT(d binary.Decoder, o *GlPatchParameteriEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func doDecodeRawGlPatchParameteriEXT(d binary.Decoder, o *GlPatchParameteriEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func (*binaryClassGlPatchParameteriEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPatchParameteriEXT(e, obj.(*GlPatchParameteriEXT))
}
func (*binaryClassGlPatchParameteriEXT) New() binary.Object {
	return &GlPatchParameteriEXT{}
}
func (*binaryClassGlPatchParameteriEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPatchParameteriEXT(d, obj.(*GlPatchParameteriEXT))
}
func (c *binaryClassGlPatchParameteriEXT) Schema() *binary.Entity {
	return &entities[ixǁGlPatchParameteriEXT]
}

type binaryClassGlPatchParameteriOES struct{}

func (*GlPatchParameteriOES) Class() binary.Class {
	return (*binaryClassGlPatchParameteriOES)(nil)
}
func doEncodeGlPatchParameteriOES(e binary.Encoder, o *GlPatchParameteriOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Value))
}
func doDecodeGlPatchParameteriOES(d binary.Decoder, o *GlPatchParameteriOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func doDecodeRawGlPatchParameteriOES(d binary.Decoder, o *GlPatchParameteriOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func (*binaryClassGlPatchParameteriOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPatchParameteriOES(e, obj.(*GlPatchParameteriOES))
}
func (*binaryClassGlPatchParameteriOES) New() binary.Object {
	return &GlPatchParameteriOES{}
}
func (*binaryClassGlPatchParameteriOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPatchParameteriOES(d, obj.(*GlPatchParameteriOES))
}
func (c *binaryClassGlPatchParameteriOES) Schema() *binary.Entity {
	return &entities[ixǁGlPatchParameteriOES]
}

type binaryClassGlPathCommandsNV struct{}

func (*GlPathCommandsNV) Class() binary.Class {
	return (*binaryClassGlPathCommandsNV)(nil)
}
func doEncodeGlPathCommandsNV(e binary.Encoder, o *GlPathCommandsNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Int32(int32(o.NumCommands))
	e.Simple(&o.Commands)
	e.Int32(int32(o.NumCoords))
	e.Uint32(uint32(o.CoordType))
	e.Simple(&o.Coords)
}
func doDecodeGlPathCommandsNV(d binary.Decoder, o *GlPathCommandsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.NumCommands = GLsizei(d.Int32())
	d.Simple(&o.Commands)
	o.NumCoords = GLsizei(d.Int32())
	o.CoordType = GLenum(d.Uint32())
	d.Simple(&o.Coords)
}
func doDecodeRawGlPathCommandsNV(d binary.Decoder, o *GlPathCommandsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.NumCommands = GLsizei(d.Int32())
	d.Simple(&o.Commands)
	o.NumCoords = GLsizei(d.Int32())
	o.CoordType = GLenum(d.Uint32())
	d.Simple(&o.Coords)
}
func (*binaryClassGlPathCommandsNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathCommandsNV(e, obj.(*GlPathCommandsNV))
}
func (*binaryClassGlPathCommandsNV) New() binary.Object {
	return &GlPathCommandsNV{}
}
func (*binaryClassGlPathCommandsNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathCommandsNV(d, obj.(*GlPathCommandsNV))
}
func (c *binaryClassGlPathCommandsNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathCommandsNV]
}

type binaryClassGlPathCoordsNV struct{}

func (*GlPathCoordsNV) Class() binary.Class {
	return (*binaryClassGlPathCoordsNV)(nil)
}
func doEncodeGlPathCoordsNV(e binary.Encoder, o *GlPathCoordsNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Int32(int32(o.NumCoords))
	e.Uint32(uint32(o.CoordType))
	e.Simple(&o.Coords)
}
func doDecodeGlPathCoordsNV(d binary.Decoder, o *GlPathCoordsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.NumCoords = GLsizei(d.Int32())
	o.CoordType = GLenum(d.Uint32())
	d.Simple(&o.Coords)
}
func doDecodeRawGlPathCoordsNV(d binary.Decoder, o *GlPathCoordsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.NumCoords = GLsizei(d.Int32())
	o.CoordType = GLenum(d.Uint32())
	d.Simple(&o.Coords)
}
func (*binaryClassGlPathCoordsNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathCoordsNV(e, obj.(*GlPathCoordsNV))
}
func (*binaryClassGlPathCoordsNV) New() binary.Object {
	return &GlPathCoordsNV{}
}
func (*binaryClassGlPathCoordsNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathCoordsNV(d, obj.(*GlPathCoordsNV))
}
func (c *binaryClassGlPathCoordsNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathCoordsNV]
}

type binaryClassGlPathCoverDepthFuncNV struct{}

func (*GlPathCoverDepthFuncNV) Class() binary.Class {
	return (*binaryClassGlPathCoverDepthFuncNV)(nil)
}
func doEncodeGlPathCoverDepthFuncNV(e binary.Encoder, o *GlPathCoverDepthFuncNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Func))
}
func doDecodeGlPathCoverDepthFuncNV(d binary.Decoder, o *GlPathCoverDepthFuncNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
}
func doDecodeRawGlPathCoverDepthFuncNV(d binary.Decoder, o *GlPathCoverDepthFuncNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
}
func (*binaryClassGlPathCoverDepthFuncNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathCoverDepthFuncNV(e, obj.(*GlPathCoverDepthFuncNV))
}
func (*binaryClassGlPathCoverDepthFuncNV) New() binary.Object {
	return &GlPathCoverDepthFuncNV{}
}
func (*binaryClassGlPathCoverDepthFuncNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathCoverDepthFuncNV(d, obj.(*GlPathCoverDepthFuncNV))
}
func (c *binaryClassGlPathCoverDepthFuncNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathCoverDepthFuncNV]
}

type binaryClassGlPathDashArrayNV struct{}

func (*GlPathDashArrayNV) Class() binary.Class {
	return (*binaryClassGlPathDashArrayNV)(nil)
}
func doEncodeGlPathDashArrayNV(e binary.Encoder, o *GlPathDashArrayNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Int32(int32(o.DashCount))
	e.Simple(&o.DashArray)
}
func doDecodeGlPathDashArrayNV(d binary.Decoder, o *GlPathDashArrayNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.DashCount = GLsizei(d.Int32())
	d.Simple(&o.DashArray)
}
func doDecodeRawGlPathDashArrayNV(d binary.Decoder, o *GlPathDashArrayNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.DashCount = GLsizei(d.Int32())
	d.Simple(&o.DashArray)
}
func (*binaryClassGlPathDashArrayNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathDashArrayNV(e, obj.(*GlPathDashArrayNV))
}
func (*binaryClassGlPathDashArrayNV) New() binary.Object {
	return &GlPathDashArrayNV{}
}
func (*binaryClassGlPathDashArrayNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathDashArrayNV(d, obj.(*GlPathDashArrayNV))
}
func (c *binaryClassGlPathDashArrayNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathDashArrayNV]
}

type binaryClassGlPathGlyphIndexArrayNV struct{}

func (*GlPathGlyphIndexArrayNV) Class() binary.Class {
	return (*binaryClassGlPathGlyphIndexArrayNV)(nil)
}
func doEncodeGlPathGlyphIndexArrayNV(e binary.Encoder, o *GlPathGlyphIndexArrayNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.FirstPathName))
	e.Uint32(uint32(o.FontTarget))
	e.Simple(&o.FontName)
	e.Uint32(uint32(o.FontStyle))
	e.Uint32(uint32(o.FirstGlyphIndex))
	e.Int32(int32(o.NumGlyphs))
	e.Uint32(uint32(o.PathParameterTemplate))
	e.Float32(float32(o.EmScale))
	e.Uint32(uint32(o.Result))
}
func doDecodeGlPathGlyphIndexArrayNV(d binary.Decoder, o *GlPathGlyphIndexArrayNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FirstPathName = GLuint(d.Uint32())
	o.FontTarget = GLenum(d.Uint32())
	d.Simple(&o.FontName)
	o.FontStyle = GLbitfield(d.Uint32())
	o.FirstGlyphIndex = GLuint(d.Uint32())
	o.NumGlyphs = GLsizei(d.Int32())
	o.PathParameterTemplate = GLuint(d.Uint32())
	o.EmScale = GLfloat(d.Float32())
	o.Result = GLenum(d.Uint32())
}
func doDecodeRawGlPathGlyphIndexArrayNV(d binary.Decoder, o *GlPathGlyphIndexArrayNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FirstPathName = GLuint(d.Uint32())
	o.FontTarget = GLenum(d.Uint32())
	d.Simple(&o.FontName)
	o.FontStyle = GLbitfield(d.Uint32())
	o.FirstGlyphIndex = GLuint(d.Uint32())
	o.NumGlyphs = GLsizei(d.Int32())
	o.PathParameterTemplate = GLuint(d.Uint32())
	o.EmScale = GLfloat(d.Float32())
	o.Result = GLenum(d.Uint32())
}
func (*binaryClassGlPathGlyphIndexArrayNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathGlyphIndexArrayNV(e, obj.(*GlPathGlyphIndexArrayNV))
}
func (*binaryClassGlPathGlyphIndexArrayNV) New() binary.Object {
	return &GlPathGlyphIndexArrayNV{}
}
func (*binaryClassGlPathGlyphIndexArrayNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathGlyphIndexArrayNV(d, obj.(*GlPathGlyphIndexArrayNV))
}
func (c *binaryClassGlPathGlyphIndexArrayNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathGlyphIndexArrayNV]
}

type binaryClassGlPathGlyphIndexRangeNV struct{}

func (*GlPathGlyphIndexRangeNV) Class() binary.Class {
	return (*binaryClassGlPathGlyphIndexRangeNV)(nil)
}
func doEncodeGlPathGlyphIndexRangeNV(e binary.Encoder, o *GlPathGlyphIndexRangeNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.FontTarget))
	e.Simple(&o.FontName)
	e.Uint32(uint32(o.FontStyle))
	e.Uint32(uint32(o.PathParameterTemplate))
	e.Float32(float32(o.EmScale))
	e.Uint32(uint32(o.BaseAndCount))
	e.Uint32(uint32(o.Result))
}
func doDecodeGlPathGlyphIndexRangeNV(d binary.Decoder, o *GlPathGlyphIndexRangeNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FontTarget = GLenum(d.Uint32())
	d.Simple(&o.FontName)
	o.FontStyle = GLbitfield(d.Uint32())
	o.PathParameterTemplate = GLuint(d.Uint32())
	o.EmScale = GLfloat(d.Float32())
	o.BaseAndCount = GLuint(d.Uint32())
	o.Result = GLenum(d.Uint32())
}
func doDecodeRawGlPathGlyphIndexRangeNV(d binary.Decoder, o *GlPathGlyphIndexRangeNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FontTarget = GLenum(d.Uint32())
	d.Simple(&o.FontName)
	o.FontStyle = GLbitfield(d.Uint32())
	o.PathParameterTemplate = GLuint(d.Uint32())
	o.EmScale = GLfloat(d.Float32())
	o.BaseAndCount = GLuint(d.Uint32())
	o.Result = GLenum(d.Uint32())
}
func (*binaryClassGlPathGlyphIndexRangeNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathGlyphIndexRangeNV(e, obj.(*GlPathGlyphIndexRangeNV))
}
func (*binaryClassGlPathGlyphIndexRangeNV) New() binary.Object {
	return &GlPathGlyphIndexRangeNV{}
}
func (*binaryClassGlPathGlyphIndexRangeNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathGlyphIndexRangeNV(d, obj.(*GlPathGlyphIndexRangeNV))
}
func (c *binaryClassGlPathGlyphIndexRangeNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathGlyphIndexRangeNV]
}

type binaryClassGlPathGlyphRangeNV struct{}

func (*GlPathGlyphRangeNV) Class() binary.Class {
	return (*binaryClassGlPathGlyphRangeNV)(nil)
}
func doEncodeGlPathGlyphRangeNV(e binary.Encoder, o *GlPathGlyphRangeNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.FirstPathName))
	e.Uint32(uint32(o.FontTarget))
	e.Simple(&o.FontName)
	e.Uint32(uint32(o.FontStyle))
	e.Uint32(uint32(o.FirstGlyph))
	e.Int32(int32(o.NumGlyphs))
	e.Uint32(uint32(o.HandleMissingGlyphs))
	e.Uint32(uint32(o.PathParameterTemplate))
	e.Float32(float32(o.EmScale))
}
func doDecodeGlPathGlyphRangeNV(d binary.Decoder, o *GlPathGlyphRangeNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FirstPathName = GLuint(d.Uint32())
	o.FontTarget = GLenum(d.Uint32())
	d.Simple(&o.FontName)
	o.FontStyle = GLbitfield(d.Uint32())
	o.FirstGlyph = GLuint(d.Uint32())
	o.NumGlyphs = GLsizei(d.Int32())
	o.HandleMissingGlyphs = GLenum(d.Uint32())
	o.PathParameterTemplate = GLuint(d.Uint32())
	o.EmScale = GLfloat(d.Float32())
}
func doDecodeRawGlPathGlyphRangeNV(d binary.Decoder, o *GlPathGlyphRangeNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FirstPathName = GLuint(d.Uint32())
	o.FontTarget = GLenum(d.Uint32())
	d.Simple(&o.FontName)
	o.FontStyle = GLbitfield(d.Uint32())
	o.FirstGlyph = GLuint(d.Uint32())
	o.NumGlyphs = GLsizei(d.Int32())
	o.HandleMissingGlyphs = GLenum(d.Uint32())
	o.PathParameterTemplate = GLuint(d.Uint32())
	o.EmScale = GLfloat(d.Float32())
}
func (*binaryClassGlPathGlyphRangeNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathGlyphRangeNV(e, obj.(*GlPathGlyphRangeNV))
}
func (*binaryClassGlPathGlyphRangeNV) New() binary.Object {
	return &GlPathGlyphRangeNV{}
}
func (*binaryClassGlPathGlyphRangeNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathGlyphRangeNV(d, obj.(*GlPathGlyphRangeNV))
}
func (c *binaryClassGlPathGlyphRangeNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathGlyphRangeNV]
}

type binaryClassGlPathGlyphsNV struct{}

func (*GlPathGlyphsNV) Class() binary.Class {
	return (*binaryClassGlPathGlyphsNV)(nil)
}
func doEncodeGlPathGlyphsNV(e binary.Encoder, o *GlPathGlyphsNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.FirstPathName))
	e.Uint32(uint32(o.FontTarget))
	e.Simple(&o.FontName)
	e.Uint32(uint32(o.FontStyle))
	e.Int32(int32(o.NumGlyphs))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Charcodes)
	e.Uint32(uint32(o.HandleMissingGlyphs))
	e.Uint32(uint32(o.PathParameterTemplate))
	e.Float32(float32(o.EmScale))
}
func doDecodeGlPathGlyphsNV(d binary.Decoder, o *GlPathGlyphsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FirstPathName = GLuint(d.Uint32())
	o.FontTarget = GLenum(d.Uint32())
	d.Simple(&o.FontName)
	o.FontStyle = GLbitfield(d.Uint32())
	o.NumGlyphs = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Charcodes)
	o.HandleMissingGlyphs = GLenum(d.Uint32())
	o.PathParameterTemplate = GLuint(d.Uint32())
	o.EmScale = GLfloat(d.Float32())
}
func doDecodeRawGlPathGlyphsNV(d binary.Decoder, o *GlPathGlyphsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FirstPathName = GLuint(d.Uint32())
	o.FontTarget = GLenum(d.Uint32())
	d.Simple(&o.FontName)
	o.FontStyle = GLbitfield(d.Uint32())
	o.NumGlyphs = GLsizei(d.Int32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Charcodes)
	o.HandleMissingGlyphs = GLenum(d.Uint32())
	o.PathParameterTemplate = GLuint(d.Uint32())
	o.EmScale = GLfloat(d.Float32())
}
func (*binaryClassGlPathGlyphsNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathGlyphsNV(e, obj.(*GlPathGlyphsNV))
}
func (*binaryClassGlPathGlyphsNV) New() binary.Object {
	return &GlPathGlyphsNV{}
}
func (*binaryClassGlPathGlyphsNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathGlyphsNV(d, obj.(*GlPathGlyphsNV))
}
func (c *binaryClassGlPathGlyphsNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathGlyphsNV]
}

type binaryClassGlPathMemoryGlyphIndexArrayNV struct{}

func (*GlPathMemoryGlyphIndexArrayNV) Class() binary.Class {
	return (*binaryClassGlPathMemoryGlyphIndexArrayNV)(nil)
}
func doEncodeGlPathMemoryGlyphIndexArrayNV(e binary.Encoder, o *GlPathMemoryGlyphIndexArrayNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.FirstPathName))
	e.Uint32(uint32(o.FontTarget))
	e.Int32(int32(o.FontSize))
	e.Simple(&o.FontData)
	e.Int32(int32(o.FaceIndex))
	e.Uint32(uint32(o.FirstGlyphIndex))
	e.Int32(int32(o.NumGlyphs))
	e.Uint32(uint32(o.PathParameterTemplate))
	e.Float32(float32(o.EmScale))
	e.Uint32(uint32(o.Result))
}
func doDecodeGlPathMemoryGlyphIndexArrayNV(d binary.Decoder, o *GlPathMemoryGlyphIndexArrayNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FirstPathName = GLuint(d.Uint32())
	o.FontTarget = GLenum(d.Uint32())
	o.FontSize = GLsizeiptr(d.Int32())
	d.Simple(&o.FontData)
	o.FaceIndex = GLsizei(d.Int32())
	o.FirstGlyphIndex = GLuint(d.Uint32())
	o.NumGlyphs = GLsizei(d.Int32())
	o.PathParameterTemplate = GLuint(d.Uint32())
	o.EmScale = GLfloat(d.Float32())
	o.Result = GLenum(d.Uint32())
}
func doDecodeRawGlPathMemoryGlyphIndexArrayNV(d binary.Decoder, o *GlPathMemoryGlyphIndexArrayNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.FirstPathName = GLuint(d.Uint32())
	o.FontTarget = GLenum(d.Uint32())
	o.FontSize = GLsizeiptr(d.Int32())
	d.Simple(&o.FontData)
	o.FaceIndex = GLsizei(d.Int32())
	o.FirstGlyphIndex = GLuint(d.Uint32())
	o.NumGlyphs = GLsizei(d.Int32())
	o.PathParameterTemplate = GLuint(d.Uint32())
	o.EmScale = GLfloat(d.Float32())
	o.Result = GLenum(d.Uint32())
}
func (*binaryClassGlPathMemoryGlyphIndexArrayNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathMemoryGlyphIndexArrayNV(e, obj.(*GlPathMemoryGlyphIndexArrayNV))
}
func (*binaryClassGlPathMemoryGlyphIndexArrayNV) New() binary.Object {
	return &GlPathMemoryGlyphIndexArrayNV{}
}
func (*binaryClassGlPathMemoryGlyphIndexArrayNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathMemoryGlyphIndexArrayNV(d, obj.(*GlPathMemoryGlyphIndexArrayNV))
}
func (c *binaryClassGlPathMemoryGlyphIndexArrayNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathMemoryGlyphIndexArrayNV]
}

type binaryClassGlPathParameterfNV struct{}

func (*GlPathParameterfNV) Class() binary.Class {
	return (*binaryClassGlPathParameterfNV)(nil)
}
func doEncodeGlPathParameterfNV(e binary.Encoder, o *GlPathParameterfNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint32(uint32(o.Pname))
	e.Float32(float32(o.Value))
}
func doDecodeGlPathParameterfNV(d binary.Decoder, o *GlPathParameterfNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Value = GLfloat(d.Float32())
}
func doDecodeRawGlPathParameterfNV(d binary.Decoder, o *GlPathParameterfNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Value = GLfloat(d.Float32())
}
func (*binaryClassGlPathParameterfNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathParameterfNV(e, obj.(*GlPathParameterfNV))
}
func (*binaryClassGlPathParameterfNV) New() binary.Object {
	return &GlPathParameterfNV{}
}
func (*binaryClassGlPathParameterfNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathParameterfNV(d, obj.(*GlPathParameterfNV))
}
func (c *binaryClassGlPathParameterfNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathParameterfNV]
}

type binaryClassGlPathParameterfvNV struct{}

func (*GlPathParameterfvNV) Class() binary.Class {
	return (*binaryClassGlPathParameterfvNV)(nil)
}
func doEncodeGlPathParameterfvNV(e binary.Encoder, o *GlPathParameterfvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Value)
}
func doDecodeGlPathParameterfvNV(d binary.Decoder, o *GlPathParameterfvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlPathParameterfvNV(d binary.Decoder, o *GlPathParameterfvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlPathParameterfvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathParameterfvNV(e, obj.(*GlPathParameterfvNV))
}
func (*binaryClassGlPathParameterfvNV) New() binary.Object {
	return &GlPathParameterfvNV{}
}
func (*binaryClassGlPathParameterfvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathParameterfvNV(d, obj.(*GlPathParameterfvNV))
}
func (c *binaryClassGlPathParameterfvNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathParameterfvNV]
}

type binaryClassGlPathParameteriNV struct{}

func (*GlPathParameteriNV) Class() binary.Class {
	return (*binaryClassGlPathParameteriNV)(nil)
}
func doEncodeGlPathParameteriNV(e binary.Encoder, o *GlPathParameteriNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Value))
}
func doDecodeGlPathParameteriNV(d binary.Decoder, o *GlPathParameteriNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func doDecodeRawGlPathParameteriNV(d binary.Decoder, o *GlPathParameteriNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func (*binaryClassGlPathParameteriNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathParameteriNV(e, obj.(*GlPathParameteriNV))
}
func (*binaryClassGlPathParameteriNV) New() binary.Object {
	return &GlPathParameteriNV{}
}
func (*binaryClassGlPathParameteriNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathParameteriNV(d, obj.(*GlPathParameteriNV))
}
func (c *binaryClassGlPathParameteriNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathParameteriNV]
}

type binaryClassGlPathParameterivNV struct{}

func (*GlPathParameterivNV) Class() binary.Class {
	return (*binaryClassGlPathParameterivNV)(nil)
}
func doEncodeGlPathParameterivNV(e binary.Encoder, o *GlPathParameterivNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Value)
}
func doDecodeGlPathParameterivNV(d binary.Decoder, o *GlPathParameterivNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlPathParameterivNV(d binary.Decoder, o *GlPathParameterivNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlPathParameterivNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathParameterivNV(e, obj.(*GlPathParameterivNV))
}
func (*binaryClassGlPathParameterivNV) New() binary.Object {
	return &GlPathParameterivNV{}
}
func (*binaryClassGlPathParameterivNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathParameterivNV(d, obj.(*GlPathParameterivNV))
}
func (c *binaryClassGlPathParameterivNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathParameterivNV]
}

type binaryClassGlPathStencilDepthOffsetNV struct{}

func (*GlPathStencilDepthOffsetNV) Class() binary.Class {
	return (*binaryClassGlPathStencilDepthOffsetNV)(nil)
}
func doEncodeGlPathStencilDepthOffsetNV(e binary.Encoder, o *GlPathStencilDepthOffsetNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Factor))
	e.Float32(float32(o.Units))
}
func doDecodeGlPathStencilDepthOffsetNV(d binary.Decoder, o *GlPathStencilDepthOffsetNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Factor = GLfloat(d.Float32())
	o.Units = GLfloat(d.Float32())
}
func doDecodeRawGlPathStencilDepthOffsetNV(d binary.Decoder, o *GlPathStencilDepthOffsetNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Factor = GLfloat(d.Float32())
	o.Units = GLfloat(d.Float32())
}
func (*binaryClassGlPathStencilDepthOffsetNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathStencilDepthOffsetNV(e, obj.(*GlPathStencilDepthOffsetNV))
}
func (*binaryClassGlPathStencilDepthOffsetNV) New() binary.Object {
	return &GlPathStencilDepthOffsetNV{}
}
func (*binaryClassGlPathStencilDepthOffsetNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathStencilDepthOffsetNV(d, obj.(*GlPathStencilDepthOffsetNV))
}
func (c *binaryClassGlPathStencilDepthOffsetNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathStencilDepthOffsetNV]
}

type binaryClassGlPathStencilFuncNV struct{}

func (*GlPathStencilFuncNV) Class() binary.Class {
	return (*binaryClassGlPathStencilFuncNV)(nil)
}
func doEncodeGlPathStencilFuncNV(e binary.Encoder, o *GlPathStencilFuncNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Func))
	e.Int32(int32(o.Ref))
	e.Uint32(uint32(o.Mask))
}
func doDecodeGlPathStencilFuncNV(d binary.Decoder, o *GlPathStencilFuncNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
	o.Ref = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
}
func doDecodeRawGlPathStencilFuncNV(d binary.Decoder, o *GlPathStencilFuncNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
	o.Ref = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
}
func (*binaryClassGlPathStencilFuncNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathStencilFuncNV(e, obj.(*GlPathStencilFuncNV))
}
func (*binaryClassGlPathStencilFuncNV) New() binary.Object {
	return &GlPathStencilFuncNV{}
}
func (*binaryClassGlPathStencilFuncNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathStencilFuncNV(d, obj.(*GlPathStencilFuncNV))
}
func (c *binaryClassGlPathStencilFuncNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathStencilFuncNV]
}

type binaryClassGlPathStringNV struct{}

func (*GlPathStringNV) Class() binary.Class {
	return (*binaryClassGlPathStringNV)(nil)
}
func doEncodeGlPathStringNV(e binary.Encoder, o *GlPathStringNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint32(uint32(o.Format))
	e.Int32(int32(o.Length))
	e.Simple(&o.PathString)
}
func doDecodeGlPathStringNV(d binary.Decoder, o *GlPathStringNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Format = GLenum(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.PathString)
}
func doDecodeRawGlPathStringNV(d binary.Decoder, o *GlPathStringNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Format = GLenum(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.PathString)
}
func (*binaryClassGlPathStringNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathStringNV(e, obj.(*GlPathStringNV))
}
func (*binaryClassGlPathStringNV) New() binary.Object {
	return &GlPathStringNV{}
}
func (*binaryClassGlPathStringNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathStringNV(d, obj.(*GlPathStringNV))
}
func (c *binaryClassGlPathStringNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathStringNV]
}

type binaryClassGlPathSubCommandsNV struct{}

func (*GlPathSubCommandsNV) Class() binary.Class {
	return (*binaryClassGlPathSubCommandsNV)(nil)
}
func doEncodeGlPathSubCommandsNV(e binary.Encoder, o *GlPathSubCommandsNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Int32(int32(o.CommandStart))
	e.Int32(int32(o.CommandsToDelete))
	e.Int32(int32(o.NumCommands))
	e.Simple(&o.Commands)
	e.Int32(int32(o.NumCoords))
	e.Uint32(uint32(o.CoordType))
	e.Simple(&o.Coords)
}
func doDecodeGlPathSubCommandsNV(d binary.Decoder, o *GlPathSubCommandsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.CommandStart = GLsizei(d.Int32())
	o.CommandsToDelete = GLsizei(d.Int32())
	o.NumCommands = GLsizei(d.Int32())
	d.Simple(&o.Commands)
	o.NumCoords = GLsizei(d.Int32())
	o.CoordType = GLenum(d.Uint32())
	d.Simple(&o.Coords)
}
func doDecodeRawGlPathSubCommandsNV(d binary.Decoder, o *GlPathSubCommandsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.CommandStart = GLsizei(d.Int32())
	o.CommandsToDelete = GLsizei(d.Int32())
	o.NumCommands = GLsizei(d.Int32())
	d.Simple(&o.Commands)
	o.NumCoords = GLsizei(d.Int32())
	o.CoordType = GLenum(d.Uint32())
	d.Simple(&o.Coords)
}
func (*binaryClassGlPathSubCommandsNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathSubCommandsNV(e, obj.(*GlPathSubCommandsNV))
}
func (*binaryClassGlPathSubCommandsNV) New() binary.Object {
	return &GlPathSubCommandsNV{}
}
func (*binaryClassGlPathSubCommandsNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathSubCommandsNV(d, obj.(*GlPathSubCommandsNV))
}
func (c *binaryClassGlPathSubCommandsNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathSubCommandsNV]
}

type binaryClassGlPathSubCoordsNV struct{}

func (*GlPathSubCoordsNV) Class() binary.Class {
	return (*binaryClassGlPathSubCoordsNV)(nil)
}
func doEncodeGlPathSubCoordsNV(e binary.Encoder, o *GlPathSubCoordsNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Int32(int32(o.CoordStart))
	e.Int32(int32(o.NumCoords))
	e.Uint32(uint32(o.CoordType))
	e.Simple(&o.Coords)
}
func doDecodeGlPathSubCoordsNV(d binary.Decoder, o *GlPathSubCoordsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.CoordStart = GLsizei(d.Int32())
	o.NumCoords = GLsizei(d.Int32())
	o.CoordType = GLenum(d.Uint32())
	d.Simple(&o.Coords)
}
func doDecodeRawGlPathSubCoordsNV(d binary.Decoder, o *GlPathSubCoordsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.CoordStart = GLsizei(d.Int32())
	o.NumCoords = GLsizei(d.Int32())
	o.CoordType = GLenum(d.Uint32())
	d.Simple(&o.Coords)
}
func (*binaryClassGlPathSubCoordsNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPathSubCoordsNV(e, obj.(*GlPathSubCoordsNV))
}
func (*binaryClassGlPathSubCoordsNV) New() binary.Object {
	return &GlPathSubCoordsNV{}
}
func (*binaryClassGlPathSubCoordsNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPathSubCoordsNV(d, obj.(*GlPathSubCoordsNV))
}
func (c *binaryClassGlPathSubCoordsNV) Schema() *binary.Entity {
	return &entities[ixǁGlPathSubCoordsNV]
}

type binaryClassGlPauseTransformFeedback struct{}

func (*GlPauseTransformFeedback) Class() binary.Class {
	return (*binaryClassGlPauseTransformFeedback)(nil)
}
func doEncodeGlPauseTransformFeedback(e binary.Encoder, o *GlPauseTransformFeedback) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlPauseTransformFeedback(d binary.Decoder, o *GlPauseTransformFeedback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlPauseTransformFeedback(d binary.Decoder, o *GlPauseTransformFeedback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlPauseTransformFeedback) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPauseTransformFeedback(e, obj.(*GlPauseTransformFeedback))
}
func (*binaryClassGlPauseTransformFeedback) New() binary.Object {
	return &GlPauseTransformFeedback{}
}
func (*binaryClassGlPauseTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPauseTransformFeedback(d, obj.(*GlPauseTransformFeedback))
}
func (c *binaryClassGlPauseTransformFeedback) Schema() *binary.Entity {
	return &entities[ixǁGlPauseTransformFeedback]
}

type binaryClassGlPixelStorei struct{}

func (*GlPixelStorei) Class() binary.Class {
	return (*binaryClassGlPixelStorei)(nil)
}
func doEncodeGlPixelStorei(e binary.Encoder, o *GlPixelStorei) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Parameter))
	e.Int32(int32(o.Value))
}
func doDecodeGlPixelStorei(d binary.Decoder, o *GlPixelStorei) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Parameter = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func doDecodeRawGlPixelStorei(d binary.Decoder, o *GlPixelStorei) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Parameter = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func (*binaryClassGlPixelStorei) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPixelStorei(e, obj.(*GlPixelStorei))
}
func (*binaryClassGlPixelStorei) New() binary.Object {
	return &GlPixelStorei{}
}
func (*binaryClassGlPixelStorei) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPixelStorei(d, obj.(*GlPixelStorei))
}
func (c *binaryClassGlPixelStorei) Schema() *binary.Entity {
	return &entities[ixǁGlPixelStorei]
}

type binaryClassGlPointAlongPathNV struct{}

func (*GlPointAlongPathNV) Class() binary.Class {
	return (*binaryClassGlPointAlongPathNV)(nil)
}
func doEncodeGlPointAlongPathNV(e binary.Encoder, o *GlPointAlongPathNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Int32(int32(o.StartSegment))
	e.Int32(int32(o.NumSegments))
	e.Float32(float32(o.Distance))
	e.Simple(&o.X)
	e.Simple(&o.Y)
	e.Simple(&o.TangentX)
	e.Simple(&o.TangentY)
	e.Uint8(uint8(o.Result))
}
func doDecodeGlPointAlongPathNV(d binary.Decoder, o *GlPointAlongPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.StartSegment = GLsizei(d.Int32())
	o.NumSegments = GLsizei(d.Int32())
	o.Distance = GLfloat(d.Float32())
	d.Simple(&o.X)
	d.Simple(&o.Y)
	d.Simple(&o.TangentX)
	d.Simple(&o.TangentY)
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlPointAlongPathNV(d binary.Decoder, o *GlPointAlongPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.StartSegment = GLsizei(d.Int32())
	o.NumSegments = GLsizei(d.Int32())
	o.Distance = GLfloat(d.Float32())
	d.Simple(&o.X)
	d.Simple(&o.Y)
	d.Simple(&o.TangentX)
	d.Simple(&o.TangentY)
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlPointAlongPathNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPointAlongPathNV(e, obj.(*GlPointAlongPathNV))
}
func (*binaryClassGlPointAlongPathNV) New() binary.Object {
	return &GlPointAlongPathNV{}
}
func (*binaryClassGlPointAlongPathNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPointAlongPathNV(d, obj.(*GlPointAlongPathNV))
}
func (c *binaryClassGlPointAlongPathNV) Schema() *binary.Entity {
	return &entities[ixǁGlPointAlongPathNV]
}

type binaryClassGlPointParameterf struct{}

func (*GlPointParameterf) Class() binary.Class {
	return (*binaryClassGlPointParameterf)(nil)
}
func doEncodeGlPointParameterf(e binary.Encoder, o *GlPointParameterf) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Float32(float32(o.Param))
}
func doDecodeGlPointParameterf(d binary.Decoder, o *GlPointParameterf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func doDecodeRawGlPointParameterf(d binary.Decoder, o *GlPointParameterf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func (*binaryClassGlPointParameterf) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPointParameterf(e, obj.(*GlPointParameterf))
}
func (*binaryClassGlPointParameterf) New() binary.Object {
	return &GlPointParameterf{}
}
func (*binaryClassGlPointParameterf) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPointParameterf(d, obj.(*GlPointParameterf))
}
func (c *binaryClassGlPointParameterf) Schema() *binary.Entity {
	return &entities[ixǁGlPointParameterf]
}

type binaryClassGlPointParameterfv struct{}

func (*GlPointParameterfv) Class() binary.Class {
	return (*binaryClassGlPointParameterfv)(nil)
}
func doEncodeGlPointParameterfv(e binary.Encoder, o *GlPointParameterfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlPointParameterfv(d binary.Decoder, o *GlPointParameterfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlPointParameterfv(d binary.Decoder, o *GlPointParameterfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlPointParameterfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPointParameterfv(e, obj.(*GlPointParameterfv))
}
func (*binaryClassGlPointParameterfv) New() binary.Object {
	return &GlPointParameterfv{}
}
func (*binaryClassGlPointParameterfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPointParameterfv(d, obj.(*GlPointParameterfv))
}
func (c *binaryClassGlPointParameterfv) Schema() *binary.Entity {
	return &entities[ixǁGlPointParameterfv]
}

type binaryClassGlPointParameterx struct{}

func (*GlPointParameterx) Class() binary.Class {
	return (*binaryClassGlPointParameterx)(nil)
}
func doEncodeGlPointParameterx(e binary.Encoder, o *GlPointParameterx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlPointParameterx(d binary.Decoder, o *GlPointParameterx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlPointParameterx(d binary.Decoder, o *GlPointParameterx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlPointParameterx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPointParameterx(e, obj.(*GlPointParameterx))
}
func (*binaryClassGlPointParameterx) New() binary.Object {
	return &GlPointParameterx{}
}
func (*binaryClassGlPointParameterx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPointParameterx(d, obj.(*GlPointParameterx))
}
func (c *binaryClassGlPointParameterx) Schema() *binary.Entity {
	return &entities[ixǁGlPointParameterx]
}

type binaryClassGlPointParameterxOES struct{}

func (*GlPointParameterxOES) Class() binary.Class {
	return (*binaryClassGlPointParameterxOES)(nil)
}
func doEncodeGlPointParameterxOES(e binary.Encoder, o *GlPointParameterxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlPointParameterxOES(d binary.Decoder, o *GlPointParameterxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlPointParameterxOES(d binary.Decoder, o *GlPointParameterxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlPointParameterxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPointParameterxOES(e, obj.(*GlPointParameterxOES))
}
func (*binaryClassGlPointParameterxOES) New() binary.Object {
	return &GlPointParameterxOES{}
}
func (*binaryClassGlPointParameterxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPointParameterxOES(d, obj.(*GlPointParameterxOES))
}
func (c *binaryClassGlPointParameterxOES) Schema() *binary.Entity {
	return &entities[ixǁGlPointParameterxOES]
}

type binaryClassGlPointParameterxv struct{}

func (*GlPointParameterxv) Class() binary.Class {
	return (*binaryClassGlPointParameterxv)(nil)
}
func doEncodeGlPointParameterxv(e binary.Encoder, o *GlPointParameterxv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlPointParameterxv(d binary.Decoder, o *GlPointParameterxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlPointParameterxv(d binary.Decoder, o *GlPointParameterxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlPointParameterxv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPointParameterxv(e, obj.(*GlPointParameterxv))
}
func (*binaryClassGlPointParameterxv) New() binary.Object {
	return &GlPointParameterxv{}
}
func (*binaryClassGlPointParameterxv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPointParameterxv(d, obj.(*GlPointParameterxv))
}
func (c *binaryClassGlPointParameterxv) Schema() *binary.Entity {
	return &entities[ixǁGlPointParameterxv]
}

type binaryClassGlPointParameterxvOES struct{}

func (*GlPointParameterxvOES) Class() binary.Class {
	return (*binaryClassGlPointParameterxvOES)(nil)
}
func doEncodeGlPointParameterxvOES(e binary.Encoder, o *GlPointParameterxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlPointParameterxvOES(d binary.Decoder, o *GlPointParameterxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlPointParameterxvOES(d binary.Decoder, o *GlPointParameterxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlPointParameterxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPointParameterxvOES(e, obj.(*GlPointParameterxvOES))
}
func (*binaryClassGlPointParameterxvOES) New() binary.Object {
	return &GlPointParameterxvOES{}
}
func (*binaryClassGlPointParameterxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPointParameterxvOES(d, obj.(*GlPointParameterxvOES))
}
func (c *binaryClassGlPointParameterxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlPointParameterxvOES]
}

type binaryClassGlPointSize struct{}

func (*GlPointSize) Class() binary.Class {
	return (*binaryClassGlPointSize)(nil)
}
func doEncodeGlPointSize(e binary.Encoder, o *GlPointSize) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Size))
}
func doDecodeGlPointSize(d binary.Decoder, o *GlPointSize) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLfloat(d.Float32())
}
func doDecodeRawGlPointSize(d binary.Decoder, o *GlPointSize) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLfloat(d.Float32())
}
func (*binaryClassGlPointSize) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPointSize(e, obj.(*GlPointSize))
}
func (*binaryClassGlPointSize) New() binary.Object {
	return &GlPointSize{}
}
func (*binaryClassGlPointSize) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPointSize(d, obj.(*GlPointSize))
}
func (c *binaryClassGlPointSize) Schema() *binary.Entity {
	return &entities[ixǁGlPointSize]
}

type binaryClassGlPointSizePointerOES struct{}

func (*GlPointSizePointerOES) Class() binary.Class {
	return (*binaryClassGlPointSizePointerOES)(nil)
}
func doEncodeGlPointSizePointerOES(e binary.Encoder, o *GlPointSizePointerOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
}
func doDecodeGlPointSizePointerOES(d binary.Decoder, o *GlPointSizePointerOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func doDecodeRawGlPointSizePointerOES(d binary.Decoder, o *GlPointSizePointerOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func (*binaryClassGlPointSizePointerOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPointSizePointerOES(e, obj.(*GlPointSizePointerOES))
}
func (*binaryClassGlPointSizePointerOES) New() binary.Object {
	return &GlPointSizePointerOES{}
}
func (*binaryClassGlPointSizePointerOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPointSizePointerOES(d, obj.(*GlPointSizePointerOES))
}
func (c *binaryClassGlPointSizePointerOES) Schema() *binary.Entity {
	return &entities[ixǁGlPointSizePointerOES]
}

type binaryClassGlPointSizePointerOESBounds struct{}

func (*GlPointSizePointerOESBounds) Class() binary.Class {
	return (*binaryClassGlPointSizePointerOESBounds)(nil)
}
func doEncodeGlPointSizePointerOESBounds(e binary.Encoder, o *GlPointSizePointerOESBounds) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
	e.Int32(int32(o.Count))
}
func doDecodeGlPointSizePointerOESBounds(d binary.Decoder, o *GlPointSizePointerOESBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func doDecodeRawGlPointSizePointerOESBounds(d binary.Decoder, o *GlPointSizePointerOESBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func (*binaryClassGlPointSizePointerOESBounds) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPointSizePointerOESBounds(e, obj.(*GlPointSizePointerOESBounds))
}
func (*binaryClassGlPointSizePointerOESBounds) New() binary.Object {
	return &GlPointSizePointerOESBounds{}
}
func (*binaryClassGlPointSizePointerOESBounds) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPointSizePointerOESBounds(d, obj.(*GlPointSizePointerOESBounds))
}
func (c *binaryClassGlPointSizePointerOESBounds) Schema() *binary.Entity {
	return &entities[ixǁGlPointSizePointerOESBounds]
}

type binaryClassGlPointSizex struct{}

func (*GlPointSizex) Class() binary.Class {
	return (*binaryClassGlPointSizex)(nil)
}
func doEncodeGlPointSizex(e binary.Encoder, o *GlPointSizex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Size))
}
func doDecodeGlPointSizex(d binary.Decoder, o *GlPointSizex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLfixed(d.Int32())
}
func doDecodeRawGlPointSizex(d binary.Decoder, o *GlPointSizex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLfixed(d.Int32())
}
func (*binaryClassGlPointSizex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPointSizex(e, obj.(*GlPointSizex))
}
func (*binaryClassGlPointSizex) New() binary.Object {
	return &GlPointSizex{}
}
func (*binaryClassGlPointSizex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPointSizex(d, obj.(*GlPointSizex))
}
func (c *binaryClassGlPointSizex) Schema() *binary.Entity {
	return &entities[ixǁGlPointSizex]
}

type binaryClassGlPointSizexOES struct{}

func (*GlPointSizexOES) Class() binary.Class {
	return (*binaryClassGlPointSizexOES)(nil)
}
func doEncodeGlPointSizexOES(e binary.Encoder, o *GlPointSizexOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Size))
}
func doDecodeGlPointSizexOES(d binary.Decoder, o *GlPointSizexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLfixed(d.Int32())
}
func doDecodeRawGlPointSizexOES(d binary.Decoder, o *GlPointSizexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLfixed(d.Int32())
}
func (*binaryClassGlPointSizexOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPointSizexOES(e, obj.(*GlPointSizexOES))
}
func (*binaryClassGlPointSizexOES) New() binary.Object {
	return &GlPointSizexOES{}
}
func (*binaryClassGlPointSizexOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPointSizexOES(d, obj.(*GlPointSizexOES))
}
func (c *binaryClassGlPointSizexOES) Schema() *binary.Entity {
	return &entities[ixǁGlPointSizexOES]
}

type binaryClassGlPolygonModeNV struct{}

func (*GlPolygonModeNV) Class() binary.Class {
	return (*binaryClassGlPolygonModeNV)(nil)
}
func doEncodeGlPolygonModeNV(e binary.Encoder, o *GlPolygonModeNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.Mode))
}
func doDecodeGlPolygonModeNV(d binary.Decoder, o *GlPolygonModeNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Mode = GLenum(d.Uint32())
}
func doDecodeRawGlPolygonModeNV(d binary.Decoder, o *GlPolygonModeNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Mode = GLenum(d.Uint32())
}
func (*binaryClassGlPolygonModeNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPolygonModeNV(e, obj.(*GlPolygonModeNV))
}
func (*binaryClassGlPolygonModeNV) New() binary.Object {
	return &GlPolygonModeNV{}
}
func (*binaryClassGlPolygonModeNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPolygonModeNV(d, obj.(*GlPolygonModeNV))
}
func (c *binaryClassGlPolygonModeNV) Schema() *binary.Entity {
	return &entities[ixǁGlPolygonModeNV]
}

type binaryClassGlPolygonOffset struct{}

func (*GlPolygonOffset) Class() binary.Class {
	return (*binaryClassGlPolygonOffset)(nil)
}
func doEncodeGlPolygonOffset(e binary.Encoder, o *GlPolygonOffset) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.ScaleFactor))
	e.Float32(float32(o.Units))
}
func doDecodeGlPolygonOffset(d binary.Decoder, o *GlPolygonOffset) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ScaleFactor = GLfloat(d.Float32())
	o.Units = GLfloat(d.Float32())
}
func doDecodeRawGlPolygonOffset(d binary.Decoder, o *GlPolygonOffset) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ScaleFactor = GLfloat(d.Float32())
	o.Units = GLfloat(d.Float32())
}
func (*binaryClassGlPolygonOffset) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPolygonOffset(e, obj.(*GlPolygonOffset))
}
func (*binaryClassGlPolygonOffset) New() binary.Object {
	return &GlPolygonOffset{}
}
func (*binaryClassGlPolygonOffset) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPolygonOffset(d, obj.(*GlPolygonOffset))
}
func (c *binaryClassGlPolygonOffset) Schema() *binary.Entity {
	return &entities[ixǁGlPolygonOffset]
}

type binaryClassGlPolygonOffsetx struct{}

func (*GlPolygonOffsetx) Class() binary.Class {
	return (*binaryClassGlPolygonOffsetx)(nil)
}
func doEncodeGlPolygonOffsetx(e binary.Encoder, o *GlPolygonOffsetx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Factor))
	e.Int32(int32(o.Units))
}
func doDecodeGlPolygonOffsetx(d binary.Decoder, o *GlPolygonOffsetx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Factor = GLfixed(d.Int32())
	o.Units = GLfixed(d.Int32())
}
func doDecodeRawGlPolygonOffsetx(d binary.Decoder, o *GlPolygonOffsetx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Factor = GLfixed(d.Int32())
	o.Units = GLfixed(d.Int32())
}
func (*binaryClassGlPolygonOffsetx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPolygonOffsetx(e, obj.(*GlPolygonOffsetx))
}
func (*binaryClassGlPolygonOffsetx) New() binary.Object {
	return &GlPolygonOffsetx{}
}
func (*binaryClassGlPolygonOffsetx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPolygonOffsetx(d, obj.(*GlPolygonOffsetx))
}
func (c *binaryClassGlPolygonOffsetx) Schema() *binary.Entity {
	return &entities[ixǁGlPolygonOffsetx]
}

type binaryClassGlPolygonOffsetxOES struct{}

func (*GlPolygonOffsetxOES) Class() binary.Class {
	return (*binaryClassGlPolygonOffsetxOES)(nil)
}
func doEncodeGlPolygonOffsetxOES(e binary.Encoder, o *GlPolygonOffsetxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Factor))
	e.Int32(int32(o.Units))
}
func doDecodeGlPolygonOffsetxOES(d binary.Decoder, o *GlPolygonOffsetxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Factor = GLfixed(d.Int32())
	o.Units = GLfixed(d.Int32())
}
func doDecodeRawGlPolygonOffsetxOES(d binary.Decoder, o *GlPolygonOffsetxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Factor = GLfixed(d.Int32())
	o.Units = GLfixed(d.Int32())
}
func (*binaryClassGlPolygonOffsetxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPolygonOffsetxOES(e, obj.(*GlPolygonOffsetxOES))
}
func (*binaryClassGlPolygonOffsetxOES) New() binary.Object {
	return &GlPolygonOffsetxOES{}
}
func (*binaryClassGlPolygonOffsetxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPolygonOffsetxOES(d, obj.(*GlPolygonOffsetxOES))
}
func (c *binaryClassGlPolygonOffsetxOES) Schema() *binary.Entity {
	return &entities[ixǁGlPolygonOffsetxOES]
}

type binaryClassGlPopDebugGroup struct{}

func (*GlPopDebugGroup) Class() binary.Class {
	return (*binaryClassGlPopDebugGroup)(nil)
}
func doEncodeGlPopDebugGroup(e binary.Encoder, o *GlPopDebugGroup) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlPopDebugGroup(d binary.Decoder, o *GlPopDebugGroup) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlPopDebugGroup(d binary.Decoder, o *GlPopDebugGroup) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlPopDebugGroup) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPopDebugGroup(e, obj.(*GlPopDebugGroup))
}
func (*binaryClassGlPopDebugGroup) New() binary.Object {
	return &GlPopDebugGroup{}
}
func (*binaryClassGlPopDebugGroup) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPopDebugGroup(d, obj.(*GlPopDebugGroup))
}
func (c *binaryClassGlPopDebugGroup) Schema() *binary.Entity {
	return &entities[ixǁGlPopDebugGroup]
}

type binaryClassGlPopDebugGroupKHR struct{}

func (*GlPopDebugGroupKHR) Class() binary.Class {
	return (*binaryClassGlPopDebugGroupKHR)(nil)
}
func doEncodeGlPopDebugGroupKHR(e binary.Encoder, o *GlPopDebugGroupKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlPopDebugGroupKHR(d binary.Decoder, o *GlPopDebugGroupKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlPopDebugGroupKHR(d binary.Decoder, o *GlPopDebugGroupKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlPopDebugGroupKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPopDebugGroupKHR(e, obj.(*GlPopDebugGroupKHR))
}
func (*binaryClassGlPopDebugGroupKHR) New() binary.Object {
	return &GlPopDebugGroupKHR{}
}
func (*binaryClassGlPopDebugGroupKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPopDebugGroupKHR(d, obj.(*GlPopDebugGroupKHR))
}
func (c *binaryClassGlPopDebugGroupKHR) Schema() *binary.Entity {
	return &entities[ixǁGlPopDebugGroupKHR]
}

type binaryClassGlPopGroupMarkerEXT struct{}

func (*GlPopGroupMarkerEXT) Class() binary.Class {
	return (*binaryClassGlPopGroupMarkerEXT)(nil)
}
func doEncodeGlPopGroupMarkerEXT(e binary.Encoder, o *GlPopGroupMarkerEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlPopGroupMarkerEXT(d binary.Decoder, o *GlPopGroupMarkerEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlPopGroupMarkerEXT(d binary.Decoder, o *GlPopGroupMarkerEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlPopGroupMarkerEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPopGroupMarkerEXT(e, obj.(*GlPopGroupMarkerEXT))
}
func (*binaryClassGlPopGroupMarkerEXT) New() binary.Object {
	return &GlPopGroupMarkerEXT{}
}
func (*binaryClassGlPopGroupMarkerEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPopGroupMarkerEXT(d, obj.(*GlPopGroupMarkerEXT))
}
func (c *binaryClassGlPopGroupMarkerEXT) Schema() *binary.Entity {
	return &entities[ixǁGlPopGroupMarkerEXT]
}

type binaryClassGlPopMatrix struct{}

func (*GlPopMatrix) Class() binary.Class {
	return (*binaryClassGlPopMatrix)(nil)
}
func doEncodeGlPopMatrix(e binary.Encoder, o *GlPopMatrix) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlPopMatrix(d binary.Decoder, o *GlPopMatrix) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlPopMatrix(d binary.Decoder, o *GlPopMatrix) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlPopMatrix) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPopMatrix(e, obj.(*GlPopMatrix))
}
func (*binaryClassGlPopMatrix) New() binary.Object {
	return &GlPopMatrix{}
}
func (*binaryClassGlPopMatrix) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPopMatrix(d, obj.(*GlPopMatrix))
}
func (c *binaryClassGlPopMatrix) Schema() *binary.Entity {
	return &entities[ixǁGlPopMatrix]
}

type binaryClassGlPrimitiveBoundingBox struct{}

func (*GlPrimitiveBoundingBox) Class() binary.Class {
	return (*binaryClassGlPrimitiveBoundingBox)(nil)
}
func doEncodeGlPrimitiveBoundingBox(e binary.Encoder, o *GlPrimitiveBoundingBox) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.MinX))
	e.Float32(float32(o.MinY))
	e.Float32(float32(o.MinZ))
	e.Float32(float32(o.MinW))
	e.Float32(float32(o.MaxX))
	e.Float32(float32(o.MaxY))
	e.Float32(float32(o.MaxZ))
	e.Float32(float32(o.MaxW))
}
func doDecodeGlPrimitiveBoundingBox(d binary.Decoder, o *GlPrimitiveBoundingBox) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MinX = GLfloat(d.Float32())
	o.MinY = GLfloat(d.Float32())
	o.MinZ = GLfloat(d.Float32())
	o.MinW = GLfloat(d.Float32())
	o.MaxX = GLfloat(d.Float32())
	o.MaxY = GLfloat(d.Float32())
	o.MaxZ = GLfloat(d.Float32())
	o.MaxW = GLfloat(d.Float32())
}
func doDecodeRawGlPrimitiveBoundingBox(d binary.Decoder, o *GlPrimitiveBoundingBox) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MinX = GLfloat(d.Float32())
	o.MinY = GLfloat(d.Float32())
	o.MinZ = GLfloat(d.Float32())
	o.MinW = GLfloat(d.Float32())
	o.MaxX = GLfloat(d.Float32())
	o.MaxY = GLfloat(d.Float32())
	o.MaxZ = GLfloat(d.Float32())
	o.MaxW = GLfloat(d.Float32())
}
func (*binaryClassGlPrimitiveBoundingBox) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPrimitiveBoundingBox(e, obj.(*GlPrimitiveBoundingBox))
}
func (*binaryClassGlPrimitiveBoundingBox) New() binary.Object {
	return &GlPrimitiveBoundingBox{}
}
func (*binaryClassGlPrimitiveBoundingBox) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPrimitiveBoundingBox(d, obj.(*GlPrimitiveBoundingBox))
}
func (c *binaryClassGlPrimitiveBoundingBox) Schema() *binary.Entity {
	return &entities[ixǁGlPrimitiveBoundingBox]
}

type binaryClassGlPrimitiveBoundingBoxEXT struct{}

func (*GlPrimitiveBoundingBoxEXT) Class() binary.Class {
	return (*binaryClassGlPrimitiveBoundingBoxEXT)(nil)
}
func doEncodeGlPrimitiveBoundingBoxEXT(e binary.Encoder, o *GlPrimitiveBoundingBoxEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.MinX))
	e.Float32(float32(o.MinY))
	e.Float32(float32(o.MinZ))
	e.Float32(float32(o.MinW))
	e.Float32(float32(o.MaxX))
	e.Float32(float32(o.MaxY))
	e.Float32(float32(o.MaxZ))
	e.Float32(float32(o.MaxW))
}
func doDecodeGlPrimitiveBoundingBoxEXT(d binary.Decoder, o *GlPrimitiveBoundingBoxEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MinX = GLfloat(d.Float32())
	o.MinY = GLfloat(d.Float32())
	o.MinZ = GLfloat(d.Float32())
	o.MinW = GLfloat(d.Float32())
	o.MaxX = GLfloat(d.Float32())
	o.MaxY = GLfloat(d.Float32())
	o.MaxZ = GLfloat(d.Float32())
	o.MaxW = GLfloat(d.Float32())
}
func doDecodeRawGlPrimitiveBoundingBoxEXT(d binary.Decoder, o *GlPrimitiveBoundingBoxEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MinX = GLfloat(d.Float32())
	o.MinY = GLfloat(d.Float32())
	o.MinZ = GLfloat(d.Float32())
	o.MinW = GLfloat(d.Float32())
	o.MaxX = GLfloat(d.Float32())
	o.MaxY = GLfloat(d.Float32())
	o.MaxZ = GLfloat(d.Float32())
	o.MaxW = GLfloat(d.Float32())
}
func (*binaryClassGlPrimitiveBoundingBoxEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPrimitiveBoundingBoxEXT(e, obj.(*GlPrimitiveBoundingBoxEXT))
}
func (*binaryClassGlPrimitiveBoundingBoxEXT) New() binary.Object {
	return &GlPrimitiveBoundingBoxEXT{}
}
func (*binaryClassGlPrimitiveBoundingBoxEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPrimitiveBoundingBoxEXT(d, obj.(*GlPrimitiveBoundingBoxEXT))
}
func (c *binaryClassGlPrimitiveBoundingBoxEXT) Schema() *binary.Entity {
	return &entities[ixǁGlPrimitiveBoundingBoxEXT]
}

type binaryClassGlPrimitiveBoundingBoxOES struct{}

func (*GlPrimitiveBoundingBoxOES) Class() binary.Class {
	return (*binaryClassGlPrimitiveBoundingBoxOES)(nil)
}
func doEncodeGlPrimitiveBoundingBoxOES(e binary.Encoder, o *GlPrimitiveBoundingBoxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.MinX))
	e.Float32(float32(o.MinY))
	e.Float32(float32(o.MinZ))
	e.Float32(float32(o.MinW))
	e.Float32(float32(o.MaxX))
	e.Float32(float32(o.MaxY))
	e.Float32(float32(o.MaxZ))
	e.Float32(float32(o.MaxW))
}
func doDecodeGlPrimitiveBoundingBoxOES(d binary.Decoder, o *GlPrimitiveBoundingBoxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MinX = GLfloat(d.Float32())
	o.MinY = GLfloat(d.Float32())
	o.MinZ = GLfloat(d.Float32())
	o.MinW = GLfloat(d.Float32())
	o.MaxX = GLfloat(d.Float32())
	o.MaxY = GLfloat(d.Float32())
	o.MaxZ = GLfloat(d.Float32())
	o.MaxW = GLfloat(d.Float32())
}
func doDecodeRawGlPrimitiveBoundingBoxOES(d binary.Decoder, o *GlPrimitiveBoundingBoxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MinX = GLfloat(d.Float32())
	o.MinY = GLfloat(d.Float32())
	o.MinZ = GLfloat(d.Float32())
	o.MinW = GLfloat(d.Float32())
	o.MaxX = GLfloat(d.Float32())
	o.MaxY = GLfloat(d.Float32())
	o.MaxZ = GLfloat(d.Float32())
	o.MaxW = GLfloat(d.Float32())
}
func (*binaryClassGlPrimitiveBoundingBoxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPrimitiveBoundingBoxOES(e, obj.(*GlPrimitiveBoundingBoxOES))
}
func (*binaryClassGlPrimitiveBoundingBoxOES) New() binary.Object {
	return &GlPrimitiveBoundingBoxOES{}
}
func (*binaryClassGlPrimitiveBoundingBoxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPrimitiveBoundingBoxOES(d, obj.(*GlPrimitiveBoundingBoxOES))
}
func (c *binaryClassGlPrimitiveBoundingBoxOES) Schema() *binary.Entity {
	return &entities[ixǁGlPrimitiveBoundingBoxOES]
}

type binaryClassGlProgramBinary struct{}

func (*GlProgramBinary) Class() binary.Class {
	return (*binaryClassGlProgramBinary)(nil)
}
func doEncodeGlProgramBinary(e binary.Encoder, o *GlProgramBinary) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.BinaryFormat))
	e.Simple(&o.Binary)
	e.Int32(int32(o.Length))
}
func doDecodeGlProgramBinary(d binary.Decoder, o *GlProgramBinary) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.BinaryFormat = GLenum(d.Uint32())
	d.Simple(&o.Binary)
	o.Length = GLsizei(d.Int32())
}
func doDecodeRawGlProgramBinary(d binary.Decoder, o *GlProgramBinary) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.BinaryFormat = GLenum(d.Uint32())
	d.Simple(&o.Binary)
	o.Length = GLsizei(d.Int32())
}
func (*binaryClassGlProgramBinary) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramBinary(e, obj.(*GlProgramBinary))
}
func (*binaryClassGlProgramBinary) New() binary.Object {
	return &GlProgramBinary{}
}
func (*binaryClassGlProgramBinary) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramBinary(d, obj.(*GlProgramBinary))
}
func (c *binaryClassGlProgramBinary) Schema() *binary.Entity {
	return &entities[ixǁGlProgramBinary]
}

type binaryClassGlProgramBinaryOES struct{}

func (*GlProgramBinaryOES) Class() binary.Class {
	return (*binaryClassGlProgramBinaryOES)(nil)
}
func doEncodeGlProgramBinaryOES(e binary.Encoder, o *GlProgramBinaryOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.BinaryFormat))
	e.Simple(&o.Binary)
	e.Int32(int32(o.BinarySize))
}
func doDecodeGlProgramBinaryOES(d binary.Decoder, o *GlProgramBinaryOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.BinaryFormat = GLenum(d.Uint32())
	d.Simple(&o.Binary)
	o.BinarySize = GLint(d.Int32())
}
func doDecodeRawGlProgramBinaryOES(d binary.Decoder, o *GlProgramBinaryOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.BinaryFormat = GLenum(d.Uint32())
	d.Simple(&o.Binary)
	o.BinarySize = GLint(d.Int32())
}
func (*binaryClassGlProgramBinaryOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramBinaryOES(e, obj.(*GlProgramBinaryOES))
}
func (*binaryClassGlProgramBinaryOES) New() binary.Object {
	return &GlProgramBinaryOES{}
}
func (*binaryClassGlProgramBinaryOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramBinaryOES(d, obj.(*GlProgramBinaryOES))
}
func (c *binaryClassGlProgramBinaryOES) Schema() *binary.Entity {
	return &entities[ixǁGlProgramBinaryOES]
}

type binaryClassGlProgramParameteri struct{}

func (*GlProgramParameteri) Class() binary.Class {
	return (*binaryClassGlProgramParameteri)(nil)
}
func doEncodeGlProgramParameteri(e binary.Encoder, o *GlProgramParameteri) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Value))
}
func doDecodeGlProgramParameteri(d binary.Decoder, o *GlProgramParameteri) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func doDecodeRawGlProgramParameteri(d binary.Decoder, o *GlProgramParameteri) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func (*binaryClassGlProgramParameteri) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramParameteri(e, obj.(*GlProgramParameteri))
}
func (*binaryClassGlProgramParameteri) New() binary.Object {
	return &GlProgramParameteri{}
}
func (*binaryClassGlProgramParameteri) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramParameteri(d, obj.(*GlProgramParameteri))
}
func (c *binaryClassGlProgramParameteri) Schema() *binary.Entity {
	return &entities[ixǁGlProgramParameteri]
}

type binaryClassGlProgramParameteriEXT struct{}

func (*GlProgramParameteriEXT) Class() binary.Class {
	return (*binaryClassGlProgramParameteriEXT)(nil)
}
func doEncodeGlProgramParameteriEXT(e binary.Encoder, o *GlProgramParameteriEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Value))
}
func doDecodeGlProgramParameteriEXT(d binary.Decoder, o *GlProgramParameteriEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func doDecodeRawGlProgramParameteriEXT(d binary.Decoder, o *GlProgramParameteriEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func (*binaryClassGlProgramParameteriEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramParameteriEXT(e, obj.(*GlProgramParameteriEXT))
}
func (*binaryClassGlProgramParameteriEXT) New() binary.Object {
	return &GlProgramParameteriEXT{}
}
func (*binaryClassGlProgramParameteriEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramParameteriEXT(d, obj.(*GlProgramParameteriEXT))
}
func (c *binaryClassGlProgramParameteriEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramParameteriEXT]
}

type binaryClassGlProgramPathFragmentInputGenNV struct{}

func (*GlProgramPathFragmentInputGenNV) Class() binary.Class {
	return (*binaryClassGlProgramPathFragmentInputGenNV)(nil)
}
func doEncodeGlProgramPathFragmentInputGenNV(e binary.Encoder, o *GlProgramPathFragmentInputGenNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.GenMode))
	e.Int32(int32(o.Components))
	e.Simple(&o.Coeffs)
}
func doDecodeGlProgramPathFragmentInputGenNV(d binary.Decoder, o *GlProgramPathFragmentInputGenNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = GLint(d.Int32())
	o.GenMode = GLenum(d.Uint32())
	o.Components = GLint(d.Int32())
	d.Simple(&o.Coeffs)
}
func doDecodeRawGlProgramPathFragmentInputGenNV(d binary.Decoder, o *GlProgramPathFragmentInputGenNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = GLint(d.Int32())
	o.GenMode = GLenum(d.Uint32())
	o.Components = GLint(d.Int32())
	d.Simple(&o.Coeffs)
}
func (*binaryClassGlProgramPathFragmentInputGenNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramPathFragmentInputGenNV(e, obj.(*GlProgramPathFragmentInputGenNV))
}
func (*binaryClassGlProgramPathFragmentInputGenNV) New() binary.Object {
	return &GlProgramPathFragmentInputGenNV{}
}
func (*binaryClassGlProgramPathFragmentInputGenNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramPathFragmentInputGenNV(d, obj.(*GlProgramPathFragmentInputGenNV))
}
func (c *binaryClassGlProgramPathFragmentInputGenNV) Schema() *binary.Entity {
	return &entities[ixǁGlProgramPathFragmentInputGenNV]
}

type binaryClassGlProgramUniform1f struct{}

func (*GlProgramUniform1f) Class() binary.Class {
	return (*binaryClassGlProgramUniform1f)(nil)
}
func doEncodeGlProgramUniform1f(e binary.Encoder, o *GlProgramUniform1f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Float32(float32(o.Value0))
}
func doDecodeGlProgramUniform1f(d binary.Decoder, o *GlProgramUniform1f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
}
func doDecodeRawGlProgramUniform1f(d binary.Decoder, o *GlProgramUniform1f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
}
func (*binaryClassGlProgramUniform1f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform1f(e, obj.(*GlProgramUniform1f))
}
func (*binaryClassGlProgramUniform1f) New() binary.Object {
	return &GlProgramUniform1f{}
}
func (*binaryClassGlProgramUniform1f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform1f(d, obj.(*GlProgramUniform1f))
}
func (c *binaryClassGlProgramUniform1f) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform1f]
}

type binaryClassGlProgramUniform1fEXT struct{}

func (*GlProgramUniform1fEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform1fEXT)(nil)
}
func doEncodeGlProgramUniform1fEXT(e binary.Encoder, o *GlProgramUniform1fEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Float32(float32(o.V0))
}
func doDecodeGlProgramUniform1fEXT(d binary.Decoder, o *GlProgramUniform1fEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLfloat(d.Float32())
}
func doDecodeRawGlProgramUniform1fEXT(d binary.Decoder, o *GlProgramUniform1fEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLfloat(d.Float32())
}
func (*binaryClassGlProgramUniform1fEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform1fEXT(e, obj.(*GlProgramUniform1fEXT))
}
func (*binaryClassGlProgramUniform1fEXT) New() binary.Object {
	return &GlProgramUniform1fEXT{}
}
func (*binaryClassGlProgramUniform1fEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform1fEXT(d, obj.(*GlProgramUniform1fEXT))
}
func (c *binaryClassGlProgramUniform1fEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform1fEXT]
}

type binaryClassGlProgramUniform1fv struct{}

func (*GlProgramUniform1fv) Class() binary.Class {
	return (*binaryClassGlProgramUniform1fv)(nil)
}
func doEncodeGlProgramUniform1fv(e binary.Encoder, o *GlProgramUniform1fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniform1fv(d binary.Decoder, o *GlProgramUniform1fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniform1fv(d binary.Decoder, o *GlProgramUniform1fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniform1fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform1fv(e, obj.(*GlProgramUniform1fv))
}
func (*binaryClassGlProgramUniform1fv) New() binary.Object {
	return &GlProgramUniform1fv{}
}
func (*binaryClassGlProgramUniform1fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform1fv(d, obj.(*GlProgramUniform1fv))
}
func (c *binaryClassGlProgramUniform1fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform1fv]
}

type binaryClassGlProgramUniform1fvEXT struct{}

func (*GlProgramUniform1fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform1fvEXT)(nil)
}
func doEncodeGlProgramUniform1fvEXT(e binary.Encoder, o *GlProgramUniform1fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniform1fvEXT(d binary.Decoder, o *GlProgramUniform1fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniform1fvEXT(d binary.Decoder, o *GlProgramUniform1fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniform1fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform1fvEXT(e, obj.(*GlProgramUniform1fvEXT))
}
func (*binaryClassGlProgramUniform1fvEXT) New() binary.Object {
	return &GlProgramUniform1fvEXT{}
}
func (*binaryClassGlProgramUniform1fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform1fvEXT(d, obj.(*GlProgramUniform1fvEXT))
}
func (c *binaryClassGlProgramUniform1fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform1fvEXT]
}

type binaryClassGlProgramUniform1i struct{}

func (*GlProgramUniform1i) Class() binary.Class {
	return (*binaryClassGlProgramUniform1i)(nil)
}
func doEncodeGlProgramUniform1i(e binary.Encoder, o *GlProgramUniform1i) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Value0))
}
func doDecodeGlProgramUniform1i(d binary.Decoder, o *GlProgramUniform1i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
}
func doDecodeRawGlProgramUniform1i(d binary.Decoder, o *GlProgramUniform1i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
}
func (*binaryClassGlProgramUniform1i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform1i(e, obj.(*GlProgramUniform1i))
}
func (*binaryClassGlProgramUniform1i) New() binary.Object {
	return &GlProgramUniform1i{}
}
func (*binaryClassGlProgramUniform1i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform1i(d, obj.(*GlProgramUniform1i))
}
func (c *binaryClassGlProgramUniform1i) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform1i]
}

type binaryClassGlProgramUniform1iEXT struct{}

func (*GlProgramUniform1iEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform1iEXT)(nil)
}
func doEncodeGlProgramUniform1iEXT(e binary.Encoder, o *GlProgramUniform1iEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.V0))
}
func doDecodeGlProgramUniform1iEXT(d binary.Decoder, o *GlProgramUniform1iEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLint(d.Int32())
}
func doDecodeRawGlProgramUniform1iEXT(d binary.Decoder, o *GlProgramUniform1iEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLint(d.Int32())
}
func (*binaryClassGlProgramUniform1iEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform1iEXT(e, obj.(*GlProgramUniform1iEXT))
}
func (*binaryClassGlProgramUniform1iEXT) New() binary.Object {
	return &GlProgramUniform1iEXT{}
}
func (*binaryClassGlProgramUniform1iEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform1iEXT(d, obj.(*GlProgramUniform1iEXT))
}
func (c *binaryClassGlProgramUniform1iEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform1iEXT]
}

type binaryClassGlProgramUniform1iv struct{}

func (*GlProgramUniform1iv) Class() binary.Class {
	return (*binaryClassGlProgramUniform1iv)(nil)
}
func doEncodeGlProgramUniform1iv(e binary.Encoder, o *GlProgramUniform1iv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniform1iv(d binary.Decoder, o *GlProgramUniform1iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniform1iv(d binary.Decoder, o *GlProgramUniform1iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniform1iv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform1iv(e, obj.(*GlProgramUniform1iv))
}
func (*binaryClassGlProgramUniform1iv) New() binary.Object {
	return &GlProgramUniform1iv{}
}
func (*binaryClassGlProgramUniform1iv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform1iv(d, obj.(*GlProgramUniform1iv))
}
func (c *binaryClassGlProgramUniform1iv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform1iv]
}

type binaryClassGlProgramUniform1ivEXT struct{}

func (*GlProgramUniform1ivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform1ivEXT)(nil)
}
func doEncodeGlProgramUniform1ivEXT(e binary.Encoder, o *GlProgramUniform1ivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniform1ivEXT(d binary.Decoder, o *GlProgramUniform1ivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniform1ivEXT(d binary.Decoder, o *GlProgramUniform1ivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniform1ivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform1ivEXT(e, obj.(*GlProgramUniform1ivEXT))
}
func (*binaryClassGlProgramUniform1ivEXT) New() binary.Object {
	return &GlProgramUniform1ivEXT{}
}
func (*binaryClassGlProgramUniform1ivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform1ivEXT(d, obj.(*GlProgramUniform1ivEXT))
}
func (c *binaryClassGlProgramUniform1ivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform1ivEXT]
}

type binaryClassGlProgramUniform1ui struct{}

func (*GlProgramUniform1ui) Class() binary.Class {
	return (*binaryClassGlProgramUniform1ui)(nil)
}
func doEncodeGlProgramUniform1ui(e binary.Encoder, o *GlProgramUniform1ui) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.Value0))
}
func doDecodeGlProgramUniform1ui(d binary.Decoder, o *GlProgramUniform1ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
}
func doDecodeRawGlProgramUniform1ui(d binary.Decoder, o *GlProgramUniform1ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
}
func (*binaryClassGlProgramUniform1ui) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform1ui(e, obj.(*GlProgramUniform1ui))
}
func (*binaryClassGlProgramUniform1ui) New() binary.Object {
	return &GlProgramUniform1ui{}
}
func (*binaryClassGlProgramUniform1ui) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform1ui(d, obj.(*GlProgramUniform1ui))
}
func (c *binaryClassGlProgramUniform1ui) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform1ui]
}

type binaryClassGlProgramUniform1uiEXT struct{}

func (*GlProgramUniform1uiEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform1uiEXT)(nil)
}
func doEncodeGlProgramUniform1uiEXT(e binary.Encoder, o *GlProgramUniform1uiEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.V0))
}
func doDecodeGlProgramUniform1uiEXT(d binary.Decoder, o *GlProgramUniform1uiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLuint(d.Uint32())
}
func doDecodeRawGlProgramUniform1uiEXT(d binary.Decoder, o *GlProgramUniform1uiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLuint(d.Uint32())
}
func (*binaryClassGlProgramUniform1uiEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform1uiEXT(e, obj.(*GlProgramUniform1uiEXT))
}
func (*binaryClassGlProgramUniform1uiEXT) New() binary.Object {
	return &GlProgramUniform1uiEXT{}
}
func (*binaryClassGlProgramUniform1uiEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform1uiEXT(d, obj.(*GlProgramUniform1uiEXT))
}
func (c *binaryClassGlProgramUniform1uiEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform1uiEXT]
}

type binaryClassGlProgramUniform1uiv struct{}

func (*GlProgramUniform1uiv) Class() binary.Class {
	return (*binaryClassGlProgramUniform1uiv)(nil)
}
func doEncodeGlProgramUniform1uiv(e binary.Encoder, o *GlProgramUniform1uiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniform1uiv(d binary.Decoder, o *GlProgramUniform1uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniform1uiv(d binary.Decoder, o *GlProgramUniform1uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniform1uiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform1uiv(e, obj.(*GlProgramUniform1uiv))
}
func (*binaryClassGlProgramUniform1uiv) New() binary.Object {
	return &GlProgramUniform1uiv{}
}
func (*binaryClassGlProgramUniform1uiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform1uiv(d, obj.(*GlProgramUniform1uiv))
}
func (c *binaryClassGlProgramUniform1uiv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform1uiv]
}

type binaryClassGlProgramUniform1uivEXT struct{}

func (*GlProgramUniform1uivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform1uivEXT)(nil)
}
func doEncodeGlProgramUniform1uivEXT(e binary.Encoder, o *GlProgramUniform1uivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniform1uivEXT(d binary.Decoder, o *GlProgramUniform1uivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniform1uivEXT(d binary.Decoder, o *GlProgramUniform1uivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniform1uivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform1uivEXT(e, obj.(*GlProgramUniform1uivEXT))
}
func (*binaryClassGlProgramUniform1uivEXT) New() binary.Object {
	return &GlProgramUniform1uivEXT{}
}
func (*binaryClassGlProgramUniform1uivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform1uivEXT(d, obj.(*GlProgramUniform1uivEXT))
}
func (c *binaryClassGlProgramUniform1uivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform1uivEXT]
}

type binaryClassGlProgramUniform2f struct{}

func (*GlProgramUniform2f) Class() binary.Class {
	return (*binaryClassGlProgramUniform2f)(nil)
}
func doEncodeGlProgramUniform2f(e binary.Encoder, o *GlProgramUniform2f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Float32(float32(o.Value0))
	e.Float32(float32(o.Value1))
}
func doDecodeGlProgramUniform2f(d binary.Decoder, o *GlProgramUniform2f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
}
func doDecodeRawGlProgramUniform2f(d binary.Decoder, o *GlProgramUniform2f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
}
func (*binaryClassGlProgramUniform2f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform2f(e, obj.(*GlProgramUniform2f))
}
func (*binaryClassGlProgramUniform2f) New() binary.Object {
	return &GlProgramUniform2f{}
}
func (*binaryClassGlProgramUniform2f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform2f(d, obj.(*GlProgramUniform2f))
}
func (c *binaryClassGlProgramUniform2f) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform2f]
}

type binaryClassGlProgramUniform2fEXT struct{}

func (*GlProgramUniform2fEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform2fEXT)(nil)
}
func doEncodeGlProgramUniform2fEXT(e binary.Encoder, o *GlProgramUniform2fEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Float32(float32(o.V0))
	e.Float32(float32(o.V1))
}
func doDecodeGlProgramUniform2fEXT(d binary.Decoder, o *GlProgramUniform2fEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLfloat(d.Float32())
	o.V1 = GLfloat(d.Float32())
}
func doDecodeRawGlProgramUniform2fEXT(d binary.Decoder, o *GlProgramUniform2fEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLfloat(d.Float32())
	o.V1 = GLfloat(d.Float32())
}
func (*binaryClassGlProgramUniform2fEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform2fEXT(e, obj.(*GlProgramUniform2fEXT))
}
func (*binaryClassGlProgramUniform2fEXT) New() binary.Object {
	return &GlProgramUniform2fEXT{}
}
func (*binaryClassGlProgramUniform2fEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform2fEXT(d, obj.(*GlProgramUniform2fEXT))
}
func (c *binaryClassGlProgramUniform2fEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform2fEXT]
}

type binaryClassGlProgramUniform2fv struct{}

func (*GlProgramUniform2fv) Class() binary.Class {
	return (*binaryClassGlProgramUniform2fv)(nil)
}
func doEncodeGlProgramUniform2fv(e binary.Encoder, o *GlProgramUniform2fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniform2fv(d binary.Decoder, o *GlProgramUniform2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniform2fv(d binary.Decoder, o *GlProgramUniform2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniform2fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform2fv(e, obj.(*GlProgramUniform2fv))
}
func (*binaryClassGlProgramUniform2fv) New() binary.Object {
	return &GlProgramUniform2fv{}
}
func (*binaryClassGlProgramUniform2fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform2fv(d, obj.(*GlProgramUniform2fv))
}
func (c *binaryClassGlProgramUniform2fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform2fv]
}

type binaryClassGlProgramUniform2fvEXT struct{}

func (*GlProgramUniform2fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform2fvEXT)(nil)
}
func doEncodeGlProgramUniform2fvEXT(e binary.Encoder, o *GlProgramUniform2fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniform2fvEXT(d binary.Decoder, o *GlProgramUniform2fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniform2fvEXT(d binary.Decoder, o *GlProgramUniform2fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniform2fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform2fvEXT(e, obj.(*GlProgramUniform2fvEXT))
}
func (*binaryClassGlProgramUniform2fvEXT) New() binary.Object {
	return &GlProgramUniform2fvEXT{}
}
func (*binaryClassGlProgramUniform2fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform2fvEXT(d, obj.(*GlProgramUniform2fvEXT))
}
func (c *binaryClassGlProgramUniform2fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform2fvEXT]
}

type binaryClassGlProgramUniform2i struct{}

func (*GlProgramUniform2i) Class() binary.Class {
	return (*binaryClassGlProgramUniform2i)(nil)
}
func doEncodeGlProgramUniform2i(e binary.Encoder, o *GlProgramUniform2i) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Value0))
	e.Int32(int32(o.Value1))
}
func doDecodeGlProgramUniform2i(d binary.Decoder, o *GlProgramUniform2i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
	o.Value1 = GLint(d.Int32())
}
func doDecodeRawGlProgramUniform2i(d binary.Decoder, o *GlProgramUniform2i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
	o.Value1 = GLint(d.Int32())
}
func (*binaryClassGlProgramUniform2i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform2i(e, obj.(*GlProgramUniform2i))
}
func (*binaryClassGlProgramUniform2i) New() binary.Object {
	return &GlProgramUniform2i{}
}
func (*binaryClassGlProgramUniform2i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform2i(d, obj.(*GlProgramUniform2i))
}
func (c *binaryClassGlProgramUniform2i) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform2i]
}

type binaryClassGlProgramUniform2iEXT struct{}

func (*GlProgramUniform2iEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform2iEXT)(nil)
}
func doEncodeGlProgramUniform2iEXT(e binary.Encoder, o *GlProgramUniform2iEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.V0))
	e.Int32(int32(o.V1))
}
func doDecodeGlProgramUniform2iEXT(d binary.Decoder, o *GlProgramUniform2iEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLint(d.Int32())
	o.V1 = GLint(d.Int32())
}
func doDecodeRawGlProgramUniform2iEXT(d binary.Decoder, o *GlProgramUniform2iEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLint(d.Int32())
	o.V1 = GLint(d.Int32())
}
func (*binaryClassGlProgramUniform2iEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform2iEXT(e, obj.(*GlProgramUniform2iEXT))
}
func (*binaryClassGlProgramUniform2iEXT) New() binary.Object {
	return &GlProgramUniform2iEXT{}
}
func (*binaryClassGlProgramUniform2iEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform2iEXT(d, obj.(*GlProgramUniform2iEXT))
}
func (c *binaryClassGlProgramUniform2iEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform2iEXT]
}

type binaryClassGlProgramUniform2iv struct{}

func (*GlProgramUniform2iv) Class() binary.Class {
	return (*binaryClassGlProgramUniform2iv)(nil)
}
func doEncodeGlProgramUniform2iv(e binary.Encoder, o *GlProgramUniform2iv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniform2iv(d binary.Decoder, o *GlProgramUniform2iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniform2iv(d binary.Decoder, o *GlProgramUniform2iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniform2iv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform2iv(e, obj.(*GlProgramUniform2iv))
}
func (*binaryClassGlProgramUniform2iv) New() binary.Object {
	return &GlProgramUniform2iv{}
}
func (*binaryClassGlProgramUniform2iv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform2iv(d, obj.(*GlProgramUniform2iv))
}
func (c *binaryClassGlProgramUniform2iv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform2iv]
}

type binaryClassGlProgramUniform2ivEXT struct{}

func (*GlProgramUniform2ivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform2ivEXT)(nil)
}
func doEncodeGlProgramUniform2ivEXT(e binary.Encoder, o *GlProgramUniform2ivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniform2ivEXT(d binary.Decoder, o *GlProgramUniform2ivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniform2ivEXT(d binary.Decoder, o *GlProgramUniform2ivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniform2ivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform2ivEXT(e, obj.(*GlProgramUniform2ivEXT))
}
func (*binaryClassGlProgramUniform2ivEXT) New() binary.Object {
	return &GlProgramUniform2ivEXT{}
}
func (*binaryClassGlProgramUniform2ivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform2ivEXT(d, obj.(*GlProgramUniform2ivEXT))
}
func (c *binaryClassGlProgramUniform2ivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform2ivEXT]
}

type binaryClassGlProgramUniform2ui struct{}

func (*GlProgramUniform2ui) Class() binary.Class {
	return (*binaryClassGlProgramUniform2ui)(nil)
}
func doEncodeGlProgramUniform2ui(e binary.Encoder, o *GlProgramUniform2ui) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.Value0))
	e.Uint32(uint32(o.Value1))
}
func doDecodeGlProgramUniform2ui(d binary.Decoder, o *GlProgramUniform2ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
	o.Value1 = GLuint(d.Uint32())
}
func doDecodeRawGlProgramUniform2ui(d binary.Decoder, o *GlProgramUniform2ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
	o.Value1 = GLuint(d.Uint32())
}
func (*binaryClassGlProgramUniform2ui) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform2ui(e, obj.(*GlProgramUniform2ui))
}
func (*binaryClassGlProgramUniform2ui) New() binary.Object {
	return &GlProgramUniform2ui{}
}
func (*binaryClassGlProgramUniform2ui) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform2ui(d, obj.(*GlProgramUniform2ui))
}
func (c *binaryClassGlProgramUniform2ui) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform2ui]
}

type binaryClassGlProgramUniform2uiEXT struct{}

func (*GlProgramUniform2uiEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform2uiEXT)(nil)
}
func doEncodeGlProgramUniform2uiEXT(e binary.Encoder, o *GlProgramUniform2uiEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.V0))
	e.Uint32(uint32(o.V1))
}
func doDecodeGlProgramUniform2uiEXT(d binary.Decoder, o *GlProgramUniform2uiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLuint(d.Uint32())
	o.V1 = GLuint(d.Uint32())
}
func doDecodeRawGlProgramUniform2uiEXT(d binary.Decoder, o *GlProgramUniform2uiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLuint(d.Uint32())
	o.V1 = GLuint(d.Uint32())
}
func (*binaryClassGlProgramUniform2uiEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform2uiEXT(e, obj.(*GlProgramUniform2uiEXT))
}
func (*binaryClassGlProgramUniform2uiEXT) New() binary.Object {
	return &GlProgramUniform2uiEXT{}
}
func (*binaryClassGlProgramUniform2uiEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform2uiEXT(d, obj.(*GlProgramUniform2uiEXT))
}
func (c *binaryClassGlProgramUniform2uiEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform2uiEXT]
}

type binaryClassGlProgramUniform2uiv struct{}

func (*GlProgramUniform2uiv) Class() binary.Class {
	return (*binaryClassGlProgramUniform2uiv)(nil)
}
func doEncodeGlProgramUniform2uiv(e binary.Encoder, o *GlProgramUniform2uiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniform2uiv(d binary.Decoder, o *GlProgramUniform2uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniform2uiv(d binary.Decoder, o *GlProgramUniform2uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniform2uiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform2uiv(e, obj.(*GlProgramUniform2uiv))
}
func (*binaryClassGlProgramUniform2uiv) New() binary.Object {
	return &GlProgramUniform2uiv{}
}
func (*binaryClassGlProgramUniform2uiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform2uiv(d, obj.(*GlProgramUniform2uiv))
}
func (c *binaryClassGlProgramUniform2uiv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform2uiv]
}

type binaryClassGlProgramUniform2uivEXT struct{}

func (*GlProgramUniform2uivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform2uivEXT)(nil)
}
func doEncodeGlProgramUniform2uivEXT(e binary.Encoder, o *GlProgramUniform2uivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniform2uivEXT(d binary.Decoder, o *GlProgramUniform2uivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniform2uivEXT(d binary.Decoder, o *GlProgramUniform2uivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniform2uivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform2uivEXT(e, obj.(*GlProgramUniform2uivEXT))
}
func (*binaryClassGlProgramUniform2uivEXT) New() binary.Object {
	return &GlProgramUniform2uivEXT{}
}
func (*binaryClassGlProgramUniform2uivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform2uivEXT(d, obj.(*GlProgramUniform2uivEXT))
}
func (c *binaryClassGlProgramUniform2uivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform2uivEXT]
}

type binaryClassGlProgramUniform3f struct{}

func (*GlProgramUniform3f) Class() binary.Class {
	return (*binaryClassGlProgramUniform3f)(nil)
}
func doEncodeGlProgramUniform3f(e binary.Encoder, o *GlProgramUniform3f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Float32(float32(o.Value0))
	e.Float32(float32(o.Value1))
	e.Float32(float32(o.Value2))
}
func doDecodeGlProgramUniform3f(d binary.Decoder, o *GlProgramUniform3f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
	o.Value2 = GLfloat(d.Float32())
}
func doDecodeRawGlProgramUniform3f(d binary.Decoder, o *GlProgramUniform3f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
	o.Value2 = GLfloat(d.Float32())
}
func (*binaryClassGlProgramUniform3f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform3f(e, obj.(*GlProgramUniform3f))
}
func (*binaryClassGlProgramUniform3f) New() binary.Object {
	return &GlProgramUniform3f{}
}
func (*binaryClassGlProgramUniform3f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform3f(d, obj.(*GlProgramUniform3f))
}
func (c *binaryClassGlProgramUniform3f) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform3f]
}

type binaryClassGlProgramUniform3fEXT struct{}

func (*GlProgramUniform3fEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform3fEXT)(nil)
}
func doEncodeGlProgramUniform3fEXT(e binary.Encoder, o *GlProgramUniform3fEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Float32(float32(o.V0))
	e.Float32(float32(o.V1))
	e.Float32(float32(o.V2))
}
func doDecodeGlProgramUniform3fEXT(d binary.Decoder, o *GlProgramUniform3fEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLfloat(d.Float32())
	o.V1 = GLfloat(d.Float32())
	o.V2 = GLfloat(d.Float32())
}
func doDecodeRawGlProgramUniform3fEXT(d binary.Decoder, o *GlProgramUniform3fEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLfloat(d.Float32())
	o.V1 = GLfloat(d.Float32())
	o.V2 = GLfloat(d.Float32())
}
func (*binaryClassGlProgramUniform3fEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform3fEXT(e, obj.(*GlProgramUniform3fEXT))
}
func (*binaryClassGlProgramUniform3fEXT) New() binary.Object {
	return &GlProgramUniform3fEXT{}
}
func (*binaryClassGlProgramUniform3fEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform3fEXT(d, obj.(*GlProgramUniform3fEXT))
}
func (c *binaryClassGlProgramUniform3fEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform3fEXT]
}

type binaryClassGlProgramUniform3fv struct{}

func (*GlProgramUniform3fv) Class() binary.Class {
	return (*binaryClassGlProgramUniform3fv)(nil)
}
func doEncodeGlProgramUniform3fv(e binary.Encoder, o *GlProgramUniform3fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniform3fv(d binary.Decoder, o *GlProgramUniform3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniform3fv(d binary.Decoder, o *GlProgramUniform3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniform3fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform3fv(e, obj.(*GlProgramUniform3fv))
}
func (*binaryClassGlProgramUniform3fv) New() binary.Object {
	return &GlProgramUniform3fv{}
}
func (*binaryClassGlProgramUniform3fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform3fv(d, obj.(*GlProgramUniform3fv))
}
func (c *binaryClassGlProgramUniform3fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform3fv]
}

type binaryClassGlProgramUniform3fvEXT struct{}

func (*GlProgramUniform3fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform3fvEXT)(nil)
}
func doEncodeGlProgramUniform3fvEXT(e binary.Encoder, o *GlProgramUniform3fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniform3fvEXT(d binary.Decoder, o *GlProgramUniform3fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniform3fvEXT(d binary.Decoder, o *GlProgramUniform3fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniform3fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform3fvEXT(e, obj.(*GlProgramUniform3fvEXT))
}
func (*binaryClassGlProgramUniform3fvEXT) New() binary.Object {
	return &GlProgramUniform3fvEXT{}
}
func (*binaryClassGlProgramUniform3fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform3fvEXT(d, obj.(*GlProgramUniform3fvEXT))
}
func (c *binaryClassGlProgramUniform3fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform3fvEXT]
}

type binaryClassGlProgramUniform3i struct{}

func (*GlProgramUniform3i) Class() binary.Class {
	return (*binaryClassGlProgramUniform3i)(nil)
}
func doEncodeGlProgramUniform3i(e binary.Encoder, o *GlProgramUniform3i) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Value0))
	e.Int32(int32(o.Value1))
	e.Int32(int32(o.Value2))
}
func doDecodeGlProgramUniform3i(d binary.Decoder, o *GlProgramUniform3i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
	o.Value1 = GLint(d.Int32())
	o.Value2 = GLint(d.Int32())
}
func doDecodeRawGlProgramUniform3i(d binary.Decoder, o *GlProgramUniform3i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
	o.Value1 = GLint(d.Int32())
	o.Value2 = GLint(d.Int32())
}
func (*binaryClassGlProgramUniform3i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform3i(e, obj.(*GlProgramUniform3i))
}
func (*binaryClassGlProgramUniform3i) New() binary.Object {
	return &GlProgramUniform3i{}
}
func (*binaryClassGlProgramUniform3i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform3i(d, obj.(*GlProgramUniform3i))
}
func (c *binaryClassGlProgramUniform3i) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform3i]
}

type binaryClassGlProgramUniform3iEXT struct{}

func (*GlProgramUniform3iEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform3iEXT)(nil)
}
func doEncodeGlProgramUniform3iEXT(e binary.Encoder, o *GlProgramUniform3iEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.V0))
	e.Int32(int32(o.V1))
	e.Int32(int32(o.V2))
}
func doDecodeGlProgramUniform3iEXT(d binary.Decoder, o *GlProgramUniform3iEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLint(d.Int32())
	o.V1 = GLint(d.Int32())
	o.V2 = GLint(d.Int32())
}
func doDecodeRawGlProgramUniform3iEXT(d binary.Decoder, o *GlProgramUniform3iEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLint(d.Int32())
	o.V1 = GLint(d.Int32())
	o.V2 = GLint(d.Int32())
}
func (*binaryClassGlProgramUniform3iEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform3iEXT(e, obj.(*GlProgramUniform3iEXT))
}
func (*binaryClassGlProgramUniform3iEXT) New() binary.Object {
	return &GlProgramUniform3iEXT{}
}
func (*binaryClassGlProgramUniform3iEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform3iEXT(d, obj.(*GlProgramUniform3iEXT))
}
func (c *binaryClassGlProgramUniform3iEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform3iEXT]
}

type binaryClassGlProgramUniform3iv struct{}

func (*GlProgramUniform3iv) Class() binary.Class {
	return (*binaryClassGlProgramUniform3iv)(nil)
}
func doEncodeGlProgramUniform3iv(e binary.Encoder, o *GlProgramUniform3iv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniform3iv(d binary.Decoder, o *GlProgramUniform3iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniform3iv(d binary.Decoder, o *GlProgramUniform3iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniform3iv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform3iv(e, obj.(*GlProgramUniform3iv))
}
func (*binaryClassGlProgramUniform3iv) New() binary.Object {
	return &GlProgramUniform3iv{}
}
func (*binaryClassGlProgramUniform3iv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform3iv(d, obj.(*GlProgramUniform3iv))
}
func (c *binaryClassGlProgramUniform3iv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform3iv]
}

type binaryClassGlProgramUniform3ivEXT struct{}

func (*GlProgramUniform3ivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform3ivEXT)(nil)
}
func doEncodeGlProgramUniform3ivEXT(e binary.Encoder, o *GlProgramUniform3ivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniform3ivEXT(d binary.Decoder, o *GlProgramUniform3ivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniform3ivEXT(d binary.Decoder, o *GlProgramUniform3ivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniform3ivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform3ivEXT(e, obj.(*GlProgramUniform3ivEXT))
}
func (*binaryClassGlProgramUniform3ivEXT) New() binary.Object {
	return &GlProgramUniform3ivEXT{}
}
func (*binaryClassGlProgramUniform3ivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform3ivEXT(d, obj.(*GlProgramUniform3ivEXT))
}
func (c *binaryClassGlProgramUniform3ivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform3ivEXT]
}

type binaryClassGlProgramUniform3ui struct{}

func (*GlProgramUniform3ui) Class() binary.Class {
	return (*binaryClassGlProgramUniform3ui)(nil)
}
func doEncodeGlProgramUniform3ui(e binary.Encoder, o *GlProgramUniform3ui) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.Value0))
	e.Uint32(uint32(o.Value1))
	e.Uint32(uint32(o.Value2))
}
func doDecodeGlProgramUniform3ui(d binary.Decoder, o *GlProgramUniform3ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
	o.Value1 = GLuint(d.Uint32())
	o.Value2 = GLuint(d.Uint32())
}
func doDecodeRawGlProgramUniform3ui(d binary.Decoder, o *GlProgramUniform3ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
	o.Value1 = GLuint(d.Uint32())
	o.Value2 = GLuint(d.Uint32())
}
func (*binaryClassGlProgramUniform3ui) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform3ui(e, obj.(*GlProgramUniform3ui))
}
func (*binaryClassGlProgramUniform3ui) New() binary.Object {
	return &GlProgramUniform3ui{}
}
func (*binaryClassGlProgramUniform3ui) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform3ui(d, obj.(*GlProgramUniform3ui))
}
func (c *binaryClassGlProgramUniform3ui) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform3ui]
}

type binaryClassGlProgramUniform3uiEXT struct{}

func (*GlProgramUniform3uiEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform3uiEXT)(nil)
}
func doEncodeGlProgramUniform3uiEXT(e binary.Encoder, o *GlProgramUniform3uiEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.V0))
	e.Uint32(uint32(o.V1))
	e.Uint32(uint32(o.V2))
}
func doDecodeGlProgramUniform3uiEXT(d binary.Decoder, o *GlProgramUniform3uiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLuint(d.Uint32())
	o.V1 = GLuint(d.Uint32())
	o.V2 = GLuint(d.Uint32())
}
func doDecodeRawGlProgramUniform3uiEXT(d binary.Decoder, o *GlProgramUniform3uiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLuint(d.Uint32())
	o.V1 = GLuint(d.Uint32())
	o.V2 = GLuint(d.Uint32())
}
func (*binaryClassGlProgramUniform3uiEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform3uiEXT(e, obj.(*GlProgramUniform3uiEXT))
}
func (*binaryClassGlProgramUniform3uiEXT) New() binary.Object {
	return &GlProgramUniform3uiEXT{}
}
func (*binaryClassGlProgramUniform3uiEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform3uiEXT(d, obj.(*GlProgramUniform3uiEXT))
}
func (c *binaryClassGlProgramUniform3uiEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform3uiEXT]
}

type binaryClassGlProgramUniform3uiv struct{}

func (*GlProgramUniform3uiv) Class() binary.Class {
	return (*binaryClassGlProgramUniform3uiv)(nil)
}
func doEncodeGlProgramUniform3uiv(e binary.Encoder, o *GlProgramUniform3uiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniform3uiv(d binary.Decoder, o *GlProgramUniform3uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniform3uiv(d binary.Decoder, o *GlProgramUniform3uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniform3uiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform3uiv(e, obj.(*GlProgramUniform3uiv))
}
func (*binaryClassGlProgramUniform3uiv) New() binary.Object {
	return &GlProgramUniform3uiv{}
}
func (*binaryClassGlProgramUniform3uiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform3uiv(d, obj.(*GlProgramUniform3uiv))
}
func (c *binaryClassGlProgramUniform3uiv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform3uiv]
}

type binaryClassGlProgramUniform3uivEXT struct{}

func (*GlProgramUniform3uivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform3uivEXT)(nil)
}
func doEncodeGlProgramUniform3uivEXT(e binary.Encoder, o *GlProgramUniform3uivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniform3uivEXT(d binary.Decoder, o *GlProgramUniform3uivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniform3uivEXT(d binary.Decoder, o *GlProgramUniform3uivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniform3uivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform3uivEXT(e, obj.(*GlProgramUniform3uivEXT))
}
func (*binaryClassGlProgramUniform3uivEXT) New() binary.Object {
	return &GlProgramUniform3uivEXT{}
}
func (*binaryClassGlProgramUniform3uivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform3uivEXT(d, obj.(*GlProgramUniform3uivEXT))
}
func (c *binaryClassGlProgramUniform3uivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform3uivEXT]
}

type binaryClassGlProgramUniform4f struct{}

func (*GlProgramUniform4f) Class() binary.Class {
	return (*binaryClassGlProgramUniform4f)(nil)
}
func doEncodeGlProgramUniform4f(e binary.Encoder, o *GlProgramUniform4f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Float32(float32(o.Value0))
	e.Float32(float32(o.Value1))
	e.Float32(float32(o.Value2))
	e.Float32(float32(o.Value3))
}
func doDecodeGlProgramUniform4f(d binary.Decoder, o *GlProgramUniform4f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
	o.Value2 = GLfloat(d.Float32())
	o.Value3 = GLfloat(d.Float32())
}
func doDecodeRawGlProgramUniform4f(d binary.Decoder, o *GlProgramUniform4f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
	o.Value2 = GLfloat(d.Float32())
	o.Value3 = GLfloat(d.Float32())
}
func (*binaryClassGlProgramUniform4f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform4f(e, obj.(*GlProgramUniform4f))
}
func (*binaryClassGlProgramUniform4f) New() binary.Object {
	return &GlProgramUniform4f{}
}
func (*binaryClassGlProgramUniform4f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform4f(d, obj.(*GlProgramUniform4f))
}
func (c *binaryClassGlProgramUniform4f) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform4f]
}

type binaryClassGlProgramUniform4fEXT struct{}

func (*GlProgramUniform4fEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform4fEXT)(nil)
}
func doEncodeGlProgramUniform4fEXT(e binary.Encoder, o *GlProgramUniform4fEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Float32(float32(o.V0))
	e.Float32(float32(o.V1))
	e.Float32(float32(o.V2))
	e.Float32(float32(o.V3))
}
func doDecodeGlProgramUniform4fEXT(d binary.Decoder, o *GlProgramUniform4fEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLfloat(d.Float32())
	o.V1 = GLfloat(d.Float32())
	o.V2 = GLfloat(d.Float32())
	o.V3 = GLfloat(d.Float32())
}
func doDecodeRawGlProgramUniform4fEXT(d binary.Decoder, o *GlProgramUniform4fEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLfloat(d.Float32())
	o.V1 = GLfloat(d.Float32())
	o.V2 = GLfloat(d.Float32())
	o.V3 = GLfloat(d.Float32())
}
func (*binaryClassGlProgramUniform4fEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform4fEXT(e, obj.(*GlProgramUniform4fEXT))
}
func (*binaryClassGlProgramUniform4fEXT) New() binary.Object {
	return &GlProgramUniform4fEXT{}
}
func (*binaryClassGlProgramUniform4fEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform4fEXT(d, obj.(*GlProgramUniform4fEXT))
}
func (c *binaryClassGlProgramUniform4fEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform4fEXT]
}

type binaryClassGlProgramUniform4fv struct{}

func (*GlProgramUniform4fv) Class() binary.Class {
	return (*binaryClassGlProgramUniform4fv)(nil)
}
func doEncodeGlProgramUniform4fv(e binary.Encoder, o *GlProgramUniform4fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniform4fv(d binary.Decoder, o *GlProgramUniform4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniform4fv(d binary.Decoder, o *GlProgramUniform4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniform4fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform4fv(e, obj.(*GlProgramUniform4fv))
}
func (*binaryClassGlProgramUniform4fv) New() binary.Object {
	return &GlProgramUniform4fv{}
}
func (*binaryClassGlProgramUniform4fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform4fv(d, obj.(*GlProgramUniform4fv))
}
func (c *binaryClassGlProgramUniform4fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform4fv]
}

type binaryClassGlProgramUniform4fvEXT struct{}

func (*GlProgramUniform4fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform4fvEXT)(nil)
}
func doEncodeGlProgramUniform4fvEXT(e binary.Encoder, o *GlProgramUniform4fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniform4fvEXT(d binary.Decoder, o *GlProgramUniform4fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniform4fvEXT(d binary.Decoder, o *GlProgramUniform4fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniform4fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform4fvEXT(e, obj.(*GlProgramUniform4fvEXT))
}
func (*binaryClassGlProgramUniform4fvEXT) New() binary.Object {
	return &GlProgramUniform4fvEXT{}
}
func (*binaryClassGlProgramUniform4fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform4fvEXT(d, obj.(*GlProgramUniform4fvEXT))
}
func (c *binaryClassGlProgramUniform4fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform4fvEXT]
}

type binaryClassGlProgramUniform4i struct{}

func (*GlProgramUniform4i) Class() binary.Class {
	return (*binaryClassGlProgramUniform4i)(nil)
}
func doEncodeGlProgramUniform4i(e binary.Encoder, o *GlProgramUniform4i) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Value0))
	e.Int32(int32(o.Value1))
	e.Int32(int32(o.Value2))
	e.Int32(int32(o.Value3))
}
func doDecodeGlProgramUniform4i(d binary.Decoder, o *GlProgramUniform4i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
	o.Value1 = GLint(d.Int32())
	o.Value2 = GLint(d.Int32())
	o.Value3 = GLint(d.Int32())
}
func doDecodeRawGlProgramUniform4i(d binary.Decoder, o *GlProgramUniform4i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
	o.Value1 = GLint(d.Int32())
	o.Value2 = GLint(d.Int32())
	o.Value3 = GLint(d.Int32())
}
func (*binaryClassGlProgramUniform4i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform4i(e, obj.(*GlProgramUniform4i))
}
func (*binaryClassGlProgramUniform4i) New() binary.Object {
	return &GlProgramUniform4i{}
}
func (*binaryClassGlProgramUniform4i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform4i(d, obj.(*GlProgramUniform4i))
}
func (c *binaryClassGlProgramUniform4i) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform4i]
}

type binaryClassGlProgramUniform4iEXT struct{}

func (*GlProgramUniform4iEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform4iEXT)(nil)
}
func doEncodeGlProgramUniform4iEXT(e binary.Encoder, o *GlProgramUniform4iEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.V0))
	e.Int32(int32(o.V1))
	e.Int32(int32(o.V2))
	e.Int32(int32(o.V3))
}
func doDecodeGlProgramUniform4iEXT(d binary.Decoder, o *GlProgramUniform4iEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLint(d.Int32())
	o.V1 = GLint(d.Int32())
	o.V2 = GLint(d.Int32())
	o.V3 = GLint(d.Int32())
}
func doDecodeRawGlProgramUniform4iEXT(d binary.Decoder, o *GlProgramUniform4iEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLint(d.Int32())
	o.V1 = GLint(d.Int32())
	o.V2 = GLint(d.Int32())
	o.V3 = GLint(d.Int32())
}
func (*binaryClassGlProgramUniform4iEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform4iEXT(e, obj.(*GlProgramUniform4iEXT))
}
func (*binaryClassGlProgramUniform4iEXT) New() binary.Object {
	return &GlProgramUniform4iEXT{}
}
func (*binaryClassGlProgramUniform4iEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform4iEXT(d, obj.(*GlProgramUniform4iEXT))
}
func (c *binaryClassGlProgramUniform4iEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform4iEXT]
}

type binaryClassGlProgramUniform4iv struct{}

func (*GlProgramUniform4iv) Class() binary.Class {
	return (*binaryClassGlProgramUniform4iv)(nil)
}
func doEncodeGlProgramUniform4iv(e binary.Encoder, o *GlProgramUniform4iv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniform4iv(d binary.Decoder, o *GlProgramUniform4iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniform4iv(d binary.Decoder, o *GlProgramUniform4iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniform4iv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform4iv(e, obj.(*GlProgramUniform4iv))
}
func (*binaryClassGlProgramUniform4iv) New() binary.Object {
	return &GlProgramUniform4iv{}
}
func (*binaryClassGlProgramUniform4iv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform4iv(d, obj.(*GlProgramUniform4iv))
}
func (c *binaryClassGlProgramUniform4iv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform4iv]
}

type binaryClassGlProgramUniform4ivEXT struct{}

func (*GlProgramUniform4ivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform4ivEXT)(nil)
}
func doEncodeGlProgramUniform4ivEXT(e binary.Encoder, o *GlProgramUniform4ivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniform4ivEXT(d binary.Decoder, o *GlProgramUniform4ivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniform4ivEXT(d binary.Decoder, o *GlProgramUniform4ivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniform4ivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform4ivEXT(e, obj.(*GlProgramUniform4ivEXT))
}
func (*binaryClassGlProgramUniform4ivEXT) New() binary.Object {
	return &GlProgramUniform4ivEXT{}
}
func (*binaryClassGlProgramUniform4ivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform4ivEXT(d, obj.(*GlProgramUniform4ivEXT))
}
func (c *binaryClassGlProgramUniform4ivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform4ivEXT]
}

type binaryClassGlProgramUniform4ui struct{}

func (*GlProgramUniform4ui) Class() binary.Class {
	return (*binaryClassGlProgramUniform4ui)(nil)
}
func doEncodeGlProgramUniform4ui(e binary.Encoder, o *GlProgramUniform4ui) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.Value0))
	e.Uint32(uint32(o.Value1))
	e.Uint32(uint32(o.Value2))
	e.Uint32(uint32(o.Value3))
}
func doDecodeGlProgramUniform4ui(d binary.Decoder, o *GlProgramUniform4ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
	o.Value1 = GLuint(d.Uint32())
	o.Value2 = GLuint(d.Uint32())
	o.Value3 = GLuint(d.Uint32())
}
func doDecodeRawGlProgramUniform4ui(d binary.Decoder, o *GlProgramUniform4ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
	o.Value1 = GLuint(d.Uint32())
	o.Value2 = GLuint(d.Uint32())
	o.Value3 = GLuint(d.Uint32())
}
func (*binaryClassGlProgramUniform4ui) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform4ui(e, obj.(*GlProgramUniform4ui))
}
func (*binaryClassGlProgramUniform4ui) New() binary.Object {
	return &GlProgramUniform4ui{}
}
func (*binaryClassGlProgramUniform4ui) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform4ui(d, obj.(*GlProgramUniform4ui))
}
func (c *binaryClassGlProgramUniform4ui) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform4ui]
}

type binaryClassGlProgramUniform4uiEXT struct{}

func (*GlProgramUniform4uiEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform4uiEXT)(nil)
}
func doEncodeGlProgramUniform4uiEXT(e binary.Encoder, o *GlProgramUniform4uiEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.V0))
	e.Uint32(uint32(o.V1))
	e.Uint32(uint32(o.V2))
	e.Uint32(uint32(o.V3))
}
func doDecodeGlProgramUniform4uiEXT(d binary.Decoder, o *GlProgramUniform4uiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLuint(d.Uint32())
	o.V1 = GLuint(d.Uint32())
	o.V2 = GLuint(d.Uint32())
	o.V3 = GLuint(d.Uint32())
}
func doDecodeRawGlProgramUniform4uiEXT(d binary.Decoder, o *GlProgramUniform4uiEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.V0 = GLuint(d.Uint32())
	o.V1 = GLuint(d.Uint32())
	o.V2 = GLuint(d.Uint32())
	o.V3 = GLuint(d.Uint32())
}
func (*binaryClassGlProgramUniform4uiEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform4uiEXT(e, obj.(*GlProgramUniform4uiEXT))
}
func (*binaryClassGlProgramUniform4uiEXT) New() binary.Object {
	return &GlProgramUniform4uiEXT{}
}
func (*binaryClassGlProgramUniform4uiEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform4uiEXT(d, obj.(*GlProgramUniform4uiEXT))
}
func (c *binaryClassGlProgramUniform4uiEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform4uiEXT]
}

type binaryClassGlProgramUniform4uiv struct{}

func (*GlProgramUniform4uiv) Class() binary.Class {
	return (*binaryClassGlProgramUniform4uiv)(nil)
}
func doEncodeGlProgramUniform4uiv(e binary.Encoder, o *GlProgramUniform4uiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniform4uiv(d binary.Decoder, o *GlProgramUniform4uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniform4uiv(d binary.Decoder, o *GlProgramUniform4uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniform4uiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform4uiv(e, obj.(*GlProgramUniform4uiv))
}
func (*binaryClassGlProgramUniform4uiv) New() binary.Object {
	return &GlProgramUniform4uiv{}
}
func (*binaryClassGlProgramUniform4uiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform4uiv(d, obj.(*GlProgramUniform4uiv))
}
func (c *binaryClassGlProgramUniform4uiv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform4uiv]
}

type binaryClassGlProgramUniform4uivEXT struct{}

func (*GlProgramUniform4uivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform4uivEXT)(nil)
}
func doEncodeGlProgramUniform4uivEXT(e binary.Encoder, o *GlProgramUniform4uivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniform4uivEXT(d binary.Decoder, o *GlProgramUniform4uivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniform4uivEXT(d binary.Decoder, o *GlProgramUniform4uivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniform4uivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniform4uivEXT(e, obj.(*GlProgramUniform4uivEXT))
}
func (*binaryClassGlProgramUniform4uivEXT) New() binary.Object {
	return &GlProgramUniform4uivEXT{}
}
func (*binaryClassGlProgramUniform4uivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniform4uivEXT(d, obj.(*GlProgramUniform4uivEXT))
}
func (c *binaryClassGlProgramUniform4uivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniform4uivEXT]
}

type binaryClassGlProgramUniformHandleui64NV struct{}

func (*GlProgramUniformHandleui64NV) Class() binary.Class {
	return (*binaryClassGlProgramUniformHandleui64NV)(nil)
}
func doEncodeGlProgramUniformHandleui64NV(e binary.Encoder, o *GlProgramUniformHandleui64NV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Uint64(uint64(o.Value))
}
func doDecodeGlProgramUniformHandleui64NV(d binary.Decoder, o *GlProgramUniformHandleui64NV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value = GLuint64(d.Uint64())
}
func doDecodeRawGlProgramUniformHandleui64NV(d binary.Decoder, o *GlProgramUniformHandleui64NV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Value = GLuint64(d.Uint64())
}
func (*binaryClassGlProgramUniformHandleui64NV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformHandleui64NV(e, obj.(*GlProgramUniformHandleui64NV))
}
func (*binaryClassGlProgramUniformHandleui64NV) New() binary.Object {
	return &GlProgramUniformHandleui64NV{}
}
func (*binaryClassGlProgramUniformHandleui64NV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformHandleui64NV(d, obj.(*GlProgramUniformHandleui64NV))
}
func (c *binaryClassGlProgramUniformHandleui64NV) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformHandleui64NV]
}

type binaryClassGlProgramUniformHandleui64vNV struct{}

func (*GlProgramUniformHandleui64vNV) Class() binary.Class {
	return (*binaryClassGlProgramUniformHandleui64vNV)(nil)
}
func doEncodeGlProgramUniformHandleui64vNV(e binary.Encoder, o *GlProgramUniformHandleui64vNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniformHandleui64vNV(d binary.Decoder, o *GlProgramUniformHandleui64vNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniformHandleui64vNV(d binary.Decoder, o *GlProgramUniformHandleui64vNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniformHandleui64vNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformHandleui64vNV(e, obj.(*GlProgramUniformHandleui64vNV))
}
func (*binaryClassGlProgramUniformHandleui64vNV) New() binary.Object {
	return &GlProgramUniformHandleui64vNV{}
}
func (*binaryClassGlProgramUniformHandleui64vNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformHandleui64vNV(d, obj.(*GlProgramUniformHandleui64vNV))
}
func (c *binaryClassGlProgramUniformHandleui64vNV) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformHandleui64vNV]
}

type binaryClassGlProgramUniformMatrix2fv struct{}

func (*GlProgramUniformMatrix2fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix2fv)(nil)
}
func doEncodeGlProgramUniformMatrix2fv(e binary.Encoder, o *GlProgramUniformMatrix2fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniformMatrix2fv(d binary.Decoder, o *GlProgramUniformMatrix2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniformMatrix2fv(d binary.Decoder, o *GlProgramUniformMatrix2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniformMatrix2fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix2fv(e, obj.(*GlProgramUniformMatrix2fv))
}
func (*binaryClassGlProgramUniformMatrix2fv) New() binary.Object {
	return &GlProgramUniformMatrix2fv{}
}
func (*binaryClassGlProgramUniformMatrix2fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix2fv(d, obj.(*GlProgramUniformMatrix2fv))
}
func (c *binaryClassGlProgramUniformMatrix2fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix2fv]
}

type binaryClassGlProgramUniformMatrix2fvEXT struct{}

func (*GlProgramUniformMatrix2fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix2fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix2fvEXT(e binary.Encoder, o *GlProgramUniformMatrix2fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniformMatrix2fvEXT(d binary.Decoder, o *GlProgramUniformMatrix2fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniformMatrix2fvEXT(d binary.Decoder, o *GlProgramUniformMatrix2fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniformMatrix2fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix2fvEXT(e, obj.(*GlProgramUniformMatrix2fvEXT))
}
func (*binaryClassGlProgramUniformMatrix2fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix2fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix2fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix2fvEXT(d, obj.(*GlProgramUniformMatrix2fvEXT))
}
func (c *binaryClassGlProgramUniformMatrix2fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix2fvEXT]
}

type binaryClassGlProgramUniformMatrix2x3fv struct{}

func (*GlProgramUniformMatrix2x3fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix2x3fv)(nil)
}
func doEncodeGlProgramUniformMatrix2x3fv(e binary.Encoder, o *GlProgramUniformMatrix2x3fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniformMatrix2x3fv(d binary.Decoder, o *GlProgramUniformMatrix2x3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniformMatrix2x3fv(d binary.Decoder, o *GlProgramUniformMatrix2x3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniformMatrix2x3fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix2x3fv(e, obj.(*GlProgramUniformMatrix2x3fv))
}
func (*binaryClassGlProgramUniformMatrix2x3fv) New() binary.Object {
	return &GlProgramUniformMatrix2x3fv{}
}
func (*binaryClassGlProgramUniformMatrix2x3fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix2x3fv(d, obj.(*GlProgramUniformMatrix2x3fv))
}
func (c *binaryClassGlProgramUniformMatrix2x3fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix2x3fv]
}

type binaryClassGlProgramUniformMatrix2x3fvEXT struct{}

func (*GlProgramUniformMatrix2x3fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix2x3fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix2x3fvEXT(e binary.Encoder, o *GlProgramUniformMatrix2x3fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniformMatrix2x3fvEXT(d binary.Decoder, o *GlProgramUniformMatrix2x3fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniformMatrix2x3fvEXT(d binary.Decoder, o *GlProgramUniformMatrix2x3fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniformMatrix2x3fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix2x3fvEXT(e, obj.(*GlProgramUniformMatrix2x3fvEXT))
}
func (*binaryClassGlProgramUniformMatrix2x3fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix2x3fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix2x3fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix2x3fvEXT(d, obj.(*GlProgramUniformMatrix2x3fvEXT))
}
func (c *binaryClassGlProgramUniformMatrix2x3fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix2x3fvEXT]
}

type binaryClassGlProgramUniformMatrix2x4fv struct{}

func (*GlProgramUniformMatrix2x4fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix2x4fv)(nil)
}
func doEncodeGlProgramUniformMatrix2x4fv(e binary.Encoder, o *GlProgramUniformMatrix2x4fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniformMatrix2x4fv(d binary.Decoder, o *GlProgramUniformMatrix2x4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniformMatrix2x4fv(d binary.Decoder, o *GlProgramUniformMatrix2x4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniformMatrix2x4fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix2x4fv(e, obj.(*GlProgramUniformMatrix2x4fv))
}
func (*binaryClassGlProgramUniformMatrix2x4fv) New() binary.Object {
	return &GlProgramUniformMatrix2x4fv{}
}
func (*binaryClassGlProgramUniformMatrix2x4fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix2x4fv(d, obj.(*GlProgramUniformMatrix2x4fv))
}
func (c *binaryClassGlProgramUniformMatrix2x4fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix2x4fv]
}

type binaryClassGlProgramUniformMatrix2x4fvEXT struct{}

func (*GlProgramUniformMatrix2x4fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix2x4fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix2x4fvEXT(e binary.Encoder, o *GlProgramUniformMatrix2x4fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniformMatrix2x4fvEXT(d binary.Decoder, o *GlProgramUniformMatrix2x4fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniformMatrix2x4fvEXT(d binary.Decoder, o *GlProgramUniformMatrix2x4fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniformMatrix2x4fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix2x4fvEXT(e, obj.(*GlProgramUniformMatrix2x4fvEXT))
}
func (*binaryClassGlProgramUniformMatrix2x4fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix2x4fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix2x4fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix2x4fvEXT(d, obj.(*GlProgramUniformMatrix2x4fvEXT))
}
func (c *binaryClassGlProgramUniformMatrix2x4fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix2x4fvEXT]
}

type binaryClassGlProgramUniformMatrix3fv struct{}

func (*GlProgramUniformMatrix3fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix3fv)(nil)
}
func doEncodeGlProgramUniformMatrix3fv(e binary.Encoder, o *GlProgramUniformMatrix3fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniformMatrix3fv(d binary.Decoder, o *GlProgramUniformMatrix3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniformMatrix3fv(d binary.Decoder, o *GlProgramUniformMatrix3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniformMatrix3fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix3fv(e, obj.(*GlProgramUniformMatrix3fv))
}
func (*binaryClassGlProgramUniformMatrix3fv) New() binary.Object {
	return &GlProgramUniformMatrix3fv{}
}
func (*binaryClassGlProgramUniformMatrix3fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix3fv(d, obj.(*GlProgramUniformMatrix3fv))
}
func (c *binaryClassGlProgramUniformMatrix3fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix3fv]
}

type binaryClassGlProgramUniformMatrix3fvEXT struct{}

func (*GlProgramUniformMatrix3fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix3fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix3fvEXT(e binary.Encoder, o *GlProgramUniformMatrix3fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniformMatrix3fvEXT(d binary.Decoder, o *GlProgramUniformMatrix3fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniformMatrix3fvEXT(d binary.Decoder, o *GlProgramUniformMatrix3fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniformMatrix3fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix3fvEXT(e, obj.(*GlProgramUniformMatrix3fvEXT))
}
func (*binaryClassGlProgramUniformMatrix3fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix3fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix3fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix3fvEXT(d, obj.(*GlProgramUniformMatrix3fvEXT))
}
func (c *binaryClassGlProgramUniformMatrix3fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix3fvEXT]
}

type binaryClassGlProgramUniformMatrix3x2fv struct{}

func (*GlProgramUniformMatrix3x2fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix3x2fv)(nil)
}
func doEncodeGlProgramUniformMatrix3x2fv(e binary.Encoder, o *GlProgramUniformMatrix3x2fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniformMatrix3x2fv(d binary.Decoder, o *GlProgramUniformMatrix3x2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniformMatrix3x2fv(d binary.Decoder, o *GlProgramUniformMatrix3x2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniformMatrix3x2fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix3x2fv(e, obj.(*GlProgramUniformMatrix3x2fv))
}
func (*binaryClassGlProgramUniformMatrix3x2fv) New() binary.Object {
	return &GlProgramUniformMatrix3x2fv{}
}
func (*binaryClassGlProgramUniformMatrix3x2fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix3x2fv(d, obj.(*GlProgramUniformMatrix3x2fv))
}
func (c *binaryClassGlProgramUniformMatrix3x2fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix3x2fv]
}

type binaryClassGlProgramUniformMatrix3x2fvEXT struct{}

func (*GlProgramUniformMatrix3x2fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix3x2fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix3x2fvEXT(e binary.Encoder, o *GlProgramUniformMatrix3x2fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniformMatrix3x2fvEXT(d binary.Decoder, o *GlProgramUniformMatrix3x2fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniformMatrix3x2fvEXT(d binary.Decoder, o *GlProgramUniformMatrix3x2fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniformMatrix3x2fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix3x2fvEXT(e, obj.(*GlProgramUniformMatrix3x2fvEXT))
}
func (*binaryClassGlProgramUniformMatrix3x2fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix3x2fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix3x2fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix3x2fvEXT(d, obj.(*GlProgramUniformMatrix3x2fvEXT))
}
func (c *binaryClassGlProgramUniformMatrix3x2fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix3x2fvEXT]
}

type binaryClassGlProgramUniformMatrix3x4fv struct{}

func (*GlProgramUniformMatrix3x4fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix3x4fv)(nil)
}
func doEncodeGlProgramUniformMatrix3x4fv(e binary.Encoder, o *GlProgramUniformMatrix3x4fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniformMatrix3x4fv(d binary.Decoder, o *GlProgramUniformMatrix3x4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniformMatrix3x4fv(d binary.Decoder, o *GlProgramUniformMatrix3x4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniformMatrix3x4fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix3x4fv(e, obj.(*GlProgramUniformMatrix3x4fv))
}
func (*binaryClassGlProgramUniformMatrix3x4fv) New() binary.Object {
	return &GlProgramUniformMatrix3x4fv{}
}
func (*binaryClassGlProgramUniformMatrix3x4fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix3x4fv(d, obj.(*GlProgramUniformMatrix3x4fv))
}
func (c *binaryClassGlProgramUniformMatrix3x4fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix3x4fv]
}

type binaryClassGlProgramUniformMatrix3x4fvEXT struct{}

func (*GlProgramUniformMatrix3x4fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix3x4fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix3x4fvEXT(e binary.Encoder, o *GlProgramUniformMatrix3x4fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniformMatrix3x4fvEXT(d binary.Decoder, o *GlProgramUniformMatrix3x4fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniformMatrix3x4fvEXT(d binary.Decoder, o *GlProgramUniformMatrix3x4fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniformMatrix3x4fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix3x4fvEXT(e, obj.(*GlProgramUniformMatrix3x4fvEXT))
}
func (*binaryClassGlProgramUniformMatrix3x4fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix3x4fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix3x4fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix3x4fvEXT(d, obj.(*GlProgramUniformMatrix3x4fvEXT))
}
func (c *binaryClassGlProgramUniformMatrix3x4fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix3x4fvEXT]
}

type binaryClassGlProgramUniformMatrix4fv struct{}

func (*GlProgramUniformMatrix4fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix4fv)(nil)
}
func doEncodeGlProgramUniformMatrix4fv(e binary.Encoder, o *GlProgramUniformMatrix4fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniformMatrix4fv(d binary.Decoder, o *GlProgramUniformMatrix4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniformMatrix4fv(d binary.Decoder, o *GlProgramUniformMatrix4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniformMatrix4fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix4fv(e, obj.(*GlProgramUniformMatrix4fv))
}
func (*binaryClassGlProgramUniformMatrix4fv) New() binary.Object {
	return &GlProgramUniformMatrix4fv{}
}
func (*binaryClassGlProgramUniformMatrix4fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix4fv(d, obj.(*GlProgramUniformMatrix4fv))
}
func (c *binaryClassGlProgramUniformMatrix4fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix4fv]
}

type binaryClassGlProgramUniformMatrix4fvEXT struct{}

func (*GlProgramUniformMatrix4fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix4fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix4fvEXT(e binary.Encoder, o *GlProgramUniformMatrix4fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniformMatrix4fvEXT(d binary.Decoder, o *GlProgramUniformMatrix4fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniformMatrix4fvEXT(d binary.Decoder, o *GlProgramUniformMatrix4fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniformMatrix4fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix4fvEXT(e, obj.(*GlProgramUniformMatrix4fvEXT))
}
func (*binaryClassGlProgramUniformMatrix4fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix4fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix4fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix4fvEXT(d, obj.(*GlProgramUniformMatrix4fvEXT))
}
func (c *binaryClassGlProgramUniformMatrix4fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix4fvEXT]
}

type binaryClassGlProgramUniformMatrix4x2fv struct{}

func (*GlProgramUniformMatrix4x2fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix4x2fv)(nil)
}
func doEncodeGlProgramUniformMatrix4x2fv(e binary.Encoder, o *GlProgramUniformMatrix4x2fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniformMatrix4x2fv(d binary.Decoder, o *GlProgramUniformMatrix4x2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniformMatrix4x2fv(d binary.Decoder, o *GlProgramUniformMatrix4x2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniformMatrix4x2fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix4x2fv(e, obj.(*GlProgramUniformMatrix4x2fv))
}
func (*binaryClassGlProgramUniformMatrix4x2fv) New() binary.Object {
	return &GlProgramUniformMatrix4x2fv{}
}
func (*binaryClassGlProgramUniformMatrix4x2fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix4x2fv(d, obj.(*GlProgramUniformMatrix4x2fv))
}
func (c *binaryClassGlProgramUniformMatrix4x2fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix4x2fv]
}

type binaryClassGlProgramUniformMatrix4x2fvEXT struct{}

func (*GlProgramUniformMatrix4x2fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix4x2fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix4x2fvEXT(e binary.Encoder, o *GlProgramUniformMatrix4x2fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniformMatrix4x2fvEXT(d binary.Decoder, o *GlProgramUniformMatrix4x2fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniformMatrix4x2fvEXT(d binary.Decoder, o *GlProgramUniformMatrix4x2fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniformMatrix4x2fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix4x2fvEXT(e, obj.(*GlProgramUniformMatrix4x2fvEXT))
}
func (*binaryClassGlProgramUniformMatrix4x2fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix4x2fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix4x2fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix4x2fvEXT(d, obj.(*GlProgramUniformMatrix4x2fvEXT))
}
func (c *binaryClassGlProgramUniformMatrix4x2fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix4x2fvEXT]
}

type binaryClassGlProgramUniformMatrix4x3fv struct{}

func (*GlProgramUniformMatrix4x3fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix4x3fv)(nil)
}
func doEncodeGlProgramUniformMatrix4x3fv(e binary.Encoder, o *GlProgramUniformMatrix4x3fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlProgramUniformMatrix4x3fv(d binary.Decoder, o *GlProgramUniformMatrix4x3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlProgramUniformMatrix4x3fv(d binary.Decoder, o *GlProgramUniformMatrix4x3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlProgramUniformMatrix4x3fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix4x3fv(e, obj.(*GlProgramUniformMatrix4x3fv))
}
func (*binaryClassGlProgramUniformMatrix4x3fv) New() binary.Object {
	return &GlProgramUniformMatrix4x3fv{}
}
func (*binaryClassGlProgramUniformMatrix4x3fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix4x3fv(d, obj.(*GlProgramUniformMatrix4x3fv))
}
func (c *binaryClassGlProgramUniformMatrix4x3fv) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix4x3fv]
}

type binaryClassGlProgramUniformMatrix4x3fvEXT struct{}

func (*GlProgramUniformMatrix4x3fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix4x3fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix4x3fvEXT(e binary.Encoder, o *GlProgramUniformMatrix4x3fvEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlProgramUniformMatrix4x3fvEXT(d binary.Decoder, o *GlProgramUniformMatrix4x3fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlProgramUniformMatrix4x3fvEXT(d binary.Decoder, o *GlProgramUniformMatrix4x3fvEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlProgramUniformMatrix4x3fvEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlProgramUniformMatrix4x3fvEXT(e, obj.(*GlProgramUniformMatrix4x3fvEXT))
}
func (*binaryClassGlProgramUniformMatrix4x3fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix4x3fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix4x3fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlProgramUniformMatrix4x3fvEXT(d, obj.(*GlProgramUniformMatrix4x3fvEXT))
}
func (c *binaryClassGlProgramUniformMatrix4x3fvEXT) Schema() *binary.Entity {
	return &entities[ixǁGlProgramUniformMatrix4x3fvEXT]
}

type binaryClassGlPushDebugGroup struct{}

func (*GlPushDebugGroup) Class() binary.Class {
	return (*binaryClassGlPushDebugGroup)(nil)
}
func doEncodeGlPushDebugGroup(e binary.Encoder, o *GlPushDebugGroup) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Source))
	e.Uint32(uint32(o.Id))
	e.Int32(int32(o.Length))
	e.Simple(&o.Message)
}
func doDecodeGlPushDebugGroup(d binary.Decoder, o *GlPushDebugGroup) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Source = GLenum(d.Uint32())
	o.Id = GLuint(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Message)
}
func doDecodeRawGlPushDebugGroup(d binary.Decoder, o *GlPushDebugGroup) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Source = GLenum(d.Uint32())
	o.Id = GLuint(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Message)
}
func (*binaryClassGlPushDebugGroup) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPushDebugGroup(e, obj.(*GlPushDebugGroup))
}
func (*binaryClassGlPushDebugGroup) New() binary.Object {
	return &GlPushDebugGroup{}
}
func (*binaryClassGlPushDebugGroup) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPushDebugGroup(d, obj.(*GlPushDebugGroup))
}
func (c *binaryClassGlPushDebugGroup) Schema() *binary.Entity {
	return &entities[ixǁGlPushDebugGroup]
}

type binaryClassGlPushDebugGroupKHR struct{}

func (*GlPushDebugGroupKHR) Class() binary.Class {
	return (*binaryClassGlPushDebugGroupKHR)(nil)
}
func doEncodeGlPushDebugGroupKHR(e binary.Encoder, o *GlPushDebugGroupKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Source))
	e.Uint32(uint32(o.Id))
	e.Int32(int32(o.Length))
	e.Simple(&o.Message)
}
func doDecodeGlPushDebugGroupKHR(d binary.Decoder, o *GlPushDebugGroupKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Source = GLenum(d.Uint32())
	o.Id = GLuint(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Message)
}
func doDecodeRawGlPushDebugGroupKHR(d binary.Decoder, o *GlPushDebugGroupKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Source = GLenum(d.Uint32())
	o.Id = GLuint(d.Uint32())
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Message)
}
func (*binaryClassGlPushDebugGroupKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPushDebugGroupKHR(e, obj.(*GlPushDebugGroupKHR))
}
func (*binaryClassGlPushDebugGroupKHR) New() binary.Object {
	return &GlPushDebugGroupKHR{}
}
func (*binaryClassGlPushDebugGroupKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPushDebugGroupKHR(d, obj.(*GlPushDebugGroupKHR))
}
func (c *binaryClassGlPushDebugGroupKHR) Schema() *binary.Entity {
	return &entities[ixǁGlPushDebugGroupKHR]
}

type binaryClassGlPushGroupMarkerEXT struct{}

func (*GlPushGroupMarkerEXT) Class() binary.Class {
	return (*binaryClassGlPushGroupMarkerEXT)(nil)
}
func doEncodeGlPushGroupMarkerEXT(e binary.Encoder, o *GlPushGroupMarkerEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Length))
	e.Simple(&o.Marker)
}
func doDecodeGlPushGroupMarkerEXT(d binary.Decoder, o *GlPushGroupMarkerEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Marker)
}
func doDecodeRawGlPushGroupMarkerEXT(d binary.Decoder, o *GlPushGroupMarkerEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Length = GLsizei(d.Int32())
	d.Simple(&o.Marker)
}
func (*binaryClassGlPushGroupMarkerEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPushGroupMarkerEXT(e, obj.(*GlPushGroupMarkerEXT))
}
func (*binaryClassGlPushGroupMarkerEXT) New() binary.Object {
	return &GlPushGroupMarkerEXT{}
}
func (*binaryClassGlPushGroupMarkerEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPushGroupMarkerEXT(d, obj.(*GlPushGroupMarkerEXT))
}
func (c *binaryClassGlPushGroupMarkerEXT) Schema() *binary.Entity {
	return &entities[ixǁGlPushGroupMarkerEXT]
}

type binaryClassGlPushMatrix struct{}

func (*GlPushMatrix) Class() binary.Class {
	return (*binaryClassGlPushMatrix)(nil)
}
func doEncodeGlPushMatrix(e binary.Encoder, o *GlPushMatrix) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlPushMatrix(d binary.Decoder, o *GlPushMatrix) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlPushMatrix(d binary.Decoder, o *GlPushMatrix) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlPushMatrix) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlPushMatrix(e, obj.(*GlPushMatrix))
}
func (*binaryClassGlPushMatrix) New() binary.Object {
	return &GlPushMatrix{}
}
func (*binaryClassGlPushMatrix) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlPushMatrix(d, obj.(*GlPushMatrix))
}
func (c *binaryClassGlPushMatrix) Schema() *binary.Entity {
	return &entities[ixǁGlPushMatrix]
}

type binaryClassGlQueryCounterEXT struct{}

func (*GlQueryCounterEXT) Class() binary.Class {
	return (*binaryClassGlQueryCounterEXT)(nil)
}
func doEncodeGlQueryCounterEXT(e binary.Encoder, o *GlQueryCounterEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Query))
	e.Uint32(uint32(o.Target))
}
func doDecodeGlQueryCounterEXT(d binary.Decoder, o *GlQueryCounterEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Target = GLenum(d.Uint32())
}
func doDecodeRawGlQueryCounterEXT(d binary.Decoder, o *GlQueryCounterEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Query = QueryId(d.Uint32())
	o.Target = GLenum(d.Uint32())
}
func (*binaryClassGlQueryCounterEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlQueryCounterEXT(e, obj.(*GlQueryCounterEXT))
}
func (*binaryClassGlQueryCounterEXT) New() binary.Object {
	return &GlQueryCounterEXT{}
}
func (*binaryClassGlQueryCounterEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlQueryCounterEXT(d, obj.(*GlQueryCounterEXT))
}
func (c *binaryClassGlQueryCounterEXT) Schema() *binary.Entity {
	return &entities[ixǁGlQueryCounterEXT]
}

type binaryClassGlQueryMatrixxOES struct{}

func (*GlQueryMatrixxOES) Class() binary.Class {
	return (*binaryClassGlQueryMatrixxOES)(nil)
}
func doEncodeGlQueryMatrixxOES(e binary.Encoder, o *GlQueryMatrixxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Mantissa)
	e.Simple(&o.Exponent)
	e.Uint32(uint32(o.Result))
}
func doDecodeGlQueryMatrixxOES(d binary.Decoder, o *GlQueryMatrixxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Mantissa)
	d.Simple(&o.Exponent)
	o.Result = GLbitfield(d.Uint32())
}
func doDecodeRawGlQueryMatrixxOES(d binary.Decoder, o *GlQueryMatrixxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Mantissa)
	d.Simple(&o.Exponent)
	o.Result = GLbitfield(d.Uint32())
}
func (*binaryClassGlQueryMatrixxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlQueryMatrixxOES(e, obj.(*GlQueryMatrixxOES))
}
func (*binaryClassGlQueryMatrixxOES) New() binary.Object {
	return &GlQueryMatrixxOES{}
}
func (*binaryClassGlQueryMatrixxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlQueryMatrixxOES(d, obj.(*GlQueryMatrixxOES))
}
func (c *binaryClassGlQueryMatrixxOES) Schema() *binary.Entity {
	return &entities[ixǁGlQueryMatrixxOES]
}

type binaryClassGlRasterSamplesEXT struct{}

func (*GlRasterSamplesEXT) Class() binary.Class {
	return (*binaryClassGlRasterSamplesEXT)(nil)
}
func doEncodeGlRasterSamplesEXT(e binary.Encoder, o *GlRasterSamplesEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Samples))
	e.Uint8(uint8(o.Fixedsamplelocations))
}
func doDecodeGlRasterSamplesEXT(d binary.Decoder, o *GlRasterSamplesEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Samples = GLuint(d.Uint32())
	o.Fixedsamplelocations = GLboolean(d.Uint8())
}
func doDecodeRawGlRasterSamplesEXT(d binary.Decoder, o *GlRasterSamplesEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Samples = GLuint(d.Uint32())
	o.Fixedsamplelocations = GLboolean(d.Uint8())
}
func (*binaryClassGlRasterSamplesEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlRasterSamplesEXT(e, obj.(*GlRasterSamplesEXT))
}
func (*binaryClassGlRasterSamplesEXT) New() binary.Object {
	return &GlRasterSamplesEXT{}
}
func (*binaryClassGlRasterSamplesEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlRasterSamplesEXT(d, obj.(*GlRasterSamplesEXT))
}
func (c *binaryClassGlRasterSamplesEXT) Schema() *binary.Entity {
	return &entities[ixǁGlRasterSamplesEXT]
}

type binaryClassGlReadBuffer struct{}

func (*GlReadBuffer) Class() binary.Class {
	return (*binaryClassGlReadBuffer)(nil)
}
func doEncodeGlReadBuffer(e binary.Encoder, o *GlReadBuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Src))
}
func doDecodeGlReadBuffer(d binary.Decoder, o *GlReadBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Src = GLenum(d.Uint32())
}
func doDecodeRawGlReadBuffer(d binary.Decoder, o *GlReadBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Src = GLenum(d.Uint32())
}
func (*binaryClassGlReadBuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlReadBuffer(e, obj.(*GlReadBuffer))
}
func (*binaryClassGlReadBuffer) New() binary.Object {
	return &GlReadBuffer{}
}
func (*binaryClassGlReadBuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlReadBuffer(d, obj.(*GlReadBuffer))
}
func (c *binaryClassGlReadBuffer) Schema() *binary.Entity {
	return &entities[ixǁGlReadBuffer]
}

type binaryClassGlReadBufferIndexedEXT struct{}

func (*GlReadBufferIndexedEXT) Class() binary.Class {
	return (*binaryClassGlReadBufferIndexedEXT)(nil)
}
func doEncodeGlReadBufferIndexedEXT(e binary.Encoder, o *GlReadBufferIndexedEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Src))
	e.Int32(int32(o.Index))
}
func doDecodeGlReadBufferIndexedEXT(d binary.Decoder, o *GlReadBufferIndexedEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Src = GLenum(d.Uint32())
	o.Index = GLint(d.Int32())
}
func doDecodeRawGlReadBufferIndexedEXT(d binary.Decoder, o *GlReadBufferIndexedEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Src = GLenum(d.Uint32())
	o.Index = GLint(d.Int32())
}
func (*binaryClassGlReadBufferIndexedEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlReadBufferIndexedEXT(e, obj.(*GlReadBufferIndexedEXT))
}
func (*binaryClassGlReadBufferIndexedEXT) New() binary.Object {
	return &GlReadBufferIndexedEXT{}
}
func (*binaryClassGlReadBufferIndexedEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlReadBufferIndexedEXT(d, obj.(*GlReadBufferIndexedEXT))
}
func (c *binaryClassGlReadBufferIndexedEXT) Schema() *binary.Entity {
	return &entities[ixǁGlReadBufferIndexedEXT]
}

type binaryClassGlReadBufferNV struct{}

func (*GlReadBufferNV) Class() binary.Class {
	return (*binaryClassGlReadBufferNV)(nil)
}
func doEncodeGlReadBufferNV(e binary.Encoder, o *GlReadBufferNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
}
func doDecodeGlReadBufferNV(d binary.Decoder, o *GlReadBufferNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
}
func doDecodeRawGlReadBufferNV(d binary.Decoder, o *GlReadBufferNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
}
func (*binaryClassGlReadBufferNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlReadBufferNV(e, obj.(*GlReadBufferNV))
}
func (*binaryClassGlReadBufferNV) New() binary.Object {
	return &GlReadBufferNV{}
}
func (*binaryClassGlReadBufferNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlReadBufferNV(d, obj.(*GlReadBufferNV))
}
func (c *binaryClassGlReadBufferNV) Schema() *binary.Entity {
	return &entities[ixǁGlReadBufferNV]
}

type binaryClassGlReadPixels struct{}

func (*GlReadPixels) Class() binary.Class {
	return (*binaryClassGlReadPixels)(nil)
}
func doEncodeGlReadPixels(e binary.Encoder, o *GlReadPixels) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Uint32(uint32(o.Format))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Data)
}
func doDecodeGlReadPixels(d binary.Decoder, o *GlReadPixels) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Data)
}
func doDecodeRawGlReadPixels(d binary.Decoder, o *GlReadPixels) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Data)
}
func (*binaryClassGlReadPixels) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlReadPixels(e, obj.(*GlReadPixels))
}
func (*binaryClassGlReadPixels) New() binary.Object {
	return &GlReadPixels{}
}
func (*binaryClassGlReadPixels) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlReadPixels(d, obj.(*GlReadPixels))
}
func (c *binaryClassGlReadPixels) Schema() *binary.Entity {
	return &entities[ixǁGlReadPixels]
}

type binaryClassGlReadnPixels struct{}

func (*GlReadnPixels) Class() binary.Class {
	return (*binaryClassGlReadnPixels)(nil)
}
func doEncodeGlReadnPixels(e binary.Encoder, o *GlReadnPixels) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Uint32(uint32(o.Format))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Data)
}
func doDecodeGlReadnPixels(d binary.Decoder, o *GlReadnPixels) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func doDecodeRawGlReadnPixels(d binary.Decoder, o *GlReadnPixels) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func (*binaryClassGlReadnPixels) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlReadnPixels(e, obj.(*GlReadnPixels))
}
func (*binaryClassGlReadnPixels) New() binary.Object {
	return &GlReadnPixels{}
}
func (*binaryClassGlReadnPixels) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlReadnPixels(d, obj.(*GlReadnPixels))
}
func (c *binaryClassGlReadnPixels) Schema() *binary.Entity {
	return &entities[ixǁGlReadnPixels]
}

type binaryClassGlReadnPixelsEXT struct{}

func (*GlReadnPixelsEXT) Class() binary.Class {
	return (*binaryClassGlReadnPixelsEXT)(nil)
}
func doEncodeGlReadnPixelsEXT(e binary.Encoder, o *GlReadnPixelsEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Uint32(uint32(o.Format))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Data)
}
func doDecodeGlReadnPixelsEXT(d binary.Decoder, o *GlReadnPixelsEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func doDecodeRawGlReadnPixelsEXT(d binary.Decoder, o *GlReadnPixelsEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func (*binaryClassGlReadnPixelsEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlReadnPixelsEXT(e, obj.(*GlReadnPixelsEXT))
}
func (*binaryClassGlReadnPixelsEXT) New() binary.Object {
	return &GlReadnPixelsEXT{}
}
func (*binaryClassGlReadnPixelsEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlReadnPixelsEXT(d, obj.(*GlReadnPixelsEXT))
}
func (c *binaryClassGlReadnPixelsEXT) Schema() *binary.Entity {
	return &entities[ixǁGlReadnPixelsEXT]
}

type binaryClassGlReadnPixelsKHR struct{}

func (*GlReadnPixelsKHR) Class() binary.Class {
	return (*binaryClassGlReadnPixelsKHR)(nil)
}
func doEncodeGlReadnPixelsKHR(e binary.Encoder, o *GlReadnPixelsKHR) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Uint32(uint32(o.Format))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.BufSize))
	e.Simple(&o.Data)
}
func doDecodeGlReadnPixelsKHR(d binary.Decoder, o *GlReadnPixelsKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func doDecodeRawGlReadnPixelsKHR(d binary.Decoder, o *GlReadnPixelsKHR) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	o.BufSize = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func (*binaryClassGlReadnPixelsKHR) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlReadnPixelsKHR(e, obj.(*GlReadnPixelsKHR))
}
func (*binaryClassGlReadnPixelsKHR) New() binary.Object {
	return &GlReadnPixelsKHR{}
}
func (*binaryClassGlReadnPixelsKHR) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlReadnPixelsKHR(d, obj.(*GlReadnPixelsKHR))
}
func (c *binaryClassGlReadnPixelsKHR) Schema() *binary.Entity {
	return &entities[ixǁGlReadnPixelsKHR]
}

type binaryClassGlReleaseShaderCompiler struct{}

func (*GlReleaseShaderCompiler) Class() binary.Class {
	return (*binaryClassGlReleaseShaderCompiler)(nil)
}
func doEncodeGlReleaseShaderCompiler(e binary.Encoder, o *GlReleaseShaderCompiler) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlReleaseShaderCompiler(d binary.Decoder, o *GlReleaseShaderCompiler) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlReleaseShaderCompiler(d binary.Decoder, o *GlReleaseShaderCompiler) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlReleaseShaderCompiler) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlReleaseShaderCompiler(e, obj.(*GlReleaseShaderCompiler))
}
func (*binaryClassGlReleaseShaderCompiler) New() binary.Object {
	return &GlReleaseShaderCompiler{}
}
func (*binaryClassGlReleaseShaderCompiler) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlReleaseShaderCompiler(d, obj.(*GlReleaseShaderCompiler))
}
func (c *binaryClassGlReleaseShaderCompiler) Schema() *binary.Entity {
	return &entities[ixǁGlReleaseShaderCompiler]
}

type binaryClassGlRenderbufferStorage struct{}

func (*GlRenderbufferStorage) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorage)(nil)
}
func doEncodeGlRenderbufferStorage(e binary.Encoder, o *GlRenderbufferStorage) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlRenderbufferStorage(d binary.Decoder, o *GlRenderbufferStorage) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlRenderbufferStorage(d binary.Decoder, o *GlRenderbufferStorage) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlRenderbufferStorage) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlRenderbufferStorage(e, obj.(*GlRenderbufferStorage))
}
func (*binaryClassGlRenderbufferStorage) New() binary.Object {
	return &GlRenderbufferStorage{}
}
func (*binaryClassGlRenderbufferStorage) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlRenderbufferStorage(d, obj.(*GlRenderbufferStorage))
}
func (c *binaryClassGlRenderbufferStorage) Schema() *binary.Entity {
	return &entities[ixǁGlRenderbufferStorage]
}

type binaryClassGlRenderbufferStorageMultisample struct{}

func (*GlRenderbufferStorageMultisample) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageMultisample)(nil)
}
func doEncodeGlRenderbufferStorageMultisample(e binary.Encoder, o *GlRenderbufferStorageMultisample) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Samples))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlRenderbufferStorageMultisample(d binary.Decoder, o *GlRenderbufferStorageMultisample) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlRenderbufferStorageMultisample(d binary.Decoder, o *GlRenderbufferStorageMultisample) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlRenderbufferStorageMultisample) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlRenderbufferStorageMultisample(e, obj.(*GlRenderbufferStorageMultisample))
}
func (*binaryClassGlRenderbufferStorageMultisample) New() binary.Object {
	return &GlRenderbufferStorageMultisample{}
}
func (*binaryClassGlRenderbufferStorageMultisample) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlRenderbufferStorageMultisample(d, obj.(*GlRenderbufferStorageMultisample))
}
func (c *binaryClassGlRenderbufferStorageMultisample) Schema() *binary.Entity {
	return &entities[ixǁGlRenderbufferStorageMultisample]
}

type binaryClassGlRenderbufferStorageMultisampleANGLE struct{}

func (*GlRenderbufferStorageMultisampleANGLE) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageMultisampleANGLE)(nil)
}
func doEncodeGlRenderbufferStorageMultisampleANGLE(e binary.Encoder, o *GlRenderbufferStorageMultisampleANGLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Samples))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlRenderbufferStorageMultisampleANGLE(d binary.Decoder, o *GlRenderbufferStorageMultisampleANGLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlRenderbufferStorageMultisampleANGLE(d binary.Decoder, o *GlRenderbufferStorageMultisampleANGLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlRenderbufferStorageMultisampleANGLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlRenderbufferStorageMultisampleANGLE(e, obj.(*GlRenderbufferStorageMultisampleANGLE))
}
func (*binaryClassGlRenderbufferStorageMultisampleANGLE) New() binary.Object {
	return &GlRenderbufferStorageMultisampleANGLE{}
}
func (*binaryClassGlRenderbufferStorageMultisampleANGLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlRenderbufferStorageMultisampleANGLE(d, obj.(*GlRenderbufferStorageMultisampleANGLE))
}
func (c *binaryClassGlRenderbufferStorageMultisampleANGLE) Schema() *binary.Entity {
	return &entities[ixǁGlRenderbufferStorageMultisampleANGLE]
}

type binaryClassGlRenderbufferStorageMultisampleAPPLE struct{}

func (*GlRenderbufferStorageMultisampleAPPLE) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageMultisampleAPPLE)(nil)
}
func doEncodeGlRenderbufferStorageMultisampleAPPLE(e binary.Encoder, o *GlRenderbufferStorageMultisampleAPPLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Samples))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlRenderbufferStorageMultisampleAPPLE(d binary.Decoder, o *GlRenderbufferStorageMultisampleAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlRenderbufferStorageMultisampleAPPLE(d binary.Decoder, o *GlRenderbufferStorageMultisampleAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlRenderbufferStorageMultisampleAPPLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlRenderbufferStorageMultisampleAPPLE(e, obj.(*GlRenderbufferStorageMultisampleAPPLE))
}
func (*binaryClassGlRenderbufferStorageMultisampleAPPLE) New() binary.Object {
	return &GlRenderbufferStorageMultisampleAPPLE{}
}
func (*binaryClassGlRenderbufferStorageMultisampleAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlRenderbufferStorageMultisampleAPPLE(d, obj.(*GlRenderbufferStorageMultisampleAPPLE))
}
func (c *binaryClassGlRenderbufferStorageMultisampleAPPLE) Schema() *binary.Entity {
	return &entities[ixǁGlRenderbufferStorageMultisampleAPPLE]
}

type binaryClassGlRenderbufferStorageMultisampleEXT struct{}

func (*GlRenderbufferStorageMultisampleEXT) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageMultisampleEXT)(nil)
}
func doEncodeGlRenderbufferStorageMultisampleEXT(e binary.Encoder, o *GlRenderbufferStorageMultisampleEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Samples))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlRenderbufferStorageMultisampleEXT(d binary.Decoder, o *GlRenderbufferStorageMultisampleEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlRenderbufferStorageMultisampleEXT(d binary.Decoder, o *GlRenderbufferStorageMultisampleEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlRenderbufferStorageMultisampleEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlRenderbufferStorageMultisampleEXT(e, obj.(*GlRenderbufferStorageMultisampleEXT))
}
func (*binaryClassGlRenderbufferStorageMultisampleEXT) New() binary.Object {
	return &GlRenderbufferStorageMultisampleEXT{}
}
func (*binaryClassGlRenderbufferStorageMultisampleEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlRenderbufferStorageMultisampleEXT(d, obj.(*GlRenderbufferStorageMultisampleEXT))
}
func (c *binaryClassGlRenderbufferStorageMultisampleEXT) Schema() *binary.Entity {
	return &entities[ixǁGlRenderbufferStorageMultisampleEXT]
}

type binaryClassGlRenderbufferStorageMultisampleIMG struct{}

func (*GlRenderbufferStorageMultisampleIMG) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageMultisampleIMG)(nil)
}
func doEncodeGlRenderbufferStorageMultisampleIMG(e binary.Encoder, o *GlRenderbufferStorageMultisampleIMG) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Samples))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlRenderbufferStorageMultisampleIMG(d binary.Decoder, o *GlRenderbufferStorageMultisampleIMG) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlRenderbufferStorageMultisampleIMG(d binary.Decoder, o *GlRenderbufferStorageMultisampleIMG) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlRenderbufferStorageMultisampleIMG) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlRenderbufferStorageMultisampleIMG(e, obj.(*GlRenderbufferStorageMultisampleIMG))
}
func (*binaryClassGlRenderbufferStorageMultisampleIMG) New() binary.Object {
	return &GlRenderbufferStorageMultisampleIMG{}
}
func (*binaryClassGlRenderbufferStorageMultisampleIMG) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlRenderbufferStorageMultisampleIMG(d, obj.(*GlRenderbufferStorageMultisampleIMG))
}
func (c *binaryClassGlRenderbufferStorageMultisampleIMG) Schema() *binary.Entity {
	return &entities[ixǁGlRenderbufferStorageMultisampleIMG]
}

type binaryClassGlRenderbufferStorageMultisampleNV struct{}

func (*GlRenderbufferStorageMultisampleNV) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageMultisampleNV)(nil)
}
func doEncodeGlRenderbufferStorageMultisampleNV(e binary.Encoder, o *GlRenderbufferStorageMultisampleNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Samples))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlRenderbufferStorageMultisampleNV(d binary.Decoder, o *GlRenderbufferStorageMultisampleNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlRenderbufferStorageMultisampleNV(d binary.Decoder, o *GlRenderbufferStorageMultisampleNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlRenderbufferStorageMultisampleNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlRenderbufferStorageMultisampleNV(e, obj.(*GlRenderbufferStorageMultisampleNV))
}
func (*binaryClassGlRenderbufferStorageMultisampleNV) New() binary.Object {
	return &GlRenderbufferStorageMultisampleNV{}
}
func (*binaryClassGlRenderbufferStorageMultisampleNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlRenderbufferStorageMultisampleNV(d, obj.(*GlRenderbufferStorageMultisampleNV))
}
func (c *binaryClassGlRenderbufferStorageMultisampleNV) Schema() *binary.Entity {
	return &entities[ixǁGlRenderbufferStorageMultisampleNV]
}

type binaryClassGlRenderbufferStorageOES struct{}

func (*GlRenderbufferStorageOES) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageOES)(nil)
}
func doEncodeGlRenderbufferStorageOES(e binary.Encoder, o *GlRenderbufferStorageOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlRenderbufferStorageOES(d binary.Decoder, o *GlRenderbufferStorageOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlRenderbufferStorageOES(d binary.Decoder, o *GlRenderbufferStorageOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlRenderbufferStorageOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlRenderbufferStorageOES(e, obj.(*GlRenderbufferStorageOES))
}
func (*binaryClassGlRenderbufferStorageOES) New() binary.Object {
	return &GlRenderbufferStorageOES{}
}
func (*binaryClassGlRenderbufferStorageOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlRenderbufferStorageOES(d, obj.(*GlRenderbufferStorageOES))
}
func (c *binaryClassGlRenderbufferStorageOES) Schema() *binary.Entity {
	return &entities[ixǁGlRenderbufferStorageOES]
}

type binaryClassGlResolveDepthValuesNV struct{}

func (*GlResolveDepthValuesNV) Class() binary.Class {
	return (*binaryClassGlResolveDepthValuesNV)(nil)
}
func doEncodeGlResolveDepthValuesNV(e binary.Encoder, o *GlResolveDepthValuesNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlResolveDepthValuesNV(d binary.Decoder, o *GlResolveDepthValuesNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlResolveDepthValuesNV(d binary.Decoder, o *GlResolveDepthValuesNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlResolveDepthValuesNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlResolveDepthValuesNV(e, obj.(*GlResolveDepthValuesNV))
}
func (*binaryClassGlResolveDepthValuesNV) New() binary.Object {
	return &GlResolveDepthValuesNV{}
}
func (*binaryClassGlResolveDepthValuesNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlResolveDepthValuesNV(d, obj.(*GlResolveDepthValuesNV))
}
func (c *binaryClassGlResolveDepthValuesNV) Schema() *binary.Entity {
	return &entities[ixǁGlResolveDepthValuesNV]
}

type binaryClassGlResolveMultisampleFramebufferAPPLE struct{}

func (*GlResolveMultisampleFramebufferAPPLE) Class() binary.Class {
	return (*binaryClassGlResolveMultisampleFramebufferAPPLE)(nil)
}
func doEncodeGlResolveMultisampleFramebufferAPPLE(e binary.Encoder, o *GlResolveMultisampleFramebufferAPPLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlResolveMultisampleFramebufferAPPLE(d binary.Decoder, o *GlResolveMultisampleFramebufferAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlResolveMultisampleFramebufferAPPLE(d binary.Decoder, o *GlResolveMultisampleFramebufferAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlResolveMultisampleFramebufferAPPLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlResolveMultisampleFramebufferAPPLE(e, obj.(*GlResolveMultisampleFramebufferAPPLE))
}
func (*binaryClassGlResolveMultisampleFramebufferAPPLE) New() binary.Object {
	return &GlResolveMultisampleFramebufferAPPLE{}
}
func (*binaryClassGlResolveMultisampleFramebufferAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlResolveMultisampleFramebufferAPPLE(d, obj.(*GlResolveMultisampleFramebufferAPPLE))
}
func (c *binaryClassGlResolveMultisampleFramebufferAPPLE) Schema() *binary.Entity {
	return &entities[ixǁGlResolveMultisampleFramebufferAPPLE]
}

type binaryClassGlResumeTransformFeedback struct{}

func (*GlResumeTransformFeedback) Class() binary.Class {
	return (*binaryClassGlResumeTransformFeedback)(nil)
}
func doEncodeGlResumeTransformFeedback(e binary.Encoder, o *GlResumeTransformFeedback) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
}
func doDecodeGlResumeTransformFeedback(d binary.Decoder, o *GlResumeTransformFeedback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func doDecodeRawGlResumeTransformFeedback(d binary.Decoder, o *GlResumeTransformFeedback) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
}
func (*binaryClassGlResumeTransformFeedback) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlResumeTransformFeedback(e, obj.(*GlResumeTransformFeedback))
}
func (*binaryClassGlResumeTransformFeedback) New() binary.Object {
	return &GlResumeTransformFeedback{}
}
func (*binaryClassGlResumeTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlResumeTransformFeedback(d, obj.(*GlResumeTransformFeedback))
}
func (c *binaryClassGlResumeTransformFeedback) Schema() *binary.Entity {
	return &entities[ixǁGlResumeTransformFeedback]
}

type binaryClassGlRotatef struct{}

func (*GlRotatef) Class() binary.Class {
	return (*binaryClassGlRotatef)(nil)
}
func doEncodeGlRotatef(e binary.Encoder, o *GlRotatef) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Angle))
	e.Float32(float32(o.X))
	e.Float32(float32(o.Y))
	e.Float32(float32(o.Z))
}
func doDecodeGlRotatef(d binary.Decoder, o *GlRotatef) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Angle = GLfloat(d.Float32())
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.Z = GLfloat(d.Float32())
}
func doDecodeRawGlRotatef(d binary.Decoder, o *GlRotatef) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Angle = GLfloat(d.Float32())
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.Z = GLfloat(d.Float32())
}
func (*binaryClassGlRotatef) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlRotatef(e, obj.(*GlRotatef))
}
func (*binaryClassGlRotatef) New() binary.Object {
	return &GlRotatef{}
}
func (*binaryClassGlRotatef) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlRotatef(d, obj.(*GlRotatef))
}
func (c *binaryClassGlRotatef) Schema() *binary.Entity {
	return &entities[ixǁGlRotatef]
}

type binaryClassGlRotatex struct{}

func (*GlRotatex) Class() binary.Class {
	return (*binaryClassGlRotatex)(nil)
}
func doEncodeGlRotatex(e binary.Encoder, o *GlRotatex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Angle))
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Z))
}
func doDecodeGlRotatex(d binary.Decoder, o *GlRotatex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Angle = GLfixed(d.Int32())
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
}
func doDecodeRawGlRotatex(d binary.Decoder, o *GlRotatex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Angle = GLfixed(d.Int32())
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
}
func (*binaryClassGlRotatex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlRotatex(e, obj.(*GlRotatex))
}
func (*binaryClassGlRotatex) New() binary.Object {
	return &GlRotatex{}
}
func (*binaryClassGlRotatex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlRotatex(d, obj.(*GlRotatex))
}
func (c *binaryClassGlRotatex) Schema() *binary.Entity {
	return &entities[ixǁGlRotatex]
}

type binaryClassGlRotatexOES struct{}

func (*GlRotatexOES) Class() binary.Class {
	return (*binaryClassGlRotatexOES)(nil)
}
func doEncodeGlRotatexOES(e binary.Encoder, o *GlRotatexOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Angle))
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Z))
}
func doDecodeGlRotatexOES(d binary.Decoder, o *GlRotatexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Angle = GLfixed(d.Int32())
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
}
func doDecodeRawGlRotatexOES(d binary.Decoder, o *GlRotatexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Angle = GLfixed(d.Int32())
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
}
func (*binaryClassGlRotatexOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlRotatexOES(e, obj.(*GlRotatexOES))
}
func (*binaryClassGlRotatexOES) New() binary.Object {
	return &GlRotatexOES{}
}
func (*binaryClassGlRotatexOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlRotatexOES(d, obj.(*GlRotatexOES))
}
func (c *binaryClassGlRotatexOES) Schema() *binary.Entity {
	return &entities[ixǁGlRotatexOES]
}

type binaryClassGlSampleCoverage struct{}

func (*GlSampleCoverage) Class() binary.Class {
	return (*binaryClassGlSampleCoverage)(nil)
}
func doEncodeGlSampleCoverage(e binary.Encoder, o *GlSampleCoverage) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.Value))
	e.Uint8(uint8(o.Invert))
}
func doDecodeGlSampleCoverage(d binary.Decoder, o *GlSampleCoverage) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Value = GLfloat(d.Float32())
	o.Invert = GLboolean(d.Uint8())
}
func doDecodeRawGlSampleCoverage(d binary.Decoder, o *GlSampleCoverage) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Value = GLfloat(d.Float32())
	o.Invert = GLboolean(d.Uint8())
}
func (*binaryClassGlSampleCoverage) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSampleCoverage(e, obj.(*GlSampleCoverage))
}
func (*binaryClassGlSampleCoverage) New() binary.Object {
	return &GlSampleCoverage{}
}
func (*binaryClassGlSampleCoverage) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSampleCoverage(d, obj.(*GlSampleCoverage))
}
func (c *binaryClassGlSampleCoverage) Schema() *binary.Entity {
	return &entities[ixǁGlSampleCoverage]
}

type binaryClassGlSampleCoveragex struct{}

func (*GlSampleCoveragex) Class() binary.Class {
	return (*binaryClassGlSampleCoveragex)(nil)
}
func doEncodeGlSampleCoveragex(e binary.Encoder, o *GlSampleCoveragex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Value))
	e.Uint8(uint8(o.Invert))
}
func doDecodeGlSampleCoveragex(d binary.Decoder, o *GlSampleCoveragex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Value = GLclampx(d.Int32())
	o.Invert = GLboolean(d.Uint8())
}
func doDecodeRawGlSampleCoveragex(d binary.Decoder, o *GlSampleCoveragex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Value = GLclampx(d.Int32())
	o.Invert = GLboolean(d.Uint8())
}
func (*binaryClassGlSampleCoveragex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSampleCoveragex(e, obj.(*GlSampleCoveragex))
}
func (*binaryClassGlSampleCoveragex) New() binary.Object {
	return &GlSampleCoveragex{}
}
func (*binaryClassGlSampleCoveragex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSampleCoveragex(d, obj.(*GlSampleCoveragex))
}
func (c *binaryClassGlSampleCoveragex) Schema() *binary.Entity {
	return &entities[ixǁGlSampleCoveragex]
}

type binaryClassGlSampleCoveragexOES struct{}

func (*GlSampleCoveragexOES) Class() binary.Class {
	return (*binaryClassGlSampleCoveragexOES)(nil)
}
func doEncodeGlSampleCoveragexOES(e binary.Encoder, o *GlSampleCoveragexOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Value))
	e.Uint8(uint8(o.Invert))
}
func doDecodeGlSampleCoveragexOES(d binary.Decoder, o *GlSampleCoveragexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Value = GLclampx(d.Int32())
	o.Invert = GLboolean(d.Uint8())
}
func doDecodeRawGlSampleCoveragexOES(d binary.Decoder, o *GlSampleCoveragexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Value = GLclampx(d.Int32())
	o.Invert = GLboolean(d.Uint8())
}
func (*binaryClassGlSampleCoveragexOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSampleCoveragexOES(e, obj.(*GlSampleCoveragexOES))
}
func (*binaryClassGlSampleCoveragexOES) New() binary.Object {
	return &GlSampleCoveragexOES{}
}
func (*binaryClassGlSampleCoveragexOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSampleCoveragexOES(d, obj.(*GlSampleCoveragexOES))
}
func (c *binaryClassGlSampleCoveragexOES) Schema() *binary.Entity {
	return &entities[ixǁGlSampleCoveragexOES]
}

type binaryClassGlSampleMaski struct{}

func (*GlSampleMaski) Class() binary.Class {
	return (*binaryClassGlSampleMaski)(nil)
}
func doEncodeGlSampleMaski(e binary.Encoder, o *GlSampleMaski) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.MaskNumber))
	e.Uint32(uint32(o.Mask))
}
func doDecodeGlSampleMaski(d binary.Decoder, o *GlSampleMaski) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MaskNumber = GLuint(d.Uint32())
	o.Mask = GLbitfield(d.Uint32())
}
func doDecodeRawGlSampleMaski(d binary.Decoder, o *GlSampleMaski) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.MaskNumber = GLuint(d.Uint32())
	o.Mask = GLbitfield(d.Uint32())
}
func (*binaryClassGlSampleMaski) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSampleMaski(e, obj.(*GlSampleMaski))
}
func (*binaryClassGlSampleMaski) New() binary.Object {
	return &GlSampleMaski{}
}
func (*binaryClassGlSampleMaski) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSampleMaski(d, obj.(*GlSampleMaski))
}
func (c *binaryClassGlSampleMaski) Schema() *binary.Entity {
	return &entities[ixǁGlSampleMaski]
}

type binaryClassGlSamplerParameterIiv struct{}

func (*GlSamplerParameterIiv) Class() binary.Class {
	return (*binaryClassGlSamplerParameterIiv)(nil)
}
func doEncodeGlSamplerParameterIiv(e binary.Encoder, o *GlSamplerParameterIiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlSamplerParameterIiv(d binary.Decoder, o *GlSamplerParameterIiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlSamplerParameterIiv(d binary.Decoder, o *GlSamplerParameterIiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlSamplerParameterIiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSamplerParameterIiv(e, obj.(*GlSamplerParameterIiv))
}
func (*binaryClassGlSamplerParameterIiv) New() binary.Object {
	return &GlSamplerParameterIiv{}
}
func (*binaryClassGlSamplerParameterIiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSamplerParameterIiv(d, obj.(*GlSamplerParameterIiv))
}
func (c *binaryClassGlSamplerParameterIiv) Schema() *binary.Entity {
	return &entities[ixǁGlSamplerParameterIiv]
}

type binaryClassGlSamplerParameterIivEXT struct{}

func (*GlSamplerParameterIivEXT) Class() binary.Class {
	return (*binaryClassGlSamplerParameterIivEXT)(nil)
}
func doEncodeGlSamplerParameterIivEXT(e binary.Encoder, o *GlSamplerParameterIivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlSamplerParameterIivEXT(d binary.Decoder, o *GlSamplerParameterIivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlSamplerParameterIivEXT(d binary.Decoder, o *GlSamplerParameterIivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlSamplerParameterIivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSamplerParameterIivEXT(e, obj.(*GlSamplerParameterIivEXT))
}
func (*binaryClassGlSamplerParameterIivEXT) New() binary.Object {
	return &GlSamplerParameterIivEXT{}
}
func (*binaryClassGlSamplerParameterIivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSamplerParameterIivEXT(d, obj.(*GlSamplerParameterIivEXT))
}
func (c *binaryClassGlSamplerParameterIivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlSamplerParameterIivEXT]
}

type binaryClassGlSamplerParameterIivOES struct{}

func (*GlSamplerParameterIivOES) Class() binary.Class {
	return (*binaryClassGlSamplerParameterIivOES)(nil)
}
func doEncodeGlSamplerParameterIivOES(e binary.Encoder, o *GlSamplerParameterIivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlSamplerParameterIivOES(d binary.Decoder, o *GlSamplerParameterIivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlSamplerParameterIivOES(d binary.Decoder, o *GlSamplerParameterIivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlSamplerParameterIivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSamplerParameterIivOES(e, obj.(*GlSamplerParameterIivOES))
}
func (*binaryClassGlSamplerParameterIivOES) New() binary.Object {
	return &GlSamplerParameterIivOES{}
}
func (*binaryClassGlSamplerParameterIivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSamplerParameterIivOES(d, obj.(*GlSamplerParameterIivOES))
}
func (c *binaryClassGlSamplerParameterIivOES) Schema() *binary.Entity {
	return &entities[ixǁGlSamplerParameterIivOES]
}

type binaryClassGlSamplerParameterIuiv struct{}

func (*GlSamplerParameterIuiv) Class() binary.Class {
	return (*binaryClassGlSamplerParameterIuiv)(nil)
}
func doEncodeGlSamplerParameterIuiv(e binary.Encoder, o *GlSamplerParameterIuiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlSamplerParameterIuiv(d binary.Decoder, o *GlSamplerParameterIuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlSamplerParameterIuiv(d binary.Decoder, o *GlSamplerParameterIuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlSamplerParameterIuiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSamplerParameterIuiv(e, obj.(*GlSamplerParameterIuiv))
}
func (*binaryClassGlSamplerParameterIuiv) New() binary.Object {
	return &GlSamplerParameterIuiv{}
}
func (*binaryClassGlSamplerParameterIuiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSamplerParameterIuiv(d, obj.(*GlSamplerParameterIuiv))
}
func (c *binaryClassGlSamplerParameterIuiv) Schema() *binary.Entity {
	return &entities[ixǁGlSamplerParameterIuiv]
}

type binaryClassGlSamplerParameterIuivEXT struct{}

func (*GlSamplerParameterIuivEXT) Class() binary.Class {
	return (*binaryClassGlSamplerParameterIuivEXT)(nil)
}
func doEncodeGlSamplerParameterIuivEXT(e binary.Encoder, o *GlSamplerParameterIuivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlSamplerParameterIuivEXT(d binary.Decoder, o *GlSamplerParameterIuivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlSamplerParameterIuivEXT(d binary.Decoder, o *GlSamplerParameterIuivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlSamplerParameterIuivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSamplerParameterIuivEXT(e, obj.(*GlSamplerParameterIuivEXT))
}
func (*binaryClassGlSamplerParameterIuivEXT) New() binary.Object {
	return &GlSamplerParameterIuivEXT{}
}
func (*binaryClassGlSamplerParameterIuivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSamplerParameterIuivEXT(d, obj.(*GlSamplerParameterIuivEXT))
}
func (c *binaryClassGlSamplerParameterIuivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlSamplerParameterIuivEXT]
}

type binaryClassGlSamplerParameterIuivOES struct{}

func (*GlSamplerParameterIuivOES) Class() binary.Class {
	return (*binaryClassGlSamplerParameterIuivOES)(nil)
}
func doEncodeGlSamplerParameterIuivOES(e binary.Encoder, o *GlSamplerParameterIuivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlSamplerParameterIuivOES(d binary.Decoder, o *GlSamplerParameterIuivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlSamplerParameterIuivOES(d binary.Decoder, o *GlSamplerParameterIuivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlSamplerParameterIuivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSamplerParameterIuivOES(e, obj.(*GlSamplerParameterIuivOES))
}
func (*binaryClassGlSamplerParameterIuivOES) New() binary.Object {
	return &GlSamplerParameterIuivOES{}
}
func (*binaryClassGlSamplerParameterIuivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSamplerParameterIuivOES(d, obj.(*GlSamplerParameterIuivOES))
}
func (c *binaryClassGlSamplerParameterIuivOES) Schema() *binary.Entity {
	return &entities[ixǁGlSamplerParameterIuivOES]
}

type binaryClassGlSamplerParameterf struct{}

func (*GlSamplerParameterf) Class() binary.Class {
	return (*binaryClassGlSamplerParameterf)(nil)
}
func doEncodeGlSamplerParameterf(e binary.Encoder, o *GlSamplerParameterf) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Float32(float32(o.Param))
}
func doDecodeGlSamplerParameterf(d binary.Decoder, o *GlSamplerParameterf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func doDecodeRawGlSamplerParameterf(d binary.Decoder, o *GlSamplerParameterf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func (*binaryClassGlSamplerParameterf) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSamplerParameterf(e, obj.(*GlSamplerParameterf))
}
func (*binaryClassGlSamplerParameterf) New() binary.Object {
	return &GlSamplerParameterf{}
}
func (*binaryClassGlSamplerParameterf) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSamplerParameterf(d, obj.(*GlSamplerParameterf))
}
func (c *binaryClassGlSamplerParameterf) Schema() *binary.Entity {
	return &entities[ixǁGlSamplerParameterf]
}

type binaryClassGlSamplerParameterfv struct{}

func (*GlSamplerParameterfv) Class() binary.Class {
	return (*binaryClassGlSamplerParameterfv)(nil)
}
func doEncodeGlSamplerParameterfv(e binary.Encoder, o *GlSamplerParameterfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlSamplerParameterfv(d binary.Decoder, o *GlSamplerParameterfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlSamplerParameterfv(d binary.Decoder, o *GlSamplerParameterfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlSamplerParameterfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSamplerParameterfv(e, obj.(*GlSamplerParameterfv))
}
func (*binaryClassGlSamplerParameterfv) New() binary.Object {
	return &GlSamplerParameterfv{}
}
func (*binaryClassGlSamplerParameterfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSamplerParameterfv(d, obj.(*GlSamplerParameterfv))
}
func (c *binaryClassGlSamplerParameterfv) Schema() *binary.Entity {
	return &entities[ixǁGlSamplerParameterfv]
}

type binaryClassGlSamplerParameteri struct{}

func (*GlSamplerParameteri) Class() binary.Class {
	return (*binaryClassGlSamplerParameteri)(nil)
}
func doEncodeGlSamplerParameteri(e binary.Encoder, o *GlSamplerParameteri) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlSamplerParameteri(d binary.Decoder, o *GlSamplerParameteri) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLint(d.Int32())
}
func doDecodeRawGlSamplerParameteri(d binary.Decoder, o *GlSamplerParameteri) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLint(d.Int32())
}
func (*binaryClassGlSamplerParameteri) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSamplerParameteri(e, obj.(*GlSamplerParameteri))
}
func (*binaryClassGlSamplerParameteri) New() binary.Object {
	return &GlSamplerParameteri{}
}
func (*binaryClassGlSamplerParameteri) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSamplerParameteri(d, obj.(*GlSamplerParameteri))
}
func (c *binaryClassGlSamplerParameteri) Schema() *binary.Entity {
	return &entities[ixǁGlSamplerParameteri]
}

type binaryClassGlSamplerParameteriv struct{}

func (*GlSamplerParameteriv) Class() binary.Class {
	return (*binaryClassGlSamplerParameteriv)(nil)
}
func doEncodeGlSamplerParameteriv(e binary.Encoder, o *GlSamplerParameteriv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Sampler))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Param)
}
func doDecodeGlSamplerParameteriv(d binary.Decoder, o *GlSamplerParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func doDecodeRawGlSamplerParameteriv(d binary.Decoder, o *GlSamplerParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Sampler = SamplerId(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Param)
}
func (*binaryClassGlSamplerParameteriv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSamplerParameteriv(e, obj.(*GlSamplerParameteriv))
}
func (*binaryClassGlSamplerParameteriv) New() binary.Object {
	return &GlSamplerParameteriv{}
}
func (*binaryClassGlSamplerParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSamplerParameteriv(d, obj.(*GlSamplerParameteriv))
}
func (c *binaryClassGlSamplerParameteriv) Schema() *binary.Entity {
	return &entities[ixǁGlSamplerParameteriv]
}

type binaryClassGlScalef struct{}

func (*GlScalef) Class() binary.Class {
	return (*binaryClassGlScalef)(nil)
}
func doEncodeGlScalef(e binary.Encoder, o *GlScalef) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.X))
	e.Float32(float32(o.Y))
	e.Float32(float32(o.Z))
}
func doDecodeGlScalef(d binary.Decoder, o *GlScalef) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.Z = GLfloat(d.Float32())
}
func doDecodeRawGlScalef(d binary.Decoder, o *GlScalef) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.Z = GLfloat(d.Float32())
}
func (*binaryClassGlScalef) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlScalef(e, obj.(*GlScalef))
}
func (*binaryClassGlScalef) New() binary.Object {
	return &GlScalef{}
}
func (*binaryClassGlScalef) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlScalef(d, obj.(*GlScalef))
}
func (c *binaryClassGlScalef) Schema() *binary.Entity {
	return &entities[ixǁGlScalef]
}

type binaryClassGlScalex struct{}

func (*GlScalex) Class() binary.Class {
	return (*binaryClassGlScalex)(nil)
}
func doEncodeGlScalex(e binary.Encoder, o *GlScalex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Z))
}
func doDecodeGlScalex(d binary.Decoder, o *GlScalex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
}
func doDecodeRawGlScalex(d binary.Decoder, o *GlScalex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
}
func (*binaryClassGlScalex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlScalex(e, obj.(*GlScalex))
}
func (*binaryClassGlScalex) New() binary.Object {
	return &GlScalex{}
}
func (*binaryClassGlScalex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlScalex(d, obj.(*GlScalex))
}
func (c *binaryClassGlScalex) Schema() *binary.Entity {
	return &entities[ixǁGlScalex]
}

type binaryClassGlScalexOES struct{}

func (*GlScalexOES) Class() binary.Class {
	return (*binaryClassGlScalexOES)(nil)
}
func doEncodeGlScalexOES(e binary.Encoder, o *GlScalexOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Z))
}
func doDecodeGlScalexOES(d binary.Decoder, o *GlScalexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
}
func doDecodeRawGlScalexOES(d binary.Decoder, o *GlScalexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
}
func (*binaryClassGlScalexOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlScalexOES(e, obj.(*GlScalexOES))
}
func (*binaryClassGlScalexOES) New() binary.Object {
	return &GlScalexOES{}
}
func (*binaryClassGlScalexOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlScalexOES(d, obj.(*GlScalexOES))
}
func (c *binaryClassGlScalexOES) Schema() *binary.Entity {
	return &entities[ixǁGlScalexOES]
}

type binaryClassGlScissor struct{}

func (*GlScissor) Class() binary.Class {
	return (*binaryClassGlScissor)(nil)
}
func doEncodeGlScissor(e binary.Encoder, o *GlScissor) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlScissor(d binary.Decoder, o *GlScissor) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlScissor(d binary.Decoder, o *GlScissor) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlScissor) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlScissor(e, obj.(*GlScissor))
}
func (*binaryClassGlScissor) New() binary.Object {
	return &GlScissor{}
}
func (*binaryClassGlScissor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlScissor(d, obj.(*GlScissor))
}
func (c *binaryClassGlScissor) Schema() *binary.Entity {
	return &entities[ixǁGlScissor]
}

type binaryClassGlScissorArrayvNV struct{}

func (*GlScissorArrayvNV) Class() binary.Class {
	return (*binaryClassGlScissorArrayvNV)(nil)
}
func doEncodeGlScissorArrayvNV(e binary.Encoder, o *GlScissorArrayvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.First))
	e.Int32(int32(o.Count))
	e.Simple(&o.V)
}
func doDecodeGlScissorArrayvNV(d binary.Decoder, o *GlScissorArrayvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.First = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func doDecodeRawGlScissorArrayvNV(d binary.Decoder, o *GlScissorArrayvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.First = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func (*binaryClassGlScissorArrayvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlScissorArrayvNV(e, obj.(*GlScissorArrayvNV))
}
func (*binaryClassGlScissorArrayvNV) New() binary.Object {
	return &GlScissorArrayvNV{}
}
func (*binaryClassGlScissorArrayvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlScissorArrayvNV(d, obj.(*GlScissorArrayvNV))
}
func (c *binaryClassGlScissorArrayvNV) Schema() *binary.Entity {
	return &entities[ixǁGlScissorArrayvNV]
}

type binaryClassGlScissorIndexedNV struct{}

func (*GlScissorIndexedNV) Class() binary.Class {
	return (*binaryClassGlScissorIndexedNV)(nil)
}
func doEncodeGlScissorIndexedNV(e binary.Encoder, o *GlScissorIndexedNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Int32(int32(o.Left))
	e.Int32(int32(o.Bottom))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlScissorIndexedNV(d binary.Decoder, o *GlScissorIndexedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = GLuint(d.Uint32())
	o.Left = GLint(d.Int32())
	o.Bottom = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlScissorIndexedNV(d binary.Decoder, o *GlScissorIndexedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = GLuint(d.Uint32())
	o.Left = GLint(d.Int32())
	o.Bottom = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlScissorIndexedNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlScissorIndexedNV(e, obj.(*GlScissorIndexedNV))
}
func (*binaryClassGlScissorIndexedNV) New() binary.Object {
	return &GlScissorIndexedNV{}
}
func (*binaryClassGlScissorIndexedNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlScissorIndexedNV(d, obj.(*GlScissorIndexedNV))
}
func (c *binaryClassGlScissorIndexedNV) Schema() *binary.Entity {
	return &entities[ixǁGlScissorIndexedNV]
}

type binaryClassGlScissorIndexedvNV struct{}

func (*GlScissorIndexedvNV) Class() binary.Class {
	return (*binaryClassGlScissorIndexedvNV)(nil)
}
func doEncodeGlScissorIndexedvNV(e binary.Encoder, o *GlScissorIndexedvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Simple(&o.V)
}
func doDecodeGlScissorIndexedvNV(d binary.Decoder, o *GlScissorIndexedvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.V)
}
func doDecodeRawGlScissorIndexedvNV(d binary.Decoder, o *GlScissorIndexedvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.V)
}
func (*binaryClassGlScissorIndexedvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlScissorIndexedvNV(e, obj.(*GlScissorIndexedvNV))
}
func (*binaryClassGlScissorIndexedvNV) New() binary.Object {
	return &GlScissorIndexedvNV{}
}
func (*binaryClassGlScissorIndexedvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlScissorIndexedvNV(d, obj.(*GlScissorIndexedvNV))
}
func (c *binaryClassGlScissorIndexedvNV) Schema() *binary.Entity {
	return &entities[ixǁGlScissorIndexedvNV]
}

type binaryClassGlSelectPerfMonitorCountersAMD struct{}

func (*GlSelectPerfMonitorCountersAMD) Class() binary.Class {
	return (*binaryClassGlSelectPerfMonitorCountersAMD)(nil)
}
func doEncodeGlSelectPerfMonitorCountersAMD(e binary.Encoder, o *GlSelectPerfMonitorCountersAMD) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Monitor))
	e.Uint8(uint8(o.Enable))
	e.Uint32(uint32(o.Group))
	e.Int32(int32(o.NumCounters))
	e.Simple(&o.CounterList)
}
func doDecodeGlSelectPerfMonitorCountersAMD(d binary.Decoder, o *GlSelectPerfMonitorCountersAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Monitor = GLuint(d.Uint32())
	o.Enable = GLboolean(d.Uint8())
	o.Group = GLuint(d.Uint32())
	o.NumCounters = GLint(d.Int32())
	d.Simple(&o.CounterList)
}
func doDecodeRawGlSelectPerfMonitorCountersAMD(d binary.Decoder, o *GlSelectPerfMonitorCountersAMD) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Monitor = GLuint(d.Uint32())
	o.Enable = GLboolean(d.Uint8())
	o.Group = GLuint(d.Uint32())
	o.NumCounters = GLint(d.Int32())
	d.Simple(&o.CounterList)
}
func (*binaryClassGlSelectPerfMonitorCountersAMD) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSelectPerfMonitorCountersAMD(e, obj.(*GlSelectPerfMonitorCountersAMD))
}
func (*binaryClassGlSelectPerfMonitorCountersAMD) New() binary.Object {
	return &GlSelectPerfMonitorCountersAMD{}
}
func (*binaryClassGlSelectPerfMonitorCountersAMD) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSelectPerfMonitorCountersAMD(d, obj.(*GlSelectPerfMonitorCountersAMD))
}
func (c *binaryClassGlSelectPerfMonitorCountersAMD) Schema() *binary.Entity {
	return &entities[ixǁGlSelectPerfMonitorCountersAMD]
}

type binaryClassGlSetFenceNV struct{}

func (*GlSetFenceNV) Class() binary.Class {
	return (*binaryClassGlSetFenceNV)(nil)
}
func doEncodeGlSetFenceNV(e binary.Encoder, o *GlSetFenceNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Fence))
	e.Uint32(uint32(o.Condition))
}
func doDecodeGlSetFenceNV(d binary.Decoder, o *GlSetFenceNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Fence = GLuint(d.Uint32())
	o.Condition = GLenum(d.Uint32())
}
func doDecodeRawGlSetFenceNV(d binary.Decoder, o *GlSetFenceNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Fence = GLuint(d.Uint32())
	o.Condition = GLenum(d.Uint32())
}
func (*binaryClassGlSetFenceNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSetFenceNV(e, obj.(*GlSetFenceNV))
}
func (*binaryClassGlSetFenceNV) New() binary.Object {
	return &GlSetFenceNV{}
}
func (*binaryClassGlSetFenceNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSetFenceNV(d, obj.(*GlSetFenceNV))
}
func (c *binaryClassGlSetFenceNV) Schema() *binary.Entity {
	return &entities[ixǁGlSetFenceNV]
}

type binaryClassGlShadeModel struct{}

func (*GlShadeModel) Class() binary.Class {
	return (*binaryClassGlShadeModel)(nil)
}
func doEncodeGlShadeModel(e binary.Encoder, o *GlShadeModel) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mode))
}
func doDecodeGlShadeModel(d binary.Decoder, o *GlShadeModel) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
}
func doDecodeRawGlShadeModel(d binary.Decoder, o *GlShadeModel) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mode = GLenum(d.Uint32())
}
func (*binaryClassGlShadeModel) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlShadeModel(e, obj.(*GlShadeModel))
}
func (*binaryClassGlShadeModel) New() binary.Object {
	return &GlShadeModel{}
}
func (*binaryClassGlShadeModel) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlShadeModel(d, obj.(*GlShadeModel))
}
func (c *binaryClassGlShadeModel) Schema() *binary.Entity {
	return &entities[ixǁGlShadeModel]
}

type binaryClassShaderIdᶜᵖ struct{}

func (*ShaderIdᶜᵖ) Class() binary.Class {
	return (*binaryClassShaderIdᶜᵖ)(nil)
}
func doEncodeShaderIdᶜᵖ(e binary.Writer, o *ShaderIdᶜᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeShaderIdᶜᵖ(d binary.Reader, o *ShaderIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawShaderIdᶜᵖ(d binary.Reader, o *ShaderIdᶜᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassShaderIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeShaderIdᶜᵖ(e, obj.(*ShaderIdᶜᵖ))
}
func (*binaryClassShaderIdᶜᵖ) New() binary.Object {
	return &ShaderIdᶜᵖ{}
}
func (*binaryClassShaderIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeShaderIdᶜᵖ(d, obj.(*ShaderIdᶜᵖ))
}
func (o *ShaderIdᶜᵖ) WriteSimple(w binary.Writer) {
	doEncodeShaderIdᶜᵖ(w, o)
}
func (o *ShaderIdᶜᵖ) ReadSimple(r binary.Reader) {
	doDecodeShaderIdᶜᵖ(r, o)
}
func (c *binaryClassShaderIdᶜᵖ) Schema() *binary.Entity {
	return &entities[ixǁShaderIdᶜᵖ]
}

type binaryClassGlShaderBinary struct{}

func (*GlShaderBinary) Class() binary.Class {
	return (*binaryClassGlShaderBinary)(nil)
}
func doEncodeGlShaderBinary(e binary.Encoder, o *GlShaderBinary) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Count))
	e.Simple(&o.Shaders)
	e.Uint32(uint32(o.BinaryFormat))
	e.Simple(&o.Binary)
	e.Int32(int32(o.BinarySize))
}
func doDecodeGlShaderBinary(d binary.Decoder, o *GlShaderBinary) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Shaders)
	o.BinaryFormat = GLenum(d.Uint32())
	d.Simple(&o.Binary)
	o.BinarySize = GLsizei(d.Int32())
}
func doDecodeRawGlShaderBinary(d binary.Decoder, o *GlShaderBinary) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Shaders)
	o.BinaryFormat = GLenum(d.Uint32())
	d.Simple(&o.Binary)
	o.BinarySize = GLsizei(d.Int32())
}
func (*binaryClassGlShaderBinary) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlShaderBinary(e, obj.(*GlShaderBinary))
}
func (*binaryClassGlShaderBinary) New() binary.Object {
	return &GlShaderBinary{}
}
func (*binaryClassGlShaderBinary) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlShaderBinary(d, obj.(*GlShaderBinary))
}
func (c *binaryClassGlShaderBinary) Schema() *binary.Entity {
	return &entities[ixǁGlShaderBinary]
}

type binaryClassGlShaderSource struct{}

func (*GlShaderSource) Class() binary.Class {
	return (*binaryClassGlShaderSource)(nil)
}
func doEncodeGlShaderSource(e binary.Encoder, o *GlShaderSource) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Shader))
	e.Int32(int32(o.Count))
	e.Simple(&o.Source)
	e.Simple(&o.Length)
}
func doDecodeGlShaderSource(d binary.Decoder, o *GlShaderSource) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Source)
	d.Simple(&o.Length)
}
func doDecodeRawGlShaderSource(d binary.Decoder, o *GlShaderSource) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Shader = ShaderId(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Source)
	d.Simple(&o.Length)
}
func (*binaryClassGlShaderSource) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlShaderSource(e, obj.(*GlShaderSource))
}
func (*binaryClassGlShaderSource) New() binary.Object {
	return &GlShaderSource{}
}
func (*binaryClassGlShaderSource) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlShaderSource(d, obj.(*GlShaderSource))
}
func (c *binaryClassGlShaderSource) Schema() *binary.Entity {
	return &entities[ixǁGlShaderSource]
}

type binaryClassGlStartTilingQCOM struct{}

func (*GlStartTilingQCOM) Class() binary.Class {
	return (*binaryClassGlStartTilingQCOM)(nil)
}
func doEncodeGlStartTilingQCOM(e binary.Encoder, o *GlStartTilingQCOM) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.X))
	e.Uint32(uint32(o.Y))
	e.Uint32(uint32(o.Width))
	e.Uint32(uint32(o.Height))
	e.Uint32(uint32(o.PreserveMask))
}
func doDecodeGlStartTilingQCOM(d binary.Decoder, o *GlStartTilingQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLuint(d.Uint32())
	o.Y = GLuint(d.Uint32())
	o.Width = GLuint(d.Uint32())
	o.Height = GLuint(d.Uint32())
	o.PreserveMask = GLbitfield(d.Uint32())
}
func doDecodeRawGlStartTilingQCOM(d binary.Decoder, o *GlStartTilingQCOM) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLuint(d.Uint32())
	o.Y = GLuint(d.Uint32())
	o.Width = GLuint(d.Uint32())
	o.Height = GLuint(d.Uint32())
	o.PreserveMask = GLbitfield(d.Uint32())
}
func (*binaryClassGlStartTilingQCOM) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStartTilingQCOM(e, obj.(*GlStartTilingQCOM))
}
func (*binaryClassGlStartTilingQCOM) New() binary.Object {
	return &GlStartTilingQCOM{}
}
func (*binaryClassGlStartTilingQCOM) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStartTilingQCOM(d, obj.(*GlStartTilingQCOM))
}
func (c *binaryClassGlStartTilingQCOM) Schema() *binary.Entity {
	return &entities[ixǁGlStartTilingQCOM]
}

type binaryClassGlStencilFillPathInstancedNV struct{}

func (*GlStencilFillPathInstancedNV) Class() binary.Class {
	return (*binaryClassGlStencilFillPathInstancedNV)(nil)
}
func doEncodeGlStencilFillPathInstancedNV(e binary.Encoder, o *GlStencilFillPathInstancedNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.NumPaths))
	e.Uint32(uint32(o.PathNameType))
	e.Simple(&o.Paths)
	e.Uint32(uint32(o.PathBase))
	e.Uint32(uint32(o.FillMode))
	e.Uint32(uint32(o.Mask))
	e.Uint32(uint32(o.TransformType))
	e.Simple(&o.TransformValues)
}
func doDecodeGlStencilFillPathInstancedNV(d binary.Decoder, o *GlStencilFillPathInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.FillMode = GLenum(d.Uint32())
	o.Mask = GLuint(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func doDecodeRawGlStencilFillPathInstancedNV(d binary.Decoder, o *GlStencilFillPathInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.FillMode = GLenum(d.Uint32())
	o.Mask = GLuint(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func (*binaryClassGlStencilFillPathInstancedNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilFillPathInstancedNV(e, obj.(*GlStencilFillPathInstancedNV))
}
func (*binaryClassGlStencilFillPathInstancedNV) New() binary.Object {
	return &GlStencilFillPathInstancedNV{}
}
func (*binaryClassGlStencilFillPathInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilFillPathInstancedNV(d, obj.(*GlStencilFillPathInstancedNV))
}
func (c *binaryClassGlStencilFillPathInstancedNV) Schema() *binary.Entity {
	return &entities[ixǁGlStencilFillPathInstancedNV]
}

type binaryClassGlStencilFillPathNV struct{}

func (*GlStencilFillPathNV) Class() binary.Class {
	return (*binaryClassGlStencilFillPathNV)(nil)
}
func doEncodeGlStencilFillPathNV(e binary.Encoder, o *GlStencilFillPathNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint32(uint32(o.FillMode))
	e.Uint32(uint32(o.Mask))
}
func doDecodeGlStencilFillPathNV(d binary.Decoder, o *GlStencilFillPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.FillMode = GLenum(d.Uint32())
	o.Mask = GLuint(d.Uint32())
}
func doDecodeRawGlStencilFillPathNV(d binary.Decoder, o *GlStencilFillPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.FillMode = GLenum(d.Uint32())
	o.Mask = GLuint(d.Uint32())
}
func (*binaryClassGlStencilFillPathNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilFillPathNV(e, obj.(*GlStencilFillPathNV))
}
func (*binaryClassGlStencilFillPathNV) New() binary.Object {
	return &GlStencilFillPathNV{}
}
func (*binaryClassGlStencilFillPathNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilFillPathNV(d, obj.(*GlStencilFillPathNV))
}
func (c *binaryClassGlStencilFillPathNV) Schema() *binary.Entity {
	return &entities[ixǁGlStencilFillPathNV]
}

type binaryClassGlStencilFunc struct{}

func (*GlStencilFunc) Class() binary.Class {
	return (*binaryClassGlStencilFunc)(nil)
}
func doEncodeGlStencilFunc(e binary.Encoder, o *GlStencilFunc) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Func))
	e.Int32(int32(o.Ref))
	e.Uint32(uint32(o.Mask))
}
func doDecodeGlStencilFunc(d binary.Decoder, o *GlStencilFunc) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
	o.Ref = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
}
func doDecodeRawGlStencilFunc(d binary.Decoder, o *GlStencilFunc) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Func = GLenum(d.Uint32())
	o.Ref = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
}
func (*binaryClassGlStencilFunc) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilFunc(e, obj.(*GlStencilFunc))
}
func (*binaryClassGlStencilFunc) New() binary.Object {
	return &GlStencilFunc{}
}
func (*binaryClassGlStencilFunc) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilFunc(d, obj.(*GlStencilFunc))
}
func (c *binaryClassGlStencilFunc) Schema() *binary.Entity {
	return &entities[ixǁGlStencilFunc]
}

type binaryClassGlStencilFuncSeparate struct{}

func (*GlStencilFuncSeparate) Class() binary.Class {
	return (*binaryClassGlStencilFuncSeparate)(nil)
}
func doEncodeGlStencilFuncSeparate(e binary.Encoder, o *GlStencilFuncSeparate) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.Function))
	e.Int32(int32(o.ReferenceValue))
	e.Uint32(uint32(o.Mask))
}
func doDecodeGlStencilFuncSeparate(d binary.Decoder, o *GlStencilFuncSeparate) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Function = GLenum(d.Uint32())
	o.ReferenceValue = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
}
func doDecodeRawGlStencilFuncSeparate(d binary.Decoder, o *GlStencilFuncSeparate) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Function = GLenum(d.Uint32())
	o.ReferenceValue = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
}
func (*binaryClassGlStencilFuncSeparate) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilFuncSeparate(e, obj.(*GlStencilFuncSeparate))
}
func (*binaryClassGlStencilFuncSeparate) New() binary.Object {
	return &GlStencilFuncSeparate{}
}
func (*binaryClassGlStencilFuncSeparate) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilFuncSeparate(d, obj.(*GlStencilFuncSeparate))
}
func (c *binaryClassGlStencilFuncSeparate) Schema() *binary.Entity {
	return &entities[ixǁGlStencilFuncSeparate]
}

type binaryClassGlStencilMask struct{}

func (*GlStencilMask) Class() binary.Class {
	return (*binaryClassGlStencilMask)(nil)
}
func doEncodeGlStencilMask(e binary.Encoder, o *GlStencilMask) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Mask))
}
func doDecodeGlStencilMask(d binary.Decoder, o *GlStencilMask) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mask = GLuint(d.Uint32())
}
func doDecodeRawGlStencilMask(d binary.Decoder, o *GlStencilMask) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Mask = GLuint(d.Uint32())
}
func (*binaryClassGlStencilMask) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilMask(e, obj.(*GlStencilMask))
}
func (*binaryClassGlStencilMask) New() binary.Object {
	return &GlStencilMask{}
}
func (*binaryClassGlStencilMask) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilMask(d, obj.(*GlStencilMask))
}
func (c *binaryClassGlStencilMask) Schema() *binary.Entity {
	return &entities[ixǁGlStencilMask]
}

type binaryClassGlStencilMaskSeparate struct{}

func (*GlStencilMaskSeparate) Class() binary.Class {
	return (*binaryClassGlStencilMaskSeparate)(nil)
}
func doEncodeGlStencilMaskSeparate(e binary.Encoder, o *GlStencilMaskSeparate) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.Mask))
}
func doDecodeGlStencilMaskSeparate(d binary.Decoder, o *GlStencilMaskSeparate) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Mask = GLuint(d.Uint32())
}
func doDecodeRawGlStencilMaskSeparate(d binary.Decoder, o *GlStencilMaskSeparate) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.Mask = GLuint(d.Uint32())
}
func (*binaryClassGlStencilMaskSeparate) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilMaskSeparate(e, obj.(*GlStencilMaskSeparate))
}
func (*binaryClassGlStencilMaskSeparate) New() binary.Object {
	return &GlStencilMaskSeparate{}
}
func (*binaryClassGlStencilMaskSeparate) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilMaskSeparate(d, obj.(*GlStencilMaskSeparate))
}
func (c *binaryClassGlStencilMaskSeparate) Schema() *binary.Entity {
	return &entities[ixǁGlStencilMaskSeparate]
}

type binaryClassGlStencilOp struct{}

func (*GlStencilOp) Class() binary.Class {
	return (*binaryClassGlStencilOp)(nil)
}
func doEncodeGlStencilOp(e binary.Encoder, o *GlStencilOp) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Fail))
	e.Uint32(uint32(o.Zfail))
	e.Uint32(uint32(o.Zpass))
}
func doDecodeGlStencilOp(d binary.Decoder, o *GlStencilOp) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Fail = GLenum(d.Uint32())
	o.Zfail = GLenum(d.Uint32())
	o.Zpass = GLenum(d.Uint32())
}
func doDecodeRawGlStencilOp(d binary.Decoder, o *GlStencilOp) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Fail = GLenum(d.Uint32())
	o.Zfail = GLenum(d.Uint32())
	o.Zpass = GLenum(d.Uint32())
}
func (*binaryClassGlStencilOp) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilOp(e, obj.(*GlStencilOp))
}
func (*binaryClassGlStencilOp) New() binary.Object {
	return &GlStencilOp{}
}
func (*binaryClassGlStencilOp) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilOp(d, obj.(*GlStencilOp))
}
func (c *binaryClassGlStencilOp) Schema() *binary.Entity {
	return &entities[ixǁGlStencilOp]
}

type binaryClassGlStencilOpSeparate struct{}

func (*GlStencilOpSeparate) Class() binary.Class {
	return (*binaryClassGlStencilOpSeparate)(nil)
}
func doEncodeGlStencilOpSeparate(e binary.Encoder, o *GlStencilOpSeparate) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Face))
	e.Uint32(uint32(o.StencilFail))
	e.Uint32(uint32(o.StencilPassDepthFail))
	e.Uint32(uint32(o.StencilPassDepthPass))
}
func doDecodeGlStencilOpSeparate(d binary.Decoder, o *GlStencilOpSeparate) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.StencilFail = GLenum(d.Uint32())
	o.StencilPassDepthFail = GLenum(d.Uint32())
	o.StencilPassDepthPass = GLenum(d.Uint32())
}
func doDecodeRawGlStencilOpSeparate(d binary.Decoder, o *GlStencilOpSeparate) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Face = GLenum(d.Uint32())
	o.StencilFail = GLenum(d.Uint32())
	o.StencilPassDepthFail = GLenum(d.Uint32())
	o.StencilPassDepthPass = GLenum(d.Uint32())
}
func (*binaryClassGlStencilOpSeparate) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilOpSeparate(e, obj.(*GlStencilOpSeparate))
}
func (*binaryClassGlStencilOpSeparate) New() binary.Object {
	return &GlStencilOpSeparate{}
}
func (*binaryClassGlStencilOpSeparate) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilOpSeparate(d, obj.(*GlStencilOpSeparate))
}
func (c *binaryClassGlStencilOpSeparate) Schema() *binary.Entity {
	return &entities[ixǁGlStencilOpSeparate]
}

type binaryClassGlStencilStrokePathInstancedNV struct{}

func (*GlStencilStrokePathInstancedNV) Class() binary.Class {
	return (*binaryClassGlStencilStrokePathInstancedNV)(nil)
}
func doEncodeGlStencilStrokePathInstancedNV(e binary.Encoder, o *GlStencilStrokePathInstancedNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.NumPaths))
	e.Uint32(uint32(o.PathNameType))
	e.Simple(&o.Paths)
	e.Uint32(uint32(o.PathBase))
	e.Int32(int32(o.Reference))
	e.Uint32(uint32(o.Mask))
	e.Uint32(uint32(o.TransformType))
	e.Simple(&o.TransformValues)
}
func doDecodeGlStencilStrokePathInstancedNV(d binary.Decoder, o *GlStencilStrokePathInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.Reference = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func doDecodeRawGlStencilStrokePathInstancedNV(d binary.Decoder, o *GlStencilStrokePathInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.Reference = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func (*binaryClassGlStencilStrokePathInstancedNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilStrokePathInstancedNV(e, obj.(*GlStencilStrokePathInstancedNV))
}
func (*binaryClassGlStencilStrokePathInstancedNV) New() binary.Object {
	return &GlStencilStrokePathInstancedNV{}
}
func (*binaryClassGlStencilStrokePathInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilStrokePathInstancedNV(d, obj.(*GlStencilStrokePathInstancedNV))
}
func (c *binaryClassGlStencilStrokePathInstancedNV) Schema() *binary.Entity {
	return &entities[ixǁGlStencilStrokePathInstancedNV]
}

type binaryClassGlStencilStrokePathNV struct{}

func (*GlStencilStrokePathNV) Class() binary.Class {
	return (*binaryClassGlStencilStrokePathNV)(nil)
}
func doEncodeGlStencilStrokePathNV(e binary.Encoder, o *GlStencilStrokePathNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Int32(int32(o.Reference))
	e.Uint32(uint32(o.Mask))
}
func doDecodeGlStencilStrokePathNV(d binary.Decoder, o *GlStencilStrokePathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Reference = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
}
func doDecodeRawGlStencilStrokePathNV(d binary.Decoder, o *GlStencilStrokePathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Reference = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
}
func (*binaryClassGlStencilStrokePathNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilStrokePathNV(e, obj.(*GlStencilStrokePathNV))
}
func (*binaryClassGlStencilStrokePathNV) New() binary.Object {
	return &GlStencilStrokePathNV{}
}
func (*binaryClassGlStencilStrokePathNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilStrokePathNV(d, obj.(*GlStencilStrokePathNV))
}
func (c *binaryClassGlStencilStrokePathNV) Schema() *binary.Entity {
	return &entities[ixǁGlStencilStrokePathNV]
}

type binaryClassGlStencilThenCoverFillPathInstancedNV struct{}

func (*GlStencilThenCoverFillPathInstancedNV) Class() binary.Class {
	return (*binaryClassGlStencilThenCoverFillPathInstancedNV)(nil)
}
func doEncodeGlStencilThenCoverFillPathInstancedNV(e binary.Encoder, o *GlStencilThenCoverFillPathInstancedNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.NumPaths))
	e.Uint32(uint32(o.PathNameType))
	e.Simple(&o.Paths)
	e.Uint32(uint32(o.PathBase))
	e.Uint32(uint32(o.FillMode))
	e.Uint32(uint32(o.Mask))
	e.Uint32(uint32(o.CoverMode))
	e.Uint32(uint32(o.TransformType))
	e.Simple(&o.TransformValues)
}
func doDecodeGlStencilThenCoverFillPathInstancedNV(d binary.Decoder, o *GlStencilThenCoverFillPathInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.FillMode = GLenum(d.Uint32())
	o.Mask = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func doDecodeRawGlStencilThenCoverFillPathInstancedNV(d binary.Decoder, o *GlStencilThenCoverFillPathInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.FillMode = GLenum(d.Uint32())
	o.Mask = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func (*binaryClassGlStencilThenCoverFillPathInstancedNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilThenCoverFillPathInstancedNV(e, obj.(*GlStencilThenCoverFillPathInstancedNV))
}
func (*binaryClassGlStencilThenCoverFillPathInstancedNV) New() binary.Object {
	return &GlStencilThenCoverFillPathInstancedNV{}
}
func (*binaryClassGlStencilThenCoverFillPathInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilThenCoverFillPathInstancedNV(d, obj.(*GlStencilThenCoverFillPathInstancedNV))
}
func (c *binaryClassGlStencilThenCoverFillPathInstancedNV) Schema() *binary.Entity {
	return &entities[ixǁGlStencilThenCoverFillPathInstancedNV]
}

type binaryClassGlStencilThenCoverFillPathNV struct{}

func (*GlStencilThenCoverFillPathNV) Class() binary.Class {
	return (*binaryClassGlStencilThenCoverFillPathNV)(nil)
}
func doEncodeGlStencilThenCoverFillPathNV(e binary.Encoder, o *GlStencilThenCoverFillPathNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Uint32(uint32(o.FillMode))
	e.Uint32(uint32(o.Mask))
	e.Uint32(uint32(o.CoverMode))
}
func doDecodeGlStencilThenCoverFillPathNV(d binary.Decoder, o *GlStencilThenCoverFillPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.FillMode = GLenum(d.Uint32())
	o.Mask = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
}
func doDecodeRawGlStencilThenCoverFillPathNV(d binary.Decoder, o *GlStencilThenCoverFillPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.FillMode = GLenum(d.Uint32())
	o.Mask = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
}
func (*binaryClassGlStencilThenCoverFillPathNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilThenCoverFillPathNV(e, obj.(*GlStencilThenCoverFillPathNV))
}
func (*binaryClassGlStencilThenCoverFillPathNV) New() binary.Object {
	return &GlStencilThenCoverFillPathNV{}
}
func (*binaryClassGlStencilThenCoverFillPathNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilThenCoverFillPathNV(d, obj.(*GlStencilThenCoverFillPathNV))
}
func (c *binaryClassGlStencilThenCoverFillPathNV) Schema() *binary.Entity {
	return &entities[ixǁGlStencilThenCoverFillPathNV]
}

type binaryClassGlStencilThenCoverStrokePathInstancedNV struct{}

func (*GlStencilThenCoverStrokePathInstancedNV) Class() binary.Class {
	return (*binaryClassGlStencilThenCoverStrokePathInstancedNV)(nil)
}
func doEncodeGlStencilThenCoverStrokePathInstancedNV(e binary.Encoder, o *GlStencilThenCoverStrokePathInstancedNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.NumPaths))
	e.Uint32(uint32(o.PathNameType))
	e.Simple(&o.Paths)
	e.Uint32(uint32(o.PathBase))
	e.Int32(int32(o.Reference))
	e.Uint32(uint32(o.Mask))
	e.Uint32(uint32(o.CoverMode))
	e.Uint32(uint32(o.TransformType))
	e.Simple(&o.TransformValues)
}
func doDecodeGlStencilThenCoverStrokePathInstancedNV(d binary.Decoder, o *GlStencilThenCoverStrokePathInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.Reference = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func doDecodeRawGlStencilThenCoverStrokePathInstancedNV(d binary.Decoder, o *GlStencilThenCoverStrokePathInstancedNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.NumPaths = GLsizei(d.Int32())
	o.PathNameType = GLenum(d.Uint32())
	d.Simple(&o.Paths)
	o.PathBase = GLuint(d.Uint32())
	o.Reference = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func (*binaryClassGlStencilThenCoverStrokePathInstancedNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilThenCoverStrokePathInstancedNV(e, obj.(*GlStencilThenCoverStrokePathInstancedNV))
}
func (*binaryClassGlStencilThenCoverStrokePathInstancedNV) New() binary.Object {
	return &GlStencilThenCoverStrokePathInstancedNV{}
}
func (*binaryClassGlStencilThenCoverStrokePathInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilThenCoverStrokePathInstancedNV(d, obj.(*GlStencilThenCoverStrokePathInstancedNV))
}
func (c *binaryClassGlStencilThenCoverStrokePathInstancedNV) Schema() *binary.Entity {
	return &entities[ixǁGlStencilThenCoverStrokePathInstancedNV]
}

type binaryClassGlStencilThenCoverStrokePathNV struct{}

func (*GlStencilThenCoverStrokePathNV) Class() binary.Class {
	return (*binaryClassGlStencilThenCoverStrokePathNV)(nil)
}
func doEncodeGlStencilThenCoverStrokePathNV(e binary.Encoder, o *GlStencilThenCoverStrokePathNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Path))
	e.Int32(int32(o.Reference))
	e.Uint32(uint32(o.Mask))
	e.Uint32(uint32(o.CoverMode))
}
func doDecodeGlStencilThenCoverStrokePathNV(d binary.Decoder, o *GlStencilThenCoverStrokePathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Reference = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
}
func doDecodeRawGlStencilThenCoverStrokePathNV(d binary.Decoder, o *GlStencilThenCoverStrokePathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Path = GLuint(d.Uint32())
	o.Reference = GLint(d.Int32())
	o.Mask = GLuint(d.Uint32())
	o.CoverMode = GLenum(d.Uint32())
}
func (*binaryClassGlStencilThenCoverStrokePathNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlStencilThenCoverStrokePathNV(e, obj.(*GlStencilThenCoverStrokePathNV))
}
func (*binaryClassGlStencilThenCoverStrokePathNV) New() binary.Object {
	return &GlStencilThenCoverStrokePathNV{}
}
func (*binaryClassGlStencilThenCoverStrokePathNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlStencilThenCoverStrokePathNV(d, obj.(*GlStencilThenCoverStrokePathNV))
}
func (c *binaryClassGlStencilThenCoverStrokePathNV) Schema() *binary.Entity {
	return &entities[ixǁGlStencilThenCoverStrokePathNV]
}

type binaryClassGlSubpixelPrecisionBiasNV struct{}

func (*GlSubpixelPrecisionBiasNV) Class() binary.Class {
	return (*binaryClassGlSubpixelPrecisionBiasNV)(nil)
}
func doEncodeGlSubpixelPrecisionBiasNV(e binary.Encoder, o *GlSubpixelPrecisionBiasNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Xbits))
	e.Uint32(uint32(o.Ybits))
}
func doDecodeGlSubpixelPrecisionBiasNV(d binary.Decoder, o *GlSubpixelPrecisionBiasNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Xbits = GLuint(d.Uint32())
	o.Ybits = GLuint(d.Uint32())
}
func doDecodeRawGlSubpixelPrecisionBiasNV(d binary.Decoder, o *GlSubpixelPrecisionBiasNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Xbits = GLuint(d.Uint32())
	o.Ybits = GLuint(d.Uint32())
}
func (*binaryClassGlSubpixelPrecisionBiasNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlSubpixelPrecisionBiasNV(e, obj.(*GlSubpixelPrecisionBiasNV))
}
func (*binaryClassGlSubpixelPrecisionBiasNV) New() binary.Object {
	return &GlSubpixelPrecisionBiasNV{}
}
func (*binaryClassGlSubpixelPrecisionBiasNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlSubpixelPrecisionBiasNV(d, obj.(*GlSubpixelPrecisionBiasNV))
}
func (c *binaryClassGlSubpixelPrecisionBiasNV) Schema() *binary.Entity {
	return &entities[ixǁGlSubpixelPrecisionBiasNV]
}

type binaryClassGlTestFenceNV struct{}

func (*GlTestFenceNV) Class() binary.Class {
	return (*binaryClassGlTestFenceNV)(nil)
}
func doEncodeGlTestFenceNV(e binary.Encoder, o *GlTestFenceNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Fence))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlTestFenceNV(d binary.Decoder, o *GlTestFenceNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Fence = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlTestFenceNV(d binary.Decoder, o *GlTestFenceNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Fence = GLuint(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlTestFenceNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTestFenceNV(e, obj.(*GlTestFenceNV))
}
func (*binaryClassGlTestFenceNV) New() binary.Object {
	return &GlTestFenceNV{}
}
func (*binaryClassGlTestFenceNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTestFenceNV(d, obj.(*GlTestFenceNV))
}
func (c *binaryClassGlTestFenceNV) Schema() *binary.Entity {
	return &entities[ixǁGlTestFenceNV]
}

type binaryClassGlTexBuffer struct{}

func (*GlTexBuffer) Class() binary.Class {
	return (*binaryClassGlTexBuffer)(nil)
}
func doEncodeGlTexBuffer(e binary.Encoder, o *GlTexBuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Internalformat))
	e.Uint32(uint32(o.Buffer))
}
func doDecodeGlTexBuffer(d binary.Decoder, o *GlTexBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
}
func doDecodeRawGlTexBuffer(d binary.Decoder, o *GlTexBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
}
func (*binaryClassGlTexBuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexBuffer(e, obj.(*GlTexBuffer))
}
func (*binaryClassGlTexBuffer) New() binary.Object {
	return &GlTexBuffer{}
}
func (*binaryClassGlTexBuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexBuffer(d, obj.(*GlTexBuffer))
}
func (c *binaryClassGlTexBuffer) Schema() *binary.Entity {
	return &entities[ixǁGlTexBuffer]
}

type binaryClassGlTexBufferEXT struct{}

func (*GlTexBufferEXT) Class() binary.Class {
	return (*binaryClassGlTexBufferEXT)(nil)
}
func doEncodeGlTexBufferEXT(e binary.Encoder, o *GlTexBufferEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Internalformat))
	e.Uint32(uint32(o.Buffer))
}
func doDecodeGlTexBufferEXT(d binary.Decoder, o *GlTexBufferEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
}
func doDecodeRawGlTexBufferEXT(d binary.Decoder, o *GlTexBufferEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
}
func (*binaryClassGlTexBufferEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexBufferEXT(e, obj.(*GlTexBufferEXT))
}
func (*binaryClassGlTexBufferEXT) New() binary.Object {
	return &GlTexBufferEXT{}
}
func (*binaryClassGlTexBufferEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexBufferEXT(d, obj.(*GlTexBufferEXT))
}
func (c *binaryClassGlTexBufferEXT) Schema() *binary.Entity {
	return &entities[ixǁGlTexBufferEXT]
}

type binaryClassGlTexBufferOES struct{}

func (*GlTexBufferOES) Class() binary.Class {
	return (*binaryClassGlTexBufferOES)(nil)
}
func doEncodeGlTexBufferOES(e binary.Encoder, o *GlTexBufferOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Internalformat))
	e.Uint32(uint32(o.Buffer))
}
func doDecodeGlTexBufferOES(d binary.Decoder, o *GlTexBufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
}
func doDecodeRawGlTexBufferOES(d binary.Decoder, o *GlTexBufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
}
func (*binaryClassGlTexBufferOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexBufferOES(e, obj.(*GlTexBufferOES))
}
func (*binaryClassGlTexBufferOES) New() binary.Object {
	return &GlTexBufferOES{}
}
func (*binaryClassGlTexBufferOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexBufferOES(d, obj.(*GlTexBufferOES))
}
func (c *binaryClassGlTexBufferOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexBufferOES]
}

type binaryClassGlTexBufferRange struct{}

func (*GlTexBufferRange) Class() binary.Class {
	return (*binaryClassGlTexBufferRange)(nil)
}
func doEncodeGlTexBufferRange(e binary.Encoder, o *GlTexBufferRange) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Internalformat))
	e.Uint32(uint32(o.Buffer))
	e.Int32(int32(o.Offset))
	e.Int32(int32(o.Size))
}
func doDecodeGlTexBufferRange(d binary.Decoder, o *GlTexBufferRange) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func doDecodeRawGlTexBufferRange(d binary.Decoder, o *GlTexBufferRange) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func (*binaryClassGlTexBufferRange) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexBufferRange(e, obj.(*GlTexBufferRange))
}
func (*binaryClassGlTexBufferRange) New() binary.Object {
	return &GlTexBufferRange{}
}
func (*binaryClassGlTexBufferRange) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexBufferRange(d, obj.(*GlTexBufferRange))
}
func (c *binaryClassGlTexBufferRange) Schema() *binary.Entity {
	return &entities[ixǁGlTexBufferRange]
}

type binaryClassGlTexBufferRangeEXT struct{}

func (*GlTexBufferRangeEXT) Class() binary.Class {
	return (*binaryClassGlTexBufferRangeEXT)(nil)
}
func doEncodeGlTexBufferRangeEXT(e binary.Encoder, o *GlTexBufferRangeEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Internalformat))
	e.Uint32(uint32(o.Buffer))
	e.Int32(int32(o.Offset))
	e.Int32(int32(o.Size))
}
func doDecodeGlTexBufferRangeEXT(d binary.Decoder, o *GlTexBufferRangeEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func doDecodeRawGlTexBufferRangeEXT(d binary.Decoder, o *GlTexBufferRangeEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func (*binaryClassGlTexBufferRangeEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexBufferRangeEXT(e, obj.(*GlTexBufferRangeEXT))
}
func (*binaryClassGlTexBufferRangeEXT) New() binary.Object {
	return &GlTexBufferRangeEXT{}
}
func (*binaryClassGlTexBufferRangeEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexBufferRangeEXT(d, obj.(*GlTexBufferRangeEXT))
}
func (c *binaryClassGlTexBufferRangeEXT) Schema() *binary.Entity {
	return &entities[ixǁGlTexBufferRangeEXT]
}

type binaryClassGlTexBufferRangeOES struct{}

func (*GlTexBufferRangeOES) Class() binary.Class {
	return (*binaryClassGlTexBufferRangeOES)(nil)
}
func doEncodeGlTexBufferRangeOES(e binary.Encoder, o *GlTexBufferRangeOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Internalformat))
	e.Uint32(uint32(o.Buffer))
	e.Int32(int32(o.Offset))
	e.Int32(int32(o.Size))
}
func doDecodeGlTexBufferRangeOES(d binary.Decoder, o *GlTexBufferRangeOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func doDecodeRawGlTexBufferRangeOES(d binary.Decoder, o *GlTexBufferRangeOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Buffer = BufferId(d.Uint32())
	o.Offset = GLintptr(d.Int32())
	o.Size = GLsizeiptr(d.Int32())
}
func (*binaryClassGlTexBufferRangeOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexBufferRangeOES(e, obj.(*GlTexBufferRangeOES))
}
func (*binaryClassGlTexBufferRangeOES) New() binary.Object {
	return &GlTexBufferRangeOES{}
}
func (*binaryClassGlTexBufferRangeOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexBufferRangeOES(d, obj.(*GlTexBufferRangeOES))
}
func (c *binaryClassGlTexBufferRangeOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexBufferRangeOES]
}

type binaryClassGlTexCoordPointer struct{}

func (*GlTexCoordPointer) Class() binary.Class {
	return (*binaryClassGlTexCoordPointer)(nil)
}
func doEncodeGlTexCoordPointer(e binary.Encoder, o *GlTexCoordPointer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
}
func doDecodeGlTexCoordPointer(d binary.Decoder, o *GlTexCoordPointer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func doDecodeRawGlTexCoordPointer(d binary.Decoder, o *GlTexCoordPointer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func (*binaryClassGlTexCoordPointer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexCoordPointer(e, obj.(*GlTexCoordPointer))
}
func (*binaryClassGlTexCoordPointer) New() binary.Object {
	return &GlTexCoordPointer{}
}
func (*binaryClassGlTexCoordPointer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexCoordPointer(d, obj.(*GlTexCoordPointer))
}
func (c *binaryClassGlTexCoordPointer) Schema() *binary.Entity {
	return &entities[ixǁGlTexCoordPointer]
}

type binaryClassGlTexCoordPointerBounds struct{}

func (*GlTexCoordPointerBounds) Class() binary.Class {
	return (*binaryClassGlTexCoordPointerBounds)(nil)
}
func doEncodeGlTexCoordPointerBounds(e binary.Encoder, o *GlTexCoordPointerBounds) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
	e.Int32(int32(o.Count))
}
func doDecodeGlTexCoordPointerBounds(d binary.Decoder, o *GlTexCoordPointerBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func doDecodeRawGlTexCoordPointerBounds(d binary.Decoder, o *GlTexCoordPointerBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func (*binaryClassGlTexCoordPointerBounds) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexCoordPointerBounds(e, obj.(*GlTexCoordPointerBounds))
}
func (*binaryClassGlTexCoordPointerBounds) New() binary.Object {
	return &GlTexCoordPointerBounds{}
}
func (*binaryClassGlTexCoordPointerBounds) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexCoordPointerBounds(d, obj.(*GlTexCoordPointerBounds))
}
func (c *binaryClassGlTexCoordPointerBounds) Schema() *binary.Entity {
	return &entities[ixǁGlTexCoordPointerBounds]
}

type binaryClassGlTexEnvf struct{}

func (*GlTexEnvf) Class() binary.Class {
	return (*binaryClassGlTexEnvf)(nil)
}
func doEncodeGlTexEnvf(e binary.Encoder, o *GlTexEnvf) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Float32(float32(o.Param))
}
func doDecodeGlTexEnvf(d binary.Decoder, o *GlTexEnvf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func doDecodeRawGlTexEnvf(d binary.Decoder, o *GlTexEnvf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func (*binaryClassGlTexEnvf) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexEnvf(e, obj.(*GlTexEnvf))
}
func (*binaryClassGlTexEnvf) New() binary.Object {
	return &GlTexEnvf{}
}
func (*binaryClassGlTexEnvf) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexEnvf(d, obj.(*GlTexEnvf))
}
func (c *binaryClassGlTexEnvf) Schema() *binary.Entity {
	return &entities[ixǁGlTexEnvf]
}

type binaryClassGlTexEnvfv struct{}

func (*GlTexEnvfv) Class() binary.Class {
	return (*binaryClassGlTexEnvfv)(nil)
}
func doEncodeGlTexEnvfv(e binary.Encoder, o *GlTexEnvfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexEnvfv(d binary.Decoder, o *GlTexEnvfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexEnvfv(d binary.Decoder, o *GlTexEnvfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexEnvfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexEnvfv(e, obj.(*GlTexEnvfv))
}
func (*binaryClassGlTexEnvfv) New() binary.Object {
	return &GlTexEnvfv{}
}
func (*binaryClassGlTexEnvfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexEnvfv(d, obj.(*GlTexEnvfv))
}
func (c *binaryClassGlTexEnvfv) Schema() *binary.Entity {
	return &entities[ixǁGlTexEnvfv]
}

type binaryClassGlTexEnvi struct{}

func (*GlTexEnvi) Class() binary.Class {
	return (*binaryClassGlTexEnvi)(nil)
}
func doEncodeGlTexEnvi(e binary.Encoder, o *GlTexEnvi) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlTexEnvi(d binary.Decoder, o *GlTexEnvi) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLint(d.Int32())
}
func doDecodeRawGlTexEnvi(d binary.Decoder, o *GlTexEnvi) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLint(d.Int32())
}
func (*binaryClassGlTexEnvi) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexEnvi(e, obj.(*GlTexEnvi))
}
func (*binaryClassGlTexEnvi) New() binary.Object {
	return &GlTexEnvi{}
}
func (*binaryClassGlTexEnvi) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexEnvi(d, obj.(*GlTexEnvi))
}
func (c *binaryClassGlTexEnvi) Schema() *binary.Entity {
	return &entities[ixǁGlTexEnvi]
}

type binaryClassGlTexEnviv struct{}

func (*GlTexEnviv) Class() binary.Class {
	return (*binaryClassGlTexEnviv)(nil)
}
func doEncodeGlTexEnviv(e binary.Encoder, o *GlTexEnviv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexEnviv(d binary.Decoder, o *GlTexEnviv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexEnviv(d binary.Decoder, o *GlTexEnviv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexEnviv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexEnviv(e, obj.(*GlTexEnviv))
}
func (*binaryClassGlTexEnviv) New() binary.Object {
	return &GlTexEnviv{}
}
func (*binaryClassGlTexEnviv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexEnviv(d, obj.(*GlTexEnviv))
}
func (c *binaryClassGlTexEnviv) Schema() *binary.Entity {
	return &entities[ixǁGlTexEnviv]
}

type binaryClassGlTexEnvx struct{}

func (*GlTexEnvx) Class() binary.Class {
	return (*binaryClassGlTexEnvx)(nil)
}
func doEncodeGlTexEnvx(e binary.Encoder, o *GlTexEnvx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlTexEnvx(d binary.Decoder, o *GlTexEnvx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlTexEnvx(d binary.Decoder, o *GlTexEnvx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlTexEnvx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexEnvx(e, obj.(*GlTexEnvx))
}
func (*binaryClassGlTexEnvx) New() binary.Object {
	return &GlTexEnvx{}
}
func (*binaryClassGlTexEnvx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexEnvx(d, obj.(*GlTexEnvx))
}
func (c *binaryClassGlTexEnvx) Schema() *binary.Entity {
	return &entities[ixǁGlTexEnvx]
}

type binaryClassGlTexEnvxOES struct{}

func (*GlTexEnvxOES) Class() binary.Class {
	return (*binaryClassGlTexEnvxOES)(nil)
}
func doEncodeGlTexEnvxOES(e binary.Encoder, o *GlTexEnvxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlTexEnvxOES(d binary.Decoder, o *GlTexEnvxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlTexEnvxOES(d binary.Decoder, o *GlTexEnvxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlTexEnvxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexEnvxOES(e, obj.(*GlTexEnvxOES))
}
func (*binaryClassGlTexEnvxOES) New() binary.Object {
	return &GlTexEnvxOES{}
}
func (*binaryClassGlTexEnvxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexEnvxOES(d, obj.(*GlTexEnvxOES))
}
func (c *binaryClassGlTexEnvxOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexEnvxOES]
}

type binaryClassGlTexEnvxv struct{}

func (*GlTexEnvxv) Class() binary.Class {
	return (*binaryClassGlTexEnvxv)(nil)
}
func doEncodeGlTexEnvxv(e binary.Encoder, o *GlTexEnvxv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexEnvxv(d binary.Decoder, o *GlTexEnvxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexEnvxv(d binary.Decoder, o *GlTexEnvxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexEnvxv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexEnvxv(e, obj.(*GlTexEnvxv))
}
func (*binaryClassGlTexEnvxv) New() binary.Object {
	return &GlTexEnvxv{}
}
func (*binaryClassGlTexEnvxv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexEnvxv(d, obj.(*GlTexEnvxv))
}
func (c *binaryClassGlTexEnvxv) Schema() *binary.Entity {
	return &entities[ixǁGlTexEnvxv]
}

type binaryClassGlTexEnvxvOES struct{}

func (*GlTexEnvxvOES) Class() binary.Class {
	return (*binaryClassGlTexEnvxvOES)(nil)
}
func doEncodeGlTexEnvxvOES(e binary.Encoder, o *GlTexEnvxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexEnvxvOES(d binary.Decoder, o *GlTexEnvxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexEnvxvOES(d binary.Decoder, o *GlTexEnvxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexEnvxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexEnvxvOES(e, obj.(*GlTexEnvxvOES))
}
func (*binaryClassGlTexEnvxvOES) New() binary.Object {
	return &GlTexEnvxvOES{}
}
func (*binaryClassGlTexEnvxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexEnvxvOES(d, obj.(*GlTexEnvxvOES))
}
func (c *binaryClassGlTexEnvxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexEnvxvOES]
}

type binaryClassGlTexGenfOES struct{}

func (*GlTexGenfOES) Class() binary.Class {
	return (*binaryClassGlTexGenfOES)(nil)
}
func doEncodeGlTexGenfOES(e binary.Encoder, o *GlTexGenfOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Coord))
	e.Uint32(uint32(o.Pname))
	e.Float32(float32(o.Param))
}
func doDecodeGlTexGenfOES(d binary.Decoder, o *GlTexGenfOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func doDecodeRawGlTexGenfOES(d binary.Decoder, o *GlTexGenfOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfloat(d.Float32())
}
func (*binaryClassGlTexGenfOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexGenfOES(e, obj.(*GlTexGenfOES))
}
func (*binaryClassGlTexGenfOES) New() binary.Object {
	return &GlTexGenfOES{}
}
func (*binaryClassGlTexGenfOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexGenfOES(d, obj.(*GlTexGenfOES))
}
func (c *binaryClassGlTexGenfOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexGenfOES]
}

type binaryClassGlTexGenfvOES struct{}

func (*GlTexGenfvOES) Class() binary.Class {
	return (*binaryClassGlTexGenfvOES)(nil)
}
func doEncodeGlTexGenfvOES(e binary.Encoder, o *GlTexGenfvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Coord))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexGenfvOES(d binary.Decoder, o *GlTexGenfvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexGenfvOES(d binary.Decoder, o *GlTexGenfvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexGenfvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexGenfvOES(e, obj.(*GlTexGenfvOES))
}
func (*binaryClassGlTexGenfvOES) New() binary.Object {
	return &GlTexGenfvOES{}
}
func (*binaryClassGlTexGenfvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexGenfvOES(d, obj.(*GlTexGenfvOES))
}
func (c *binaryClassGlTexGenfvOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexGenfvOES]
}

type binaryClassGlTexGeniOES struct{}

func (*GlTexGeniOES) Class() binary.Class {
	return (*binaryClassGlTexGeniOES)(nil)
}
func doEncodeGlTexGeniOES(e binary.Encoder, o *GlTexGeniOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Coord))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlTexGeniOES(d binary.Decoder, o *GlTexGeniOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLint(d.Int32())
}
func doDecodeRawGlTexGeniOES(d binary.Decoder, o *GlTexGeniOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLint(d.Int32())
}
func (*binaryClassGlTexGeniOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexGeniOES(e, obj.(*GlTexGeniOES))
}
func (*binaryClassGlTexGeniOES) New() binary.Object {
	return &GlTexGeniOES{}
}
func (*binaryClassGlTexGeniOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexGeniOES(d, obj.(*GlTexGeniOES))
}
func (c *binaryClassGlTexGeniOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexGeniOES]
}

type binaryClassGlTexGenivOES struct{}

func (*GlTexGenivOES) Class() binary.Class {
	return (*binaryClassGlTexGenivOES)(nil)
}
func doEncodeGlTexGenivOES(e binary.Encoder, o *GlTexGenivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Coord))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexGenivOES(d binary.Decoder, o *GlTexGenivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexGenivOES(d binary.Decoder, o *GlTexGenivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexGenivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexGenivOES(e, obj.(*GlTexGenivOES))
}
func (*binaryClassGlTexGenivOES) New() binary.Object {
	return &GlTexGenivOES{}
}
func (*binaryClassGlTexGenivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexGenivOES(d, obj.(*GlTexGenivOES))
}
func (c *binaryClassGlTexGenivOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexGenivOES]
}

type binaryClassGlTexGenxOES struct{}

func (*GlTexGenxOES) Class() binary.Class {
	return (*binaryClassGlTexGenxOES)(nil)
}
func doEncodeGlTexGenxOES(e binary.Encoder, o *GlTexGenxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Coord))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlTexGenxOES(d binary.Decoder, o *GlTexGenxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlTexGenxOES(d binary.Decoder, o *GlTexGenxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlTexGenxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexGenxOES(e, obj.(*GlTexGenxOES))
}
func (*binaryClassGlTexGenxOES) New() binary.Object {
	return &GlTexGenxOES{}
}
func (*binaryClassGlTexGenxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexGenxOES(d, obj.(*GlTexGenxOES))
}
func (c *binaryClassGlTexGenxOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexGenxOES]
}

type binaryClassGlTexGenxvOES struct{}

func (*GlTexGenxvOES) Class() binary.Class {
	return (*binaryClassGlTexGenxvOES)(nil)
}
func doEncodeGlTexGenxvOES(e binary.Encoder, o *GlTexGenxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Coord))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexGenxvOES(d binary.Decoder, o *GlTexGenxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexGenxvOES(d binary.Decoder, o *GlTexGenxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Coord = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexGenxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexGenxvOES(e, obj.(*GlTexGenxvOES))
}
func (*binaryClassGlTexGenxvOES) New() binary.Object {
	return &GlTexGenxvOES{}
}
func (*binaryClassGlTexGenxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexGenxvOES(d, obj.(*GlTexGenxvOES))
}
func (c *binaryClassGlTexGenxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexGenxvOES]
}

type binaryClassGlTexImage2D struct{}

func (*GlTexImage2D) Class() binary.Class {
	return (*binaryClassGlTexImage2D)(nil)
}
func doEncodeGlTexImage2D(e binary.Encoder, o *GlTexImage2D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Border))
	e.Uint32(uint32(o.Format))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Data)
}
func doDecodeGlTexImage2D(d binary.Decoder, o *GlTexImage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Internalformat = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Data)
}
func doDecodeRawGlTexImage2D(d binary.Decoder, o *GlTexImage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Internalformat = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Data)
}
func (*binaryClassGlTexImage2D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexImage2D(e, obj.(*GlTexImage2D))
}
func (*binaryClassGlTexImage2D) New() binary.Object {
	return &GlTexImage2D{}
}
func (*binaryClassGlTexImage2D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexImage2D(d, obj.(*GlTexImage2D))
}
func (c *binaryClassGlTexImage2D) Schema() *binary.Entity {
	return &entities[ixǁGlTexImage2D]
}

type binaryClassGlTexImage3D struct{}

func (*GlTexImage3D) Class() binary.Class {
	return (*binaryClassGlTexImage3D)(nil)
}
func doEncodeGlTexImage3D(e binary.Encoder, o *GlTexImage3D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
	e.Int32(int32(o.Border))
	e.Uint32(uint32(o.Format))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Data)
}
func doDecodeGlTexImage3D(d binary.Decoder, o *GlTexImage3D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Internalformat = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Data)
}
func doDecodeRawGlTexImage3D(d binary.Decoder, o *GlTexImage3D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Internalformat = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Data)
}
func (*binaryClassGlTexImage3D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexImage3D(e, obj.(*GlTexImage3D))
}
func (*binaryClassGlTexImage3D) New() binary.Object {
	return &GlTexImage3D{}
}
func (*binaryClassGlTexImage3D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexImage3D(d, obj.(*GlTexImage3D))
}
func (c *binaryClassGlTexImage3D) Schema() *binary.Entity {
	return &entities[ixǁGlTexImage3D]
}

type binaryClassGlTexImage3DOES struct{}

func (*GlTexImage3DOES) Class() binary.Class {
	return (*binaryClassGlTexImage3DOES)(nil)
}
func doEncodeGlTexImage3DOES(e binary.Encoder, o *GlTexImage3DOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
	e.Int32(int32(o.Border))
	e.Uint32(uint32(o.Format))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Pixels)
}
func doDecodeGlTexImage3DOES(d binary.Decoder, o *GlTexImage3DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Pixels)
}
func doDecodeRawGlTexImage3DOES(d binary.Decoder, o *GlTexImage3DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Border = GLint(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Pixels)
}
func (*binaryClassGlTexImage3DOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexImage3DOES(e, obj.(*GlTexImage3DOES))
}
func (*binaryClassGlTexImage3DOES) New() binary.Object {
	return &GlTexImage3DOES{}
}
func (*binaryClassGlTexImage3DOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexImage3DOES(d, obj.(*GlTexImage3DOES))
}
func (c *binaryClassGlTexImage3DOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexImage3DOES]
}

type binaryClassGlTexPageCommitmentEXT struct{}

func (*GlTexPageCommitmentEXT) Class() binary.Class {
	return (*binaryClassGlTexPageCommitmentEXT)(nil)
}
func doEncodeGlTexPageCommitmentEXT(e binary.Encoder, o *GlTexPageCommitmentEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Xoffset))
	e.Int32(int32(o.Yoffset))
	e.Int32(int32(o.Zoffset))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
	e.Uint8(uint8(o.Commit))
}
func doDecodeGlTexPageCommitmentEXT(d binary.Decoder, o *GlTexPageCommitmentEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Commit = GLboolean(d.Uint8())
}
func doDecodeRawGlTexPageCommitmentEXT(d binary.Decoder, o *GlTexPageCommitmentEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Commit = GLboolean(d.Uint8())
}
func (*binaryClassGlTexPageCommitmentEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexPageCommitmentEXT(e, obj.(*GlTexPageCommitmentEXT))
}
func (*binaryClassGlTexPageCommitmentEXT) New() binary.Object {
	return &GlTexPageCommitmentEXT{}
}
func (*binaryClassGlTexPageCommitmentEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexPageCommitmentEXT(d, obj.(*GlTexPageCommitmentEXT))
}
func (c *binaryClassGlTexPageCommitmentEXT) Schema() *binary.Entity {
	return &entities[ixǁGlTexPageCommitmentEXT]
}

type binaryClassGlTexParameterIiv struct{}

func (*GlTexParameterIiv) Class() binary.Class {
	return (*binaryClassGlTexParameterIiv)(nil)
}
func doEncodeGlTexParameterIiv(e binary.Encoder, o *GlTexParameterIiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexParameterIiv(d binary.Decoder, o *GlTexParameterIiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexParameterIiv(d binary.Decoder, o *GlTexParameterIiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexParameterIiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameterIiv(e, obj.(*GlTexParameterIiv))
}
func (*binaryClassGlTexParameterIiv) New() binary.Object {
	return &GlTexParameterIiv{}
}
func (*binaryClassGlTexParameterIiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameterIiv(d, obj.(*GlTexParameterIiv))
}
func (c *binaryClassGlTexParameterIiv) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameterIiv]
}

type binaryClassGlTexParameterIivEXT struct{}

func (*GlTexParameterIivEXT) Class() binary.Class {
	return (*binaryClassGlTexParameterIivEXT)(nil)
}
func doEncodeGlTexParameterIivEXT(e binary.Encoder, o *GlTexParameterIivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexParameterIivEXT(d binary.Decoder, o *GlTexParameterIivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexParameterIivEXT(d binary.Decoder, o *GlTexParameterIivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexParameterIivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameterIivEXT(e, obj.(*GlTexParameterIivEXT))
}
func (*binaryClassGlTexParameterIivEXT) New() binary.Object {
	return &GlTexParameterIivEXT{}
}
func (*binaryClassGlTexParameterIivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameterIivEXT(d, obj.(*GlTexParameterIivEXT))
}
func (c *binaryClassGlTexParameterIivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameterIivEXT]
}

type binaryClassGlTexParameterIivOES struct{}

func (*GlTexParameterIivOES) Class() binary.Class {
	return (*binaryClassGlTexParameterIivOES)(nil)
}
func doEncodeGlTexParameterIivOES(e binary.Encoder, o *GlTexParameterIivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexParameterIivOES(d binary.Decoder, o *GlTexParameterIivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexParameterIivOES(d binary.Decoder, o *GlTexParameterIivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexParameterIivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameterIivOES(e, obj.(*GlTexParameterIivOES))
}
func (*binaryClassGlTexParameterIivOES) New() binary.Object {
	return &GlTexParameterIivOES{}
}
func (*binaryClassGlTexParameterIivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameterIivOES(d, obj.(*GlTexParameterIivOES))
}
func (c *binaryClassGlTexParameterIivOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameterIivOES]
}

type binaryClassGlTexParameterIuiv struct{}

func (*GlTexParameterIuiv) Class() binary.Class {
	return (*binaryClassGlTexParameterIuiv)(nil)
}
func doEncodeGlTexParameterIuiv(e binary.Encoder, o *GlTexParameterIuiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexParameterIuiv(d binary.Decoder, o *GlTexParameterIuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexParameterIuiv(d binary.Decoder, o *GlTexParameterIuiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexParameterIuiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameterIuiv(e, obj.(*GlTexParameterIuiv))
}
func (*binaryClassGlTexParameterIuiv) New() binary.Object {
	return &GlTexParameterIuiv{}
}
func (*binaryClassGlTexParameterIuiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameterIuiv(d, obj.(*GlTexParameterIuiv))
}
func (c *binaryClassGlTexParameterIuiv) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameterIuiv]
}

type binaryClassGlTexParameterIuivEXT struct{}

func (*GlTexParameterIuivEXT) Class() binary.Class {
	return (*binaryClassGlTexParameterIuivEXT)(nil)
}
func doEncodeGlTexParameterIuivEXT(e binary.Encoder, o *GlTexParameterIuivEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexParameterIuivEXT(d binary.Decoder, o *GlTexParameterIuivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexParameterIuivEXT(d binary.Decoder, o *GlTexParameterIuivEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexParameterIuivEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameterIuivEXT(e, obj.(*GlTexParameterIuivEXT))
}
func (*binaryClassGlTexParameterIuivEXT) New() binary.Object {
	return &GlTexParameterIuivEXT{}
}
func (*binaryClassGlTexParameterIuivEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameterIuivEXT(d, obj.(*GlTexParameterIuivEXT))
}
func (c *binaryClassGlTexParameterIuivEXT) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameterIuivEXT]
}

type binaryClassGlTexParameterIuivOES struct{}

func (*GlTexParameterIuivOES) Class() binary.Class {
	return (*binaryClassGlTexParameterIuivOES)(nil)
}
func doEncodeGlTexParameterIuivOES(e binary.Encoder, o *GlTexParameterIuivOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexParameterIuivOES(d binary.Decoder, o *GlTexParameterIuivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexParameterIuivOES(d binary.Decoder, o *GlTexParameterIuivOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexParameterIuivOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameterIuivOES(e, obj.(*GlTexParameterIuivOES))
}
func (*binaryClassGlTexParameterIuivOES) New() binary.Object {
	return &GlTexParameterIuivOES{}
}
func (*binaryClassGlTexParameterIuivOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameterIuivOES(d, obj.(*GlTexParameterIuivOES))
}
func (c *binaryClassGlTexParameterIuivOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameterIuivOES]
}

type binaryClassGlTexParameterf struct{}

func (*GlTexParameterf) Class() binary.Class {
	return (*binaryClassGlTexParameterf)(nil)
}
func doEncodeGlTexParameterf(e binary.Encoder, o *GlTexParameterf) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Parameter))
	e.Float32(float32(o.Value))
}
func doDecodeGlTexParameterf(d binary.Decoder, o *GlTexParameterf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	o.Value = GLfloat(d.Float32())
}
func doDecodeRawGlTexParameterf(d binary.Decoder, o *GlTexParameterf) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	o.Value = GLfloat(d.Float32())
}
func (*binaryClassGlTexParameterf) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameterf(e, obj.(*GlTexParameterf))
}
func (*binaryClassGlTexParameterf) New() binary.Object {
	return &GlTexParameterf{}
}
func (*binaryClassGlTexParameterf) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameterf(d, obj.(*GlTexParameterf))
}
func (c *binaryClassGlTexParameterf) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameterf]
}

type binaryClassGlTexParameterfv struct{}

func (*GlTexParameterfv) Class() binary.Class {
	return (*binaryClassGlTexParameterfv)(nil)
}
func doEncodeGlTexParameterfv(e binary.Encoder, o *GlTexParameterfv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexParameterfv(d binary.Decoder, o *GlTexParameterfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexParameterfv(d binary.Decoder, o *GlTexParameterfv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexParameterfv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameterfv(e, obj.(*GlTexParameterfv))
}
func (*binaryClassGlTexParameterfv) New() binary.Object {
	return &GlTexParameterfv{}
}
func (*binaryClassGlTexParameterfv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameterfv(d, obj.(*GlTexParameterfv))
}
func (c *binaryClassGlTexParameterfv) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameterfv]
}

type binaryClassGlTexParameteri struct{}

func (*GlTexParameteri) Class() binary.Class {
	return (*binaryClassGlTexParameteri)(nil)
}
func doEncodeGlTexParameteri(e binary.Encoder, o *GlTexParameteri) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Parameter))
	e.Int32(int32(o.Value))
}
func doDecodeGlTexParameteri(d binary.Decoder, o *GlTexParameteri) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func doDecodeRawGlTexParameteri(d binary.Decoder, o *GlTexParameteri) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Parameter = GLenum(d.Uint32())
	o.Value = GLint(d.Int32())
}
func (*binaryClassGlTexParameteri) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameteri(e, obj.(*GlTexParameteri))
}
func (*binaryClassGlTexParameteri) New() binary.Object {
	return &GlTexParameteri{}
}
func (*binaryClassGlTexParameteri) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameteri(d, obj.(*GlTexParameteri))
}
func (c *binaryClassGlTexParameteri) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameteri]
}

type binaryClassGlTexParameteriv struct{}

func (*GlTexParameteriv) Class() binary.Class {
	return (*binaryClassGlTexParameteriv)(nil)
}
func doEncodeGlTexParameteriv(e binary.Encoder, o *GlTexParameteriv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexParameteriv(d binary.Decoder, o *GlTexParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexParameteriv(d binary.Decoder, o *GlTexParameteriv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexParameteriv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameteriv(e, obj.(*GlTexParameteriv))
}
func (*binaryClassGlTexParameteriv) New() binary.Object {
	return &GlTexParameteriv{}
}
func (*binaryClassGlTexParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameteriv(d, obj.(*GlTexParameteriv))
}
func (c *binaryClassGlTexParameteriv) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameteriv]
}

type binaryClassGlTexParameterx struct{}

func (*GlTexParameterx) Class() binary.Class {
	return (*binaryClassGlTexParameterx)(nil)
}
func doEncodeGlTexParameterx(e binary.Encoder, o *GlTexParameterx) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlTexParameterx(d binary.Decoder, o *GlTexParameterx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlTexParameterx(d binary.Decoder, o *GlTexParameterx) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlTexParameterx) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameterx(e, obj.(*GlTexParameterx))
}
func (*binaryClassGlTexParameterx) New() binary.Object {
	return &GlTexParameterx{}
}
func (*binaryClassGlTexParameterx) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameterx(d, obj.(*GlTexParameterx))
}
func (c *binaryClassGlTexParameterx) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameterx]
}

type binaryClassGlTexParameterxOES struct{}

func (*GlTexParameterxOES) Class() binary.Class {
	return (*binaryClassGlTexParameterxOES)(nil)
}
func doEncodeGlTexParameterxOES(e binary.Encoder, o *GlTexParameterxOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Int32(int32(o.Param))
}
func doDecodeGlTexParameterxOES(d binary.Decoder, o *GlTexParameterxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func doDecodeRawGlTexParameterxOES(d binary.Decoder, o *GlTexParameterxOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	o.Param = GLfixed(d.Int32())
}
func (*binaryClassGlTexParameterxOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameterxOES(e, obj.(*GlTexParameterxOES))
}
func (*binaryClassGlTexParameterxOES) New() binary.Object {
	return &GlTexParameterxOES{}
}
func (*binaryClassGlTexParameterxOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameterxOES(d, obj.(*GlTexParameterxOES))
}
func (c *binaryClassGlTexParameterxOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameterxOES]
}

type binaryClassGlTexParameterxv struct{}

func (*GlTexParameterxv) Class() binary.Class {
	return (*binaryClassGlTexParameterxv)(nil)
}
func doEncodeGlTexParameterxv(e binary.Encoder, o *GlTexParameterxv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexParameterxv(d binary.Decoder, o *GlTexParameterxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexParameterxv(d binary.Decoder, o *GlTexParameterxv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexParameterxv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameterxv(e, obj.(*GlTexParameterxv))
}
func (*binaryClassGlTexParameterxv) New() binary.Object {
	return &GlTexParameterxv{}
}
func (*binaryClassGlTexParameterxv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameterxv(d, obj.(*GlTexParameterxv))
}
func (c *binaryClassGlTexParameterxv) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameterxv]
}

type binaryClassGlTexParameterxvOES struct{}

func (*GlTexParameterxvOES) Class() binary.Class {
	return (*binaryClassGlTexParameterxvOES)(nil)
}
func doEncodeGlTexParameterxvOES(e binary.Encoder, o *GlTexParameterxvOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Pname))
	e.Simple(&o.Params)
}
func doDecodeGlTexParameterxvOES(d binary.Decoder, o *GlTexParameterxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func doDecodeRawGlTexParameterxvOES(d binary.Decoder, o *GlTexParameterxvOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Pname = GLenum(d.Uint32())
	d.Simple(&o.Params)
}
func (*binaryClassGlTexParameterxvOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexParameterxvOES(e, obj.(*GlTexParameterxvOES))
}
func (*binaryClassGlTexParameterxvOES) New() binary.Object {
	return &GlTexParameterxvOES{}
}
func (*binaryClassGlTexParameterxvOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexParameterxvOES(d, obj.(*GlTexParameterxvOES))
}
func (c *binaryClassGlTexParameterxvOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexParameterxvOES]
}

type binaryClassGlTexStorage1D struct{}

func (*GlTexStorage1D) Class() binary.Class {
	return (*binaryClassGlTexStorage1D)(nil)
}
func doEncodeGlTexStorage1D(e binary.Encoder, o *GlTexStorage1D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Levels))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
}
func doDecodeGlTexStorage1D(d binary.Decoder, o *GlTexStorage1D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
}
func doDecodeRawGlTexStorage1D(d binary.Decoder, o *GlTexStorage1D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
}
func (*binaryClassGlTexStorage1D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexStorage1D(e, obj.(*GlTexStorage1D))
}
func (*binaryClassGlTexStorage1D) New() binary.Object {
	return &GlTexStorage1D{}
}
func (*binaryClassGlTexStorage1D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexStorage1D(d, obj.(*GlTexStorage1D))
}
func (c *binaryClassGlTexStorage1D) Schema() *binary.Entity {
	return &entities[ixǁGlTexStorage1D]
}

type binaryClassGlTexStorage1DEXT struct{}

func (*GlTexStorage1DEXT) Class() binary.Class {
	return (*binaryClassGlTexStorage1DEXT)(nil)
}
func doEncodeGlTexStorage1DEXT(e binary.Encoder, o *GlTexStorage1DEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Levels))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
}
func doDecodeGlTexStorage1DEXT(d binary.Decoder, o *GlTexStorage1DEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
}
func doDecodeRawGlTexStorage1DEXT(d binary.Decoder, o *GlTexStorage1DEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
}
func (*binaryClassGlTexStorage1DEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexStorage1DEXT(e, obj.(*GlTexStorage1DEXT))
}
func (*binaryClassGlTexStorage1DEXT) New() binary.Object {
	return &GlTexStorage1DEXT{}
}
func (*binaryClassGlTexStorage1DEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexStorage1DEXT(d, obj.(*GlTexStorage1DEXT))
}
func (c *binaryClassGlTexStorage1DEXT) Schema() *binary.Entity {
	return &entities[ixǁGlTexStorage1DEXT]
}

type binaryClassGlTexStorage2D struct{}

func (*GlTexStorage2D) Class() binary.Class {
	return (*binaryClassGlTexStorage2D)(nil)
}
func doEncodeGlTexStorage2D(e binary.Encoder, o *GlTexStorage2D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Levels))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlTexStorage2D(d binary.Decoder, o *GlTexStorage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlTexStorage2D(d binary.Decoder, o *GlTexStorage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlTexStorage2D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexStorage2D(e, obj.(*GlTexStorage2D))
}
func (*binaryClassGlTexStorage2D) New() binary.Object {
	return &GlTexStorage2D{}
}
func (*binaryClassGlTexStorage2D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexStorage2D(d, obj.(*GlTexStorage2D))
}
func (c *binaryClassGlTexStorage2D) Schema() *binary.Entity {
	return &entities[ixǁGlTexStorage2D]
}

type binaryClassGlTexStorage2DEXT struct{}

func (*GlTexStorage2DEXT) Class() binary.Class {
	return (*binaryClassGlTexStorage2DEXT)(nil)
}
func doEncodeGlTexStorage2DEXT(e binary.Encoder, o *GlTexStorage2DEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Levels))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlTexStorage2DEXT(d binary.Decoder, o *GlTexStorage2DEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlTexStorage2DEXT(d binary.Decoder, o *GlTexStorage2DEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlTexStorage2DEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexStorage2DEXT(e, obj.(*GlTexStorage2DEXT))
}
func (*binaryClassGlTexStorage2DEXT) New() binary.Object {
	return &GlTexStorage2DEXT{}
}
func (*binaryClassGlTexStorage2DEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexStorage2DEXT(d, obj.(*GlTexStorage2DEXT))
}
func (c *binaryClassGlTexStorage2DEXT) Schema() *binary.Entity {
	return &entities[ixǁGlTexStorage2DEXT]
}

type binaryClassGlTexStorage2DMultisample struct{}

func (*GlTexStorage2DMultisample) Class() binary.Class {
	return (*binaryClassGlTexStorage2DMultisample)(nil)
}
func doEncodeGlTexStorage2DMultisample(e binary.Encoder, o *GlTexStorage2DMultisample) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Samples))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Uint8(uint8(o.Fixedsamplelocations))
}
func doDecodeGlTexStorage2DMultisample(d binary.Decoder, o *GlTexStorage2DMultisample) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Fixedsamplelocations = GLboolean(d.Uint8())
}
func doDecodeRawGlTexStorage2DMultisample(d binary.Decoder, o *GlTexStorage2DMultisample) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Fixedsamplelocations = GLboolean(d.Uint8())
}
func (*binaryClassGlTexStorage2DMultisample) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexStorage2DMultisample(e, obj.(*GlTexStorage2DMultisample))
}
func (*binaryClassGlTexStorage2DMultisample) New() binary.Object {
	return &GlTexStorage2DMultisample{}
}
func (*binaryClassGlTexStorage2DMultisample) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexStorage2DMultisample(d, obj.(*GlTexStorage2DMultisample))
}
func (c *binaryClassGlTexStorage2DMultisample) Schema() *binary.Entity {
	return &entities[ixǁGlTexStorage2DMultisample]
}

type binaryClassGlTexStorage3D struct{}

func (*GlTexStorage3D) Class() binary.Class {
	return (*binaryClassGlTexStorage3D)(nil)
}
func doEncodeGlTexStorage3D(e binary.Encoder, o *GlTexStorage3D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Levels))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
}
func doDecodeGlTexStorage3D(d binary.Decoder, o *GlTexStorage3D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
}
func doDecodeRawGlTexStorage3D(d binary.Decoder, o *GlTexStorage3D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
}
func (*binaryClassGlTexStorage3D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexStorage3D(e, obj.(*GlTexStorage3D))
}
func (*binaryClassGlTexStorage3D) New() binary.Object {
	return &GlTexStorage3D{}
}
func (*binaryClassGlTexStorage3D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexStorage3D(d, obj.(*GlTexStorage3D))
}
func (c *binaryClassGlTexStorage3D) Schema() *binary.Entity {
	return &entities[ixǁGlTexStorage3D]
}

type binaryClassGlTexStorage3DEXT struct{}

func (*GlTexStorage3DEXT) Class() binary.Class {
	return (*binaryClassGlTexStorage3DEXT)(nil)
}
func doEncodeGlTexStorage3DEXT(e binary.Encoder, o *GlTexStorage3DEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Levels))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
}
func doDecodeGlTexStorage3DEXT(d binary.Decoder, o *GlTexStorage3DEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
}
func doDecodeRawGlTexStorage3DEXT(d binary.Decoder, o *GlTexStorage3DEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
}
func (*binaryClassGlTexStorage3DEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexStorage3DEXT(e, obj.(*GlTexStorage3DEXT))
}
func (*binaryClassGlTexStorage3DEXT) New() binary.Object {
	return &GlTexStorage3DEXT{}
}
func (*binaryClassGlTexStorage3DEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexStorage3DEXT(d, obj.(*GlTexStorage3DEXT))
}
func (c *binaryClassGlTexStorage3DEXT) Schema() *binary.Entity {
	return &entities[ixǁGlTexStorage3DEXT]
}

type binaryClassGlTexStorage3DMultisample struct{}

func (*GlTexStorage3DMultisample) Class() binary.Class {
	return (*binaryClassGlTexStorage3DMultisample)(nil)
}
func doEncodeGlTexStorage3DMultisample(e binary.Encoder, o *GlTexStorage3DMultisample) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Samples))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
	e.Uint8(uint8(o.Fixedsamplelocations))
}
func doDecodeGlTexStorage3DMultisample(d binary.Decoder, o *GlTexStorage3DMultisample) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Fixedsamplelocations = GLboolean(d.Uint8())
}
func doDecodeRawGlTexStorage3DMultisample(d binary.Decoder, o *GlTexStorage3DMultisample) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Fixedsamplelocations = GLboolean(d.Uint8())
}
func (*binaryClassGlTexStorage3DMultisample) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexStorage3DMultisample(e, obj.(*GlTexStorage3DMultisample))
}
func (*binaryClassGlTexStorage3DMultisample) New() binary.Object {
	return &GlTexStorage3DMultisample{}
}
func (*binaryClassGlTexStorage3DMultisample) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexStorage3DMultisample(d, obj.(*GlTexStorage3DMultisample))
}
func (c *binaryClassGlTexStorage3DMultisample) Schema() *binary.Entity {
	return &entities[ixǁGlTexStorage3DMultisample]
}

type binaryClassGlTexStorage3DMultisampleOES struct{}

func (*GlTexStorage3DMultisampleOES) Class() binary.Class {
	return (*binaryClassGlTexStorage3DMultisampleOES)(nil)
}
func doEncodeGlTexStorage3DMultisampleOES(e binary.Encoder, o *GlTexStorage3DMultisampleOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Samples))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
	e.Uint8(uint8(o.Fixedsamplelocations))
}
func doDecodeGlTexStorage3DMultisampleOES(d binary.Decoder, o *GlTexStorage3DMultisampleOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Fixedsamplelocations = GLboolean(d.Uint8())
}
func doDecodeRawGlTexStorage3DMultisampleOES(d binary.Decoder, o *GlTexStorage3DMultisampleOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Samples = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Fixedsamplelocations = GLboolean(d.Uint8())
}
func (*binaryClassGlTexStorage3DMultisampleOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexStorage3DMultisampleOES(e, obj.(*GlTexStorage3DMultisampleOES))
}
func (*binaryClassGlTexStorage3DMultisampleOES) New() binary.Object {
	return &GlTexStorage3DMultisampleOES{}
}
func (*binaryClassGlTexStorage3DMultisampleOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexStorage3DMultisampleOES(d, obj.(*GlTexStorage3DMultisampleOES))
}
func (c *binaryClassGlTexStorage3DMultisampleOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexStorage3DMultisampleOES]
}

type binaryClassGlTexSubImage2D struct{}

func (*GlTexSubImage2D) Class() binary.Class {
	return (*binaryClassGlTexSubImage2D)(nil)
}
func doEncodeGlTexSubImage2D(e binary.Encoder, o *GlTexSubImage2D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Xoffset))
	e.Int32(int32(o.Yoffset))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Uint32(uint32(o.Format))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Data)
}
func doDecodeGlTexSubImage2D(d binary.Decoder, o *GlTexSubImage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Data)
}
func doDecodeRawGlTexSubImage2D(d binary.Decoder, o *GlTexSubImage2D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Data)
}
func (*binaryClassGlTexSubImage2D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexSubImage2D(e, obj.(*GlTexSubImage2D))
}
func (*binaryClassGlTexSubImage2D) New() binary.Object {
	return &GlTexSubImage2D{}
}
func (*binaryClassGlTexSubImage2D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexSubImage2D(d, obj.(*GlTexSubImage2D))
}
func (c *binaryClassGlTexSubImage2D) Schema() *binary.Entity {
	return &entities[ixǁGlTexSubImage2D]
}

type binaryClassGlTexSubImage3D struct{}

func (*GlTexSubImage3D) Class() binary.Class {
	return (*binaryClassGlTexSubImage3D)(nil)
}
func doEncodeGlTexSubImage3D(e binary.Encoder, o *GlTexSubImage3D) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Xoffset))
	e.Int32(int32(o.Yoffset))
	e.Int32(int32(o.Zoffset))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
	e.Uint32(uint32(o.Format))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Data)
}
func doDecodeGlTexSubImage3D(d binary.Decoder, o *GlTexSubImage3D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Data)
}
func doDecodeRawGlTexSubImage3D(d binary.Decoder, o *GlTexSubImage3D) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Data)
}
func (*binaryClassGlTexSubImage3D) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexSubImage3D(e, obj.(*GlTexSubImage3D))
}
func (*binaryClassGlTexSubImage3D) New() binary.Object {
	return &GlTexSubImage3D{}
}
func (*binaryClassGlTexSubImage3D) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexSubImage3D(d, obj.(*GlTexSubImage3D))
}
func (c *binaryClassGlTexSubImage3D) Schema() *binary.Entity {
	return &entities[ixǁGlTexSubImage3D]
}

type binaryClassGlTexSubImage3DOES struct{}

func (*GlTexSubImage3DOES) Class() binary.Class {
	return (*binaryClassGlTexSubImage3DOES)(nil)
}
func doEncodeGlTexSubImage3DOES(e binary.Encoder, o *GlTexSubImage3DOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Level))
	e.Int32(int32(o.Xoffset))
	e.Int32(int32(o.Yoffset))
	e.Int32(int32(o.Zoffset))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
	e.Uint32(uint32(o.Format))
	e.Uint32(uint32(o.Type))
	e.Simple(&o.Pixels)
}
func doDecodeGlTexSubImage3DOES(d binary.Decoder, o *GlTexSubImage3DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Pixels)
}
func doDecodeRawGlTexSubImage3DOES(d binary.Decoder, o *GlTexSubImage3DOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Level = GLint(d.Int32())
	o.Xoffset = GLint(d.Int32())
	o.Yoffset = GLint(d.Int32())
	o.Zoffset = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
	o.Format = GLenum(d.Uint32())
	o.Type = GLenum(d.Uint32())
	d.Simple(&o.Pixels)
}
func (*binaryClassGlTexSubImage3DOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTexSubImage3DOES(e, obj.(*GlTexSubImage3DOES))
}
func (*binaryClassGlTexSubImage3DOES) New() binary.Object {
	return &GlTexSubImage3DOES{}
}
func (*binaryClassGlTexSubImage3DOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTexSubImage3DOES(d, obj.(*GlTexSubImage3DOES))
}
func (c *binaryClassGlTexSubImage3DOES) Schema() *binary.Entity {
	return &entities[ixǁGlTexSubImage3DOES]
}

type binaryClassGlTextureStorage1DEXT struct{}

func (*GlTextureStorage1DEXT) Class() binary.Class {
	return (*binaryClassGlTextureStorage1DEXT)(nil)
}
func doEncodeGlTextureStorage1DEXT(e binary.Encoder, o *GlTextureStorage1DEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Levels))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
}
func doDecodeGlTextureStorage1DEXT(d binary.Decoder, o *GlTextureStorage1DEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
}
func doDecodeRawGlTextureStorage1DEXT(d binary.Decoder, o *GlTextureStorage1DEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
}
func (*binaryClassGlTextureStorage1DEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTextureStorage1DEXT(e, obj.(*GlTextureStorage1DEXT))
}
func (*binaryClassGlTextureStorage1DEXT) New() binary.Object {
	return &GlTextureStorage1DEXT{}
}
func (*binaryClassGlTextureStorage1DEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTextureStorage1DEXT(d, obj.(*GlTextureStorage1DEXT))
}
func (c *binaryClassGlTextureStorage1DEXT) Schema() *binary.Entity {
	return &entities[ixǁGlTextureStorage1DEXT]
}

type binaryClassGlTextureStorage2DEXT struct{}

func (*GlTextureStorage2DEXT) Class() binary.Class {
	return (*binaryClassGlTextureStorage2DEXT)(nil)
}
func doEncodeGlTextureStorage2DEXT(e binary.Encoder, o *GlTextureStorage2DEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Levels))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlTextureStorage2DEXT(d binary.Decoder, o *GlTextureStorage2DEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlTextureStorage2DEXT(d binary.Decoder, o *GlTextureStorage2DEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlTextureStorage2DEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTextureStorage2DEXT(e, obj.(*GlTextureStorage2DEXT))
}
func (*binaryClassGlTextureStorage2DEXT) New() binary.Object {
	return &GlTextureStorage2DEXT{}
}
func (*binaryClassGlTextureStorage2DEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTextureStorage2DEXT(d, obj.(*GlTextureStorage2DEXT))
}
func (c *binaryClassGlTextureStorage2DEXT) Schema() *binary.Entity {
	return &entities[ixǁGlTextureStorage2DEXT]
}

type binaryClassGlTextureStorage3DEXT struct{}

func (*GlTextureStorage3DEXT) Class() binary.Class {
	return (*binaryClassGlTextureStorage3DEXT)(nil)
}
func doEncodeGlTextureStorage3DEXT(e binary.Encoder, o *GlTextureStorage3DEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
	e.Uint32(uint32(o.Target))
	e.Int32(int32(o.Levels))
	e.Uint32(uint32(o.Internalformat))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
	e.Int32(int32(o.Depth))
}
func doDecodeGlTextureStorage3DEXT(d binary.Decoder, o *GlTextureStorage3DEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
}
func doDecodeRawGlTextureStorage3DEXT(d binary.Decoder, o *GlTextureStorage3DEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Target = GLenum(d.Uint32())
	o.Levels = GLsizei(d.Int32())
	o.Internalformat = GLenum(d.Uint32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
	o.Depth = GLsizei(d.Int32())
}
func (*binaryClassGlTextureStorage3DEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTextureStorage3DEXT(e, obj.(*GlTextureStorage3DEXT))
}
func (*binaryClassGlTextureStorage3DEXT) New() binary.Object {
	return &GlTextureStorage3DEXT{}
}
func (*binaryClassGlTextureStorage3DEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTextureStorage3DEXT(d, obj.(*GlTextureStorage3DEXT))
}
func (c *binaryClassGlTextureStorage3DEXT) Schema() *binary.Entity {
	return &entities[ixǁGlTextureStorage3DEXT]
}

type binaryClassGlTextureViewEXT struct{}

func (*GlTextureViewEXT) Class() binary.Class {
	return (*binaryClassGlTextureViewEXT)(nil)
}
func doEncodeGlTextureViewEXT(e binary.Encoder, o *GlTextureViewEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Origtexture))
	e.Uint32(uint32(o.Internalformat))
	e.Uint32(uint32(o.Minlevel))
	e.Uint32(uint32(o.Numlevels))
	e.Uint32(uint32(o.Minlayer))
	e.Uint32(uint32(o.Numlayers))
}
func doDecodeGlTextureViewEXT(d binary.Decoder, o *GlTextureViewEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Target = GLenum(d.Uint32())
	o.Origtexture = GLuint(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Minlevel = GLuint(d.Uint32())
	o.Numlevels = GLuint(d.Uint32())
	o.Minlayer = GLuint(d.Uint32())
	o.Numlayers = GLuint(d.Uint32())
}
func doDecodeRawGlTextureViewEXT(d binary.Decoder, o *GlTextureViewEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Target = GLenum(d.Uint32())
	o.Origtexture = GLuint(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Minlevel = GLuint(d.Uint32())
	o.Numlevels = GLuint(d.Uint32())
	o.Minlayer = GLuint(d.Uint32())
	o.Numlayers = GLuint(d.Uint32())
}
func (*binaryClassGlTextureViewEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTextureViewEXT(e, obj.(*GlTextureViewEXT))
}
func (*binaryClassGlTextureViewEXT) New() binary.Object {
	return &GlTextureViewEXT{}
}
func (*binaryClassGlTextureViewEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTextureViewEXT(d, obj.(*GlTextureViewEXT))
}
func (c *binaryClassGlTextureViewEXT) Schema() *binary.Entity {
	return &entities[ixǁGlTextureViewEXT]
}

type binaryClassGlTextureViewOES struct{}

func (*GlTextureViewOES) Class() binary.Class {
	return (*binaryClassGlTextureViewOES)(nil)
}
func doEncodeGlTextureViewOES(e binary.Encoder, o *GlTextureViewOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Texture))
	e.Uint32(uint32(o.Target))
	e.Uint32(uint32(o.Origtexture))
	e.Uint32(uint32(o.Internalformat))
	e.Uint32(uint32(o.Minlevel))
	e.Uint32(uint32(o.Numlevels))
	e.Uint32(uint32(o.Minlayer))
	e.Uint32(uint32(o.Numlayers))
}
func doDecodeGlTextureViewOES(d binary.Decoder, o *GlTextureViewOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Target = GLenum(d.Uint32())
	o.Origtexture = GLuint(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Minlevel = GLuint(d.Uint32())
	o.Numlevels = GLuint(d.Uint32())
	o.Minlayer = GLuint(d.Uint32())
	o.Numlayers = GLuint(d.Uint32())
}
func doDecodeRawGlTextureViewOES(d binary.Decoder, o *GlTextureViewOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Texture = TextureId(d.Uint32())
	o.Target = GLenum(d.Uint32())
	o.Origtexture = GLuint(d.Uint32())
	o.Internalformat = GLenum(d.Uint32())
	o.Minlevel = GLuint(d.Uint32())
	o.Numlevels = GLuint(d.Uint32())
	o.Minlayer = GLuint(d.Uint32())
	o.Numlayers = GLuint(d.Uint32())
}
func (*binaryClassGlTextureViewOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTextureViewOES(e, obj.(*GlTextureViewOES))
}
func (*binaryClassGlTextureViewOES) New() binary.Object {
	return &GlTextureViewOES{}
}
func (*binaryClassGlTextureViewOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTextureViewOES(d, obj.(*GlTextureViewOES))
}
func (c *binaryClassGlTextureViewOES) Schema() *binary.Entity {
	return &entities[ixǁGlTextureViewOES]
}

type binaryClassGlTransformFeedbackVaryings struct{}

func (*GlTransformFeedbackVaryings) Class() binary.Class {
	return (*binaryClassGlTransformFeedbackVaryings)(nil)
}
func doEncodeGlTransformFeedbackVaryings(e binary.Encoder, o *GlTransformFeedbackVaryings) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Int32(int32(o.Count))
	e.Simple(&o.Varyings)
	e.Uint32(uint32(o.BufferMode))
}
func doDecodeGlTransformFeedbackVaryings(d binary.Decoder, o *GlTransformFeedbackVaryings) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Varyings)
	o.BufferMode = GLenum(d.Uint32())
}
func doDecodeRawGlTransformFeedbackVaryings(d binary.Decoder, o *GlTransformFeedbackVaryings) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Varyings)
	o.BufferMode = GLenum(d.Uint32())
}
func (*binaryClassGlTransformFeedbackVaryings) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTransformFeedbackVaryings(e, obj.(*GlTransformFeedbackVaryings))
}
func (*binaryClassGlTransformFeedbackVaryings) New() binary.Object {
	return &GlTransformFeedbackVaryings{}
}
func (*binaryClassGlTransformFeedbackVaryings) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTransformFeedbackVaryings(d, obj.(*GlTransformFeedbackVaryings))
}
func (c *binaryClassGlTransformFeedbackVaryings) Schema() *binary.Entity {
	return &entities[ixǁGlTransformFeedbackVaryings]
}

type binaryClassGlTransformPathNV struct{}

func (*GlTransformPathNV) Class() binary.Class {
	return (*binaryClassGlTransformPathNV)(nil)
}
func doEncodeGlTransformPathNV(e binary.Encoder, o *GlTransformPathNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.ResultPath))
	e.Uint32(uint32(o.SrcPath))
	e.Uint32(uint32(o.TransformType))
	e.Simple(&o.TransformValues)
}
func doDecodeGlTransformPathNV(d binary.Decoder, o *GlTransformPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ResultPath = GLuint(d.Uint32())
	o.SrcPath = GLuint(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func doDecodeRawGlTransformPathNV(d binary.Decoder, o *GlTransformPathNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ResultPath = GLuint(d.Uint32())
	o.SrcPath = GLuint(d.Uint32())
	o.TransformType = GLenum(d.Uint32())
	d.Simple(&o.TransformValues)
}
func (*binaryClassGlTransformPathNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTransformPathNV(e, obj.(*GlTransformPathNV))
}
func (*binaryClassGlTransformPathNV) New() binary.Object {
	return &GlTransformPathNV{}
}
func (*binaryClassGlTransformPathNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTransformPathNV(d, obj.(*GlTransformPathNV))
}
func (c *binaryClassGlTransformPathNV) Schema() *binary.Entity {
	return &entities[ixǁGlTransformPathNV]
}

type binaryClassGlTranslatef struct{}

func (*GlTranslatef) Class() binary.Class {
	return (*binaryClassGlTranslatef)(nil)
}
func doEncodeGlTranslatef(e binary.Encoder, o *GlTranslatef) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Float32(float32(o.X))
	e.Float32(float32(o.Y))
	e.Float32(float32(o.Z))
}
func doDecodeGlTranslatef(d binary.Decoder, o *GlTranslatef) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.Z = GLfloat(d.Float32())
}
func doDecodeRawGlTranslatef(d binary.Decoder, o *GlTranslatef) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.Z = GLfloat(d.Float32())
}
func (*binaryClassGlTranslatef) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTranslatef(e, obj.(*GlTranslatef))
}
func (*binaryClassGlTranslatef) New() binary.Object {
	return &GlTranslatef{}
}
func (*binaryClassGlTranslatef) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTranslatef(d, obj.(*GlTranslatef))
}
func (c *binaryClassGlTranslatef) Schema() *binary.Entity {
	return &entities[ixǁGlTranslatef]
}

type binaryClassGlTranslatex struct{}

func (*GlTranslatex) Class() binary.Class {
	return (*binaryClassGlTranslatex)(nil)
}
func doEncodeGlTranslatex(e binary.Encoder, o *GlTranslatex) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Z))
}
func doDecodeGlTranslatex(d binary.Decoder, o *GlTranslatex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
}
func doDecodeRawGlTranslatex(d binary.Decoder, o *GlTranslatex) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
}
func (*binaryClassGlTranslatex) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTranslatex(e, obj.(*GlTranslatex))
}
func (*binaryClassGlTranslatex) New() binary.Object {
	return &GlTranslatex{}
}
func (*binaryClassGlTranslatex) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTranslatex(d, obj.(*GlTranslatex))
}
func (c *binaryClassGlTranslatex) Schema() *binary.Entity {
	return &entities[ixǁGlTranslatex]
}

type binaryClassGlTranslatexOES struct{}

func (*GlTranslatexOES) Class() binary.Class {
	return (*binaryClassGlTranslatexOES)(nil)
}
func doEncodeGlTranslatexOES(e binary.Encoder, o *GlTranslatexOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Z))
}
func doDecodeGlTranslatexOES(d binary.Decoder, o *GlTranslatexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
}
func doDecodeRawGlTranslatexOES(d binary.Decoder, o *GlTranslatexOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLfixed(d.Int32())
	o.Y = GLfixed(d.Int32())
	o.Z = GLfixed(d.Int32())
}
func (*binaryClassGlTranslatexOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlTranslatexOES(e, obj.(*GlTranslatexOES))
}
func (*binaryClassGlTranslatexOES) New() binary.Object {
	return &GlTranslatexOES{}
}
func (*binaryClassGlTranslatexOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlTranslatexOES(d, obj.(*GlTranslatexOES))
}
func (c *binaryClassGlTranslatexOES) Schema() *binary.Entity {
	return &entities[ixǁGlTranslatexOES]
}

type binaryClassGlUniform1f struct{}

func (*GlUniform1f) Class() binary.Class {
	return (*binaryClassGlUniform1f)(nil)
}
func doEncodeGlUniform1f(e binary.Encoder, o *GlUniform1f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Float32(float32(o.Value))
}
func doDecodeGlUniform1f(d binary.Decoder, o *GlUniform1f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value = GLfloat(d.Float32())
}
func doDecodeRawGlUniform1f(d binary.Decoder, o *GlUniform1f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value = GLfloat(d.Float32())
}
func (*binaryClassGlUniform1f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform1f(e, obj.(*GlUniform1f))
}
func (*binaryClassGlUniform1f) New() binary.Object {
	return &GlUniform1f{}
}
func (*binaryClassGlUniform1f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform1f(d, obj.(*GlUniform1f))
}
func (c *binaryClassGlUniform1f) Schema() *binary.Entity {
	return &entities[ixǁGlUniform1f]
}

type binaryClassGlUniform1fv struct{}

func (*GlUniform1fv) Class() binary.Class {
	return (*binaryClassGlUniform1fv)(nil)
}
func doEncodeGlUniform1fv(e binary.Encoder, o *GlUniform1fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlUniform1fv(d binary.Decoder, o *GlUniform1fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniform1fv(d binary.Decoder, o *GlUniform1fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniform1fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform1fv(e, obj.(*GlUniform1fv))
}
func (*binaryClassGlUniform1fv) New() binary.Object {
	return &GlUniform1fv{}
}
func (*binaryClassGlUniform1fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform1fv(d, obj.(*GlUniform1fv))
}
func (c *binaryClassGlUniform1fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniform1fv]
}

type binaryClassGlUniform1i struct{}

func (*GlUniform1i) Class() binary.Class {
	return (*binaryClassGlUniform1i)(nil)
}
func doEncodeGlUniform1i(e binary.Encoder, o *GlUniform1i) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Value))
}
func doDecodeGlUniform1i(d binary.Decoder, o *GlUniform1i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value = GLint(d.Int32())
}
func doDecodeRawGlUniform1i(d binary.Decoder, o *GlUniform1i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value = GLint(d.Int32())
}
func (*binaryClassGlUniform1i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform1i(e, obj.(*GlUniform1i))
}
func (*binaryClassGlUniform1i) New() binary.Object {
	return &GlUniform1i{}
}
func (*binaryClassGlUniform1i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform1i(d, obj.(*GlUniform1i))
}
func (c *binaryClassGlUniform1i) Schema() *binary.Entity {
	return &entities[ixǁGlUniform1i]
}

type binaryClassGlUniform1iv struct{}

func (*GlUniform1iv) Class() binary.Class {
	return (*binaryClassGlUniform1iv)(nil)
}
func doEncodeGlUniform1iv(e binary.Encoder, o *GlUniform1iv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlUniform1iv(d binary.Decoder, o *GlUniform1iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniform1iv(d binary.Decoder, o *GlUniform1iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniform1iv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform1iv(e, obj.(*GlUniform1iv))
}
func (*binaryClassGlUniform1iv) New() binary.Object {
	return &GlUniform1iv{}
}
func (*binaryClassGlUniform1iv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform1iv(d, obj.(*GlUniform1iv))
}
func (c *binaryClassGlUniform1iv) Schema() *binary.Entity {
	return &entities[ixǁGlUniform1iv]
}

type binaryClassGlUniform1ui struct{}

func (*GlUniform1ui) Class() binary.Class {
	return (*binaryClassGlUniform1ui)(nil)
}
func doEncodeGlUniform1ui(e binary.Encoder, o *GlUniform1ui) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.Value0))
}
func doDecodeGlUniform1ui(d binary.Decoder, o *GlUniform1ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
}
func doDecodeRawGlUniform1ui(d binary.Decoder, o *GlUniform1ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
}
func (*binaryClassGlUniform1ui) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform1ui(e, obj.(*GlUniform1ui))
}
func (*binaryClassGlUniform1ui) New() binary.Object {
	return &GlUniform1ui{}
}
func (*binaryClassGlUniform1ui) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform1ui(d, obj.(*GlUniform1ui))
}
func (c *binaryClassGlUniform1ui) Schema() *binary.Entity {
	return &entities[ixǁGlUniform1ui]
}

type binaryClassGlUniform1uiv struct{}

func (*GlUniform1uiv) Class() binary.Class {
	return (*binaryClassGlUniform1uiv)(nil)
}
func doEncodeGlUniform1uiv(e binary.Encoder, o *GlUniform1uiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlUniform1uiv(d binary.Decoder, o *GlUniform1uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniform1uiv(d binary.Decoder, o *GlUniform1uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniform1uiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform1uiv(e, obj.(*GlUniform1uiv))
}
func (*binaryClassGlUniform1uiv) New() binary.Object {
	return &GlUniform1uiv{}
}
func (*binaryClassGlUniform1uiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform1uiv(d, obj.(*GlUniform1uiv))
}
func (c *binaryClassGlUniform1uiv) Schema() *binary.Entity {
	return &entities[ixǁGlUniform1uiv]
}

type binaryClassGlUniform2f struct{}

func (*GlUniform2f) Class() binary.Class {
	return (*binaryClassGlUniform2f)(nil)
}
func doEncodeGlUniform2f(e binary.Encoder, o *GlUniform2f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Float32(float32(o.Value0))
	e.Float32(float32(o.Value1))
}
func doDecodeGlUniform2f(d binary.Decoder, o *GlUniform2f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
}
func doDecodeRawGlUniform2f(d binary.Decoder, o *GlUniform2f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
}
func (*binaryClassGlUniform2f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform2f(e, obj.(*GlUniform2f))
}
func (*binaryClassGlUniform2f) New() binary.Object {
	return &GlUniform2f{}
}
func (*binaryClassGlUniform2f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform2f(d, obj.(*GlUniform2f))
}
func (c *binaryClassGlUniform2f) Schema() *binary.Entity {
	return &entities[ixǁGlUniform2f]
}

type binaryClassGlUniform2fv struct{}

func (*GlUniform2fv) Class() binary.Class {
	return (*binaryClassGlUniform2fv)(nil)
}
func doEncodeGlUniform2fv(e binary.Encoder, o *GlUniform2fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlUniform2fv(d binary.Decoder, o *GlUniform2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniform2fv(d binary.Decoder, o *GlUniform2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniform2fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform2fv(e, obj.(*GlUniform2fv))
}
func (*binaryClassGlUniform2fv) New() binary.Object {
	return &GlUniform2fv{}
}
func (*binaryClassGlUniform2fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform2fv(d, obj.(*GlUniform2fv))
}
func (c *binaryClassGlUniform2fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniform2fv]
}

type binaryClassGlUniform2i struct{}

func (*GlUniform2i) Class() binary.Class {
	return (*binaryClassGlUniform2i)(nil)
}
func doEncodeGlUniform2i(e binary.Encoder, o *GlUniform2i) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Value0))
	e.Int32(int32(o.Value1))
}
func doDecodeGlUniform2i(d binary.Decoder, o *GlUniform2i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
	o.Value1 = GLint(d.Int32())
}
func doDecodeRawGlUniform2i(d binary.Decoder, o *GlUniform2i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
	o.Value1 = GLint(d.Int32())
}
func (*binaryClassGlUniform2i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform2i(e, obj.(*GlUniform2i))
}
func (*binaryClassGlUniform2i) New() binary.Object {
	return &GlUniform2i{}
}
func (*binaryClassGlUniform2i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform2i(d, obj.(*GlUniform2i))
}
func (c *binaryClassGlUniform2i) Schema() *binary.Entity {
	return &entities[ixǁGlUniform2i]
}

type binaryClassGlUniform2iv struct{}

func (*GlUniform2iv) Class() binary.Class {
	return (*binaryClassGlUniform2iv)(nil)
}
func doEncodeGlUniform2iv(e binary.Encoder, o *GlUniform2iv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlUniform2iv(d binary.Decoder, o *GlUniform2iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniform2iv(d binary.Decoder, o *GlUniform2iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniform2iv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform2iv(e, obj.(*GlUniform2iv))
}
func (*binaryClassGlUniform2iv) New() binary.Object {
	return &GlUniform2iv{}
}
func (*binaryClassGlUniform2iv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform2iv(d, obj.(*GlUniform2iv))
}
func (c *binaryClassGlUniform2iv) Schema() *binary.Entity {
	return &entities[ixǁGlUniform2iv]
}

type binaryClassGlUniform2ui struct{}

func (*GlUniform2ui) Class() binary.Class {
	return (*binaryClassGlUniform2ui)(nil)
}
func doEncodeGlUniform2ui(e binary.Encoder, o *GlUniform2ui) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.Value0))
	e.Uint32(uint32(o.Value1))
}
func doDecodeGlUniform2ui(d binary.Decoder, o *GlUniform2ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
	o.Value1 = GLuint(d.Uint32())
}
func doDecodeRawGlUniform2ui(d binary.Decoder, o *GlUniform2ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
	o.Value1 = GLuint(d.Uint32())
}
func (*binaryClassGlUniform2ui) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform2ui(e, obj.(*GlUniform2ui))
}
func (*binaryClassGlUniform2ui) New() binary.Object {
	return &GlUniform2ui{}
}
func (*binaryClassGlUniform2ui) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform2ui(d, obj.(*GlUniform2ui))
}
func (c *binaryClassGlUniform2ui) Schema() *binary.Entity {
	return &entities[ixǁGlUniform2ui]
}

type binaryClassGlUniform2uiv struct{}

func (*GlUniform2uiv) Class() binary.Class {
	return (*binaryClassGlUniform2uiv)(nil)
}
func doEncodeGlUniform2uiv(e binary.Encoder, o *GlUniform2uiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlUniform2uiv(d binary.Decoder, o *GlUniform2uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniform2uiv(d binary.Decoder, o *GlUniform2uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniform2uiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform2uiv(e, obj.(*GlUniform2uiv))
}
func (*binaryClassGlUniform2uiv) New() binary.Object {
	return &GlUniform2uiv{}
}
func (*binaryClassGlUniform2uiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform2uiv(d, obj.(*GlUniform2uiv))
}
func (c *binaryClassGlUniform2uiv) Schema() *binary.Entity {
	return &entities[ixǁGlUniform2uiv]
}

type binaryClassGlUniform3f struct{}

func (*GlUniform3f) Class() binary.Class {
	return (*binaryClassGlUniform3f)(nil)
}
func doEncodeGlUniform3f(e binary.Encoder, o *GlUniform3f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Float32(float32(o.Value0))
	e.Float32(float32(o.Value1))
	e.Float32(float32(o.Value2))
}
func doDecodeGlUniform3f(d binary.Decoder, o *GlUniform3f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
	o.Value2 = GLfloat(d.Float32())
}
func doDecodeRawGlUniform3f(d binary.Decoder, o *GlUniform3f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
	o.Value2 = GLfloat(d.Float32())
}
func (*binaryClassGlUniform3f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform3f(e, obj.(*GlUniform3f))
}
func (*binaryClassGlUniform3f) New() binary.Object {
	return &GlUniform3f{}
}
func (*binaryClassGlUniform3f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform3f(d, obj.(*GlUniform3f))
}
func (c *binaryClassGlUniform3f) Schema() *binary.Entity {
	return &entities[ixǁGlUniform3f]
}

type binaryClassGlUniform3fv struct{}

func (*GlUniform3fv) Class() binary.Class {
	return (*binaryClassGlUniform3fv)(nil)
}
func doEncodeGlUniform3fv(e binary.Encoder, o *GlUniform3fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlUniform3fv(d binary.Decoder, o *GlUniform3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniform3fv(d binary.Decoder, o *GlUniform3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniform3fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform3fv(e, obj.(*GlUniform3fv))
}
func (*binaryClassGlUniform3fv) New() binary.Object {
	return &GlUniform3fv{}
}
func (*binaryClassGlUniform3fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform3fv(d, obj.(*GlUniform3fv))
}
func (c *binaryClassGlUniform3fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniform3fv]
}

type binaryClassGlUniform3i struct{}

func (*GlUniform3i) Class() binary.Class {
	return (*binaryClassGlUniform3i)(nil)
}
func doEncodeGlUniform3i(e binary.Encoder, o *GlUniform3i) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Value0))
	e.Int32(int32(o.Value1))
	e.Int32(int32(o.Value2))
}
func doDecodeGlUniform3i(d binary.Decoder, o *GlUniform3i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
	o.Value1 = GLint(d.Int32())
	o.Value2 = GLint(d.Int32())
}
func doDecodeRawGlUniform3i(d binary.Decoder, o *GlUniform3i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
	o.Value1 = GLint(d.Int32())
	o.Value2 = GLint(d.Int32())
}
func (*binaryClassGlUniform3i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform3i(e, obj.(*GlUniform3i))
}
func (*binaryClassGlUniform3i) New() binary.Object {
	return &GlUniform3i{}
}
func (*binaryClassGlUniform3i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform3i(d, obj.(*GlUniform3i))
}
func (c *binaryClassGlUniform3i) Schema() *binary.Entity {
	return &entities[ixǁGlUniform3i]
}

type binaryClassGlUniform3iv struct{}

func (*GlUniform3iv) Class() binary.Class {
	return (*binaryClassGlUniform3iv)(nil)
}
func doEncodeGlUniform3iv(e binary.Encoder, o *GlUniform3iv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlUniform3iv(d binary.Decoder, o *GlUniform3iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniform3iv(d binary.Decoder, o *GlUniform3iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniform3iv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform3iv(e, obj.(*GlUniform3iv))
}
func (*binaryClassGlUniform3iv) New() binary.Object {
	return &GlUniform3iv{}
}
func (*binaryClassGlUniform3iv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform3iv(d, obj.(*GlUniform3iv))
}
func (c *binaryClassGlUniform3iv) Schema() *binary.Entity {
	return &entities[ixǁGlUniform3iv]
}

type binaryClassGlUniform3ui struct{}

func (*GlUniform3ui) Class() binary.Class {
	return (*binaryClassGlUniform3ui)(nil)
}
func doEncodeGlUniform3ui(e binary.Encoder, o *GlUniform3ui) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.Value0))
	e.Uint32(uint32(o.Value1))
	e.Uint32(uint32(o.Value2))
}
func doDecodeGlUniform3ui(d binary.Decoder, o *GlUniform3ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
	o.Value1 = GLuint(d.Uint32())
	o.Value2 = GLuint(d.Uint32())
}
func doDecodeRawGlUniform3ui(d binary.Decoder, o *GlUniform3ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
	o.Value1 = GLuint(d.Uint32())
	o.Value2 = GLuint(d.Uint32())
}
func (*binaryClassGlUniform3ui) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform3ui(e, obj.(*GlUniform3ui))
}
func (*binaryClassGlUniform3ui) New() binary.Object {
	return &GlUniform3ui{}
}
func (*binaryClassGlUniform3ui) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform3ui(d, obj.(*GlUniform3ui))
}
func (c *binaryClassGlUniform3ui) Schema() *binary.Entity {
	return &entities[ixǁGlUniform3ui]
}

type binaryClassGlUniform3uiv struct{}

func (*GlUniform3uiv) Class() binary.Class {
	return (*binaryClassGlUniform3uiv)(nil)
}
func doEncodeGlUniform3uiv(e binary.Encoder, o *GlUniform3uiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlUniform3uiv(d binary.Decoder, o *GlUniform3uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniform3uiv(d binary.Decoder, o *GlUniform3uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniform3uiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform3uiv(e, obj.(*GlUniform3uiv))
}
func (*binaryClassGlUniform3uiv) New() binary.Object {
	return &GlUniform3uiv{}
}
func (*binaryClassGlUniform3uiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform3uiv(d, obj.(*GlUniform3uiv))
}
func (c *binaryClassGlUniform3uiv) Schema() *binary.Entity {
	return &entities[ixǁGlUniform3uiv]
}

type binaryClassGlUniform4f struct{}

func (*GlUniform4f) Class() binary.Class {
	return (*binaryClassGlUniform4f)(nil)
}
func doEncodeGlUniform4f(e binary.Encoder, o *GlUniform4f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Float32(float32(o.Value0))
	e.Float32(float32(o.Value1))
	e.Float32(float32(o.Value2))
	e.Float32(float32(o.Value3))
}
func doDecodeGlUniform4f(d binary.Decoder, o *GlUniform4f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
	o.Value2 = GLfloat(d.Float32())
	o.Value3 = GLfloat(d.Float32())
}
func doDecodeRawGlUniform4f(d binary.Decoder, o *GlUniform4f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
	o.Value2 = GLfloat(d.Float32())
	o.Value3 = GLfloat(d.Float32())
}
func (*binaryClassGlUniform4f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform4f(e, obj.(*GlUniform4f))
}
func (*binaryClassGlUniform4f) New() binary.Object {
	return &GlUniform4f{}
}
func (*binaryClassGlUniform4f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform4f(d, obj.(*GlUniform4f))
}
func (c *binaryClassGlUniform4f) Schema() *binary.Entity {
	return &entities[ixǁGlUniform4f]
}

type binaryClassGlUniform4fv struct{}

func (*GlUniform4fv) Class() binary.Class {
	return (*binaryClassGlUniform4fv)(nil)
}
func doEncodeGlUniform4fv(e binary.Encoder, o *GlUniform4fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlUniform4fv(d binary.Decoder, o *GlUniform4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniform4fv(d binary.Decoder, o *GlUniform4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniform4fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform4fv(e, obj.(*GlUniform4fv))
}
func (*binaryClassGlUniform4fv) New() binary.Object {
	return &GlUniform4fv{}
}
func (*binaryClassGlUniform4fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform4fv(d, obj.(*GlUniform4fv))
}
func (c *binaryClassGlUniform4fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniform4fv]
}

type binaryClassGlUniform4i struct{}

func (*GlUniform4i) Class() binary.Class {
	return (*binaryClassGlUniform4i)(nil)
}
func doEncodeGlUniform4i(e binary.Encoder, o *GlUniform4i) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Value0))
	e.Int32(int32(o.Value1))
	e.Int32(int32(o.Value2))
	e.Int32(int32(o.Value3))
}
func doDecodeGlUniform4i(d binary.Decoder, o *GlUniform4i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
	o.Value1 = GLint(d.Int32())
	o.Value2 = GLint(d.Int32())
	o.Value3 = GLint(d.Int32())
}
func doDecodeRawGlUniform4i(d binary.Decoder, o *GlUniform4i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLint(d.Int32())
	o.Value1 = GLint(d.Int32())
	o.Value2 = GLint(d.Int32())
	o.Value3 = GLint(d.Int32())
}
func (*binaryClassGlUniform4i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform4i(e, obj.(*GlUniform4i))
}
func (*binaryClassGlUniform4i) New() binary.Object {
	return &GlUniform4i{}
}
func (*binaryClassGlUniform4i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform4i(d, obj.(*GlUniform4i))
}
func (c *binaryClassGlUniform4i) Schema() *binary.Entity {
	return &entities[ixǁGlUniform4i]
}

type binaryClassGlUniform4iv struct{}

func (*GlUniform4iv) Class() binary.Class {
	return (*binaryClassGlUniform4iv)(nil)
}
func doEncodeGlUniform4iv(e binary.Encoder, o *GlUniform4iv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlUniform4iv(d binary.Decoder, o *GlUniform4iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniform4iv(d binary.Decoder, o *GlUniform4iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniform4iv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform4iv(e, obj.(*GlUniform4iv))
}
func (*binaryClassGlUniform4iv) New() binary.Object {
	return &GlUniform4iv{}
}
func (*binaryClassGlUniform4iv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform4iv(d, obj.(*GlUniform4iv))
}
func (c *binaryClassGlUniform4iv) Schema() *binary.Entity {
	return &entities[ixǁGlUniform4iv]
}

type binaryClassGlUniform4ui struct{}

func (*GlUniform4ui) Class() binary.Class {
	return (*binaryClassGlUniform4ui)(nil)
}
func doEncodeGlUniform4ui(e binary.Encoder, o *GlUniform4ui) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Uint32(uint32(o.Value0))
	e.Uint32(uint32(o.Value1))
	e.Uint32(uint32(o.Value2))
	e.Uint32(uint32(o.Value3))
}
func doDecodeGlUniform4ui(d binary.Decoder, o *GlUniform4ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
	o.Value1 = GLuint(d.Uint32())
	o.Value2 = GLuint(d.Uint32())
	o.Value3 = GLuint(d.Uint32())
}
func doDecodeRawGlUniform4ui(d binary.Decoder, o *GlUniform4ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value0 = GLuint(d.Uint32())
	o.Value1 = GLuint(d.Uint32())
	o.Value2 = GLuint(d.Uint32())
	o.Value3 = GLuint(d.Uint32())
}
func (*binaryClassGlUniform4ui) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform4ui(e, obj.(*GlUniform4ui))
}
func (*binaryClassGlUniform4ui) New() binary.Object {
	return &GlUniform4ui{}
}
func (*binaryClassGlUniform4ui) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform4ui(d, obj.(*GlUniform4ui))
}
func (c *binaryClassGlUniform4ui) Schema() *binary.Entity {
	return &entities[ixǁGlUniform4ui]
}

type binaryClassGlUniform4uiv struct{}

func (*GlUniform4uiv) Class() binary.Class {
	return (*binaryClassGlUniform4uiv)(nil)
}
func doEncodeGlUniform4uiv(e binary.Encoder, o *GlUniform4uiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Values)
}
func doDecodeGlUniform4uiv(d binary.Decoder, o *GlUniform4uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniform4uiv(d binary.Decoder, o *GlUniform4uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniform4uiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniform4uiv(e, obj.(*GlUniform4uiv))
}
func (*binaryClassGlUniform4uiv) New() binary.Object {
	return &GlUniform4uiv{}
}
func (*binaryClassGlUniform4uiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniform4uiv(d, obj.(*GlUniform4uiv))
}
func (c *binaryClassGlUniform4uiv) Schema() *binary.Entity {
	return &entities[ixǁGlUniform4uiv]
}

type binaryClassGlUniformBlockBinding struct{}

func (*GlUniformBlockBinding) Class() binary.Class {
	return (*binaryClassGlUniformBlockBinding)(nil)
}
func doEncodeGlUniformBlockBinding(e binary.Encoder, o *GlUniformBlockBinding) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
	e.Uint32(uint32(o.UniformBlockIndex))
	e.Uint32(uint32(o.UniformBlockBinding))
}
func doDecodeGlUniformBlockBinding(d binary.Decoder, o *GlUniformBlockBinding) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.UniformBlockIndex = UniformBlockId(d.Uint32())
	o.UniformBlockBinding = GLuint(d.Uint32())
}
func doDecodeRawGlUniformBlockBinding(d binary.Decoder, o *GlUniformBlockBinding) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
	o.UniformBlockIndex = UniformBlockId(d.Uint32())
	o.UniformBlockBinding = GLuint(d.Uint32())
}
func (*binaryClassGlUniformBlockBinding) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformBlockBinding(e, obj.(*GlUniformBlockBinding))
}
func (*binaryClassGlUniformBlockBinding) New() binary.Object {
	return &GlUniformBlockBinding{}
}
func (*binaryClassGlUniformBlockBinding) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformBlockBinding(d, obj.(*GlUniformBlockBinding))
}
func (c *binaryClassGlUniformBlockBinding) Schema() *binary.Entity {
	return &entities[ixǁGlUniformBlockBinding]
}

type binaryClassGlUniformHandleui64NV struct{}

func (*GlUniformHandleui64NV) Class() binary.Class {
	return (*binaryClassGlUniformHandleui64NV)(nil)
}
func doEncodeGlUniformHandleui64NV(e binary.Encoder, o *GlUniformHandleui64NV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Uint64(uint64(o.Value))
}
func doDecodeGlUniformHandleui64NV(d binary.Decoder, o *GlUniformHandleui64NV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value = GLuint64(d.Uint64())
}
func doDecodeRawGlUniformHandleui64NV(d binary.Decoder, o *GlUniformHandleui64NV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Value = GLuint64(d.Uint64())
}
func (*binaryClassGlUniformHandleui64NV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformHandleui64NV(e, obj.(*GlUniformHandleui64NV))
}
func (*binaryClassGlUniformHandleui64NV) New() binary.Object {
	return &GlUniformHandleui64NV{}
}
func (*binaryClassGlUniformHandleui64NV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformHandleui64NV(d, obj.(*GlUniformHandleui64NV))
}
func (c *binaryClassGlUniformHandleui64NV) Schema() *binary.Entity {
	return &entities[ixǁGlUniformHandleui64NV]
}

type binaryClassGlUniformHandleui64vNV struct{}

func (*GlUniformHandleui64vNV) Class() binary.Class {
	return (*binaryClassGlUniformHandleui64vNV)(nil)
}
func doEncodeGlUniformHandleui64vNV(e binary.Encoder, o *GlUniformHandleui64vNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Simple(&o.Value)
}
func doDecodeGlUniformHandleui64vNV(d binary.Decoder, o *GlUniformHandleui64vNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func doDecodeRawGlUniformHandleui64vNV(d binary.Decoder, o *GlUniformHandleui64vNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.Value)
}
func (*binaryClassGlUniformHandleui64vNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformHandleui64vNV(e, obj.(*GlUniformHandleui64vNV))
}
func (*binaryClassGlUniformHandleui64vNV) New() binary.Object {
	return &GlUniformHandleui64vNV{}
}
func (*binaryClassGlUniformHandleui64vNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformHandleui64vNV(d, obj.(*GlUniformHandleui64vNV))
}
func (c *binaryClassGlUniformHandleui64vNV) Schema() *binary.Entity {
	return &entities[ixǁGlUniformHandleui64vNV]
}

type binaryClassGlUniformMatrix2fv struct{}

func (*GlUniformMatrix2fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix2fv)(nil)
}
func doEncodeGlUniformMatrix2fv(e binary.Encoder, o *GlUniformMatrix2fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlUniformMatrix2fv(d binary.Decoder, o *GlUniformMatrix2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniformMatrix2fv(d binary.Decoder, o *GlUniformMatrix2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniformMatrix2fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix2fv(e, obj.(*GlUniformMatrix2fv))
}
func (*binaryClassGlUniformMatrix2fv) New() binary.Object {
	return &GlUniformMatrix2fv{}
}
func (*binaryClassGlUniformMatrix2fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix2fv(d, obj.(*GlUniformMatrix2fv))
}
func (c *binaryClassGlUniformMatrix2fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix2fv]
}

type binaryClassGlUniformMatrix2x3fv struct{}

func (*GlUniformMatrix2x3fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix2x3fv)(nil)
}
func doEncodeGlUniformMatrix2x3fv(e binary.Encoder, o *GlUniformMatrix2x3fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlUniformMatrix2x3fv(d binary.Decoder, o *GlUniformMatrix2x3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniformMatrix2x3fv(d binary.Decoder, o *GlUniformMatrix2x3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniformMatrix2x3fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix2x3fv(e, obj.(*GlUniformMatrix2x3fv))
}
func (*binaryClassGlUniformMatrix2x3fv) New() binary.Object {
	return &GlUniformMatrix2x3fv{}
}
func (*binaryClassGlUniformMatrix2x3fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix2x3fv(d, obj.(*GlUniformMatrix2x3fv))
}
func (c *binaryClassGlUniformMatrix2x3fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix2x3fv]
}

type binaryClassGlUniformMatrix2x3fvNV struct{}

func (*GlUniformMatrix2x3fvNV) Class() binary.Class {
	return (*binaryClassGlUniformMatrix2x3fvNV)(nil)
}
func doEncodeGlUniformMatrix2x3fvNV(e binary.Encoder, o *GlUniformMatrix2x3fvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlUniformMatrix2x3fvNV(d binary.Decoder, o *GlUniformMatrix2x3fvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlUniformMatrix2x3fvNV(d binary.Decoder, o *GlUniformMatrix2x3fvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlUniformMatrix2x3fvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix2x3fvNV(e, obj.(*GlUniformMatrix2x3fvNV))
}
func (*binaryClassGlUniformMatrix2x3fvNV) New() binary.Object {
	return &GlUniformMatrix2x3fvNV{}
}
func (*binaryClassGlUniformMatrix2x3fvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix2x3fvNV(d, obj.(*GlUniformMatrix2x3fvNV))
}
func (c *binaryClassGlUniformMatrix2x3fvNV) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix2x3fvNV]
}

type binaryClassGlUniformMatrix2x4fv struct{}

func (*GlUniformMatrix2x4fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix2x4fv)(nil)
}
func doEncodeGlUniformMatrix2x4fv(e binary.Encoder, o *GlUniformMatrix2x4fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlUniformMatrix2x4fv(d binary.Decoder, o *GlUniformMatrix2x4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniformMatrix2x4fv(d binary.Decoder, o *GlUniformMatrix2x4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniformMatrix2x4fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix2x4fv(e, obj.(*GlUniformMatrix2x4fv))
}
func (*binaryClassGlUniformMatrix2x4fv) New() binary.Object {
	return &GlUniformMatrix2x4fv{}
}
func (*binaryClassGlUniformMatrix2x4fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix2x4fv(d, obj.(*GlUniformMatrix2x4fv))
}
func (c *binaryClassGlUniformMatrix2x4fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix2x4fv]
}

type binaryClassGlUniformMatrix2x4fvNV struct{}

func (*GlUniformMatrix2x4fvNV) Class() binary.Class {
	return (*binaryClassGlUniformMatrix2x4fvNV)(nil)
}
func doEncodeGlUniformMatrix2x4fvNV(e binary.Encoder, o *GlUniformMatrix2x4fvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlUniformMatrix2x4fvNV(d binary.Decoder, o *GlUniformMatrix2x4fvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlUniformMatrix2x4fvNV(d binary.Decoder, o *GlUniformMatrix2x4fvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlUniformMatrix2x4fvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix2x4fvNV(e, obj.(*GlUniformMatrix2x4fvNV))
}
func (*binaryClassGlUniformMatrix2x4fvNV) New() binary.Object {
	return &GlUniformMatrix2x4fvNV{}
}
func (*binaryClassGlUniformMatrix2x4fvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix2x4fvNV(d, obj.(*GlUniformMatrix2x4fvNV))
}
func (c *binaryClassGlUniformMatrix2x4fvNV) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix2x4fvNV]
}

type binaryClassGlUniformMatrix3fv struct{}

func (*GlUniformMatrix3fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix3fv)(nil)
}
func doEncodeGlUniformMatrix3fv(e binary.Encoder, o *GlUniformMatrix3fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlUniformMatrix3fv(d binary.Decoder, o *GlUniformMatrix3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniformMatrix3fv(d binary.Decoder, o *GlUniformMatrix3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniformMatrix3fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix3fv(e, obj.(*GlUniformMatrix3fv))
}
func (*binaryClassGlUniformMatrix3fv) New() binary.Object {
	return &GlUniformMatrix3fv{}
}
func (*binaryClassGlUniformMatrix3fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix3fv(d, obj.(*GlUniformMatrix3fv))
}
func (c *binaryClassGlUniformMatrix3fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix3fv]
}

type binaryClassGlUniformMatrix3x2fv struct{}

func (*GlUniformMatrix3x2fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix3x2fv)(nil)
}
func doEncodeGlUniformMatrix3x2fv(e binary.Encoder, o *GlUniformMatrix3x2fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlUniformMatrix3x2fv(d binary.Decoder, o *GlUniformMatrix3x2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniformMatrix3x2fv(d binary.Decoder, o *GlUniformMatrix3x2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniformMatrix3x2fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix3x2fv(e, obj.(*GlUniformMatrix3x2fv))
}
func (*binaryClassGlUniformMatrix3x2fv) New() binary.Object {
	return &GlUniformMatrix3x2fv{}
}
func (*binaryClassGlUniformMatrix3x2fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix3x2fv(d, obj.(*GlUniformMatrix3x2fv))
}
func (c *binaryClassGlUniformMatrix3x2fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix3x2fv]
}

type binaryClassGlUniformMatrix3x2fvNV struct{}

func (*GlUniformMatrix3x2fvNV) Class() binary.Class {
	return (*binaryClassGlUniformMatrix3x2fvNV)(nil)
}
func doEncodeGlUniformMatrix3x2fvNV(e binary.Encoder, o *GlUniformMatrix3x2fvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlUniformMatrix3x2fvNV(d binary.Decoder, o *GlUniformMatrix3x2fvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlUniformMatrix3x2fvNV(d binary.Decoder, o *GlUniformMatrix3x2fvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlUniformMatrix3x2fvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix3x2fvNV(e, obj.(*GlUniformMatrix3x2fvNV))
}
func (*binaryClassGlUniformMatrix3x2fvNV) New() binary.Object {
	return &GlUniformMatrix3x2fvNV{}
}
func (*binaryClassGlUniformMatrix3x2fvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix3x2fvNV(d, obj.(*GlUniformMatrix3x2fvNV))
}
func (c *binaryClassGlUniformMatrix3x2fvNV) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix3x2fvNV]
}

type binaryClassGlUniformMatrix3x4fv struct{}

func (*GlUniformMatrix3x4fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix3x4fv)(nil)
}
func doEncodeGlUniformMatrix3x4fv(e binary.Encoder, o *GlUniformMatrix3x4fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlUniformMatrix3x4fv(d binary.Decoder, o *GlUniformMatrix3x4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniformMatrix3x4fv(d binary.Decoder, o *GlUniformMatrix3x4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniformMatrix3x4fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix3x4fv(e, obj.(*GlUniformMatrix3x4fv))
}
func (*binaryClassGlUniformMatrix3x4fv) New() binary.Object {
	return &GlUniformMatrix3x4fv{}
}
func (*binaryClassGlUniformMatrix3x4fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix3x4fv(d, obj.(*GlUniformMatrix3x4fv))
}
func (c *binaryClassGlUniformMatrix3x4fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix3x4fv]
}

type binaryClassGlUniformMatrix3x4fvNV struct{}

func (*GlUniformMatrix3x4fvNV) Class() binary.Class {
	return (*binaryClassGlUniformMatrix3x4fvNV)(nil)
}
func doEncodeGlUniformMatrix3x4fvNV(e binary.Encoder, o *GlUniformMatrix3x4fvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlUniformMatrix3x4fvNV(d binary.Decoder, o *GlUniformMatrix3x4fvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlUniformMatrix3x4fvNV(d binary.Decoder, o *GlUniformMatrix3x4fvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlUniformMatrix3x4fvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix3x4fvNV(e, obj.(*GlUniformMatrix3x4fvNV))
}
func (*binaryClassGlUniformMatrix3x4fvNV) New() binary.Object {
	return &GlUniformMatrix3x4fvNV{}
}
func (*binaryClassGlUniformMatrix3x4fvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix3x4fvNV(d, obj.(*GlUniformMatrix3x4fvNV))
}
func (c *binaryClassGlUniformMatrix3x4fvNV) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix3x4fvNV]
}

type binaryClassGlUniformMatrix4fv struct{}

func (*GlUniformMatrix4fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix4fv)(nil)
}
func doEncodeGlUniformMatrix4fv(e binary.Encoder, o *GlUniformMatrix4fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlUniformMatrix4fv(d binary.Decoder, o *GlUniformMatrix4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniformMatrix4fv(d binary.Decoder, o *GlUniformMatrix4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniformMatrix4fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix4fv(e, obj.(*GlUniformMatrix4fv))
}
func (*binaryClassGlUniformMatrix4fv) New() binary.Object {
	return &GlUniformMatrix4fv{}
}
func (*binaryClassGlUniformMatrix4fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix4fv(d, obj.(*GlUniformMatrix4fv))
}
func (c *binaryClassGlUniformMatrix4fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix4fv]
}

type binaryClassGlUniformMatrix4x2fv struct{}

func (*GlUniformMatrix4x2fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix4x2fv)(nil)
}
func doEncodeGlUniformMatrix4x2fv(e binary.Encoder, o *GlUniformMatrix4x2fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlUniformMatrix4x2fv(d binary.Decoder, o *GlUniformMatrix4x2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniformMatrix4x2fv(d binary.Decoder, o *GlUniformMatrix4x2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniformMatrix4x2fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix4x2fv(e, obj.(*GlUniformMatrix4x2fv))
}
func (*binaryClassGlUniformMatrix4x2fv) New() binary.Object {
	return &GlUniformMatrix4x2fv{}
}
func (*binaryClassGlUniformMatrix4x2fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix4x2fv(d, obj.(*GlUniformMatrix4x2fv))
}
func (c *binaryClassGlUniformMatrix4x2fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix4x2fv]
}

type binaryClassGlUniformMatrix4x2fvNV struct{}

func (*GlUniformMatrix4x2fvNV) Class() binary.Class {
	return (*binaryClassGlUniformMatrix4x2fvNV)(nil)
}
func doEncodeGlUniformMatrix4x2fvNV(e binary.Encoder, o *GlUniformMatrix4x2fvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlUniformMatrix4x2fvNV(d binary.Decoder, o *GlUniformMatrix4x2fvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlUniformMatrix4x2fvNV(d binary.Decoder, o *GlUniformMatrix4x2fvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlUniformMatrix4x2fvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix4x2fvNV(e, obj.(*GlUniformMatrix4x2fvNV))
}
func (*binaryClassGlUniformMatrix4x2fvNV) New() binary.Object {
	return &GlUniformMatrix4x2fvNV{}
}
func (*binaryClassGlUniformMatrix4x2fvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix4x2fvNV(d, obj.(*GlUniformMatrix4x2fvNV))
}
func (c *binaryClassGlUniformMatrix4x2fvNV) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix4x2fvNV]
}

type binaryClassGlUniformMatrix4x3fv struct{}

func (*GlUniformMatrix4x3fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix4x3fv)(nil)
}
func doEncodeGlUniformMatrix4x3fv(e binary.Encoder, o *GlUniformMatrix4x3fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Values)
}
func doDecodeGlUniformMatrix4x3fv(d binary.Decoder, o *GlUniformMatrix4x3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func doDecodeRawGlUniformMatrix4x3fv(d binary.Decoder, o *GlUniformMatrix4x3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Values)
}
func (*binaryClassGlUniformMatrix4x3fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix4x3fv(e, obj.(*GlUniformMatrix4x3fv))
}
func (*binaryClassGlUniformMatrix4x3fv) New() binary.Object {
	return &GlUniformMatrix4x3fv{}
}
func (*binaryClassGlUniformMatrix4x3fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix4x3fv(d, obj.(*GlUniformMatrix4x3fv))
}
func (c *binaryClassGlUniformMatrix4x3fv) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix4x3fv]
}

type binaryClassGlUniformMatrix4x3fvNV struct{}

func (*GlUniformMatrix4x3fvNV) Class() binary.Class {
	return (*binaryClassGlUniformMatrix4x3fvNV)(nil)
}
func doEncodeGlUniformMatrix4x3fvNV(e binary.Encoder, o *GlUniformMatrix4x3fvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Location))
	e.Int32(int32(o.Count))
	e.Uint8(uint8(o.Transpose))
	e.Simple(&o.Value)
}
func doDecodeGlUniformMatrix4x3fvNV(d binary.Decoder, o *GlUniformMatrix4x3fvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func doDecodeRawGlUniformMatrix4x3fvNV(d binary.Decoder, o *GlUniformMatrix4x3fvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = UniformLocation(d.Int32())
	o.Count = GLsizei(d.Int32())
	o.Transpose = GLboolean(d.Uint8())
	d.Simple(&o.Value)
}
func (*binaryClassGlUniformMatrix4x3fvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUniformMatrix4x3fvNV(e, obj.(*GlUniformMatrix4x3fvNV))
}
func (*binaryClassGlUniformMatrix4x3fvNV) New() binary.Object {
	return &GlUniformMatrix4x3fvNV{}
}
func (*binaryClassGlUniformMatrix4x3fvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUniformMatrix4x3fvNV(d, obj.(*GlUniformMatrix4x3fvNV))
}
func (c *binaryClassGlUniformMatrix4x3fvNV) Schema() *binary.Entity {
	return &entities[ixǁGlUniformMatrix4x3fvNV]
}

type binaryClassGlUnmapBuffer struct{}

func (*GlUnmapBuffer) Class() binary.Class {
	return (*binaryClassGlUnmapBuffer)(nil)
}
func doEncodeGlUnmapBuffer(e binary.Encoder, o *GlUnmapBuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlUnmapBuffer(d binary.Decoder, o *GlUnmapBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlUnmapBuffer(d binary.Decoder, o *GlUnmapBuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlUnmapBuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUnmapBuffer(e, obj.(*GlUnmapBuffer))
}
func (*binaryClassGlUnmapBuffer) New() binary.Object {
	return &GlUnmapBuffer{}
}
func (*binaryClassGlUnmapBuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUnmapBuffer(d, obj.(*GlUnmapBuffer))
}
func (c *binaryClassGlUnmapBuffer) Schema() *binary.Entity {
	return &entities[ixǁGlUnmapBuffer]
}

type binaryClassGlUnmapBufferOES struct{}

func (*GlUnmapBufferOES) Class() binary.Class {
	return (*binaryClassGlUnmapBufferOES)(nil)
}
func doEncodeGlUnmapBufferOES(e binary.Encoder, o *GlUnmapBufferOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Target))
	e.Uint8(uint8(o.Result))
}
func doDecodeGlUnmapBufferOES(d binary.Decoder, o *GlUnmapBufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func doDecodeRawGlUnmapBufferOES(d binary.Decoder, o *GlUnmapBufferOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Target = GLenum(d.Uint32())
	o.Result = GLboolean(d.Uint8())
}
func (*binaryClassGlUnmapBufferOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUnmapBufferOES(e, obj.(*GlUnmapBufferOES))
}
func (*binaryClassGlUnmapBufferOES) New() binary.Object {
	return &GlUnmapBufferOES{}
}
func (*binaryClassGlUnmapBufferOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUnmapBufferOES(d, obj.(*GlUnmapBufferOES))
}
func (c *binaryClassGlUnmapBufferOES) Schema() *binary.Entity {
	return &entities[ixǁGlUnmapBufferOES]
}

type binaryClassGlUseProgram struct{}

func (*GlUseProgram) Class() binary.Class {
	return (*binaryClassGlUseProgram)(nil)
}
func doEncodeGlUseProgram(e binary.Encoder, o *GlUseProgram) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
}
func doDecodeGlUseProgram(d binary.Decoder, o *GlUseProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
}
func doDecodeRawGlUseProgram(d binary.Decoder, o *GlUseProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
}
func (*binaryClassGlUseProgram) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUseProgram(e, obj.(*GlUseProgram))
}
func (*binaryClassGlUseProgram) New() binary.Object {
	return &GlUseProgram{}
}
func (*binaryClassGlUseProgram) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUseProgram(d, obj.(*GlUseProgram))
}
func (c *binaryClassGlUseProgram) Schema() *binary.Entity {
	return &entities[ixǁGlUseProgram]
}

type binaryClassGlUseProgramStages struct{}

func (*GlUseProgramStages) Class() binary.Class {
	return (*binaryClassGlUseProgramStages)(nil)
}
func doEncodeGlUseProgramStages(e binary.Encoder, o *GlUseProgramStages) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
	e.Uint32(uint32(o.Stages))
	e.Uint32(uint32(o.Program))
}
func doDecodeGlUseProgramStages(d binary.Decoder, o *GlUseProgramStages) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Stages = GLbitfield(d.Uint32())
	o.Program = ProgramId(d.Uint32())
}
func doDecodeRawGlUseProgramStages(d binary.Decoder, o *GlUseProgramStages) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Stages = GLbitfield(d.Uint32())
	o.Program = ProgramId(d.Uint32())
}
func (*binaryClassGlUseProgramStages) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUseProgramStages(e, obj.(*GlUseProgramStages))
}
func (*binaryClassGlUseProgramStages) New() binary.Object {
	return &GlUseProgramStages{}
}
func (*binaryClassGlUseProgramStages) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUseProgramStages(d, obj.(*GlUseProgramStages))
}
func (c *binaryClassGlUseProgramStages) Schema() *binary.Entity {
	return &entities[ixǁGlUseProgramStages]
}

type binaryClassGlUseProgramStagesEXT struct{}

func (*GlUseProgramStagesEXT) Class() binary.Class {
	return (*binaryClassGlUseProgramStagesEXT)(nil)
}
func doEncodeGlUseProgramStagesEXT(e binary.Encoder, o *GlUseProgramStagesEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
	e.Uint32(uint32(o.Stages))
	e.Uint32(uint32(o.Program))
}
func doDecodeGlUseProgramStagesEXT(d binary.Decoder, o *GlUseProgramStagesEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Stages = GLbitfield(d.Uint32())
	o.Program = ProgramId(d.Uint32())
}
func doDecodeRawGlUseProgramStagesEXT(d binary.Decoder, o *GlUseProgramStagesEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
	o.Stages = GLbitfield(d.Uint32())
	o.Program = ProgramId(d.Uint32())
}
func (*binaryClassGlUseProgramStagesEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlUseProgramStagesEXT(e, obj.(*GlUseProgramStagesEXT))
}
func (*binaryClassGlUseProgramStagesEXT) New() binary.Object {
	return &GlUseProgramStagesEXT{}
}
func (*binaryClassGlUseProgramStagesEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlUseProgramStagesEXT(d, obj.(*GlUseProgramStagesEXT))
}
func (c *binaryClassGlUseProgramStagesEXT) Schema() *binary.Entity {
	return &entities[ixǁGlUseProgramStagesEXT]
}

type binaryClassGlValidateProgram struct{}

func (*GlValidateProgram) Class() binary.Class {
	return (*binaryClassGlValidateProgram)(nil)
}
func doEncodeGlValidateProgram(e binary.Encoder, o *GlValidateProgram) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Program))
}
func doDecodeGlValidateProgram(d binary.Decoder, o *GlValidateProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
}
func doDecodeRawGlValidateProgram(d binary.Decoder, o *GlValidateProgram) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Program = ProgramId(d.Uint32())
}
func (*binaryClassGlValidateProgram) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlValidateProgram(e, obj.(*GlValidateProgram))
}
func (*binaryClassGlValidateProgram) New() binary.Object {
	return &GlValidateProgram{}
}
func (*binaryClassGlValidateProgram) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlValidateProgram(d, obj.(*GlValidateProgram))
}
func (c *binaryClassGlValidateProgram) Schema() *binary.Entity {
	return &entities[ixǁGlValidateProgram]
}

type binaryClassGlValidateProgramPipeline struct{}

func (*GlValidateProgramPipeline) Class() binary.Class {
	return (*binaryClassGlValidateProgramPipeline)(nil)
}
func doEncodeGlValidateProgramPipeline(e binary.Encoder, o *GlValidateProgramPipeline) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
}
func doDecodeGlValidateProgramPipeline(d binary.Decoder, o *GlValidateProgramPipeline) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
}
func doDecodeRawGlValidateProgramPipeline(d binary.Decoder, o *GlValidateProgramPipeline) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
}
func (*binaryClassGlValidateProgramPipeline) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlValidateProgramPipeline(e, obj.(*GlValidateProgramPipeline))
}
func (*binaryClassGlValidateProgramPipeline) New() binary.Object {
	return &GlValidateProgramPipeline{}
}
func (*binaryClassGlValidateProgramPipeline) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlValidateProgramPipeline(d, obj.(*GlValidateProgramPipeline))
}
func (c *binaryClassGlValidateProgramPipeline) Schema() *binary.Entity {
	return &entities[ixǁGlValidateProgramPipeline]
}

type binaryClassGlValidateProgramPipelineEXT struct{}

func (*GlValidateProgramPipelineEXT) Class() binary.Class {
	return (*binaryClassGlValidateProgramPipelineEXT)(nil)
}
func doEncodeGlValidateProgramPipelineEXT(e binary.Encoder, o *GlValidateProgramPipelineEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Pipeline))
}
func doDecodeGlValidateProgramPipelineEXT(d binary.Decoder, o *GlValidateProgramPipelineEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
}
func doDecodeRawGlValidateProgramPipelineEXT(d binary.Decoder, o *GlValidateProgramPipelineEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Pipeline = PipelineId(d.Uint32())
}
func (*binaryClassGlValidateProgramPipelineEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlValidateProgramPipelineEXT(e, obj.(*GlValidateProgramPipelineEXT))
}
func (*binaryClassGlValidateProgramPipelineEXT) New() binary.Object {
	return &GlValidateProgramPipelineEXT{}
}
func (*binaryClassGlValidateProgramPipelineEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlValidateProgramPipelineEXT(d, obj.(*GlValidateProgramPipelineEXT))
}
func (c *binaryClassGlValidateProgramPipelineEXT) Schema() *binary.Entity {
	return &entities[ixǁGlValidateProgramPipelineEXT]
}

type binaryClassGlVertexAttrib1f struct{}

func (*GlVertexAttrib1f) Class() binary.Class {
	return (*binaryClassGlVertexAttrib1f)(nil)
}
func doEncodeGlVertexAttrib1f(e binary.Encoder, o *GlVertexAttrib1f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Location))
	e.Float32(float32(o.Value0))
}
func doDecodeGlVertexAttrib1f(d binary.Decoder, o *GlVertexAttrib1f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	o.Value0 = GLfloat(d.Float32())
}
func doDecodeRawGlVertexAttrib1f(d binary.Decoder, o *GlVertexAttrib1f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	o.Value0 = GLfloat(d.Float32())
}
func (*binaryClassGlVertexAttrib1f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttrib1f(e, obj.(*GlVertexAttrib1f))
}
func (*binaryClassGlVertexAttrib1f) New() binary.Object {
	return &GlVertexAttrib1f{}
}
func (*binaryClassGlVertexAttrib1f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttrib1f(d, obj.(*GlVertexAttrib1f))
}
func (c *binaryClassGlVertexAttrib1f) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttrib1f]
}

type binaryClassGlVertexAttrib1fv struct{}

func (*GlVertexAttrib1fv) Class() binary.Class {
	return (*binaryClassGlVertexAttrib1fv)(nil)
}
func doEncodeGlVertexAttrib1fv(e binary.Encoder, o *GlVertexAttrib1fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Location))
	e.Simple(&o.Value)
}
func doDecodeGlVertexAttrib1fv(d binary.Decoder, o *GlVertexAttrib1fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlVertexAttrib1fv(d binary.Decoder, o *GlVertexAttrib1fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlVertexAttrib1fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttrib1fv(e, obj.(*GlVertexAttrib1fv))
}
func (*binaryClassGlVertexAttrib1fv) New() binary.Object {
	return &GlVertexAttrib1fv{}
}
func (*binaryClassGlVertexAttrib1fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttrib1fv(d, obj.(*GlVertexAttrib1fv))
}
func (c *binaryClassGlVertexAttrib1fv) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttrib1fv]
}

type binaryClassGlVertexAttrib2f struct{}

func (*GlVertexAttrib2f) Class() binary.Class {
	return (*binaryClassGlVertexAttrib2f)(nil)
}
func doEncodeGlVertexAttrib2f(e binary.Encoder, o *GlVertexAttrib2f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Location))
	e.Float32(float32(o.Value0))
	e.Float32(float32(o.Value1))
}
func doDecodeGlVertexAttrib2f(d binary.Decoder, o *GlVertexAttrib2f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
}
func doDecodeRawGlVertexAttrib2f(d binary.Decoder, o *GlVertexAttrib2f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
}
func (*binaryClassGlVertexAttrib2f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttrib2f(e, obj.(*GlVertexAttrib2f))
}
func (*binaryClassGlVertexAttrib2f) New() binary.Object {
	return &GlVertexAttrib2f{}
}
func (*binaryClassGlVertexAttrib2f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttrib2f(d, obj.(*GlVertexAttrib2f))
}
func (c *binaryClassGlVertexAttrib2f) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttrib2f]
}

type binaryClassGlVertexAttrib2fv struct{}

func (*GlVertexAttrib2fv) Class() binary.Class {
	return (*binaryClassGlVertexAttrib2fv)(nil)
}
func doEncodeGlVertexAttrib2fv(e binary.Encoder, o *GlVertexAttrib2fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Location))
	e.Simple(&o.Value)
}
func doDecodeGlVertexAttrib2fv(d binary.Decoder, o *GlVertexAttrib2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlVertexAttrib2fv(d binary.Decoder, o *GlVertexAttrib2fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlVertexAttrib2fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttrib2fv(e, obj.(*GlVertexAttrib2fv))
}
func (*binaryClassGlVertexAttrib2fv) New() binary.Object {
	return &GlVertexAttrib2fv{}
}
func (*binaryClassGlVertexAttrib2fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttrib2fv(d, obj.(*GlVertexAttrib2fv))
}
func (c *binaryClassGlVertexAttrib2fv) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttrib2fv]
}

type binaryClassGlVertexAttrib3f struct{}

func (*GlVertexAttrib3f) Class() binary.Class {
	return (*binaryClassGlVertexAttrib3f)(nil)
}
func doEncodeGlVertexAttrib3f(e binary.Encoder, o *GlVertexAttrib3f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Location))
	e.Float32(float32(o.Value0))
	e.Float32(float32(o.Value1))
	e.Float32(float32(o.Value2))
}
func doDecodeGlVertexAttrib3f(d binary.Decoder, o *GlVertexAttrib3f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
	o.Value2 = GLfloat(d.Float32())
}
func doDecodeRawGlVertexAttrib3f(d binary.Decoder, o *GlVertexAttrib3f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
	o.Value2 = GLfloat(d.Float32())
}
func (*binaryClassGlVertexAttrib3f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttrib3f(e, obj.(*GlVertexAttrib3f))
}
func (*binaryClassGlVertexAttrib3f) New() binary.Object {
	return &GlVertexAttrib3f{}
}
func (*binaryClassGlVertexAttrib3f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttrib3f(d, obj.(*GlVertexAttrib3f))
}
func (c *binaryClassGlVertexAttrib3f) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttrib3f]
}

type binaryClassGlVertexAttrib3fv struct{}

func (*GlVertexAttrib3fv) Class() binary.Class {
	return (*binaryClassGlVertexAttrib3fv)(nil)
}
func doEncodeGlVertexAttrib3fv(e binary.Encoder, o *GlVertexAttrib3fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Location))
	e.Simple(&o.Value)
}
func doDecodeGlVertexAttrib3fv(d binary.Decoder, o *GlVertexAttrib3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlVertexAttrib3fv(d binary.Decoder, o *GlVertexAttrib3fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlVertexAttrib3fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttrib3fv(e, obj.(*GlVertexAttrib3fv))
}
func (*binaryClassGlVertexAttrib3fv) New() binary.Object {
	return &GlVertexAttrib3fv{}
}
func (*binaryClassGlVertexAttrib3fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttrib3fv(d, obj.(*GlVertexAttrib3fv))
}
func (c *binaryClassGlVertexAttrib3fv) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttrib3fv]
}

type binaryClassGlVertexAttrib4f struct{}

func (*GlVertexAttrib4f) Class() binary.Class {
	return (*binaryClassGlVertexAttrib4f)(nil)
}
func doEncodeGlVertexAttrib4f(e binary.Encoder, o *GlVertexAttrib4f) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Location))
	e.Float32(float32(o.Value0))
	e.Float32(float32(o.Value1))
	e.Float32(float32(o.Value2))
	e.Float32(float32(o.Value3))
}
func doDecodeGlVertexAttrib4f(d binary.Decoder, o *GlVertexAttrib4f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
	o.Value2 = GLfloat(d.Float32())
	o.Value3 = GLfloat(d.Float32())
}
func doDecodeRawGlVertexAttrib4f(d binary.Decoder, o *GlVertexAttrib4f) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	o.Value0 = GLfloat(d.Float32())
	o.Value1 = GLfloat(d.Float32())
	o.Value2 = GLfloat(d.Float32())
	o.Value3 = GLfloat(d.Float32())
}
func (*binaryClassGlVertexAttrib4f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttrib4f(e, obj.(*GlVertexAttrib4f))
}
func (*binaryClassGlVertexAttrib4f) New() binary.Object {
	return &GlVertexAttrib4f{}
}
func (*binaryClassGlVertexAttrib4f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttrib4f(d, obj.(*GlVertexAttrib4f))
}
func (c *binaryClassGlVertexAttrib4f) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttrib4f]
}

type binaryClassGlVertexAttrib4fv struct{}

func (*GlVertexAttrib4fv) Class() binary.Class {
	return (*binaryClassGlVertexAttrib4fv)(nil)
}
func doEncodeGlVertexAttrib4fv(e binary.Encoder, o *GlVertexAttrib4fv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Location))
	e.Simple(&o.Value)
}
func doDecodeGlVertexAttrib4fv(d binary.Decoder, o *GlVertexAttrib4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	d.Simple(&o.Value)
}
func doDecodeRawGlVertexAttrib4fv(d binary.Decoder, o *GlVertexAttrib4fv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	d.Simple(&o.Value)
}
func (*binaryClassGlVertexAttrib4fv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttrib4fv(e, obj.(*GlVertexAttrib4fv))
}
func (*binaryClassGlVertexAttrib4fv) New() binary.Object {
	return &GlVertexAttrib4fv{}
}
func (*binaryClassGlVertexAttrib4fv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttrib4fv(d, obj.(*GlVertexAttrib4fv))
}
func (c *binaryClassGlVertexAttrib4fv) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttrib4fv]
}

type binaryClassGlVertexAttribBinding struct{}

func (*GlVertexAttribBinding) Class() binary.Class {
	return (*binaryClassGlVertexAttribBinding)(nil)
}
func doEncodeGlVertexAttribBinding(e binary.Encoder, o *GlVertexAttribBinding) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.BindingIndex))
}
func doDecodeGlVertexAttribBinding(d binary.Decoder, o *GlVertexAttribBinding) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.BindingIndex = VertexBufferBindingIndex(d.Uint32())
}
func doDecodeRawGlVertexAttribBinding(d binary.Decoder, o *GlVertexAttribBinding) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.BindingIndex = VertexBufferBindingIndex(d.Uint32())
}
func (*binaryClassGlVertexAttribBinding) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribBinding(e, obj.(*GlVertexAttribBinding))
}
func (*binaryClassGlVertexAttribBinding) New() binary.Object {
	return &GlVertexAttribBinding{}
}
func (*binaryClassGlVertexAttribBinding) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribBinding(d, obj.(*GlVertexAttribBinding))
}
func (c *binaryClassGlVertexAttribBinding) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribBinding]
}

type binaryClassGlVertexAttribDivisor struct{}

func (*GlVertexAttribDivisor) Class() binary.Class {
	return (*binaryClassGlVertexAttribDivisor)(nil)
}
func doEncodeGlVertexAttribDivisor(e binary.Encoder, o *GlVertexAttribDivisor) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.Divisor))
}
func doDecodeGlVertexAttribDivisor(d binary.Decoder, o *GlVertexAttribDivisor) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Divisor = GLuint(d.Uint32())
}
func doDecodeRawGlVertexAttribDivisor(d binary.Decoder, o *GlVertexAttribDivisor) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Divisor = GLuint(d.Uint32())
}
func (*binaryClassGlVertexAttribDivisor) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribDivisor(e, obj.(*GlVertexAttribDivisor))
}
func (*binaryClassGlVertexAttribDivisor) New() binary.Object {
	return &GlVertexAttribDivisor{}
}
func (*binaryClassGlVertexAttribDivisor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribDivisor(d, obj.(*GlVertexAttribDivisor))
}
func (c *binaryClassGlVertexAttribDivisor) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribDivisor]
}

type binaryClassGlVertexAttribDivisorANGLE struct{}

func (*GlVertexAttribDivisorANGLE) Class() binary.Class {
	return (*binaryClassGlVertexAttribDivisorANGLE)(nil)
}
func doEncodeGlVertexAttribDivisorANGLE(e binary.Encoder, o *GlVertexAttribDivisorANGLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.Divisor))
}
func doDecodeGlVertexAttribDivisorANGLE(d binary.Decoder, o *GlVertexAttribDivisorANGLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Divisor = GLuint(d.Uint32())
}
func doDecodeRawGlVertexAttribDivisorANGLE(d binary.Decoder, o *GlVertexAttribDivisorANGLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Divisor = GLuint(d.Uint32())
}
func (*binaryClassGlVertexAttribDivisorANGLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribDivisorANGLE(e, obj.(*GlVertexAttribDivisorANGLE))
}
func (*binaryClassGlVertexAttribDivisorANGLE) New() binary.Object {
	return &GlVertexAttribDivisorANGLE{}
}
func (*binaryClassGlVertexAttribDivisorANGLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribDivisorANGLE(d, obj.(*GlVertexAttribDivisorANGLE))
}
func (c *binaryClassGlVertexAttribDivisorANGLE) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribDivisorANGLE]
}

type binaryClassGlVertexAttribDivisorEXT struct{}

func (*GlVertexAttribDivisorEXT) Class() binary.Class {
	return (*binaryClassGlVertexAttribDivisorEXT)(nil)
}
func doEncodeGlVertexAttribDivisorEXT(e binary.Encoder, o *GlVertexAttribDivisorEXT) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.Divisor))
}
func doDecodeGlVertexAttribDivisorEXT(d binary.Decoder, o *GlVertexAttribDivisorEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Divisor = GLuint(d.Uint32())
}
func doDecodeRawGlVertexAttribDivisorEXT(d binary.Decoder, o *GlVertexAttribDivisorEXT) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Divisor = GLuint(d.Uint32())
}
func (*binaryClassGlVertexAttribDivisorEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribDivisorEXT(e, obj.(*GlVertexAttribDivisorEXT))
}
func (*binaryClassGlVertexAttribDivisorEXT) New() binary.Object {
	return &GlVertexAttribDivisorEXT{}
}
func (*binaryClassGlVertexAttribDivisorEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribDivisorEXT(d, obj.(*GlVertexAttribDivisorEXT))
}
func (c *binaryClassGlVertexAttribDivisorEXT) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribDivisorEXT]
}

type binaryClassGlVertexAttribDivisorNV struct{}

func (*GlVertexAttribDivisorNV) Class() binary.Class {
	return (*binaryClassGlVertexAttribDivisorNV)(nil)
}
func doEncodeGlVertexAttribDivisorNV(e binary.Encoder, o *GlVertexAttribDivisorNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.Divisor))
}
func doDecodeGlVertexAttribDivisorNV(d binary.Decoder, o *GlVertexAttribDivisorNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Divisor = GLuint(d.Uint32())
}
func doDecodeRawGlVertexAttribDivisorNV(d binary.Decoder, o *GlVertexAttribDivisorNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Divisor = GLuint(d.Uint32())
}
func (*binaryClassGlVertexAttribDivisorNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribDivisorNV(e, obj.(*GlVertexAttribDivisorNV))
}
func (*binaryClassGlVertexAttribDivisorNV) New() binary.Object {
	return &GlVertexAttribDivisorNV{}
}
func (*binaryClassGlVertexAttribDivisorNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribDivisorNV(d, obj.(*GlVertexAttribDivisorNV))
}
func (c *binaryClassGlVertexAttribDivisorNV) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribDivisorNV]
}

type binaryClassGlVertexAttribFormat struct{}

func (*GlVertexAttribFormat) Class() binary.Class {
	return (*binaryClassGlVertexAttribFormat)(nil)
}
func doEncodeGlVertexAttribFormat(e binary.Encoder, o *GlVertexAttribFormat) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Uint8(uint8(o.Normalized))
	e.Uint32(uint32(o.Relativeoffset))
}
func doDecodeGlVertexAttribFormat(d binary.Decoder, o *GlVertexAttribFormat) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Normalized = GLboolean(d.Uint8())
	o.Relativeoffset = GLuint(d.Uint32())
}
func doDecodeRawGlVertexAttribFormat(d binary.Decoder, o *GlVertexAttribFormat) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Normalized = GLboolean(d.Uint8())
	o.Relativeoffset = GLuint(d.Uint32())
}
func (*binaryClassGlVertexAttribFormat) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribFormat(e, obj.(*GlVertexAttribFormat))
}
func (*binaryClassGlVertexAttribFormat) New() binary.Object {
	return &GlVertexAttribFormat{}
}
func (*binaryClassGlVertexAttribFormat) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribFormat(d, obj.(*GlVertexAttribFormat))
}
func (c *binaryClassGlVertexAttribFormat) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribFormat]
}

type binaryClassGlVertexAttribI4i struct{}

func (*GlVertexAttribI4i) Class() binary.Class {
	return (*binaryClassGlVertexAttribI4i)(nil)
}
func doEncodeGlVertexAttribI4i(e binary.Encoder, o *GlVertexAttribI4i) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Z))
	e.Int32(int32(o.W))
}
func doDecodeGlVertexAttribI4i(d binary.Decoder, o *GlVertexAttribI4i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Z = GLint(d.Int32())
	o.W = GLint(d.Int32())
}
func doDecodeRawGlVertexAttribI4i(d binary.Decoder, o *GlVertexAttribI4i) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Z = GLint(d.Int32())
	o.W = GLint(d.Int32())
}
func (*binaryClassGlVertexAttribI4i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribI4i(e, obj.(*GlVertexAttribI4i))
}
func (*binaryClassGlVertexAttribI4i) New() binary.Object {
	return &GlVertexAttribI4i{}
}
func (*binaryClassGlVertexAttribI4i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribI4i(d, obj.(*GlVertexAttribI4i))
}
func (c *binaryClassGlVertexAttribI4i) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribI4i]
}

type binaryClassGlVertexAttribI4iv struct{}

func (*GlVertexAttribI4iv) Class() binary.Class {
	return (*binaryClassGlVertexAttribI4iv)(nil)
}
func doEncodeGlVertexAttribI4iv(e binary.Encoder, o *GlVertexAttribI4iv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Simple(&o.Values)
}
func doDecodeGlVertexAttribI4iv(d binary.Decoder, o *GlVertexAttribI4iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	d.Simple(&o.Values)
}
func doDecodeRawGlVertexAttribI4iv(d binary.Decoder, o *GlVertexAttribI4iv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	d.Simple(&o.Values)
}
func (*binaryClassGlVertexAttribI4iv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribI4iv(e, obj.(*GlVertexAttribI4iv))
}
func (*binaryClassGlVertexAttribI4iv) New() binary.Object {
	return &GlVertexAttribI4iv{}
}
func (*binaryClassGlVertexAttribI4iv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribI4iv(d, obj.(*GlVertexAttribI4iv))
}
func (c *binaryClassGlVertexAttribI4iv) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribI4iv]
}

type binaryClassGlVertexAttribI4ui struct{}

func (*GlVertexAttribI4ui) Class() binary.Class {
	return (*binaryClassGlVertexAttribI4ui)(nil)
}
func doEncodeGlVertexAttribI4ui(e binary.Encoder, o *GlVertexAttribI4ui) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Uint32(uint32(o.X))
	e.Uint32(uint32(o.Y))
	e.Uint32(uint32(o.Z))
	e.Uint32(uint32(o.W))
}
func doDecodeGlVertexAttribI4ui(d binary.Decoder, o *GlVertexAttribI4ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.X = GLuint(d.Uint32())
	o.Y = GLuint(d.Uint32())
	o.Z = GLuint(d.Uint32())
	o.W = GLuint(d.Uint32())
}
func doDecodeRawGlVertexAttribI4ui(d binary.Decoder, o *GlVertexAttribI4ui) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.X = GLuint(d.Uint32())
	o.Y = GLuint(d.Uint32())
	o.Z = GLuint(d.Uint32())
	o.W = GLuint(d.Uint32())
}
func (*binaryClassGlVertexAttribI4ui) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribI4ui(e, obj.(*GlVertexAttribI4ui))
}
func (*binaryClassGlVertexAttribI4ui) New() binary.Object {
	return &GlVertexAttribI4ui{}
}
func (*binaryClassGlVertexAttribI4ui) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribI4ui(d, obj.(*GlVertexAttribI4ui))
}
func (c *binaryClassGlVertexAttribI4ui) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribI4ui]
}

type binaryClassGlVertexAttribI4uiv struct{}

func (*GlVertexAttribI4uiv) Class() binary.Class {
	return (*binaryClassGlVertexAttribI4uiv)(nil)
}
func doEncodeGlVertexAttribI4uiv(e binary.Encoder, o *GlVertexAttribI4uiv) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Simple(&o.Values)
}
func doDecodeGlVertexAttribI4uiv(d binary.Decoder, o *GlVertexAttribI4uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	d.Simple(&o.Values)
}
func doDecodeRawGlVertexAttribI4uiv(d binary.Decoder, o *GlVertexAttribI4uiv) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	d.Simple(&o.Values)
}
func (*binaryClassGlVertexAttribI4uiv) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribI4uiv(e, obj.(*GlVertexAttribI4uiv))
}
func (*binaryClassGlVertexAttribI4uiv) New() binary.Object {
	return &GlVertexAttribI4uiv{}
}
func (*binaryClassGlVertexAttribI4uiv) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribI4uiv(d, obj.(*GlVertexAttribI4uiv))
}
func (c *binaryClassGlVertexAttribI4uiv) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribI4uiv]
}

type binaryClassGlVertexAttribIFormat struct{}

func (*GlVertexAttribIFormat) Class() binary.Class {
	return (*binaryClassGlVertexAttribIFormat)(nil)
}
func doEncodeGlVertexAttribIFormat(e binary.Encoder, o *GlVertexAttribIFormat) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Uint32(uint32(o.Relativeoffset))
}
func doDecodeGlVertexAttribIFormat(d binary.Decoder, o *GlVertexAttribIFormat) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Relativeoffset = GLuint(d.Uint32())
}
func doDecodeRawGlVertexAttribIFormat(d binary.Decoder, o *GlVertexAttribIFormat) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = AttributeLocation(d.Uint32())
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Relativeoffset = GLuint(d.Uint32())
}
func (*binaryClassGlVertexAttribIFormat) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribIFormat(e, obj.(*GlVertexAttribIFormat))
}
func (*binaryClassGlVertexAttribIFormat) New() binary.Object {
	return &GlVertexAttribIFormat{}
}
func (*binaryClassGlVertexAttribIFormat) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribIFormat(d, obj.(*GlVertexAttribIFormat))
}
func (c *binaryClassGlVertexAttribIFormat) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribIFormat]
}

type binaryClassGlVertexAttribIPointer struct{}

func (*GlVertexAttribIPointer) Class() binary.Class {
	return (*binaryClassGlVertexAttribIPointer)(nil)
}
func doEncodeGlVertexAttribIPointer(e binary.Encoder, o *GlVertexAttribIPointer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Location))
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Data)
}
func doDecodeGlVertexAttribIPointer(d binary.Decoder, o *GlVertexAttribIPointer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func doDecodeRawGlVertexAttribIPointer(d binary.Decoder, o *GlVertexAttribIPointer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func (*binaryClassGlVertexAttribIPointer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribIPointer(e, obj.(*GlVertexAttribIPointer))
}
func (*binaryClassGlVertexAttribIPointer) New() binary.Object {
	return &GlVertexAttribIPointer{}
}
func (*binaryClassGlVertexAttribIPointer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribIPointer(d, obj.(*GlVertexAttribIPointer))
}
func (c *binaryClassGlVertexAttribIPointer) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribIPointer]
}

type binaryClassGlVertexAttribPointer struct{}

func (*GlVertexAttribPointer) Class() binary.Class {
	return (*binaryClassGlVertexAttribPointer)(nil)
}
func doEncodeGlVertexAttribPointer(e binary.Encoder, o *GlVertexAttribPointer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Location))
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Uint8(uint8(o.Normalized))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Data)
}
func doDecodeGlVertexAttribPointer(d binary.Decoder, o *GlVertexAttribPointer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Normalized = GLboolean(d.Uint8())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func doDecodeRawGlVertexAttribPointer(d binary.Decoder, o *GlVertexAttribPointer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Location = AttributeLocation(d.Uint32())
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Normalized = GLboolean(d.Uint8())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Data)
}
func (*binaryClassGlVertexAttribPointer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexAttribPointer(e, obj.(*GlVertexAttribPointer))
}
func (*binaryClassGlVertexAttribPointer) New() binary.Object {
	return &GlVertexAttribPointer{}
}
func (*binaryClassGlVertexAttribPointer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexAttribPointer(d, obj.(*GlVertexAttribPointer))
}
func (c *binaryClassGlVertexAttribPointer) Schema() *binary.Entity {
	return &entities[ixǁGlVertexAttribPointer]
}

type binaryClassGlVertexBindingDivisor struct{}

func (*GlVertexBindingDivisor) Class() binary.Class {
	return (*binaryClassGlVertexBindingDivisor)(nil)
}
func doEncodeGlVertexBindingDivisor(e binary.Encoder, o *GlVertexBindingDivisor) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.BindingIndex))
	e.Uint32(uint32(o.Divisor))
}
func doDecodeGlVertexBindingDivisor(d binary.Decoder, o *GlVertexBindingDivisor) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.BindingIndex = VertexBufferBindingIndex(d.Uint32())
	o.Divisor = GLuint(d.Uint32())
}
func doDecodeRawGlVertexBindingDivisor(d binary.Decoder, o *GlVertexBindingDivisor) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.BindingIndex = VertexBufferBindingIndex(d.Uint32())
	o.Divisor = GLuint(d.Uint32())
}
func (*binaryClassGlVertexBindingDivisor) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexBindingDivisor(e, obj.(*GlVertexBindingDivisor))
}
func (*binaryClassGlVertexBindingDivisor) New() binary.Object {
	return &GlVertexBindingDivisor{}
}
func (*binaryClassGlVertexBindingDivisor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexBindingDivisor(d, obj.(*GlVertexBindingDivisor))
}
func (c *binaryClassGlVertexBindingDivisor) Schema() *binary.Entity {
	return &entities[ixǁGlVertexBindingDivisor]
}

type binaryClassGlVertexPointer struct{}

func (*GlVertexPointer) Class() binary.Class {
	return (*binaryClassGlVertexPointer)(nil)
}
func doEncodeGlVertexPointer(e binary.Encoder, o *GlVertexPointer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
}
func doDecodeGlVertexPointer(d binary.Decoder, o *GlVertexPointer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func doDecodeRawGlVertexPointer(d binary.Decoder, o *GlVertexPointer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func (*binaryClassGlVertexPointer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexPointer(e, obj.(*GlVertexPointer))
}
func (*binaryClassGlVertexPointer) New() binary.Object {
	return &GlVertexPointer{}
}
func (*binaryClassGlVertexPointer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexPointer(d, obj.(*GlVertexPointer))
}
func (c *binaryClassGlVertexPointer) Schema() *binary.Entity {
	return &entities[ixǁGlVertexPointer]
}

type binaryClassGlVertexPointerBounds struct{}

func (*GlVertexPointerBounds) Class() binary.Class {
	return (*binaryClassGlVertexPointerBounds)(nil)
}
func doEncodeGlVertexPointerBounds(e binary.Encoder, o *GlVertexPointerBounds) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
	e.Int32(int32(o.Count))
}
func doDecodeGlVertexPointerBounds(d binary.Decoder, o *GlVertexPointerBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func doDecodeRawGlVertexPointerBounds(d binary.Decoder, o *GlVertexPointerBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func (*binaryClassGlVertexPointerBounds) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlVertexPointerBounds(e, obj.(*GlVertexPointerBounds))
}
func (*binaryClassGlVertexPointerBounds) New() binary.Object {
	return &GlVertexPointerBounds{}
}
func (*binaryClassGlVertexPointerBounds) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlVertexPointerBounds(d, obj.(*GlVertexPointerBounds))
}
func (c *binaryClassGlVertexPointerBounds) Schema() *binary.Entity {
	return &entities[ixǁGlVertexPointerBounds]
}

type binaryClassGlViewport struct{}

func (*GlViewport) Class() binary.Class {
	return (*binaryClassGlViewport)(nil)
}
func doEncodeGlViewport(e binary.Encoder, o *GlViewport) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.X))
	e.Int32(int32(o.Y))
	e.Int32(int32(o.Width))
	e.Int32(int32(o.Height))
}
func doDecodeGlViewport(d binary.Decoder, o *GlViewport) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func doDecodeRawGlViewport(d binary.Decoder, o *GlViewport) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.X = GLint(d.Int32())
	o.Y = GLint(d.Int32())
	o.Width = GLsizei(d.Int32())
	o.Height = GLsizei(d.Int32())
}
func (*binaryClassGlViewport) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlViewport(e, obj.(*GlViewport))
}
func (*binaryClassGlViewport) New() binary.Object {
	return &GlViewport{}
}
func (*binaryClassGlViewport) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlViewport(d, obj.(*GlViewport))
}
func (c *binaryClassGlViewport) Schema() *binary.Entity {
	return &entities[ixǁGlViewport]
}

type binaryClassGlViewportArrayvNV struct{}

func (*GlViewportArrayvNV) Class() binary.Class {
	return (*binaryClassGlViewportArrayvNV)(nil)
}
func doEncodeGlViewportArrayvNV(e binary.Encoder, o *GlViewportArrayvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.First))
	e.Int32(int32(o.Count))
	e.Simple(&o.V)
}
func doDecodeGlViewportArrayvNV(d binary.Decoder, o *GlViewportArrayvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.First = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func doDecodeRawGlViewportArrayvNV(d binary.Decoder, o *GlViewportArrayvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.First = GLuint(d.Uint32())
	o.Count = GLsizei(d.Int32())
	d.Simple(&o.V)
}
func (*binaryClassGlViewportArrayvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlViewportArrayvNV(e, obj.(*GlViewportArrayvNV))
}
func (*binaryClassGlViewportArrayvNV) New() binary.Object {
	return &GlViewportArrayvNV{}
}
func (*binaryClassGlViewportArrayvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlViewportArrayvNV(d, obj.(*GlViewportArrayvNV))
}
func (c *binaryClassGlViewportArrayvNV) Schema() *binary.Entity {
	return &entities[ixǁGlViewportArrayvNV]
}

type binaryClassGlViewportIndexedfNV struct{}

func (*GlViewportIndexedfNV) Class() binary.Class {
	return (*binaryClassGlViewportIndexedfNV)(nil)
}
func doEncodeGlViewportIndexedfNV(e binary.Encoder, o *GlViewportIndexedfNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Float32(float32(o.X))
	e.Float32(float32(o.Y))
	e.Float32(float32(o.W))
	e.Float32(float32(o.H))
}
func doDecodeGlViewportIndexedfNV(d binary.Decoder, o *GlViewportIndexedfNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = GLuint(d.Uint32())
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.W = GLfloat(d.Float32())
	o.H = GLfloat(d.Float32())
}
func doDecodeRawGlViewportIndexedfNV(d binary.Decoder, o *GlViewportIndexedfNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = GLuint(d.Uint32())
	o.X = GLfloat(d.Float32())
	o.Y = GLfloat(d.Float32())
	o.W = GLfloat(d.Float32())
	o.H = GLfloat(d.Float32())
}
func (*binaryClassGlViewportIndexedfNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlViewportIndexedfNV(e, obj.(*GlViewportIndexedfNV))
}
func (*binaryClassGlViewportIndexedfNV) New() binary.Object {
	return &GlViewportIndexedfNV{}
}
func (*binaryClassGlViewportIndexedfNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlViewportIndexedfNV(d, obj.(*GlViewportIndexedfNV))
}
func (c *binaryClassGlViewportIndexedfNV) Schema() *binary.Entity {
	return &entities[ixǁGlViewportIndexedfNV]
}

type binaryClassGlViewportIndexedfvNV struct{}

func (*GlViewportIndexedfvNV) Class() binary.Class {
	return (*binaryClassGlViewportIndexedfvNV)(nil)
}
func doEncodeGlViewportIndexedfvNV(e binary.Encoder, o *GlViewportIndexedfvNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.Index))
	e.Simple(&o.V)
}
func doDecodeGlViewportIndexedfvNV(d binary.Decoder, o *GlViewportIndexedfvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.V)
}
func doDecodeRawGlViewportIndexedfvNV(d binary.Decoder, o *GlViewportIndexedfvNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = GLuint(d.Uint32())
	d.Simple(&o.V)
}
func (*binaryClassGlViewportIndexedfvNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlViewportIndexedfvNV(e, obj.(*GlViewportIndexedfvNV))
}
func (*binaryClassGlViewportIndexedfvNV) New() binary.Object {
	return &GlViewportIndexedfvNV{}
}
func (*binaryClassGlViewportIndexedfvNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlViewportIndexedfvNV(d, obj.(*GlViewportIndexedfvNV))
}
func (c *binaryClassGlViewportIndexedfvNV) Schema() *binary.Entity {
	return &entities[ixǁGlViewportIndexedfvNV]
}

type binaryClassGlWaitSync struct{}

func (*GlWaitSync) Class() binary.Class {
	return (*binaryClassGlWaitSync)(nil)
}
func doEncodeGlWaitSync(e binary.Encoder, o *GlWaitSync) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Sync)
	e.Uint32(uint32(o.SyncFlags))
	e.Uint64(uint64(o.Timeout))
}
func doDecodeGlWaitSync(d binary.Decoder, o *GlWaitSync) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.SyncFlags = GLbitfield(d.Uint32())
	o.Timeout = GLuint64(d.Uint64())
}
func doDecodeRawGlWaitSync(d binary.Decoder, o *GlWaitSync) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.SyncFlags = GLbitfield(d.Uint32())
	o.Timeout = GLuint64(d.Uint64())
}
func (*binaryClassGlWaitSync) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlWaitSync(e, obj.(*GlWaitSync))
}
func (*binaryClassGlWaitSync) New() binary.Object {
	return &GlWaitSync{}
}
func (*binaryClassGlWaitSync) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlWaitSync(d, obj.(*GlWaitSync))
}
func (c *binaryClassGlWaitSync) Schema() *binary.Entity {
	return &entities[ixǁGlWaitSync]
}

type binaryClassGlWaitSyncAPPLE struct{}

func (*GlWaitSyncAPPLE) Class() binary.Class {
	return (*binaryClassGlWaitSyncAPPLE)(nil)
}
func doEncodeGlWaitSyncAPPLE(e binary.Encoder, o *GlWaitSyncAPPLE) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Sync)
	e.Uint32(uint32(o.Flag))
	e.Uint64(uint64(o.Timeout))
}
func doDecodeGlWaitSyncAPPLE(d binary.Decoder, o *GlWaitSyncAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.Flag = GLbitfield(d.Uint32())
	o.Timeout = GLuint64(d.Uint64())
}
func doDecodeRawGlWaitSyncAPPLE(d binary.Decoder, o *GlWaitSyncAPPLE) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Sync)
	o.Flag = GLbitfield(d.Uint32())
	o.Timeout = GLuint64(d.Uint64())
}
func (*binaryClassGlWaitSyncAPPLE) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlWaitSyncAPPLE(e, obj.(*GlWaitSyncAPPLE))
}
func (*binaryClassGlWaitSyncAPPLE) New() binary.Object {
	return &GlWaitSyncAPPLE{}
}
func (*binaryClassGlWaitSyncAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlWaitSyncAPPLE(d, obj.(*GlWaitSyncAPPLE))
}
func (c *binaryClassGlWaitSyncAPPLE) Schema() *binary.Entity {
	return &entities[ixǁGlWaitSyncAPPLE]
}

type binaryClassGlWeightPathsNV struct{}

func (*GlWeightPathsNV) Class() binary.Class {
	return (*binaryClassGlWeightPathsNV)(nil)
}
func doEncodeGlWeightPathsNV(e binary.Encoder, o *GlWeightPathsNV) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(uint32(o.ResultPath))
	e.Int32(int32(o.NumPaths))
	e.Simple(&o.Paths)
	e.Simple(&o.Weights)
}
func doDecodeGlWeightPathsNV(d binary.Decoder, o *GlWeightPathsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ResultPath = GLuint(d.Uint32())
	o.NumPaths = GLsizei(d.Int32())
	d.Simple(&o.Paths)
	d.Simple(&o.Weights)
}
func doDecodeRawGlWeightPathsNV(d binary.Decoder, o *GlWeightPathsNV) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.ResultPath = GLuint(d.Uint32())
	o.NumPaths = GLsizei(d.Int32())
	d.Simple(&o.Paths)
	d.Simple(&o.Weights)
}
func (*binaryClassGlWeightPathsNV) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlWeightPathsNV(e, obj.(*GlWeightPathsNV))
}
func (*binaryClassGlWeightPathsNV) New() binary.Object {
	return &GlWeightPathsNV{}
}
func (*binaryClassGlWeightPathsNV) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlWeightPathsNV(d, obj.(*GlWeightPathsNV))
}
func (c *binaryClassGlWeightPathsNV) Schema() *binary.Entity {
	return &entities[ixǁGlWeightPathsNV]
}

type binaryClassGlWeightPointerOES struct{}

func (*GlWeightPointerOES) Class() binary.Class {
	return (*binaryClassGlWeightPointerOES)(nil)
}
func doEncodeGlWeightPointerOES(e binary.Encoder, o *GlWeightPointerOES) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
}
func doDecodeGlWeightPointerOES(d binary.Decoder, o *GlWeightPointerOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func doDecodeRawGlWeightPointerOES(d binary.Decoder, o *GlWeightPointerOES) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
}
func (*binaryClassGlWeightPointerOES) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlWeightPointerOES(e, obj.(*GlWeightPointerOES))
}
func (*binaryClassGlWeightPointerOES) New() binary.Object {
	return &GlWeightPointerOES{}
}
func (*binaryClassGlWeightPointerOES) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlWeightPointerOES(d, obj.(*GlWeightPointerOES))
}
func (c *binaryClassGlWeightPointerOES) Schema() *binary.Entity {
	return &entities[ixǁGlWeightPointerOES]
}

type binaryClassGlWeightPointerOESBounds struct{}

func (*GlWeightPointerOESBounds) Class() binary.Class {
	return (*binaryClassGlWeightPointerOESBounds)(nil)
}
func doEncodeGlWeightPointerOESBounds(e binary.Encoder, o *GlWeightPointerOESBounds) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.Size))
	e.Uint32(uint32(o.Type))
	e.Int32(int32(o.Stride))
	e.Simple(&o.Pointer)
	e.Int32(int32(o.Count))
}
func doDecodeGlWeightPointerOESBounds(d binary.Decoder, o *GlWeightPointerOESBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func doDecodeRawGlWeightPointerOESBounds(d binary.Decoder, o *GlWeightPointerOESBounds) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Size = GLint(d.Int32())
	o.Type = GLenum(d.Uint32())
	o.Stride = GLsizei(d.Int32())
	d.Simple(&o.Pointer)
	o.Count = GLsizei(d.Int32())
}
func (*binaryClassGlWeightPointerOESBounds) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlWeightPointerOESBounds(e, obj.(*GlWeightPointerOESBounds))
}
func (*binaryClassGlWeightPointerOESBounds) New() binary.Object {
	return &GlWeightPointerOESBounds{}
}
func (*binaryClassGlWeightPointerOESBounds) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlWeightPointerOESBounds(d, obj.(*GlWeightPointerOESBounds))
}
func (c *binaryClassGlWeightPointerOESBounds) Schema() *binary.Entity {
	return &entities[ixǁGlWeightPointerOESBounds]
}

type binaryClassGlXCreateContext struct{}

func (*GlXCreateContext) Class() binary.Class {
	return (*binaryClassGlXCreateContext)(nil)
}
func doEncodeGlXCreateContext(e binary.Encoder, o *GlXCreateContext) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Dpy)
	e.Simple(&o.Vis)
	e.Simple(&o.ShareList)
	e.Bool(o.Direct)
	e.Simple(&o.Result)
}
func doDecodeGlXCreateContext(d binary.Decoder, o *GlXCreateContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Vis)
	d.Simple(&o.ShareList)
	o.Direct = bool(d.Bool())
	d.Simple(&o.Result)
}
func doDecodeRawGlXCreateContext(d binary.Decoder, o *GlXCreateContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Dpy)
	d.Simple(&o.Vis)
	d.Simple(&o.ShareList)
	o.Direct = bool(d.Bool())
	d.Simple(&o.Result)
}
func (*binaryClassGlXCreateContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlXCreateContext(e, obj.(*GlXCreateContext))
}
func (*binaryClassGlXCreateContext) New() binary.Object {
	return &GlXCreateContext{}
}
func (*binaryClassGlXCreateContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlXCreateContext(d, obj.(*GlXCreateContext))
}
func (c *binaryClassGlXCreateContext) Schema() *binary.Entity {
	return &entities[ixǁGlXCreateContext]
}

type binaryClassGlXCreateNewContext struct{}

func (*GlXCreateNewContext) Class() binary.Class {
	return (*binaryClassGlXCreateNewContext)(nil)
}
func doEncodeGlXCreateNewContext(e binary.Encoder, o *GlXCreateNewContext) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Fbconfig)
	e.Uint32(o.Type)
	e.Simple(&o.Shared)
	e.Bool(o.Direct)
	e.Simple(&o.Result)
}
func doDecodeGlXCreateNewContext(d binary.Decoder, o *GlXCreateNewContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Fbconfig)
	o.Type = uint32(d.Uint32())
	d.Simple(&o.Shared)
	o.Direct = bool(d.Bool())
	d.Simple(&o.Result)
}
func doDecodeRawGlXCreateNewContext(d binary.Decoder, o *GlXCreateNewContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Fbconfig)
	o.Type = uint32(d.Uint32())
	d.Simple(&o.Shared)
	o.Direct = bool(d.Bool())
	d.Simple(&o.Result)
}
func (*binaryClassGlXCreateNewContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlXCreateNewContext(e, obj.(*GlXCreateNewContext))
}
func (*binaryClassGlXCreateNewContext) New() binary.Object {
	return &GlXCreateNewContext{}
}
func (*binaryClassGlXCreateNewContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlXCreateNewContext(d, obj.(*GlXCreateNewContext))
}
func (c *binaryClassGlXCreateNewContext) Schema() *binary.Entity {
	return &entities[ixǁGlXCreateNewContext]
}

type binaryClassGlXMakeContextCurrent struct{}

func (*GlXMakeContextCurrent) Class() binary.Class {
	return (*binaryClassGlXMakeContextCurrent)(nil)
}
func doEncodeGlXMakeContextCurrent(e binary.Encoder, o *GlXMakeContextCurrent) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Draw)
	e.Simple(&o.Read)
	e.Simple(&o.Ctx)
	e.Int64(int64(o.Result))
}
func doDecodeGlXMakeContextCurrent(d binary.Decoder, o *GlXMakeContextCurrent) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Draw)
	d.Simple(&o.Read)
	d.Simple(&o.Ctx)
	o.Result = Bool(d.Int64())
}
func doDecodeRawGlXMakeContextCurrent(d binary.Decoder, o *GlXMakeContextCurrent) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Draw)
	d.Simple(&o.Read)
	d.Simple(&o.Ctx)
	o.Result = Bool(d.Int64())
}
func (*binaryClassGlXMakeContextCurrent) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlXMakeContextCurrent(e, obj.(*GlXMakeContextCurrent))
}
func (*binaryClassGlXMakeContextCurrent) New() binary.Object {
	return &GlXMakeContextCurrent{}
}
func (*binaryClassGlXMakeContextCurrent) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlXMakeContextCurrent(d, obj.(*GlXMakeContextCurrent))
}
func (c *binaryClassGlXMakeContextCurrent) Schema() *binary.Entity {
	return &entities[ixǁGlXMakeContextCurrent]
}

type binaryClassGlXMakeCurrent struct{}

func (*GlXMakeCurrent) Class() binary.Class {
	return (*binaryClassGlXMakeCurrent)(nil)
}
func doEncodeGlXMakeCurrent(e binary.Encoder, o *GlXMakeCurrent) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Drawable)
	e.Simple(&o.Ctx)
	e.Int64(int64(o.Result))
}
func doDecodeGlXMakeCurrent(d binary.Decoder, o *GlXMakeCurrent) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Drawable)
	d.Simple(&o.Ctx)
	o.Result = Bool(d.Int64())
}
func doDecodeRawGlXMakeCurrent(d binary.Decoder, o *GlXMakeCurrent) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Drawable)
	d.Simple(&o.Ctx)
	o.Result = Bool(d.Int64())
}
func (*binaryClassGlXMakeCurrent) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlXMakeCurrent(e, obj.(*GlXMakeCurrent))
}
func (*binaryClassGlXMakeCurrent) New() binary.Object {
	return &GlXMakeCurrent{}
}
func (*binaryClassGlXMakeCurrent) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlXMakeCurrent(d, obj.(*GlXMakeCurrent))
}
func (c *binaryClassGlXMakeCurrent) Schema() *binary.Entity {
	return &entities[ixǁGlXMakeCurrent]
}

type binaryClassIntᵖ struct{}

func (*Intᵖ) Class() binary.Class {
	return (*binaryClassIntᵖ)(nil)
}
func doEncodeIntᵖ(e binary.Writer, o *Intᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeIntᵖ(d binary.Reader, o *Intᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawIntᵖ(d binary.Reader, o *Intᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassIntᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeIntᵖ(e, obj.(*Intᵖ))
}
func (*binaryClassIntᵖ) New() binary.Object {
	return &Intᵖ{}
}
func (*binaryClassIntᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeIntᵖ(d, obj.(*Intᵖ))
}
func (o *Intᵖ) WriteSimple(w binary.Writer) {
	doEncodeIntᵖ(w, o)
}
func (o *Intᵖ) ReadSimple(r binary.Reader) {
	doDecodeIntᵖ(r, o)
}
func (c *binaryClassIntᵖ) Schema() *binary.Entity {
	return &entities[ixǁIntᵖ]
}

type binaryClassGlXQueryDrawable struct{}

func (*GlXQueryDrawable) Class() binary.Class {
	return (*binaryClassGlXQueryDrawable)(nil)
}
func doEncodeGlXQueryDrawable(e binary.Encoder, o *GlXQueryDrawable) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Draw)
	e.Int64(o.Attribute)
	e.Simple(&o.Value)
	e.Int64(o.Result)
}
func doDecodeGlXQueryDrawable(d binary.Decoder, o *GlXQueryDrawable) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Draw)
	o.Attribute = int64(d.Int64())
	d.Simple(&o.Value)
	o.Result = int64(d.Int64())
}
func doDecodeRawGlXQueryDrawable(d binary.Decoder, o *GlXQueryDrawable) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Draw)
	o.Attribute = int64(d.Int64())
	d.Simple(&o.Value)
	o.Result = int64(d.Int64())
}
func (*binaryClassGlXQueryDrawable) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlXQueryDrawable(e, obj.(*GlXQueryDrawable))
}
func (*binaryClassGlXQueryDrawable) New() binary.Object {
	return &GlXQueryDrawable{}
}
func (*binaryClassGlXQueryDrawable) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlXQueryDrawable(d, obj.(*GlXQueryDrawable))
}
func (c *binaryClassGlXQueryDrawable) Schema() *binary.Entity {
	return &entities[ixǁGlXQueryDrawable]
}

type binaryClassGlXSwapBuffers struct{}

func (*GlXSwapBuffers) Class() binary.Class {
	return (*binaryClassGlXSwapBuffers)(nil)
}
func doEncodeGlXSwapBuffers(e binary.Encoder, o *GlXSwapBuffers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Display)
	e.Simple(&o.Drawable)
}
func doDecodeGlXSwapBuffers(d binary.Decoder, o *GlXSwapBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Drawable)
}
func doDecodeRawGlXSwapBuffers(d binary.Decoder, o *GlXSwapBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Display)
	d.Simple(&o.Drawable)
}
func (*binaryClassGlXSwapBuffers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeGlXSwapBuffers(e, obj.(*GlXSwapBuffers))
}
func (*binaryClassGlXSwapBuffers) New() binary.Object {
	return &GlXSwapBuffers{}
}
func (*binaryClassGlXSwapBuffers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeGlXSwapBuffers(d, obj.(*GlXSwapBuffers))
}
func (c *binaryClassGlXSwapBuffers) Schema() *binary.Entity {
	return &entities[ixǁGlXSwapBuffers]
}

type binaryClassHDC struct{}

func (*HDC) Class() binary.Class {
	return (*binaryClassHDC)(nil)
}
func doEncodeHDC(e binary.Writer, o *HDC) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeHDC(d binary.Reader, o *HDC) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawHDC(d binary.Reader, o *HDC) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassHDC) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeHDC(e, obj.(*HDC))
}
func (*binaryClassHDC) New() binary.Object {
	return &HDC{}
}
func (*binaryClassHDC) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeHDC(d, obj.(*HDC))
}
func (o *HDC) WriteSimple(w binary.Writer) {
	doEncodeHDC(w, o)
}
func (o *HDC) ReadSimple(r binary.Reader) {
	doDecodeHDC(r, o)
}
func (c *binaryClassHDC) Schema() *binary.Entity {
	return &entities[ixǁHDC]
}

type binaryClassHGLRC struct{}

func (*HGLRC) Class() binary.Class {
	return (*binaryClassHGLRC)(nil)
}
func doEncodeHGLRC(e binary.Writer, o *HGLRC) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeHGLRC(d binary.Reader, o *HGLRC) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawHGLRC(d binary.Reader, o *HGLRC) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassHGLRC) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeHGLRC(e, obj.(*HGLRC))
}
func (*binaryClassHGLRC) New() binary.Object {
	return &HGLRC{}
}
func (*binaryClassHGLRC) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeHGLRC(d, obj.(*HGLRC))
}
func (o *HGLRC) WriteSimple(w binary.Writer) {
	doEncodeHGLRC(w, o)
}
func (o *HGLRC) ReadSimple(r binary.Reader) {
	doDecodeHGLRC(r, o)
}
func (c *binaryClassHGLRC) Schema() *binary.Entity {
	return &entities[ixǁHGLRC]
}

type binaryClassIntˢ struct{}

func (*Intˢ) Class() binary.Class {
	return (*binaryClassIntˢ)(nil)
}
func doEncodeIntˢ(e binary.Writer, o *Intˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeIntˢ(d binary.Reader, o *Intˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawIntˢ(d binary.Reader, o *Intˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassIntˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeIntˢ(e, obj.(*Intˢ))
}
func (*binaryClassIntˢ) New() binary.Object {
	return &Intˢ{}
}
func (*binaryClassIntˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeIntˢ(d, obj.(*Intˢ))
}
func (o *Intˢ) WriteSimple(w binary.Writer) {
	doEncodeIntˢ(w, o)
}
func (o *Intˢ) ReadSimple(r binary.Reader) {
	doDecodeIntˢ(r, o)
}
func (c *binaryClassIntˢ) Schema() *binary.Entity {
	return &entities[ixǁIntˢ]
}

type binaryClassLazyGLSLParseResult struct{}

func (*LazyGLSLParseResult) Class() binary.Class {
	return (*binaryClassLazyGLSLParseResult)(nil)
}
func doEncodeLazyGLSLParseResult(e binary.Writer, o *LazyGLSLParseResult) {
	e.String(o.ShaderSource)
	e.Uint8(o.Language)
}
func doDecodeLazyGLSLParseResult(d binary.Reader, o *LazyGLSLParseResult) {
	o.ShaderSource = string(d.String())
	o.Language = uint8(d.Uint8())
}
func doDecodeRawLazyGLSLParseResult(d binary.Reader, o *LazyGLSLParseResult) {
	o.ShaderSource = string(d.String())
	o.Language = uint8(d.Uint8())
}
func (*binaryClassLazyGLSLParseResult) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeLazyGLSLParseResult(e, obj.(*LazyGLSLParseResult))
}
func (*binaryClassLazyGLSLParseResult) New() binary.Object {
	return &LazyGLSLParseResult{}
}
func (*binaryClassLazyGLSLParseResult) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeLazyGLSLParseResult(d, obj.(*LazyGLSLParseResult))
}
func (o *LazyGLSLParseResult) WriteSimple(w binary.Writer) {
	doEncodeLazyGLSLParseResult(w, o)
}
func (o *LazyGLSLParseResult) ReadSimple(r binary.Reader) {
	doDecodeLazyGLSLParseResult(r, o)
}
func (c *binaryClassLazyGLSLParseResult) Schema() *binary.Entity {
	return &entities[ixǁLazyGLSLParseResult]
}

type binaryClassMat2f struct{}

func (*Mat2f) Class() binary.Class {
	return (*binaryClassMat2f)(nil)
}
func doEncodeMat2f(e binary.Writer, o *Mat2f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeMat2f(d binary.Reader, o *Mat2f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawMat2f(d binary.Reader, o *Mat2f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassMat2f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat2f(e, obj.(*Mat2f))
}
func (*binaryClassMat2f) New() binary.Object {
	return &Mat2f{}
}
func (*binaryClassMat2f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat2f(d, obj.(*Mat2f))
}
func (o *Mat2f) WriteSimple(w binary.Writer) {
	doEncodeMat2f(w, o)
}
func (o *Mat2f) ReadSimple(r binary.Reader) {
	doDecodeMat2f(r, o)
}
func (c *binaryClassMat2f) Schema() *binary.Entity {
	return &entities[ixǁMat2f]
}

type binaryClassMat2fˢ struct{}

func (*Mat2fˢ) Class() binary.Class {
	return (*binaryClassMat2fˢ)(nil)
}
func doEncodeMat2fˢ(e binary.Writer, o *Mat2fˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeMat2fˢ(d binary.Reader, o *Mat2fˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawMat2fˢ(d binary.Reader, o *Mat2fˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassMat2fˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat2fˢ(e, obj.(*Mat2fˢ))
}
func (*binaryClassMat2fˢ) New() binary.Object {
	return &Mat2fˢ{}
}
func (*binaryClassMat2fˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat2fˢ(d, obj.(*Mat2fˢ))
}
func (o *Mat2fˢ) WriteSimple(w binary.Writer) {
	doEncodeMat2fˢ(w, o)
}
func (o *Mat2fˢ) ReadSimple(r binary.Reader) {
	doDecodeMat2fˢ(r, o)
}
func (c *binaryClassMat2fˢ) Schema() *binary.Entity {
	return &entities[ixǁMat2fˢ]
}

type binaryClassMat2fᵖ struct{}

func (*Mat2fᵖ) Class() binary.Class {
	return (*binaryClassMat2fᵖ)(nil)
}
func doEncodeMat2fᵖ(e binary.Writer, o *Mat2fᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeMat2fᵖ(d binary.Reader, o *Mat2fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawMat2fᵖ(d binary.Reader, o *Mat2fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassMat2fᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat2fᵖ(e, obj.(*Mat2fᵖ))
}
func (*binaryClassMat2fᵖ) New() binary.Object {
	return &Mat2fᵖ{}
}
func (*binaryClassMat2fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat2fᵖ(d, obj.(*Mat2fᵖ))
}
func (o *Mat2fᵖ) WriteSimple(w binary.Writer) {
	doEncodeMat2fᵖ(w, o)
}
func (o *Mat2fᵖ) ReadSimple(r binary.Reader) {
	doDecodeMat2fᵖ(r, o)
}
func (c *binaryClassMat2fᵖ) Schema() *binary.Entity {
	return &entities[ixǁMat2fᵖ]
}

type binaryClassVec3f struct{}

func (*Vec3f) Class() binary.Class {
	return (*binaryClassVec3f)(nil)
}
func doEncodeVec3f(e binary.Writer, o *Vec3f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Float32(float32(*curr))
	}
}
func doDecodeVec3f(d binary.Reader, o *Vec3f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func doDecodeRawVec3f(d binary.Reader, o *Vec3f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func (*binaryClassVec3f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec3f(e, obj.(*Vec3f))
}
func (*binaryClassVec3f) New() binary.Object {
	return &Vec3f{}
}
func (*binaryClassVec3f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec3f(d, obj.(*Vec3f))
}
func (o *Vec3f) WriteSimple(w binary.Writer) {
	doEncodeVec3f(w, o)
}
func (o *Vec3f) ReadSimple(r binary.Reader) {
	doDecodeVec3f(r, o)
}
func (c *binaryClassVec3f) Schema() *binary.Entity {
	return &entities[ixǁVec3f]
}

type binaryClassMat2x3f struct{}

func (*Mat2x3f) Class() binary.Class {
	return (*binaryClassMat2x3f)(nil)
}
func doEncodeMat2x3f(e binary.Writer, o *Mat2x3f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeMat2x3f(d binary.Reader, o *Mat2x3f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawMat2x3f(d binary.Reader, o *Mat2x3f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassMat2x3f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat2x3f(e, obj.(*Mat2x3f))
}
func (*binaryClassMat2x3f) New() binary.Object {
	return &Mat2x3f{}
}
func (*binaryClassMat2x3f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat2x3f(d, obj.(*Mat2x3f))
}
func (o *Mat2x3f) WriteSimple(w binary.Writer) {
	doEncodeMat2x3f(w, o)
}
func (o *Mat2x3f) ReadSimple(r binary.Reader) {
	doDecodeMat2x3f(r, o)
}
func (c *binaryClassMat2x3f) Schema() *binary.Entity {
	return &entities[ixǁMat2x3f]
}

type binaryClassMat2x3fˢ struct{}

func (*Mat2x3fˢ) Class() binary.Class {
	return (*binaryClassMat2x3fˢ)(nil)
}
func doEncodeMat2x3fˢ(e binary.Writer, o *Mat2x3fˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeMat2x3fˢ(d binary.Reader, o *Mat2x3fˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawMat2x3fˢ(d binary.Reader, o *Mat2x3fˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassMat2x3fˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat2x3fˢ(e, obj.(*Mat2x3fˢ))
}
func (*binaryClassMat2x3fˢ) New() binary.Object {
	return &Mat2x3fˢ{}
}
func (*binaryClassMat2x3fˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat2x3fˢ(d, obj.(*Mat2x3fˢ))
}
func (o *Mat2x3fˢ) WriteSimple(w binary.Writer) {
	doEncodeMat2x3fˢ(w, o)
}
func (o *Mat2x3fˢ) ReadSimple(r binary.Reader) {
	doDecodeMat2x3fˢ(r, o)
}
func (c *binaryClassMat2x3fˢ) Schema() *binary.Entity {
	return &entities[ixǁMat2x3fˢ]
}

type binaryClassMat2x3fᵖ struct{}

func (*Mat2x3fᵖ) Class() binary.Class {
	return (*binaryClassMat2x3fᵖ)(nil)
}
func doEncodeMat2x3fᵖ(e binary.Writer, o *Mat2x3fᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeMat2x3fᵖ(d binary.Reader, o *Mat2x3fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawMat2x3fᵖ(d binary.Reader, o *Mat2x3fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassMat2x3fᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat2x3fᵖ(e, obj.(*Mat2x3fᵖ))
}
func (*binaryClassMat2x3fᵖ) New() binary.Object {
	return &Mat2x3fᵖ{}
}
func (*binaryClassMat2x3fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat2x3fᵖ(d, obj.(*Mat2x3fᵖ))
}
func (o *Mat2x3fᵖ) WriteSimple(w binary.Writer) {
	doEncodeMat2x3fᵖ(w, o)
}
func (o *Mat2x3fᵖ) ReadSimple(r binary.Reader) {
	doDecodeMat2x3fᵖ(r, o)
}
func (c *binaryClassMat2x3fᵖ) Schema() *binary.Entity {
	return &entities[ixǁMat2x3fᵖ]
}

type binaryClassMat2x4f struct{}

func (*Mat2x4f) Class() binary.Class {
	return (*binaryClassMat2x4f)(nil)
}
func doEncodeMat2x4f(e binary.Writer, o *Mat2x4f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeMat2x4f(d binary.Reader, o *Mat2x4f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawMat2x4f(d binary.Reader, o *Mat2x4f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassMat2x4f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat2x4f(e, obj.(*Mat2x4f))
}
func (*binaryClassMat2x4f) New() binary.Object {
	return &Mat2x4f{}
}
func (*binaryClassMat2x4f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat2x4f(d, obj.(*Mat2x4f))
}
func (o *Mat2x4f) WriteSimple(w binary.Writer) {
	doEncodeMat2x4f(w, o)
}
func (o *Mat2x4f) ReadSimple(r binary.Reader) {
	doDecodeMat2x4f(r, o)
}
func (c *binaryClassMat2x4f) Schema() *binary.Entity {
	return &entities[ixǁMat2x4f]
}

type binaryClassMat2x4fˢ struct{}

func (*Mat2x4fˢ) Class() binary.Class {
	return (*binaryClassMat2x4fˢ)(nil)
}
func doEncodeMat2x4fˢ(e binary.Writer, o *Mat2x4fˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeMat2x4fˢ(d binary.Reader, o *Mat2x4fˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawMat2x4fˢ(d binary.Reader, o *Mat2x4fˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassMat2x4fˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat2x4fˢ(e, obj.(*Mat2x4fˢ))
}
func (*binaryClassMat2x4fˢ) New() binary.Object {
	return &Mat2x4fˢ{}
}
func (*binaryClassMat2x4fˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat2x4fˢ(d, obj.(*Mat2x4fˢ))
}
func (o *Mat2x4fˢ) WriteSimple(w binary.Writer) {
	doEncodeMat2x4fˢ(w, o)
}
func (o *Mat2x4fˢ) ReadSimple(r binary.Reader) {
	doDecodeMat2x4fˢ(r, o)
}
func (c *binaryClassMat2x4fˢ) Schema() *binary.Entity {
	return &entities[ixǁMat2x4fˢ]
}

type binaryClassMat2x4fᵖ struct{}

func (*Mat2x4fᵖ) Class() binary.Class {
	return (*binaryClassMat2x4fᵖ)(nil)
}
func doEncodeMat2x4fᵖ(e binary.Writer, o *Mat2x4fᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeMat2x4fᵖ(d binary.Reader, o *Mat2x4fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawMat2x4fᵖ(d binary.Reader, o *Mat2x4fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassMat2x4fᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat2x4fᵖ(e, obj.(*Mat2x4fᵖ))
}
func (*binaryClassMat2x4fᵖ) New() binary.Object {
	return &Mat2x4fᵖ{}
}
func (*binaryClassMat2x4fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat2x4fᵖ(d, obj.(*Mat2x4fᵖ))
}
func (o *Mat2x4fᵖ) WriteSimple(w binary.Writer) {
	doEncodeMat2x4fᵖ(w, o)
}
func (o *Mat2x4fᵖ) ReadSimple(r binary.Reader) {
	doDecodeMat2x4fᵖ(r, o)
}
func (c *binaryClassMat2x4fᵖ) Schema() *binary.Entity {
	return &entities[ixǁMat2x4fᵖ]
}

type binaryClassMat3f struct{}

func (*Mat3f) Class() binary.Class {
	return (*binaryClassMat3f)(nil)
}
func doEncodeMat3f(e binary.Writer, o *Mat3f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeMat3f(d binary.Reader, o *Mat3f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawMat3f(d binary.Reader, o *Mat3f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassMat3f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat3f(e, obj.(*Mat3f))
}
func (*binaryClassMat3f) New() binary.Object {
	return &Mat3f{}
}
func (*binaryClassMat3f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat3f(d, obj.(*Mat3f))
}
func (o *Mat3f) WriteSimple(w binary.Writer) {
	doEncodeMat3f(w, o)
}
func (o *Mat3f) ReadSimple(r binary.Reader) {
	doDecodeMat3f(r, o)
}
func (c *binaryClassMat3f) Schema() *binary.Entity {
	return &entities[ixǁMat3f]
}

type binaryClassMat3fˢ struct{}

func (*Mat3fˢ) Class() binary.Class {
	return (*binaryClassMat3fˢ)(nil)
}
func doEncodeMat3fˢ(e binary.Writer, o *Mat3fˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeMat3fˢ(d binary.Reader, o *Mat3fˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawMat3fˢ(d binary.Reader, o *Mat3fˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassMat3fˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat3fˢ(e, obj.(*Mat3fˢ))
}
func (*binaryClassMat3fˢ) New() binary.Object {
	return &Mat3fˢ{}
}
func (*binaryClassMat3fˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat3fˢ(d, obj.(*Mat3fˢ))
}
func (o *Mat3fˢ) WriteSimple(w binary.Writer) {
	doEncodeMat3fˢ(w, o)
}
func (o *Mat3fˢ) ReadSimple(r binary.Reader) {
	doDecodeMat3fˢ(r, o)
}
func (c *binaryClassMat3fˢ) Schema() *binary.Entity {
	return &entities[ixǁMat3fˢ]
}

type binaryClassMat3fᵖ struct{}

func (*Mat3fᵖ) Class() binary.Class {
	return (*binaryClassMat3fᵖ)(nil)
}
func doEncodeMat3fᵖ(e binary.Writer, o *Mat3fᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeMat3fᵖ(d binary.Reader, o *Mat3fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawMat3fᵖ(d binary.Reader, o *Mat3fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassMat3fᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat3fᵖ(e, obj.(*Mat3fᵖ))
}
func (*binaryClassMat3fᵖ) New() binary.Object {
	return &Mat3fᵖ{}
}
func (*binaryClassMat3fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat3fᵖ(d, obj.(*Mat3fᵖ))
}
func (o *Mat3fᵖ) WriteSimple(w binary.Writer) {
	doEncodeMat3fᵖ(w, o)
}
func (o *Mat3fᵖ) ReadSimple(r binary.Reader) {
	doDecodeMat3fᵖ(r, o)
}
func (c *binaryClassMat3fᵖ) Schema() *binary.Entity {
	return &entities[ixǁMat3fᵖ]
}

type binaryClassMat3x2f struct{}

func (*Mat3x2f) Class() binary.Class {
	return (*binaryClassMat3x2f)(nil)
}
func doEncodeMat3x2f(e binary.Writer, o *Mat3x2f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeMat3x2f(d binary.Reader, o *Mat3x2f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawMat3x2f(d binary.Reader, o *Mat3x2f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassMat3x2f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat3x2f(e, obj.(*Mat3x2f))
}
func (*binaryClassMat3x2f) New() binary.Object {
	return &Mat3x2f{}
}
func (*binaryClassMat3x2f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat3x2f(d, obj.(*Mat3x2f))
}
func (o *Mat3x2f) WriteSimple(w binary.Writer) {
	doEncodeMat3x2f(w, o)
}
func (o *Mat3x2f) ReadSimple(r binary.Reader) {
	doDecodeMat3x2f(r, o)
}
func (c *binaryClassMat3x2f) Schema() *binary.Entity {
	return &entities[ixǁMat3x2f]
}

type binaryClassMat3x2fˢ struct{}

func (*Mat3x2fˢ) Class() binary.Class {
	return (*binaryClassMat3x2fˢ)(nil)
}
func doEncodeMat3x2fˢ(e binary.Writer, o *Mat3x2fˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeMat3x2fˢ(d binary.Reader, o *Mat3x2fˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawMat3x2fˢ(d binary.Reader, o *Mat3x2fˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassMat3x2fˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat3x2fˢ(e, obj.(*Mat3x2fˢ))
}
func (*binaryClassMat3x2fˢ) New() binary.Object {
	return &Mat3x2fˢ{}
}
func (*binaryClassMat3x2fˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat3x2fˢ(d, obj.(*Mat3x2fˢ))
}
func (o *Mat3x2fˢ) WriteSimple(w binary.Writer) {
	doEncodeMat3x2fˢ(w, o)
}
func (o *Mat3x2fˢ) ReadSimple(r binary.Reader) {
	doDecodeMat3x2fˢ(r, o)
}
func (c *binaryClassMat3x2fˢ) Schema() *binary.Entity {
	return &entities[ixǁMat3x2fˢ]
}

type binaryClassMat3x2fᵖ struct{}

func (*Mat3x2fᵖ) Class() binary.Class {
	return (*binaryClassMat3x2fᵖ)(nil)
}
func doEncodeMat3x2fᵖ(e binary.Writer, o *Mat3x2fᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeMat3x2fᵖ(d binary.Reader, o *Mat3x2fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawMat3x2fᵖ(d binary.Reader, o *Mat3x2fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassMat3x2fᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat3x2fᵖ(e, obj.(*Mat3x2fᵖ))
}
func (*binaryClassMat3x2fᵖ) New() binary.Object {
	return &Mat3x2fᵖ{}
}
func (*binaryClassMat3x2fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat3x2fᵖ(d, obj.(*Mat3x2fᵖ))
}
func (o *Mat3x2fᵖ) WriteSimple(w binary.Writer) {
	doEncodeMat3x2fᵖ(w, o)
}
func (o *Mat3x2fᵖ) ReadSimple(r binary.Reader) {
	doDecodeMat3x2fᵖ(r, o)
}
func (c *binaryClassMat3x2fᵖ) Schema() *binary.Entity {
	return &entities[ixǁMat3x2fᵖ]
}

type binaryClassMat3x4f struct{}

func (*Mat3x4f) Class() binary.Class {
	return (*binaryClassMat3x4f)(nil)
}
func doEncodeMat3x4f(e binary.Writer, o *Mat3x4f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeMat3x4f(d binary.Reader, o *Mat3x4f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawMat3x4f(d binary.Reader, o *Mat3x4f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassMat3x4f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat3x4f(e, obj.(*Mat3x4f))
}
func (*binaryClassMat3x4f) New() binary.Object {
	return &Mat3x4f{}
}
func (*binaryClassMat3x4f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat3x4f(d, obj.(*Mat3x4f))
}
func (o *Mat3x4f) WriteSimple(w binary.Writer) {
	doEncodeMat3x4f(w, o)
}
func (o *Mat3x4f) ReadSimple(r binary.Reader) {
	doDecodeMat3x4f(r, o)
}
func (c *binaryClassMat3x4f) Schema() *binary.Entity {
	return &entities[ixǁMat3x4f]
}

type binaryClassMat3x4fˢ struct{}

func (*Mat3x4fˢ) Class() binary.Class {
	return (*binaryClassMat3x4fˢ)(nil)
}
func doEncodeMat3x4fˢ(e binary.Writer, o *Mat3x4fˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeMat3x4fˢ(d binary.Reader, o *Mat3x4fˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawMat3x4fˢ(d binary.Reader, o *Mat3x4fˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassMat3x4fˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat3x4fˢ(e, obj.(*Mat3x4fˢ))
}
func (*binaryClassMat3x4fˢ) New() binary.Object {
	return &Mat3x4fˢ{}
}
func (*binaryClassMat3x4fˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat3x4fˢ(d, obj.(*Mat3x4fˢ))
}
func (o *Mat3x4fˢ) WriteSimple(w binary.Writer) {
	doEncodeMat3x4fˢ(w, o)
}
func (o *Mat3x4fˢ) ReadSimple(r binary.Reader) {
	doDecodeMat3x4fˢ(r, o)
}
func (c *binaryClassMat3x4fˢ) Schema() *binary.Entity {
	return &entities[ixǁMat3x4fˢ]
}

type binaryClassMat3x4fᵖ struct{}

func (*Mat3x4fᵖ) Class() binary.Class {
	return (*binaryClassMat3x4fᵖ)(nil)
}
func doEncodeMat3x4fᵖ(e binary.Writer, o *Mat3x4fᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeMat3x4fᵖ(d binary.Reader, o *Mat3x4fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawMat3x4fᵖ(d binary.Reader, o *Mat3x4fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassMat3x4fᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat3x4fᵖ(e, obj.(*Mat3x4fᵖ))
}
func (*binaryClassMat3x4fᵖ) New() binary.Object {
	return &Mat3x4fᵖ{}
}
func (*binaryClassMat3x4fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat3x4fᵖ(d, obj.(*Mat3x4fᵖ))
}
func (o *Mat3x4fᵖ) WriteSimple(w binary.Writer) {
	doEncodeMat3x4fᵖ(w, o)
}
func (o *Mat3x4fᵖ) ReadSimple(r binary.Reader) {
	doDecodeMat3x4fᵖ(r, o)
}
func (c *binaryClassMat3x4fᵖ) Schema() *binary.Entity {
	return &entities[ixǁMat3x4fᵖ]
}

type binaryClassMat4f struct{}

func (*Mat4f) Class() binary.Class {
	return (*binaryClassMat4f)(nil)
}
func doEncodeMat4f(e binary.Writer, o *Mat4f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeMat4f(d binary.Reader, o *Mat4f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawMat4f(d binary.Reader, o *Mat4f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassMat4f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat4f(e, obj.(*Mat4f))
}
func (*binaryClassMat4f) New() binary.Object {
	return &Mat4f{}
}
func (*binaryClassMat4f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat4f(d, obj.(*Mat4f))
}
func (o *Mat4f) WriteSimple(w binary.Writer) {
	doEncodeMat4f(w, o)
}
func (o *Mat4f) ReadSimple(r binary.Reader) {
	doDecodeMat4f(r, o)
}
func (c *binaryClassMat4f) Schema() *binary.Entity {
	return &entities[ixǁMat4f]
}

type binaryClassMat4fˢ struct{}

func (*Mat4fˢ) Class() binary.Class {
	return (*binaryClassMat4fˢ)(nil)
}
func doEncodeMat4fˢ(e binary.Writer, o *Mat4fˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeMat4fˢ(d binary.Reader, o *Mat4fˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawMat4fˢ(d binary.Reader, o *Mat4fˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassMat4fˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat4fˢ(e, obj.(*Mat4fˢ))
}
func (*binaryClassMat4fˢ) New() binary.Object {
	return &Mat4fˢ{}
}
func (*binaryClassMat4fˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat4fˢ(d, obj.(*Mat4fˢ))
}
func (o *Mat4fˢ) WriteSimple(w binary.Writer) {
	doEncodeMat4fˢ(w, o)
}
func (o *Mat4fˢ) ReadSimple(r binary.Reader) {
	doDecodeMat4fˢ(r, o)
}
func (c *binaryClassMat4fˢ) Schema() *binary.Entity {
	return &entities[ixǁMat4fˢ]
}

type binaryClassMat4fᵖ struct{}

func (*Mat4fᵖ) Class() binary.Class {
	return (*binaryClassMat4fᵖ)(nil)
}
func doEncodeMat4fᵖ(e binary.Writer, o *Mat4fᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeMat4fᵖ(d binary.Reader, o *Mat4fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawMat4fᵖ(d binary.Reader, o *Mat4fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassMat4fᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat4fᵖ(e, obj.(*Mat4fᵖ))
}
func (*binaryClassMat4fᵖ) New() binary.Object {
	return &Mat4fᵖ{}
}
func (*binaryClassMat4fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat4fᵖ(d, obj.(*Mat4fᵖ))
}
func (o *Mat4fᵖ) WriteSimple(w binary.Writer) {
	doEncodeMat4fᵖ(w, o)
}
func (o *Mat4fᵖ) ReadSimple(r binary.Reader) {
	doDecodeMat4fᵖ(r, o)
}
func (c *binaryClassMat4fᵖ) Schema() *binary.Entity {
	return &entities[ixǁMat4fᵖ]
}

type binaryClassMat4x2f struct{}

func (*Mat4x2f) Class() binary.Class {
	return (*binaryClassMat4x2f)(nil)
}
func doEncodeMat4x2f(e binary.Writer, o *Mat4x2f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeMat4x2f(d binary.Reader, o *Mat4x2f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawMat4x2f(d binary.Reader, o *Mat4x2f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassMat4x2f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat4x2f(e, obj.(*Mat4x2f))
}
func (*binaryClassMat4x2f) New() binary.Object {
	return &Mat4x2f{}
}
func (*binaryClassMat4x2f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat4x2f(d, obj.(*Mat4x2f))
}
func (o *Mat4x2f) WriteSimple(w binary.Writer) {
	doEncodeMat4x2f(w, o)
}
func (o *Mat4x2f) ReadSimple(r binary.Reader) {
	doDecodeMat4x2f(r, o)
}
func (c *binaryClassMat4x2f) Schema() *binary.Entity {
	return &entities[ixǁMat4x2f]
}

type binaryClassMat4x2fˢ struct{}

func (*Mat4x2fˢ) Class() binary.Class {
	return (*binaryClassMat4x2fˢ)(nil)
}
func doEncodeMat4x2fˢ(e binary.Writer, o *Mat4x2fˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeMat4x2fˢ(d binary.Reader, o *Mat4x2fˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawMat4x2fˢ(d binary.Reader, o *Mat4x2fˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassMat4x2fˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat4x2fˢ(e, obj.(*Mat4x2fˢ))
}
func (*binaryClassMat4x2fˢ) New() binary.Object {
	return &Mat4x2fˢ{}
}
func (*binaryClassMat4x2fˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat4x2fˢ(d, obj.(*Mat4x2fˢ))
}
func (o *Mat4x2fˢ) WriteSimple(w binary.Writer) {
	doEncodeMat4x2fˢ(w, o)
}
func (o *Mat4x2fˢ) ReadSimple(r binary.Reader) {
	doDecodeMat4x2fˢ(r, o)
}
func (c *binaryClassMat4x2fˢ) Schema() *binary.Entity {
	return &entities[ixǁMat4x2fˢ]
}

type binaryClassMat4x2fᵖ struct{}

func (*Mat4x2fᵖ) Class() binary.Class {
	return (*binaryClassMat4x2fᵖ)(nil)
}
func doEncodeMat4x2fᵖ(e binary.Writer, o *Mat4x2fᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeMat4x2fᵖ(d binary.Reader, o *Mat4x2fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawMat4x2fᵖ(d binary.Reader, o *Mat4x2fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassMat4x2fᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat4x2fᵖ(e, obj.(*Mat4x2fᵖ))
}
func (*binaryClassMat4x2fᵖ) New() binary.Object {
	return &Mat4x2fᵖ{}
}
func (*binaryClassMat4x2fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat4x2fᵖ(d, obj.(*Mat4x2fᵖ))
}
func (o *Mat4x2fᵖ) WriteSimple(w binary.Writer) {
	doEncodeMat4x2fᵖ(w, o)
}
func (o *Mat4x2fᵖ) ReadSimple(r binary.Reader) {
	doDecodeMat4x2fᵖ(r, o)
}
func (c *binaryClassMat4x2fᵖ) Schema() *binary.Entity {
	return &entities[ixǁMat4x2fᵖ]
}

type binaryClassMat4x3f struct{}

func (*Mat4x3f) Class() binary.Class {
	return (*binaryClassMat4x3f)(nil)
}
func doEncodeMat4x3f(e binary.Writer, o *Mat4x3f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeMat4x3f(d binary.Reader, o *Mat4x3f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawMat4x3f(d binary.Reader, o *Mat4x3f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassMat4x3f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat4x3f(e, obj.(*Mat4x3f))
}
func (*binaryClassMat4x3f) New() binary.Object {
	return &Mat4x3f{}
}
func (*binaryClassMat4x3f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat4x3f(d, obj.(*Mat4x3f))
}
func (o *Mat4x3f) WriteSimple(w binary.Writer) {
	doEncodeMat4x3f(w, o)
}
func (o *Mat4x3f) ReadSimple(r binary.Reader) {
	doDecodeMat4x3f(r, o)
}
func (c *binaryClassMat4x3f) Schema() *binary.Entity {
	return &entities[ixǁMat4x3f]
}

type binaryClassMat4x3fˢ struct{}

func (*Mat4x3fˢ) Class() binary.Class {
	return (*binaryClassMat4x3fˢ)(nil)
}
func doEncodeMat4x3fˢ(e binary.Writer, o *Mat4x3fˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeMat4x3fˢ(d binary.Reader, o *Mat4x3fˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawMat4x3fˢ(d binary.Reader, o *Mat4x3fˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassMat4x3fˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat4x3fˢ(e, obj.(*Mat4x3fˢ))
}
func (*binaryClassMat4x3fˢ) New() binary.Object {
	return &Mat4x3fˢ{}
}
func (*binaryClassMat4x3fˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat4x3fˢ(d, obj.(*Mat4x3fˢ))
}
func (o *Mat4x3fˢ) WriteSimple(w binary.Writer) {
	doEncodeMat4x3fˢ(w, o)
}
func (o *Mat4x3fˢ) ReadSimple(r binary.Reader) {
	doDecodeMat4x3fˢ(r, o)
}
func (c *binaryClassMat4x3fˢ) Schema() *binary.Entity {
	return &entities[ixǁMat4x3fˢ]
}

type binaryClassMat4x3fᵖ struct{}

func (*Mat4x3fᵖ) Class() binary.Class {
	return (*binaryClassMat4x3fᵖ)(nil)
}
func doEncodeMat4x3fᵖ(e binary.Writer, o *Mat4x3fᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeMat4x3fᵖ(d binary.Reader, o *Mat4x3fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawMat4x3fᵖ(d binary.Reader, o *Mat4x3fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassMat4x3fᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMat4x3fᵖ(e, obj.(*Mat4x3fᵖ))
}
func (*binaryClassMat4x3fᵖ) New() binary.Object {
	return &Mat4x3fᵖ{}
}
func (*binaryClassMat4x3fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMat4x3fᵖ(d, obj.(*Mat4x3fᵖ))
}
func (o *Mat4x3fᵖ) WriteSimple(w binary.Writer) {
	doEncodeMat4x3fᵖ(w, o)
}
func (o *Mat4x3fᵖ) ReadSimple(r binary.Reader) {
	doDecodeMat4x3fᵖ(r, o)
}
func (c *binaryClassMat4x3fᵖ) Schema() *binary.Entity {
	return &entities[ixǁMat4x3fᵖ]
}

type binaryClassPipelineIdˢ struct{}

func (*PipelineIdˢ) Class() binary.Class {
	return (*binaryClassPipelineIdˢ)(nil)
}
func doEncodePipelineIdˢ(e binary.Writer, o *PipelineIdˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodePipelineIdˢ(d binary.Reader, o *PipelineIdˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawPipelineIdˢ(d binary.Reader, o *PipelineIdˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassPipelineIdˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodePipelineIdˢ(e, obj.(*PipelineIdˢ))
}
func (*binaryClassPipelineIdˢ) New() binary.Object {
	return &PipelineIdˢ{}
}
func (*binaryClassPipelineIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodePipelineIdˢ(d, obj.(*PipelineIdˢ))
}
func (o *PipelineIdˢ) WriteSimple(w binary.Writer) {
	doEncodePipelineIdˢ(w, o)
}
func (o *PipelineIdˢ) ReadSimple(r binary.Reader) {
	doDecodePipelineIdˢ(r, o)
}
func (c *binaryClassPipelineIdˢ) Schema() *binary.Entity {
	return &entities[ixǁPipelineIdˢ]
}

type binaryClassProgramIdˢ struct{}

func (*ProgramIdˢ) Class() binary.Class {
	return (*binaryClassProgramIdˢ)(nil)
}
func doEncodeProgramIdˢ(e binary.Writer, o *ProgramIdˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeProgramIdˢ(d binary.Reader, o *ProgramIdˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawProgramIdˢ(d binary.Reader, o *ProgramIdˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassProgramIdˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeProgramIdˢ(e, obj.(*ProgramIdˢ))
}
func (*binaryClassProgramIdˢ) New() binary.Object {
	return &ProgramIdˢ{}
}
func (*binaryClassProgramIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeProgramIdˢ(d, obj.(*ProgramIdˢ))
}
func (o *ProgramIdˢ) WriteSimple(w binary.Writer) {
	doEncodeProgramIdˢ(w, o)
}
func (o *ProgramIdˢ) ReadSimple(r binary.Reader) {
	doDecodeProgramIdˢ(r, o)
}
func (c *binaryClassProgramIdˢ) Schema() *binary.Entity {
	return &entities[ixǁProgramIdˢ]
}

type binaryClassProgramInfo struct{}

func (*ProgramInfo) Class() binary.Class {
	return (*binaryClassProgramInfo)(nil)
}
func doEncodeProgramInfo(e binary.Writer, o *ProgramInfo) {
	e.Uint8(uint8(o.LinkStatus))
	e.String(o.InfoLog)
	e.Uint32(uint32(len(o.ActiveAttributes)))
	for _, k := range (o.ActiveAttributes).KeysSorted() {
		v := (o.ActiveAttributes)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
	e.Uint32(uint32(len(o.ActiveUniforms)))
	for _, k := range (o.ActiveUniforms).KeysSorted() {
		v := (o.ActiveUniforms)[k]
		e.Uint32(uint32(k))
		e.Simple(&v)
	}
}
func doDecodeProgramInfo(d binary.Reader, o *ProgramInfo) {
	o.LinkStatus = GLboolean(d.Uint8())
	o.InfoLog = string(d.String())
	if count := d.Count(); count > 0 {
		o.ActiveAttributes = make(AttributeIndexːActiveAttributeᵐ, count)
		m := o.ActiveAttributes
		for i := uint32(0); i < count; i++ {
			var k AttributeIndex
			var v ActiveAttribute
			k = AttributeIndex(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.ActiveUniforms = make(UniformIndexːActiveUniformᵐ, count)
		m := o.ActiveUniforms
		for i := uint32(0); i < count; i++ {
			var k UniformIndex
			var v ActiveUniform
			k = UniformIndex(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
}
func doDecodeRawProgramInfo(d binary.Reader, o *ProgramInfo) {
	o.LinkStatus = GLboolean(d.Uint8())
	o.InfoLog = string(d.String())
	if count := d.Count(); count > 0 {
		o.ActiveAttributes = make(AttributeIndexːActiveAttributeᵐ, count)
		m := o.ActiveAttributes
		for i := uint32(0); i < count; i++ {
			var k AttributeIndex
			var v ActiveAttribute
			k = AttributeIndex(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.ActiveUniforms = make(UniformIndexːActiveUniformᵐ, count)
		m := o.ActiveUniforms
		for i := uint32(0); i < count; i++ {
			var k UniformIndex
			var v ActiveUniform
			k = UniformIndex(d.Uint32())
			d.Simple(&v)
			m[k] = v
		}
	}
}
func (*binaryClassProgramInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeProgramInfo(e, obj.(*ProgramInfo))
}
func (*binaryClassProgramInfo) New() binary.Object {
	return &ProgramInfo{}
}
func (*binaryClassProgramInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeProgramInfo(d, obj.(*ProgramInfo))
}
func (o *ProgramInfo) WriteSimple(w binary.Writer) {
	doEncodeProgramInfo(w, o)
}
func (o *ProgramInfo) ReadSimple(r binary.Reader) {
	doDecodeProgramInfo(r, o)
}
func (c *binaryClassProgramInfo) Schema() *binary.Entity {
	return &entities[ixǁProgramInfo]
}

type binaryClassQueryIdˢ struct{}

func (*QueryIdˢ) Class() binary.Class {
	return (*binaryClassQueryIdˢ)(nil)
}
func doEncodeQueryIdˢ(e binary.Writer, o *QueryIdˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeQueryIdˢ(d binary.Reader, o *QueryIdˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawQueryIdˢ(d binary.Reader, o *QueryIdˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassQueryIdˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeQueryIdˢ(e, obj.(*QueryIdˢ))
}
func (*binaryClassQueryIdˢ) New() binary.Object {
	return &QueryIdˢ{}
}
func (*binaryClassQueryIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeQueryIdˢ(d, obj.(*QueryIdˢ))
}
func (o *QueryIdˢ) WriteSimple(w binary.Writer) {
	doEncodeQueryIdˢ(w, o)
}
func (o *QueryIdˢ) ReadSimple(r binary.Reader) {
	doDecodeQueryIdˢ(r, o)
}
func (c *binaryClassQueryIdˢ) Schema() *binary.Entity {
	return &entities[ixǁQueryIdˢ]
}

type binaryClassRenderbufferIdˢ struct{}

func (*RenderbufferIdˢ) Class() binary.Class {
	return (*binaryClassRenderbufferIdˢ)(nil)
}
func doEncodeRenderbufferIdˢ(e binary.Writer, o *RenderbufferIdˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeRenderbufferIdˢ(d binary.Reader, o *RenderbufferIdˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawRenderbufferIdˢ(d binary.Reader, o *RenderbufferIdˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassRenderbufferIdˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeRenderbufferIdˢ(e, obj.(*RenderbufferIdˢ))
}
func (*binaryClassRenderbufferIdˢ) New() binary.Object {
	return &RenderbufferIdˢ{}
}
func (*binaryClassRenderbufferIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeRenderbufferIdˢ(d, obj.(*RenderbufferIdˢ))
}
func (o *RenderbufferIdˢ) WriteSimple(w binary.Writer) {
	doEncodeRenderbufferIdˢ(w, o)
}
func (o *RenderbufferIdˢ) ReadSimple(r binary.Reader) {
	doDecodeRenderbufferIdˢ(r, o)
}
func (c *binaryClassRenderbufferIdˢ) Schema() *binary.Entity {
	return &entities[ixǁRenderbufferIdˢ]
}

type binaryClassReplayBindRenderer struct{}

func (*ReplayBindRenderer) Class() binary.Class {
	return (*binaryClassReplayBindRenderer)(nil)
}
func doEncodeReplayBindRenderer(e binary.Encoder, o *ReplayBindRenderer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(o.Id)
}
func doDecodeReplayBindRenderer(d binary.Decoder, o *ReplayBindRenderer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Id = uint32(d.Uint32())
}
func doDecodeRawReplayBindRenderer(d binary.Decoder, o *ReplayBindRenderer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Id = uint32(d.Uint32())
}
func (*binaryClassReplayBindRenderer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeReplayBindRenderer(e, obj.(*ReplayBindRenderer))
}
func (*binaryClassReplayBindRenderer) New() binary.Object {
	return &ReplayBindRenderer{}
}
func (*binaryClassReplayBindRenderer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeReplayBindRenderer(d, obj.(*ReplayBindRenderer))
}
func (c *binaryClassReplayBindRenderer) Schema() *binary.Entity {
	return &entities[ixǁReplayBindRenderer]
}

type binaryClassReplayChangeBackbuffer struct{}

func (*ReplayChangeBackbuffer) Class() binary.Class {
	return (*binaryClassReplayChangeBackbuffer)(nil)
}
func doEncodeReplayChangeBackbuffer(e binary.Encoder, o *ReplayChangeBackbuffer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Int32(int32(o.BackbufferWidth))
	e.Int32(int32(o.BackbufferHeight))
	e.Uint32(uint32(o.BackbufferColorFmt))
	e.Uint32(uint32(o.BackbufferDepthFmt))
	e.Uint32(uint32(o.BackbufferStencilFmt))
	e.Bool(o.ResetViewportScissor)
}
func doDecodeReplayChangeBackbuffer(d binary.Decoder, o *ReplayChangeBackbuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.BackbufferWidth = GLsizei(d.Int32())
	o.BackbufferHeight = GLsizei(d.Int32())
	o.BackbufferColorFmt = GLenum(d.Uint32())
	o.BackbufferDepthFmt = GLenum(d.Uint32())
	o.BackbufferStencilFmt = GLenum(d.Uint32())
	o.ResetViewportScissor = bool(d.Bool())
}
func doDecodeRawReplayChangeBackbuffer(d binary.Decoder, o *ReplayChangeBackbuffer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.BackbufferWidth = GLsizei(d.Int32())
	o.BackbufferHeight = GLsizei(d.Int32())
	o.BackbufferColorFmt = GLenum(d.Uint32())
	o.BackbufferDepthFmt = GLenum(d.Uint32())
	o.BackbufferStencilFmt = GLenum(d.Uint32())
	o.ResetViewportScissor = bool(d.Bool())
}
func (*binaryClassReplayChangeBackbuffer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeReplayChangeBackbuffer(e, obj.(*ReplayChangeBackbuffer))
}
func (*binaryClassReplayChangeBackbuffer) New() binary.Object {
	return &ReplayChangeBackbuffer{}
}
func (*binaryClassReplayChangeBackbuffer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeReplayChangeBackbuffer(d, obj.(*ReplayChangeBackbuffer))
}
func (c *binaryClassReplayChangeBackbuffer) Schema() *binary.Entity {
	return &entities[ixǁReplayChangeBackbuffer]
}

type binaryClassReplayCreateRenderer struct{}

func (*ReplayCreateRenderer) Class() binary.Class {
	return (*binaryClassReplayCreateRenderer)(nil)
}
func doEncodeReplayCreateRenderer(e binary.Encoder, o *ReplayCreateRenderer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint32(o.Id)
}
func doDecodeReplayCreateRenderer(d binary.Decoder, o *ReplayCreateRenderer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Id = uint32(d.Uint32())
}
func doDecodeRawReplayCreateRenderer(d binary.Decoder, o *ReplayCreateRenderer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Id = uint32(d.Uint32())
}
func (*binaryClassReplayCreateRenderer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeReplayCreateRenderer(e, obj.(*ReplayCreateRenderer))
}
func (*binaryClassReplayCreateRenderer) New() binary.Object {
	return &ReplayCreateRenderer{}
}
func (*binaryClassReplayCreateRenderer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeReplayCreateRenderer(d, obj.(*ReplayCreateRenderer))
}
func (c *binaryClassReplayCreateRenderer) Schema() *binary.Entity {
	return &entities[ixǁReplayCreateRenderer]
}

type binaryClassS64ˢ struct{}

func (*S64ˢ) Class() binary.Class {
	return (*binaryClassS64ˢ)(nil)
}
func doEncodeS64ˢ(e binary.Writer, o *S64ˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeS64ˢ(d binary.Reader, o *S64ˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawS64ˢ(d binary.Reader, o *S64ˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassS64ˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeS64ˢ(e, obj.(*S64ˢ))
}
func (*binaryClassS64ˢ) New() binary.Object {
	return &S64ˢ{}
}
func (*binaryClassS64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeS64ˢ(d, obj.(*S64ˢ))
}
func (o *S64ˢ) WriteSimple(w binary.Writer) {
	doEncodeS64ˢ(w, o)
}
func (o *S64ˢ) ReadSimple(r binary.Reader) {
	doDecodeS64ˢ(r, o)
}
func (c *binaryClassS64ˢ) Schema() *binary.Entity {
	return &entities[ixǁS64ˢ]
}

type binaryClassSamplerIdˢ struct{}

func (*SamplerIdˢ) Class() binary.Class {
	return (*binaryClassSamplerIdˢ)(nil)
}
func doEncodeSamplerIdˢ(e binary.Writer, o *SamplerIdˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeSamplerIdˢ(d binary.Reader, o *SamplerIdˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawSamplerIdˢ(d binary.Reader, o *SamplerIdˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassSamplerIdˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeSamplerIdˢ(e, obj.(*SamplerIdˢ))
}
func (*binaryClassSamplerIdˢ) New() binary.Object {
	return &SamplerIdˢ{}
}
func (*binaryClassSamplerIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeSamplerIdˢ(d, obj.(*SamplerIdˢ))
}
func (o *SamplerIdˢ) WriteSimple(w binary.Writer) {
	doEncodeSamplerIdˢ(w, o)
}
func (o *SamplerIdˢ) ReadSimple(r binary.Reader) {
	doDecodeSamplerIdˢ(r, o)
}
func (c *binaryClassSamplerIdˢ) Schema() *binary.Entity {
	return &entities[ixǁSamplerIdˢ]
}

type binaryClassShaderIdˢ struct{}

func (*ShaderIdˢ) Class() binary.Class {
	return (*binaryClassShaderIdˢ)(nil)
}
func doEncodeShaderIdˢ(e binary.Writer, o *ShaderIdˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeShaderIdˢ(d binary.Reader, o *ShaderIdˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawShaderIdˢ(d binary.Reader, o *ShaderIdˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassShaderIdˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeShaderIdˢ(e, obj.(*ShaderIdˢ))
}
func (*binaryClassShaderIdˢ) New() binary.Object {
	return &ShaderIdˢ{}
}
func (*binaryClassShaderIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeShaderIdˢ(d, obj.(*ShaderIdˢ))
}
func (o *ShaderIdˢ) WriteSimple(w binary.Writer) {
	doEncodeShaderIdˢ(w, o)
}
func (o *ShaderIdˢ) ReadSimple(r binary.Reader) {
	doDecodeShaderIdˢ(r, o)
}
func (c *binaryClassShaderIdˢ) Schema() *binary.Entity {
	return &entities[ixǁShaderIdˢ]
}

type binaryClassStartTimer struct{}

func (*StartTimer) Class() binary.Class {
	return (*binaryClassStartTimer)(nil)
}
func doEncodeStartTimer(e binary.Encoder, o *StartTimer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint8(o.Index)
}
func doDecodeStartTimer(d binary.Decoder, o *StartTimer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = uint8(d.Uint8())
}
func doDecodeRawStartTimer(d binary.Decoder, o *StartTimer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = uint8(d.Uint8())
}
func (*binaryClassStartTimer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeStartTimer(e, obj.(*StartTimer))
}
func (*binaryClassStartTimer) New() binary.Object {
	return &StartTimer{}
}
func (*binaryClassStartTimer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeStartTimer(d, obj.(*StartTimer))
}
func (c *binaryClassStartTimer) Schema() *binary.Entity {
	return &entities[ixǁStartTimer]
}

type binaryClassState struct{}

func (*State) Class() binary.Class {
	return (*binaryClassState)(nil)
}
func doEncodeState(e binary.Encoder, o *State) {
	e.Uint32(uint32(len(o.EGLContexts)))
	for _, k := range (o.EGLContexts).KeysSorted() {
		v := (o.EGLContexts)[k]
		e.Simple(&k)
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(o.NextContextID))
	e.Uint64(uint64(o.CurrentThread))
	e.Uint32(uint32(len(o.Contexts)))
	for _, k := range (o.Contexts).KeysSorted() {
		v := (o.Contexts)[k]
		e.Uint64(uint64(k))
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.GLXContexts)))
	for _, k := range (o.GLXContexts).KeysSorted() {
		v := (o.GLXContexts)[k]
		e.Simple(&k)
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.WGLContexts)))
	for _, k := range (o.WGLContexts).KeysSorted() {
		v := (o.WGLContexts)[k]
		e.Simple(&k)
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
	e.Uint32(uint32(len(o.CGLContexts)))
	for _, k := range (o.CGLContexts).KeysSorted() {
		v := (o.CGLContexts)[k]
		e.Simple(&k)
		if v != nil {
			e.Object(v)
		} else {
			e.Object(nil)
		}
	}
}
func doDecodeState(d binary.Decoder, o *State) {
	if count := d.Count(); count > 0 {
		o.EGLContexts = make(EGLContextːContextʳᵐ, count)
		m := o.EGLContexts
		for i := uint32(0); i < count; i++ {
			var k EGLContext
			var v *Context
			d.Simple(&k)
			if obj := d.Object(); obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	o.NextContextID = ContextID(d.Uint32())
	o.CurrentThread = ThreadID(d.Uint64())
	if count := d.Count(); count > 0 {
		o.Contexts = make(ThreadIDːContextʳᵐ, count)
		m := o.Contexts
		for i := uint32(0); i < count; i++ {
			var k ThreadID
			var v *Context
			k = ThreadID(d.Uint64())
			if obj := d.Object(); obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.GLXContexts = make(GLXContextːContextʳᵐ, count)
		m := o.GLXContexts
		for i := uint32(0); i < count; i++ {
			var k GLXContext
			var v *Context
			d.Simple(&k)
			if obj := d.Object(); obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.WGLContexts = make(HGLRCːContextʳᵐ, count)
		m := o.WGLContexts
		for i := uint32(0); i < count; i++ {
			var k HGLRC
			var v *Context
			d.Simple(&k)
			if obj := d.Object(); obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.CGLContexts = make(CGLContextObjːContextʳᵐ, count)
		m := o.CGLContexts
		for i := uint32(0); i < count; i++ {
			var k CGLContextObj
			var v *Context
			d.Simple(&k)
			if obj := d.Object(); obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
}
func doDecodeRawState(d binary.Decoder, o *State) {
	if count := d.Count(); count > 0 {
		o.EGLContexts = make(EGLContextːContextʳᵐ, count)
		m := o.EGLContexts
		for i := uint32(0); i < count; i++ {
			var k EGLContext
			var v *Context
			d.Simple(&k)
			if obj := d.Object(); obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	o.NextContextID = ContextID(d.Uint32())
	o.CurrentThread = ThreadID(d.Uint64())
	if count := d.Count(); count > 0 {
		o.Contexts = make(ThreadIDːContextʳᵐ, count)
		m := o.Contexts
		for i := uint32(0); i < count; i++ {
			var k ThreadID
			var v *Context
			k = ThreadID(d.Uint64())
			if obj := d.Object(); obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.GLXContexts = make(GLXContextːContextʳᵐ, count)
		m := o.GLXContexts
		for i := uint32(0); i < count; i++ {
			var k GLXContext
			var v *Context
			d.Simple(&k)
			if obj := d.Object(); obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.WGLContexts = make(HGLRCːContextʳᵐ, count)
		m := o.WGLContexts
		for i := uint32(0); i < count; i++ {
			var k HGLRC
			var v *Context
			d.Simple(&k)
			if obj := d.Object(); obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count := d.Count(); count > 0 {
		o.CGLContexts = make(CGLContextObjːContextʳᵐ, count)
		m := o.CGLContexts
		for i := uint32(0); i < count; i++ {
			var k CGLContextObj
			var v *Context
			d.Simple(&k)
			if obj := d.Object(); obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
}
func (*binaryClassState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeState(e, obj.(*State))
}
func (*binaryClassState) New() binary.Object {
	return &State{}
}
func (*binaryClassState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeState(d, obj.(*State))
}
func (c *binaryClassState) Schema() *binary.Entity {
	return &entities[ixǁState]
}

type binaryClassStaticContextState struct{}

func (*StaticContextState) Class() binary.Class {
	return (*binaryClassStaticContextState)(nil)
}
func doEncodeStaticContextState(e binary.Writer, o *StaticContextState) {
	e.Simple(&o.Constants)
}
func doDecodeStaticContextState(d binary.Reader, o *StaticContextState) {
	d.Simple(&o.Constants)
}
func doDecodeRawStaticContextState(d binary.Reader, o *StaticContextState) {
	d.Simple(&o.Constants)
}
func (*binaryClassStaticContextState) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeStaticContextState(e, obj.(*StaticContextState))
}
func (*binaryClassStaticContextState) New() binary.Object {
	return &StaticContextState{}
}
func (*binaryClassStaticContextState) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeStaticContextState(d, obj.(*StaticContextState))
}
func (o *StaticContextState) WriteSimple(w binary.Writer) {
	doEncodeStaticContextState(w, o)
}
func (o *StaticContextState) ReadSimple(r binary.Reader) {
	doDecodeStaticContextState(r, o)
}
func (c *binaryClassStaticContextState) Schema() *binary.Entity {
	return &entities[ixǁStaticContextState]
}

type binaryClassStopTimer struct{}

func (*StopTimer) Class() binary.Class {
	return (*binaryClassStopTimer)(nil)
}
func doEncodeStopTimer(e binary.Encoder, o *StopTimer) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Uint8(o.Index)
	e.Uint64(o.Result)
}
func doDecodeStopTimer(d binary.Decoder, o *StopTimer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = uint8(d.Uint8())
	o.Result = uint64(d.Uint64())
}
func doDecodeRawStopTimer(d binary.Decoder, o *StopTimer) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	o.Index = uint8(d.Uint8())
	o.Result = uint64(d.Uint64())
}
func (*binaryClassStopTimer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeStopTimer(e, obj.(*StopTimer))
}
func (*binaryClassStopTimer) New() binary.Object {
	return &StopTimer{}
}
func (*binaryClassStopTimer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeStopTimer(d, obj.(*StopTimer))
}
func (c *binaryClassStopTimer) Schema() *binary.Entity {
	return &entities[ixǁStopTimer]
}

type binaryClassTAG_ATOM_NAME struct{}

func (*TAG_ATOM_NAME) Class() binary.Class {
	return (*binaryClassTAG_ATOM_NAME)(nil)
}
func doEncodeTAG_ATOM_NAME(e binary.Writer, o *TAG_ATOM_NAME) {
	e.String(o.Atom)
}
func doDecodeTAG_ATOM_NAME(d binary.Reader, o *TAG_ATOM_NAME) {
	o.Atom = string(d.String())
}
func doDecodeRawTAG_ATOM_NAME(d binary.Reader, o *TAG_ATOM_NAME) {
	o.Atom = string(d.String())
}
func (*binaryClassTAG_ATOM_NAME) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTAG_ATOM_NAME(e, obj.(*TAG_ATOM_NAME))
}
func (*binaryClassTAG_ATOM_NAME) New() binary.Object {
	return &TAG_ATOM_NAME{}
}
func (*binaryClassTAG_ATOM_NAME) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTAG_ATOM_NAME(d, obj.(*TAG_ATOM_NAME))
}
func (o *TAG_ATOM_NAME) WriteSimple(w binary.Writer) {
	doEncodeTAG_ATOM_NAME(w, o)
}
func (o *TAG_ATOM_NAME) ReadSimple(r binary.Reader) {
	doDecodeTAG_ATOM_NAME(r, o)
}
func (c *binaryClassTAG_ATOM_NAME) Schema() *binary.Entity {
	return &entities[ixǁTAG_ATOM_NAME]
}

type binaryClassTextureIdˢ struct{}

func (*TextureIdˢ) Class() binary.Class {
	return (*binaryClassTextureIdˢ)(nil)
}
func doEncodeTextureIdˢ(e binary.Writer, o *TextureIdˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeTextureIdˢ(d binary.Reader, o *TextureIdˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawTextureIdˢ(d binary.Reader, o *TextureIdˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassTextureIdˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTextureIdˢ(e, obj.(*TextureIdˢ))
}
func (*binaryClassTextureIdˢ) New() binary.Object {
	return &TextureIdˢ{}
}
func (*binaryClassTextureIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTextureIdˢ(d, obj.(*TextureIdˢ))
}
func (o *TextureIdˢ) WriteSimple(w binary.Writer) {
	doEncodeTextureIdˢ(w, o)
}
func (o *TextureIdˢ) ReadSimple(r binary.Reader) {
	doDecodeTextureIdˢ(r, o)
}
func (c *binaryClassTextureIdˢ) Schema() *binary.Entity {
	return &entities[ixǁTextureIdˢ]
}

type binaryClassTransformFeedbackIdˢ struct{}

func (*TransformFeedbackIdˢ) Class() binary.Class {
	return (*binaryClassTransformFeedbackIdˢ)(nil)
}
func doEncodeTransformFeedbackIdˢ(e binary.Writer, o *TransformFeedbackIdˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeTransformFeedbackIdˢ(d binary.Reader, o *TransformFeedbackIdˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawTransformFeedbackIdˢ(d binary.Reader, o *TransformFeedbackIdˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassTransformFeedbackIdˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTransformFeedbackIdˢ(e, obj.(*TransformFeedbackIdˢ))
}
func (*binaryClassTransformFeedbackIdˢ) New() binary.Object {
	return &TransformFeedbackIdˢ{}
}
func (*binaryClassTransformFeedbackIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTransformFeedbackIdˢ(d, obj.(*TransformFeedbackIdˢ))
}
func (o *TransformFeedbackIdˢ) WriteSimple(w binary.Writer) {
	doEncodeTransformFeedbackIdˢ(w, o)
}
func (o *TransformFeedbackIdˢ) ReadSimple(r binary.Reader) {
	doDecodeTransformFeedbackIdˢ(r, o)
}
func (c *binaryClassTransformFeedbackIdˢ) Schema() *binary.Entity {
	return &entities[ixǁTransformFeedbackIdˢ]
}

type binaryClassU32ˢ struct{}

func (*U32ˢ) Class() binary.Class {
	return (*binaryClassU32ˢ)(nil)
}
func doEncodeU32ˢ(e binary.Writer, o *U32ˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeU32ˢ(d binary.Reader, o *U32ˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawU32ˢ(d binary.Reader, o *U32ˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassU32ˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeU32ˢ(e, obj.(*U32ˢ))
}
func (*binaryClassU32ˢ) New() binary.Object {
	return &U32ˢ{}
}
func (*binaryClassU32ˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeU32ˢ(d, obj.(*U32ˢ))
}
func (o *U32ˢ) WriteSimple(w binary.Writer) {
	doEncodeU32ˢ(w, o)
}
func (o *U32ˢ) ReadSimple(r binary.Reader) {
	doDecodeU32ˢ(r, o)
}
func (c *binaryClassU32ˢ) Schema() *binary.Entity {
	return &entities[ixǁU32ˢ]
}

type binaryClassU64ˢ struct{}

func (*U64ˢ) Class() binary.Class {
	return (*binaryClassU64ˢ)(nil)
}
func doEncodeU64ˢ(e binary.Writer, o *U64ˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeU64ˢ(d binary.Reader, o *U64ˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawU64ˢ(d binary.Reader, o *U64ˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassU64ˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeU64ˢ(e, obj.(*U64ˢ))
}
func (*binaryClassU64ˢ) New() binary.Object {
	return &U64ˢ{}
}
func (*binaryClassU64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeU64ˢ(d, obj.(*U64ˢ))
}
func (o *U64ˢ) WriteSimple(w binary.Writer) {
	doEncodeU64ˢ(w, o)
}
func (o *U64ˢ) ReadSimple(r binary.Reader) {
	doDecodeU64ˢ(r, o)
}
func (c *binaryClassU64ˢ) Schema() *binary.Entity {
	return &entities[ixǁU64ˢ]
}

type binaryClassUniformIndexˢ struct{}

func (*UniformIndexˢ) Class() binary.Class {
	return (*binaryClassUniformIndexˢ)(nil)
}
func doEncodeUniformIndexˢ(e binary.Writer, o *UniformIndexˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeUniformIndexˢ(d binary.Reader, o *UniformIndexˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawUniformIndexˢ(d binary.Reader, o *UniformIndexˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassUniformIndexˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeUniformIndexˢ(e, obj.(*UniformIndexˢ))
}
func (*binaryClassUniformIndexˢ) New() binary.Object {
	return &UniformIndexˢ{}
}
func (*binaryClassUniformIndexˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeUniformIndexˢ(d, obj.(*UniformIndexˢ))
}
func (o *UniformIndexˢ) WriteSimple(w binary.Writer) {
	doEncodeUniformIndexˢ(w, o)
}
func (o *UniformIndexˢ) ReadSimple(r binary.Reader) {
	doDecodeUniformIndexˢ(r, o)
}
func (c *binaryClassUniformIndexˢ) Schema() *binary.Entity {
	return &entities[ixǁUniformIndexˢ]
}

type binaryClassVec1f struct{}

func (*Vec1f) Class() binary.Class {
	return (*binaryClassVec1f)(nil)
}
func doEncodeVec1f(e binary.Writer, o *Vec1f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Float32(float32(*curr))
	}
}
func doDecodeVec1f(d binary.Reader, o *Vec1f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func doDecodeRawVec1f(d binary.Reader, o *Vec1f) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLfloat(d.Float32())
	}
}
func (*binaryClassVec1f) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec1f(e, obj.(*Vec1f))
}
func (*binaryClassVec1f) New() binary.Object {
	return &Vec1f{}
}
func (*binaryClassVec1f) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec1f(d, obj.(*Vec1f))
}
func (o *Vec1f) WriteSimple(w binary.Writer) {
	doEncodeVec1f(w, o)
}
func (o *Vec1f) ReadSimple(r binary.Reader) {
	doDecodeVec1f(r, o)
}
func (c *binaryClassVec1f) Schema() *binary.Entity {
	return &entities[ixǁVec1f]
}

type binaryClassVec1i struct{}

func (*Vec1i) Class() binary.Class {
	return (*binaryClassVec1i)(nil)
}
func doEncodeVec1i(e binary.Writer, o *Vec1i) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Int32(int32(*curr))
	}
}
func doDecodeVec1i(d binary.Reader, o *Vec1i) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func doDecodeRawVec1i(d binary.Reader, o *Vec1i) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func (*binaryClassVec1i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec1i(e, obj.(*Vec1i))
}
func (*binaryClassVec1i) New() binary.Object {
	return &Vec1i{}
}
func (*binaryClassVec1i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec1i(d, obj.(*Vec1i))
}
func (o *Vec1i) WriteSimple(w binary.Writer) {
	doEncodeVec1i(w, o)
}
func (o *Vec1i) ReadSimple(r binary.Reader) {
	doDecodeVec1i(r, o)
}
func (c *binaryClassVec1i) Schema() *binary.Entity {
	return &entities[ixǁVec1i]
}

type binaryClassVec2fː2ᵃ struct{}

func (*Vec2fː2ᵃ) Class() binary.Class {
	return (*binaryClassVec2fː2ᵃ)(nil)
}
func doEncodeVec2fː2ᵃ(e binary.Writer, o *Vec2fː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeVec2fː2ᵃ(d binary.Reader, o *Vec2fː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawVec2fː2ᵃ(d binary.Reader, o *Vec2fː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassVec2fː2ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec2fː2ᵃ(e, obj.(*Vec2fː2ᵃ))
}
func (*binaryClassVec2fː2ᵃ) New() binary.Object {
	return &Vec2fː2ᵃ{}
}
func (*binaryClassVec2fː2ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec2fː2ᵃ(d, obj.(*Vec2fː2ᵃ))
}
func (o *Vec2fː2ᵃ) WriteSimple(w binary.Writer) {
	doEncodeVec2fː2ᵃ(w, o)
}
func (o *Vec2fː2ᵃ) ReadSimple(r binary.Reader) {
	doDecodeVec2fː2ᵃ(r, o)
}
func (c *binaryClassVec2fː2ᵃ) Schema() *binary.Entity {
	return &entities[ixǁVec2fː2ᵃ]
}

type binaryClassVec2fː3ᵃ struct{}

func (*Vec2fː3ᵃ) Class() binary.Class {
	return (*binaryClassVec2fː3ᵃ)(nil)
}
func doEncodeVec2fː3ᵃ(e binary.Writer, o *Vec2fː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeVec2fː3ᵃ(d binary.Reader, o *Vec2fː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawVec2fː3ᵃ(d binary.Reader, o *Vec2fː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassVec2fː3ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec2fː3ᵃ(e, obj.(*Vec2fː3ᵃ))
}
func (*binaryClassVec2fː3ᵃ) New() binary.Object {
	return &Vec2fː3ᵃ{}
}
func (*binaryClassVec2fː3ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec2fː3ᵃ(d, obj.(*Vec2fː3ᵃ))
}
func (o *Vec2fː3ᵃ) WriteSimple(w binary.Writer) {
	doEncodeVec2fː3ᵃ(w, o)
}
func (o *Vec2fː3ᵃ) ReadSimple(r binary.Reader) {
	doDecodeVec2fː3ᵃ(r, o)
}
func (c *binaryClassVec2fː3ᵃ) Schema() *binary.Entity {
	return &entities[ixǁVec2fː3ᵃ]
}

type binaryClassVec2fː4ᵃ struct{}

func (*Vec2fː4ᵃ) Class() binary.Class {
	return (*binaryClassVec2fː4ᵃ)(nil)
}
func doEncodeVec2fː4ᵃ(e binary.Writer, o *Vec2fː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeVec2fː4ᵃ(d binary.Reader, o *Vec2fː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawVec2fː4ᵃ(d binary.Reader, o *Vec2fː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassVec2fː4ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec2fː4ᵃ(e, obj.(*Vec2fː4ᵃ))
}
func (*binaryClassVec2fː4ᵃ) New() binary.Object {
	return &Vec2fː4ᵃ{}
}
func (*binaryClassVec2fː4ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec2fː4ᵃ(d, obj.(*Vec2fː4ᵃ))
}
func (o *Vec2fː4ᵃ) WriteSimple(w binary.Writer) {
	doEncodeVec2fː4ᵃ(w, o)
}
func (o *Vec2fː4ᵃ) ReadSimple(r binary.Reader) {
	doDecodeVec2fː4ᵃ(r, o)
}
func (c *binaryClassVec2fː4ᵃ) Schema() *binary.Entity {
	return &entities[ixǁVec2fː4ᵃ]
}

type binaryClassVec2fˢ struct{}

func (*Vec2fˢ) Class() binary.Class {
	return (*binaryClassVec2fˢ)(nil)
}
func doEncodeVec2fˢ(e binary.Writer, o *Vec2fˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVec2fˢ(d binary.Reader, o *Vec2fˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVec2fˢ(d binary.Reader, o *Vec2fˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVec2fˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec2fˢ(e, obj.(*Vec2fˢ))
}
func (*binaryClassVec2fˢ) New() binary.Object {
	return &Vec2fˢ{}
}
func (*binaryClassVec2fˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec2fˢ(d, obj.(*Vec2fˢ))
}
func (o *Vec2fˢ) WriteSimple(w binary.Writer) {
	doEncodeVec2fˢ(w, o)
}
func (o *Vec2fˢ) ReadSimple(r binary.Reader) {
	doDecodeVec2fˢ(r, o)
}
func (c *binaryClassVec2fˢ) Schema() *binary.Entity {
	return &entities[ixǁVec2fˢ]
}

type binaryClassVec2fᵖ struct{}

func (*Vec2fᵖ) Class() binary.Class {
	return (*binaryClassVec2fᵖ)(nil)
}
func doEncodeVec2fᵖ(e binary.Writer, o *Vec2fᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVec2fᵖ(d binary.Reader, o *Vec2fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVec2fᵖ(d binary.Reader, o *Vec2fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVec2fᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec2fᵖ(e, obj.(*Vec2fᵖ))
}
func (*binaryClassVec2fᵖ) New() binary.Object {
	return &Vec2fᵖ{}
}
func (*binaryClassVec2fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec2fᵖ(d, obj.(*Vec2fᵖ))
}
func (o *Vec2fᵖ) WriteSimple(w binary.Writer) {
	doEncodeVec2fᵖ(w, o)
}
func (o *Vec2fᵖ) ReadSimple(r binary.Reader) {
	doDecodeVec2fᵖ(r, o)
}
func (c *binaryClassVec2fᵖ) Schema() *binary.Entity {
	return &entities[ixǁVec2fᵖ]
}

type binaryClassVec2i struct{}

func (*Vec2i) Class() binary.Class {
	return (*binaryClassVec2i)(nil)
}
func doEncodeVec2i(e binary.Writer, o *Vec2i) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Int32(int32(*curr))
	}
}
func doDecodeVec2i(d binary.Reader, o *Vec2i) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func doDecodeRawVec2i(d binary.Reader, o *Vec2i) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func (*binaryClassVec2i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec2i(e, obj.(*Vec2i))
}
func (*binaryClassVec2i) New() binary.Object {
	return &Vec2i{}
}
func (*binaryClassVec2i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec2i(d, obj.(*Vec2i))
}
func (o *Vec2i) WriteSimple(w binary.Writer) {
	doEncodeVec2i(w, o)
}
func (o *Vec2i) ReadSimple(r binary.Reader) {
	doDecodeVec2i(r, o)
}
func (c *binaryClassVec2i) Schema() *binary.Entity {
	return &entities[ixǁVec2i]
}

type binaryClassVec2iˢ struct{}

func (*Vec2iˢ) Class() binary.Class {
	return (*binaryClassVec2iˢ)(nil)
}
func doEncodeVec2iˢ(e binary.Writer, o *Vec2iˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVec2iˢ(d binary.Reader, o *Vec2iˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVec2iˢ(d binary.Reader, o *Vec2iˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVec2iˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec2iˢ(e, obj.(*Vec2iˢ))
}
func (*binaryClassVec2iˢ) New() binary.Object {
	return &Vec2iˢ{}
}
func (*binaryClassVec2iˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec2iˢ(d, obj.(*Vec2iˢ))
}
func (o *Vec2iˢ) WriteSimple(w binary.Writer) {
	doEncodeVec2iˢ(w, o)
}
func (o *Vec2iˢ) ReadSimple(r binary.Reader) {
	doDecodeVec2iˢ(r, o)
}
func (c *binaryClassVec2iˢ) Schema() *binary.Entity {
	return &entities[ixǁVec2iˢ]
}

type binaryClassVec2iᵖ struct{}

func (*Vec2iᵖ) Class() binary.Class {
	return (*binaryClassVec2iᵖ)(nil)
}
func doEncodeVec2iᵖ(e binary.Writer, o *Vec2iᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVec2iᵖ(d binary.Reader, o *Vec2iᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVec2iᵖ(d binary.Reader, o *Vec2iᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVec2iᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec2iᵖ(e, obj.(*Vec2iᵖ))
}
func (*binaryClassVec2iᵖ) New() binary.Object {
	return &Vec2iᵖ{}
}
func (*binaryClassVec2iᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec2iᵖ(d, obj.(*Vec2iᵖ))
}
func (o *Vec2iᵖ) WriteSimple(w binary.Writer) {
	doEncodeVec2iᵖ(w, o)
}
func (o *Vec2iᵖ) ReadSimple(r binary.Reader) {
	doDecodeVec2iᵖ(r, o)
}
func (c *binaryClassVec2iᵖ) Schema() *binary.Entity {
	return &entities[ixǁVec2iᵖ]
}

type binaryClassVec2u struct{}

func (*Vec2u) Class() binary.Class {
	return (*binaryClassVec2u)(nil)
}
func doEncodeVec2u(e binary.Writer, o *Vec2u) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Uint32(uint32(*curr))
	}
}
func doDecodeVec2u(d binary.Reader, o *Vec2u) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLuint(d.Uint32())
	}
}
func doDecodeRawVec2u(d binary.Reader, o *Vec2u) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLuint(d.Uint32())
	}
}
func (*binaryClassVec2u) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec2u(e, obj.(*Vec2u))
}
func (*binaryClassVec2u) New() binary.Object {
	return &Vec2u{}
}
func (*binaryClassVec2u) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec2u(d, obj.(*Vec2u))
}
func (o *Vec2u) WriteSimple(w binary.Writer) {
	doEncodeVec2u(w, o)
}
func (o *Vec2u) ReadSimple(r binary.Reader) {
	doDecodeVec2u(r, o)
}
func (c *binaryClassVec2u) Schema() *binary.Entity {
	return &entities[ixǁVec2u]
}

type binaryClassVec2uˢ struct{}

func (*Vec2uˢ) Class() binary.Class {
	return (*binaryClassVec2uˢ)(nil)
}
func doEncodeVec2uˢ(e binary.Writer, o *Vec2uˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVec2uˢ(d binary.Reader, o *Vec2uˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVec2uˢ(d binary.Reader, o *Vec2uˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVec2uˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec2uˢ(e, obj.(*Vec2uˢ))
}
func (*binaryClassVec2uˢ) New() binary.Object {
	return &Vec2uˢ{}
}
func (*binaryClassVec2uˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec2uˢ(d, obj.(*Vec2uˢ))
}
func (o *Vec2uˢ) WriteSimple(w binary.Writer) {
	doEncodeVec2uˢ(w, o)
}
func (o *Vec2uˢ) ReadSimple(r binary.Reader) {
	doDecodeVec2uˢ(r, o)
}
func (c *binaryClassVec2uˢ) Schema() *binary.Entity {
	return &entities[ixǁVec2uˢ]
}

type binaryClassVec2uᵖ struct{}

func (*Vec2uᵖ) Class() binary.Class {
	return (*binaryClassVec2uᵖ)(nil)
}
func doEncodeVec2uᵖ(e binary.Writer, o *Vec2uᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVec2uᵖ(d binary.Reader, o *Vec2uᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVec2uᵖ(d binary.Reader, o *Vec2uᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVec2uᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec2uᵖ(e, obj.(*Vec2uᵖ))
}
func (*binaryClassVec2uᵖ) New() binary.Object {
	return &Vec2uᵖ{}
}
func (*binaryClassVec2uᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec2uᵖ(d, obj.(*Vec2uᵖ))
}
func (o *Vec2uᵖ) WriteSimple(w binary.Writer) {
	doEncodeVec2uᵖ(w, o)
}
func (o *Vec2uᵖ) ReadSimple(r binary.Reader) {
	doDecodeVec2uᵖ(r, o)
}
func (c *binaryClassVec2uᵖ) Schema() *binary.Entity {
	return &entities[ixǁVec2uᵖ]
}

type binaryClassVec3fː2ᵃ struct{}

func (*Vec3fː2ᵃ) Class() binary.Class {
	return (*binaryClassVec3fː2ᵃ)(nil)
}
func doEncodeVec3fː2ᵃ(e binary.Writer, o *Vec3fː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeVec3fː2ᵃ(d binary.Reader, o *Vec3fː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawVec3fː2ᵃ(d binary.Reader, o *Vec3fː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassVec3fː2ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec3fː2ᵃ(e, obj.(*Vec3fː2ᵃ))
}
func (*binaryClassVec3fː2ᵃ) New() binary.Object {
	return &Vec3fː2ᵃ{}
}
func (*binaryClassVec3fː2ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec3fː2ᵃ(d, obj.(*Vec3fː2ᵃ))
}
func (o *Vec3fː2ᵃ) WriteSimple(w binary.Writer) {
	doEncodeVec3fː2ᵃ(w, o)
}
func (o *Vec3fː2ᵃ) ReadSimple(r binary.Reader) {
	doDecodeVec3fː2ᵃ(r, o)
}
func (c *binaryClassVec3fː2ᵃ) Schema() *binary.Entity {
	return &entities[ixǁVec3fː2ᵃ]
}

type binaryClassVec3fː3ᵃ struct{}

func (*Vec3fː3ᵃ) Class() binary.Class {
	return (*binaryClassVec3fː3ᵃ)(nil)
}
func doEncodeVec3fː3ᵃ(e binary.Writer, o *Vec3fː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeVec3fː3ᵃ(d binary.Reader, o *Vec3fː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawVec3fː3ᵃ(d binary.Reader, o *Vec3fː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassVec3fː3ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec3fː3ᵃ(e, obj.(*Vec3fː3ᵃ))
}
func (*binaryClassVec3fː3ᵃ) New() binary.Object {
	return &Vec3fː3ᵃ{}
}
func (*binaryClassVec3fː3ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec3fː3ᵃ(d, obj.(*Vec3fː3ᵃ))
}
func (o *Vec3fː3ᵃ) WriteSimple(w binary.Writer) {
	doEncodeVec3fː3ᵃ(w, o)
}
func (o *Vec3fː3ᵃ) ReadSimple(r binary.Reader) {
	doDecodeVec3fː3ᵃ(r, o)
}
func (c *binaryClassVec3fː3ᵃ) Schema() *binary.Entity {
	return &entities[ixǁVec3fː3ᵃ]
}

type binaryClassVec3fː4ᵃ struct{}

func (*Vec3fː4ᵃ) Class() binary.Class {
	return (*binaryClassVec3fː4ᵃ)(nil)
}
func doEncodeVec3fː4ᵃ(e binary.Writer, o *Vec3fː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeVec3fː4ᵃ(d binary.Reader, o *Vec3fː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawVec3fː4ᵃ(d binary.Reader, o *Vec3fː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassVec3fː4ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec3fː4ᵃ(e, obj.(*Vec3fː4ᵃ))
}
func (*binaryClassVec3fː4ᵃ) New() binary.Object {
	return &Vec3fː4ᵃ{}
}
func (*binaryClassVec3fː4ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec3fː4ᵃ(d, obj.(*Vec3fː4ᵃ))
}
func (o *Vec3fː4ᵃ) WriteSimple(w binary.Writer) {
	doEncodeVec3fː4ᵃ(w, o)
}
func (o *Vec3fː4ᵃ) ReadSimple(r binary.Reader) {
	doDecodeVec3fː4ᵃ(r, o)
}
func (c *binaryClassVec3fː4ᵃ) Schema() *binary.Entity {
	return &entities[ixǁVec3fː4ᵃ]
}

type binaryClassVec3fˢ struct{}

func (*Vec3fˢ) Class() binary.Class {
	return (*binaryClassVec3fˢ)(nil)
}
func doEncodeVec3fˢ(e binary.Writer, o *Vec3fˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVec3fˢ(d binary.Reader, o *Vec3fˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVec3fˢ(d binary.Reader, o *Vec3fˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVec3fˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec3fˢ(e, obj.(*Vec3fˢ))
}
func (*binaryClassVec3fˢ) New() binary.Object {
	return &Vec3fˢ{}
}
func (*binaryClassVec3fˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec3fˢ(d, obj.(*Vec3fˢ))
}
func (o *Vec3fˢ) WriteSimple(w binary.Writer) {
	doEncodeVec3fˢ(w, o)
}
func (o *Vec3fˢ) ReadSimple(r binary.Reader) {
	doDecodeVec3fˢ(r, o)
}
func (c *binaryClassVec3fˢ) Schema() *binary.Entity {
	return &entities[ixǁVec3fˢ]
}

type binaryClassVec3fᵖ struct{}

func (*Vec3fᵖ) Class() binary.Class {
	return (*binaryClassVec3fᵖ)(nil)
}
func doEncodeVec3fᵖ(e binary.Writer, o *Vec3fᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVec3fᵖ(d binary.Reader, o *Vec3fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVec3fᵖ(d binary.Reader, o *Vec3fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVec3fᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec3fᵖ(e, obj.(*Vec3fᵖ))
}
func (*binaryClassVec3fᵖ) New() binary.Object {
	return &Vec3fᵖ{}
}
func (*binaryClassVec3fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec3fᵖ(d, obj.(*Vec3fᵖ))
}
func (o *Vec3fᵖ) WriteSimple(w binary.Writer) {
	doEncodeVec3fᵖ(w, o)
}
func (o *Vec3fᵖ) ReadSimple(r binary.Reader) {
	doDecodeVec3fᵖ(r, o)
}
func (c *binaryClassVec3fᵖ) Schema() *binary.Entity {
	return &entities[ixǁVec3fᵖ]
}

type binaryClassVec3i struct{}

func (*Vec3i) Class() binary.Class {
	return (*binaryClassVec3i)(nil)
}
func doEncodeVec3i(e binary.Writer, o *Vec3i) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Int32(int32(*curr))
	}
}
func doDecodeVec3i(d binary.Reader, o *Vec3i) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func doDecodeRawVec3i(d binary.Reader, o *Vec3i) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func (*binaryClassVec3i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec3i(e, obj.(*Vec3i))
}
func (*binaryClassVec3i) New() binary.Object {
	return &Vec3i{}
}
func (*binaryClassVec3i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec3i(d, obj.(*Vec3i))
}
func (o *Vec3i) WriteSimple(w binary.Writer) {
	doEncodeVec3i(w, o)
}
func (o *Vec3i) ReadSimple(r binary.Reader) {
	doDecodeVec3i(r, o)
}
func (c *binaryClassVec3i) Schema() *binary.Entity {
	return &entities[ixǁVec3i]
}

type binaryClassVec3iˢ struct{}

func (*Vec3iˢ) Class() binary.Class {
	return (*binaryClassVec3iˢ)(nil)
}
func doEncodeVec3iˢ(e binary.Writer, o *Vec3iˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVec3iˢ(d binary.Reader, o *Vec3iˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVec3iˢ(d binary.Reader, o *Vec3iˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVec3iˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec3iˢ(e, obj.(*Vec3iˢ))
}
func (*binaryClassVec3iˢ) New() binary.Object {
	return &Vec3iˢ{}
}
func (*binaryClassVec3iˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec3iˢ(d, obj.(*Vec3iˢ))
}
func (o *Vec3iˢ) WriteSimple(w binary.Writer) {
	doEncodeVec3iˢ(w, o)
}
func (o *Vec3iˢ) ReadSimple(r binary.Reader) {
	doDecodeVec3iˢ(r, o)
}
func (c *binaryClassVec3iˢ) Schema() *binary.Entity {
	return &entities[ixǁVec3iˢ]
}

type binaryClassVec3iᵖ struct{}

func (*Vec3iᵖ) Class() binary.Class {
	return (*binaryClassVec3iᵖ)(nil)
}
func doEncodeVec3iᵖ(e binary.Writer, o *Vec3iᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVec3iᵖ(d binary.Reader, o *Vec3iᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVec3iᵖ(d binary.Reader, o *Vec3iᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVec3iᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec3iᵖ(e, obj.(*Vec3iᵖ))
}
func (*binaryClassVec3iᵖ) New() binary.Object {
	return &Vec3iᵖ{}
}
func (*binaryClassVec3iᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec3iᵖ(d, obj.(*Vec3iᵖ))
}
func (o *Vec3iᵖ) WriteSimple(w binary.Writer) {
	doEncodeVec3iᵖ(w, o)
}
func (o *Vec3iᵖ) ReadSimple(r binary.Reader) {
	doDecodeVec3iᵖ(r, o)
}
func (c *binaryClassVec3iᵖ) Schema() *binary.Entity {
	return &entities[ixǁVec3iᵖ]
}

type binaryClassVec3u struct{}

func (*Vec3u) Class() binary.Class {
	return (*binaryClassVec3u)(nil)
}
func doEncodeVec3u(e binary.Writer, o *Vec3u) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Uint32(uint32(*curr))
	}
}
func doDecodeVec3u(d binary.Reader, o *Vec3u) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLuint(d.Uint32())
	}
}
func doDecodeRawVec3u(d binary.Reader, o *Vec3u) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLuint(d.Uint32())
	}
}
func (*binaryClassVec3u) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec3u(e, obj.(*Vec3u))
}
func (*binaryClassVec3u) New() binary.Object {
	return &Vec3u{}
}
func (*binaryClassVec3u) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec3u(d, obj.(*Vec3u))
}
func (o *Vec3u) WriteSimple(w binary.Writer) {
	doEncodeVec3u(w, o)
}
func (o *Vec3u) ReadSimple(r binary.Reader) {
	doDecodeVec3u(r, o)
}
func (c *binaryClassVec3u) Schema() *binary.Entity {
	return &entities[ixǁVec3u]
}

type binaryClassVec3uˢ struct{}

func (*Vec3uˢ) Class() binary.Class {
	return (*binaryClassVec3uˢ)(nil)
}
func doEncodeVec3uˢ(e binary.Writer, o *Vec3uˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVec3uˢ(d binary.Reader, o *Vec3uˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVec3uˢ(d binary.Reader, o *Vec3uˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVec3uˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec3uˢ(e, obj.(*Vec3uˢ))
}
func (*binaryClassVec3uˢ) New() binary.Object {
	return &Vec3uˢ{}
}
func (*binaryClassVec3uˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec3uˢ(d, obj.(*Vec3uˢ))
}
func (o *Vec3uˢ) WriteSimple(w binary.Writer) {
	doEncodeVec3uˢ(w, o)
}
func (o *Vec3uˢ) ReadSimple(r binary.Reader) {
	doDecodeVec3uˢ(r, o)
}
func (c *binaryClassVec3uˢ) Schema() *binary.Entity {
	return &entities[ixǁVec3uˢ]
}

type binaryClassVec3uᵖ struct{}

func (*Vec3uᵖ) Class() binary.Class {
	return (*binaryClassVec3uᵖ)(nil)
}
func doEncodeVec3uᵖ(e binary.Writer, o *Vec3uᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVec3uᵖ(d binary.Reader, o *Vec3uᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVec3uᵖ(d binary.Reader, o *Vec3uᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVec3uᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec3uᵖ(e, obj.(*Vec3uᵖ))
}
func (*binaryClassVec3uᵖ) New() binary.Object {
	return &Vec3uᵖ{}
}
func (*binaryClassVec3uᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec3uᵖ(d, obj.(*Vec3uᵖ))
}
func (o *Vec3uᵖ) WriteSimple(w binary.Writer) {
	doEncodeVec3uᵖ(w, o)
}
func (o *Vec3uᵖ) ReadSimple(r binary.Reader) {
	doDecodeVec3uᵖ(r, o)
}
func (c *binaryClassVec3uᵖ) Schema() *binary.Entity {
	return &entities[ixǁVec3uᵖ]
}

type binaryClassVec4fː2ᵃ struct{}

func (*Vec4fː2ᵃ) Class() binary.Class {
	return (*binaryClassVec4fː2ᵃ)(nil)
}
func doEncodeVec4fː2ᵃ(e binary.Writer, o *Vec4fː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeVec4fː2ᵃ(d binary.Reader, o *Vec4fː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawVec4fː2ᵃ(d binary.Reader, o *Vec4fː2ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassVec4fː2ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4fː2ᵃ(e, obj.(*Vec4fː2ᵃ))
}
func (*binaryClassVec4fː2ᵃ) New() binary.Object {
	return &Vec4fː2ᵃ{}
}
func (*binaryClassVec4fː2ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4fː2ᵃ(d, obj.(*Vec4fː2ᵃ))
}
func (o *Vec4fː2ᵃ) WriteSimple(w binary.Writer) {
	doEncodeVec4fː2ᵃ(w, o)
}
func (o *Vec4fː2ᵃ) ReadSimple(r binary.Reader) {
	doDecodeVec4fː2ᵃ(r, o)
}
func (c *binaryClassVec4fː2ᵃ) Schema() *binary.Entity {
	return &entities[ixǁVec4fː2ᵃ]
}

type binaryClassVec4fː3ᵃ struct{}

func (*Vec4fː3ᵃ) Class() binary.Class {
	return (*binaryClassVec4fː3ᵃ)(nil)
}
func doEncodeVec4fː3ᵃ(e binary.Writer, o *Vec4fː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeVec4fː3ᵃ(d binary.Reader, o *Vec4fː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawVec4fː3ᵃ(d binary.Reader, o *Vec4fː3ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassVec4fː3ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4fː3ᵃ(e, obj.(*Vec4fː3ᵃ))
}
func (*binaryClassVec4fː3ᵃ) New() binary.Object {
	return &Vec4fː3ᵃ{}
}
func (*binaryClassVec4fː3ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4fː3ᵃ(d, obj.(*Vec4fː3ᵃ))
}
func (o *Vec4fː3ᵃ) WriteSimple(w binary.Writer) {
	doEncodeVec4fː3ᵃ(w, o)
}
func (o *Vec4fː3ᵃ) ReadSimple(r binary.Reader) {
	doDecodeVec4fː3ᵃ(r, o)
}
func (c *binaryClassVec4fː3ᵃ) Schema() *binary.Entity {
	return &entities[ixǁVec4fː3ᵃ]
}

type binaryClassVec4fː4ᵃ struct{}

func (*Vec4fː4ᵃ) Class() binary.Class {
	return (*binaryClassVec4fː4ᵃ)(nil)
}
func doEncodeVec4fː4ᵃ(e binary.Writer, o *Vec4fː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Simple(&(*curr))
	}
}
func doDecodeVec4fː4ᵃ(d binary.Reader, o *Vec4fː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func doDecodeRawVec4fː4ᵃ(d binary.Reader, o *Vec4fː4ᵃ) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		d.Simple(&(*curr))
	}
}
func (*binaryClassVec4fː4ᵃ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4fː4ᵃ(e, obj.(*Vec4fː4ᵃ))
}
func (*binaryClassVec4fː4ᵃ) New() binary.Object {
	return &Vec4fː4ᵃ{}
}
func (*binaryClassVec4fː4ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4fː4ᵃ(d, obj.(*Vec4fː4ᵃ))
}
func (o *Vec4fː4ᵃ) WriteSimple(w binary.Writer) {
	doEncodeVec4fː4ᵃ(w, o)
}
func (o *Vec4fː4ᵃ) ReadSimple(r binary.Reader) {
	doDecodeVec4fː4ᵃ(r, o)
}
func (c *binaryClassVec4fː4ᵃ) Schema() *binary.Entity {
	return &entities[ixǁVec4fː4ᵃ]
}

type binaryClassVec4fˢ struct{}

func (*Vec4fˢ) Class() binary.Class {
	return (*binaryClassVec4fˢ)(nil)
}
func doEncodeVec4fˢ(e binary.Writer, o *Vec4fˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVec4fˢ(d binary.Reader, o *Vec4fˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVec4fˢ(d binary.Reader, o *Vec4fˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVec4fˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4fˢ(e, obj.(*Vec4fˢ))
}
func (*binaryClassVec4fˢ) New() binary.Object {
	return &Vec4fˢ{}
}
func (*binaryClassVec4fˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4fˢ(d, obj.(*Vec4fˢ))
}
func (o *Vec4fˢ) WriteSimple(w binary.Writer) {
	doEncodeVec4fˢ(w, o)
}
func (o *Vec4fˢ) ReadSimple(r binary.Reader) {
	doDecodeVec4fˢ(r, o)
}
func (c *binaryClassVec4fˢ) Schema() *binary.Entity {
	return &entities[ixǁVec4fˢ]
}

type binaryClassVec4fᵖ struct{}

func (*Vec4fᵖ) Class() binary.Class {
	return (*binaryClassVec4fᵖ)(nil)
}
func doEncodeVec4fᵖ(e binary.Writer, o *Vec4fᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVec4fᵖ(d binary.Reader, o *Vec4fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVec4fᵖ(d binary.Reader, o *Vec4fᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVec4fᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4fᵖ(e, obj.(*Vec4fᵖ))
}
func (*binaryClassVec4fᵖ) New() binary.Object {
	return &Vec4fᵖ{}
}
func (*binaryClassVec4fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4fᵖ(d, obj.(*Vec4fᵖ))
}
func (o *Vec4fᵖ) WriteSimple(w binary.Writer) {
	doEncodeVec4fᵖ(w, o)
}
func (o *Vec4fᵖ) ReadSimple(r binary.Reader) {
	doDecodeVec4fᵖ(r, o)
}
func (c *binaryClassVec4fᵖ) Schema() *binary.Entity {
	return &entities[ixǁVec4fᵖ]
}

type binaryClassVec4i struct{}

func (*Vec4i) Class() binary.Class {
	return (*binaryClassVec4i)(nil)
}
func doEncodeVec4i(e binary.Writer, o *Vec4i) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Int32(int32(*curr))
	}
}
func doDecodeVec4i(d binary.Reader, o *Vec4i) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func doDecodeRawVec4i(d binary.Reader, o *Vec4i) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLint(d.Int32())
	}
}
func (*binaryClassVec4i) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4i(e, obj.(*Vec4i))
}
func (*binaryClassVec4i) New() binary.Object {
	return &Vec4i{}
}
func (*binaryClassVec4i) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4i(d, obj.(*Vec4i))
}
func (o *Vec4i) WriteSimple(w binary.Writer) {
	doEncodeVec4i(w, o)
}
func (o *Vec4i) ReadSimple(r binary.Reader) {
	doDecodeVec4i(r, o)
}
func (c *binaryClassVec4i) Schema() *binary.Entity {
	return &entities[ixǁVec4i]
}

type binaryClassVec4iˢ struct{}

func (*Vec4iˢ) Class() binary.Class {
	return (*binaryClassVec4iˢ)(nil)
}
func doEncodeVec4iˢ(e binary.Writer, o *Vec4iˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVec4iˢ(d binary.Reader, o *Vec4iˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVec4iˢ(d binary.Reader, o *Vec4iˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVec4iˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4iˢ(e, obj.(*Vec4iˢ))
}
func (*binaryClassVec4iˢ) New() binary.Object {
	return &Vec4iˢ{}
}
func (*binaryClassVec4iˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4iˢ(d, obj.(*Vec4iˢ))
}
func (o *Vec4iˢ) WriteSimple(w binary.Writer) {
	doEncodeVec4iˢ(w, o)
}
func (o *Vec4iˢ) ReadSimple(r binary.Reader) {
	doDecodeVec4iˢ(r, o)
}
func (c *binaryClassVec4iˢ) Schema() *binary.Entity {
	return &entities[ixǁVec4iˢ]
}

type binaryClassVec4iᵖ struct{}

func (*Vec4iᵖ) Class() binary.Class {
	return (*binaryClassVec4iᵖ)(nil)
}
func doEncodeVec4iᵖ(e binary.Writer, o *Vec4iᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVec4iᵖ(d binary.Reader, o *Vec4iᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVec4iᵖ(d binary.Reader, o *Vec4iᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVec4iᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4iᵖ(e, obj.(*Vec4iᵖ))
}
func (*binaryClassVec4iᵖ) New() binary.Object {
	return &Vec4iᵖ{}
}
func (*binaryClassVec4iᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4iᵖ(d, obj.(*Vec4iᵖ))
}
func (o *Vec4iᵖ) WriteSimple(w binary.Writer) {
	doEncodeVec4iᵖ(w, o)
}
func (o *Vec4iᵖ) ReadSimple(r binary.Reader) {
	doDecodeVec4iᵖ(r, o)
}
func (c *binaryClassVec4iᵖ) Schema() *binary.Entity {
	return &entities[ixǁVec4iᵖ]
}

type binaryClassVec4u struct{}

func (*Vec4u) Class() binary.Class {
	return (*binaryClassVec4u)(nil)
}
func doEncodeVec4u(e binary.Writer, o *Vec4u) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		e.Uint32(uint32(*curr))
	}
}
func doDecodeVec4u(d binary.Reader, o *Vec4u) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLuint(d.Uint32())
	}
}
func doDecodeRawVec4u(d binary.Reader, o *Vec4u) {
	for i := range o.Elements {
		curr := &o.Elements[i]
		*curr = GLuint(d.Uint32())
	}
}
func (*binaryClassVec4u) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4u(e, obj.(*Vec4u))
}
func (*binaryClassVec4u) New() binary.Object {
	return &Vec4u{}
}
func (*binaryClassVec4u) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4u(d, obj.(*Vec4u))
}
func (o *Vec4u) WriteSimple(w binary.Writer) {
	doEncodeVec4u(w, o)
}
func (o *Vec4u) ReadSimple(r binary.Reader) {
	doDecodeVec4u(r, o)
}
func (c *binaryClassVec4u) Schema() *binary.Entity {
	return &entities[ixǁVec4u]
}

type binaryClassVec4uˢ struct{}

func (*Vec4uˢ) Class() binary.Class {
	return (*binaryClassVec4uˢ)(nil)
}
func doEncodeVec4uˢ(e binary.Writer, o *Vec4uˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVec4uˢ(d binary.Reader, o *Vec4uˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVec4uˢ(d binary.Reader, o *Vec4uˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVec4uˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4uˢ(e, obj.(*Vec4uˢ))
}
func (*binaryClassVec4uˢ) New() binary.Object {
	return &Vec4uˢ{}
}
func (*binaryClassVec4uˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4uˢ(d, obj.(*Vec4uˢ))
}
func (o *Vec4uˢ) WriteSimple(w binary.Writer) {
	doEncodeVec4uˢ(w, o)
}
func (o *Vec4uˢ) ReadSimple(r binary.Reader) {
	doDecodeVec4uˢ(r, o)
}
func (c *binaryClassVec4uˢ) Schema() *binary.Entity {
	return &entities[ixǁVec4uˢ]
}

type binaryClassVec4uᵖ struct{}

func (*Vec4uᵖ) Class() binary.Class {
	return (*binaryClassVec4uᵖ)(nil)
}
func doEncodeVec4uᵖ(e binary.Writer, o *Vec4uᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVec4uᵖ(d binary.Reader, o *Vec4uᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVec4uᵖ(d binary.Reader, o *Vec4uᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVec4uᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVec4uᵖ(e, obj.(*Vec4uᵖ))
}
func (*binaryClassVec4uᵖ) New() binary.Object {
	return &Vec4uᵖ{}
}
func (*binaryClassVec4uᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVec4uᵖ(d, obj.(*Vec4uᵖ))
}
func (o *Vec4uᵖ) WriteSimple(w binary.Writer) {
	doEncodeVec4uᵖ(w, o)
}
func (o *Vec4uᵖ) ReadSimple(r binary.Reader) {
	doDecodeVec4uᵖ(r, o)
}
func (c *binaryClassVec4uᵖ) Schema() *binary.Entity {
	return &entities[ixǁVec4uᵖ]
}

type binaryClassVertexArrayIdˢ struct{}

func (*VertexArrayIdˢ) Class() binary.Class {
	return (*binaryClassVertexArrayIdˢ)(nil)
}
func doEncodeVertexArrayIdˢ(e binary.Writer, o *VertexArrayIdˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVertexArrayIdˢ(d binary.Reader, o *VertexArrayIdˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVertexArrayIdˢ(d binary.Reader, o *VertexArrayIdˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVertexArrayIdˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVertexArrayIdˢ(e, obj.(*VertexArrayIdˢ))
}
func (*binaryClassVertexArrayIdˢ) New() binary.Object {
	return &VertexArrayIdˢ{}
}
func (*binaryClassVertexArrayIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVertexArrayIdˢ(d, obj.(*VertexArrayIdˢ))
}
func (o *VertexArrayIdˢ) WriteSimple(w binary.Writer) {
	doEncodeVertexArrayIdˢ(w, o)
}
func (o *VertexArrayIdˢ) ReadSimple(r binary.Reader) {
	doDecodeVertexArrayIdˢ(r, o)
}
func (c *binaryClassVertexArrayIdˢ) Schema() *binary.Entity {
	return &entities[ixǁVertexArrayIdˢ]
}

type binaryClassVoidˢ struct{}

func (*Voidˢ) Class() binary.Class {
	return (*binaryClassVoidˢ)(nil)
}
func doEncodeVoidˢ(e binary.Writer, o *Voidˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVoidˢ(d binary.Reader, o *Voidˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVoidˢ(d binary.Reader, o *Voidˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVoidˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVoidˢ(e, obj.(*Voidˢ))
}
func (*binaryClassVoidˢ) New() binary.Object {
	return &Voidˢ{}
}
func (*binaryClassVoidˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVoidˢ(d, obj.(*Voidˢ))
}
func (o *Voidˢ) WriteSimple(w binary.Writer) {
	doEncodeVoidˢ(w, o)
}
func (o *Voidˢ) ReadSimple(r binary.Reader) {
	doDecodeVoidˢ(r, o)
}
func (c *binaryClassVoidˢ) Schema() *binary.Entity {
	return &entities[ixǁVoidˢ]
}

type binaryClassVoidᵖˢ struct{}

func (*Voidᵖˢ) Class() binary.Class {
	return (*binaryClassVoidᵖˢ)(nil)
}
func doEncodeVoidᵖˢ(e binary.Writer, o *Voidᵖˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVoidᵖˢ(d binary.Reader, o *Voidᵖˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVoidᵖˢ(d binary.Reader, o *Voidᵖˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVoidᵖˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVoidᵖˢ(e, obj.(*Voidᵖˢ))
}
func (*binaryClassVoidᵖˢ) New() binary.Object {
	return &Voidᵖˢ{}
}
func (*binaryClassVoidᵖˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVoidᵖˢ(d, obj.(*Voidᵖˢ))
}
func (o *Voidᵖˢ) WriteSimple(w binary.Writer) {
	doEncodeVoidᵖˢ(w, o)
}
func (o *Voidᵖˢ) ReadSimple(r binary.Reader) {
	doDecodeVoidᵖˢ(r, o)
}
func (c *binaryClassVoidᵖˢ) Schema() *binary.Entity {
	return &entities[ixǁVoidᵖˢ]
}

type binaryClassVoidᶜᵖˢ struct{}

func (*Voidᶜᵖˢ) Class() binary.Class {
	return (*binaryClassVoidᶜᵖˢ)(nil)
}
func doEncodeVoidᶜᵖˢ(e binary.Writer, o *Voidᶜᵖˢ) {
	e.Simple(&o.SliceInfo)
}
func doDecodeVoidᶜᵖˢ(d binary.Reader, o *Voidᶜᵖˢ) {
	d.Simple(&o.SliceInfo)
}
func doDecodeRawVoidᶜᵖˢ(d binary.Reader, o *Voidᶜᵖˢ) {
	d.Simple(&o.SliceInfo)
}
func (*binaryClassVoidᶜᵖˢ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVoidᶜᵖˢ(e, obj.(*Voidᶜᵖˢ))
}
func (*binaryClassVoidᶜᵖˢ) New() binary.Object {
	return &Voidᶜᵖˢ{}
}
func (*binaryClassVoidᶜᵖˢ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVoidᶜᵖˢ(d, obj.(*Voidᶜᵖˢ))
}
func (o *Voidᶜᵖˢ) WriteSimple(w binary.Writer) {
	doEncodeVoidᶜᵖˢ(w, o)
}
func (o *Voidᶜᵖˢ) ReadSimple(r binary.Reader) {
	doDecodeVoidᶜᵖˢ(r, o)
}
func (c *binaryClassVoidᶜᵖˢ) Schema() *binary.Entity {
	return &entities[ixǁVoidᶜᵖˢ]
}

type binaryClassVoidᶜᵖᵖ struct{}

func (*Voidᶜᵖᵖ) Class() binary.Class {
	return (*binaryClassVoidᶜᵖᵖ)(nil)
}
func doEncodeVoidᶜᵖᵖ(e binary.Writer, o *Voidᶜᵖᵖ) {
	e.Uint64(o.Address)
	e.Uint32(uint32(o.Pool))
}
func doDecodeVoidᶜᵖᵖ(d binary.Reader, o *Voidᶜᵖᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func doDecodeRawVoidᶜᵖᵖ(d binary.Reader, o *Voidᶜᵖᵖ) {
	o.Address = uint64(d.Uint64())
	o.Pool = memory.PoolID(d.Uint32())
}
func (*binaryClassVoidᶜᵖᵖ) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeVoidᶜᵖᵖ(e, obj.(*Voidᶜᵖᵖ))
}
func (*binaryClassVoidᶜᵖᵖ) New() binary.Object {
	return &Voidᶜᵖᵖ{}
}
func (*binaryClassVoidᶜᵖᵖ) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeVoidᶜᵖᵖ(d, obj.(*Voidᶜᵖᵖ))
}
func (o *Voidᶜᵖᵖ) WriteSimple(w binary.Writer) {
	doEncodeVoidᶜᵖᵖ(w, o)
}
func (o *Voidᶜᵖᵖ) ReadSimple(r binary.Reader) {
	doDecodeVoidᶜᵖᵖ(r, o)
}
func (c *binaryClassVoidᶜᵖᵖ) Schema() *binary.Entity {
	return &entities[ixǁVoidᶜᵖᵖ]
}

type binaryClassWARN_UNKNOWN_CONTEXT struct{}

func (*WARN_UNKNOWN_CONTEXT) Class() binary.Class {
	return (*binaryClassWARN_UNKNOWN_CONTEXT)(nil)
}
func doEncodeWARN_UNKNOWN_CONTEXT(e binary.Writer, o *WARN_UNKNOWN_CONTEXT) {
	e.Uint64(o.Id)
}
func doDecodeWARN_UNKNOWN_CONTEXT(d binary.Reader, o *WARN_UNKNOWN_CONTEXT) {
	o.Id = uint64(d.Uint64())
}
func doDecodeRawWARN_UNKNOWN_CONTEXT(d binary.Reader, o *WARN_UNKNOWN_CONTEXT) {
	o.Id = uint64(d.Uint64())
}
func (*binaryClassWARN_UNKNOWN_CONTEXT) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeWARN_UNKNOWN_CONTEXT(e, obj.(*WARN_UNKNOWN_CONTEXT))
}
func (*binaryClassWARN_UNKNOWN_CONTEXT) New() binary.Object {
	return &WARN_UNKNOWN_CONTEXT{}
}
func (*binaryClassWARN_UNKNOWN_CONTEXT) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeWARN_UNKNOWN_CONTEXT(d, obj.(*WARN_UNKNOWN_CONTEXT))
}
func (o *WARN_UNKNOWN_CONTEXT) WriteSimple(w binary.Writer) {
	doEncodeWARN_UNKNOWN_CONTEXT(w, o)
}
func (o *WARN_UNKNOWN_CONTEXT) ReadSimple(r binary.Reader) {
	doDecodeWARN_UNKNOWN_CONTEXT(r, o)
}
func (c *binaryClassWARN_UNKNOWN_CONTEXT) Schema() *binary.Entity {
	return &entities[ixǁWARN_UNKNOWN_CONTEXT]
}

type binaryClassWglCreateContext struct{}

func (*WglCreateContext) Class() binary.Class {
	return (*binaryClassWglCreateContext)(nil)
}
func doEncodeWglCreateContext(e binary.Encoder, o *WglCreateContext) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Hdc)
	e.Simple(&o.Result)
}
func doDecodeWglCreateContext(d binary.Decoder, o *WglCreateContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Hdc)
	d.Simple(&o.Result)
}
func doDecodeRawWglCreateContext(d binary.Decoder, o *WglCreateContext) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Hdc)
	d.Simple(&o.Result)
}
func (*binaryClassWglCreateContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeWglCreateContext(e, obj.(*WglCreateContext))
}
func (*binaryClassWglCreateContext) New() binary.Object {
	return &WglCreateContext{}
}
func (*binaryClassWglCreateContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeWglCreateContext(d, obj.(*WglCreateContext))
}
func (c *binaryClassWglCreateContext) Schema() *binary.Entity {
	return &entities[ixǁWglCreateContext]
}

type binaryClassWglCreateContextAttribsARB struct{}

func (*WglCreateContextAttribsARB) Class() binary.Class {
	return (*binaryClassWglCreateContextAttribsARB)(nil)
}
func doEncodeWglCreateContextAttribsARB(e binary.Encoder, o *WglCreateContextAttribsARB) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Hdc)
	e.Simple(&o.HShareContext)
	e.Simple(&o.AttribList)
	e.Simple(&o.Result)
}
func doDecodeWglCreateContextAttribsARB(d binary.Decoder, o *WglCreateContextAttribsARB) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Hdc)
	d.Simple(&o.HShareContext)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func doDecodeRawWglCreateContextAttribsARB(d binary.Decoder, o *WglCreateContextAttribsARB) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Hdc)
	d.Simple(&o.HShareContext)
	d.Simple(&o.AttribList)
	d.Simple(&o.Result)
}
func (*binaryClassWglCreateContextAttribsARB) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeWglCreateContextAttribsARB(e, obj.(*WglCreateContextAttribsARB))
}
func (*binaryClassWglCreateContextAttribsARB) New() binary.Object {
	return &WglCreateContextAttribsARB{}
}
func (*binaryClassWglCreateContextAttribsARB) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeWglCreateContextAttribsARB(d, obj.(*WglCreateContextAttribsARB))
}
func (c *binaryClassWglCreateContextAttribsARB) Schema() *binary.Entity {
	return &entities[ixǁWglCreateContextAttribsARB]
}

type binaryClassWglMakeCurrent struct{}

func (*WglMakeCurrent) Class() binary.Class {
	return (*binaryClassWglMakeCurrent)(nil)
}
func doEncodeWglMakeCurrent(e binary.Encoder, o *WglMakeCurrent) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Hdc)
	e.Simple(&o.Hglrc)
	e.Int64(int64(o.Result))
}
func doDecodeWglMakeCurrent(d binary.Decoder, o *WglMakeCurrent) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Hdc)
	d.Simple(&o.Hglrc)
	o.Result = BOOL(d.Int64())
}
func doDecodeRawWglMakeCurrent(d binary.Decoder, o *WglMakeCurrent) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Hdc)
	d.Simple(&o.Hglrc)
	o.Result = BOOL(d.Int64())
}
func (*binaryClassWglMakeCurrent) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeWglMakeCurrent(e, obj.(*WglMakeCurrent))
}
func (*binaryClassWglMakeCurrent) New() binary.Object {
	return &WglMakeCurrent{}
}
func (*binaryClassWglMakeCurrent) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeWglMakeCurrent(d, obj.(*WglMakeCurrent))
}
func (c *binaryClassWglMakeCurrent) Schema() *binary.Entity {
	return &entities[ixǁWglMakeCurrent]
}

type binaryClassWglSwapBuffers struct{}

func (*WglSwapBuffers) Class() binary.Class {
	return (*binaryClassWglSwapBuffers)(nil)
}
func doEncodeWglSwapBuffers(e binary.Encoder, o *WglSwapBuffers) {
	e.Uint32(uint32(len(o.extras)))
	for i := range o.extras {
		curr := &o.extras[i]
		e.Object(*curr)
	}
	e.Simple(&o.Hdc)
}
func doDecodeWglSwapBuffers(d binary.Decoder, o *WglSwapBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Hdc)
}
func doDecodeRawWglSwapBuffers(d binary.Decoder, o *WglSwapBuffers) {
	if count := d.Count(); count > 0 {
		o.extras = make(atom.Extras, count)
		for i := range o.extras {
			curr := &o.extras[i]
			*curr = atom.ExtraCast(d.Object())
		}
	}
	d.Simple(&o.Hdc)
}
func (*binaryClassWglSwapBuffers) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeWglSwapBuffers(e, obj.(*WglSwapBuffers))
}
func (*binaryClassWglSwapBuffers) New() binary.Object {
	return &WglSwapBuffers{}
}
func (*binaryClassWglSwapBuffers) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeWglSwapBuffers(d, obj.(*WglSwapBuffers))
}
func (c *binaryClassWglSwapBuffers) Schema() *binary.Entity {
	return &entities[ixǁWglSwapBuffers]
}

type binaryClassu32Limits struct{}

func (*u32Limits) Class() binary.Class {
	return (*binaryClassu32Limits)(nil)
}
func doEncodeu32Limits(e binary.Writer, o *u32Limits) {
	e.Uint32(o.First)
	e.Uint32(o.Last)
}
func doDecodeu32Limits(d binary.Reader, o *u32Limits) {
	o.First = uint32(d.Uint32())
	o.Last = uint32(d.Uint32())
}
func doDecodeRawu32Limits(d binary.Reader, o *u32Limits) {
	o.First = uint32(d.Uint32())
	o.Last = uint32(d.Uint32())
}
func (*binaryClassu32Limits) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeu32Limits(e, obj.(*u32Limits))
}
func (*binaryClassu32Limits) New() binary.Object {
	return &u32Limits{}
}
func (*binaryClassu32Limits) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeu32Limits(d, obj.(*u32Limits))
}
func (o *u32Limits) WriteSimple(w binary.Writer) {
	doEncodeu32Limits(w, o)
}
func (o *u32Limits) ReadSimple(r binary.Reader) {
	doDecodeu32Limits(r, o)
}
func (c *binaryClassu32Limits) Schema() *binary.Entity {
	return &entities[ixǁu32Limits]
}