Google Git
Sign in
android / platform / tools / gpu / 7d5278cd7c9e3b532ee45225a3d13df58351dd8a / . / gfxapi / gles / gles_binary.go
blob: eb3647babab91af4944dd8caa90db3c862b73a6a [file] [log] [blame]
////////////////////////////////////////////////////////////////////////////////
// Do not modify!
// Generated by codergen -go
////////////////////////////////////////////////////////////////////////////////
package gles
import (
"fmt"
"android.googlesource.com/platform/tools/gpu/atom"
"android.googlesource.com/platform/tools/gpu/binary"
"android.googlesource.com/platform/tools/gpu/binary/registry"
"android.googlesource.com/platform/tools/gpu/binary/schema"
"android.googlesource.com/platform/tools/gpu/memory"
)
func init() {
registry.Add((*BackbufferInfo)(nil).Class())
registry.Add((*Color)(nil).Class())
registry.Add((*BlendState)(nil).Class())
registry.Add((*Boolˢ)(nil).Class())
registry.Add((*Boolᵖ)(nil).Class())
registry.Add((*U8ˢ)(nil).Class())
registry.Add((*Buffer)(nil).Class())
registry.Add((*BufferDataPointer)(nil).Class())
registry.Add((*BufferIdˢ)(nil).Class())
registry.Add((*BufferIdᵖ)(nil).Class())
registry.Add((*CGLContextObj)(nil).Class())
registry.Add((*CGLContextObjˢ)(nil).Class())
registry.Add((*CGLContextObjᵖ)(nil).Class())
registry.Add((*CGLPixelFormatObj)(nil).Class())
registry.Add((*CGLCreateContext)(nil).Class())
registry.Add((*CGLSetCurrentContext)(nil).Class())
registry.Add((*Charˢ)(nil).Class())
registry.Add((*Charᵖ)(nil).Class())
registry.Add((*Charᵖˢ)(nil).Class())
registry.Add((*Charᵖᵖ)(nil).Class())
registry.Add((*ClearState)(nil).Class())
registry.Add((*Rect)(nil).Class())
registry.Add((*RasterizerState)(nil).Class())
registry.Add((*VertexPointer)(nil).Class())
registry.Add((*VertexAttributeArray)(nil).Class())
registry.Add((*Renderbuffer)(nil).Class())
registry.Add((*Image)(nil).Class())
registry.Add((*CubemapLevel)(nil).Class())
registry.Add((*Texture)(nil).Class())
registry.Add((*FramebufferAttachmentInfo)(nil).Class())
registry.Add((*Framebuffer)(nil).Class())
registry.Add((*Shader)(nil).Class())
registry.Add((*VertexAttribute)(nil).Class())
registry.Add((*Vec2f)(nil).Class())
registry.Add((*Vec3f)(nil).Class())
registry.Add((*Vec4f)(nil).Class())
registry.Add((*Vec2i)(nil).Class())
registry.Add((*Vec3i)(nil).Class())
registry.Add((*Vec4i)(nil).Class())
registry.Add((*Mat2f)(nil).Class())
registry.Add((*Mat3f)(nil).Class())
registry.Add((*Mat4f)(nil).Class())
registry.Add((*UniformValue)(nil).Class())
registry.Add((*Uniform)(nil).Class())
registry.Add((*Program)(nil).Class())
registry.Add((*VertexArray)(nil).Class())
registry.Add((*Query)(nil).Class())
registry.Add((*Objects)(nil).Class())
registry.Add((*Context)(nil).Class())
registry.Add((*DiscardFramebufferAttachmentˢ)(nil).Class())
registry.Add((*DiscardFramebufferAttachmentᵖ)(nil).Class())
registry.Add((*EGLConfig)(nil).Class())
registry.Add((*EGLContext)(nil).Class())
registry.Add((*EGLDisplay)(nil).Class())
registry.Add((*EGLSurface)(nil).Class())
registry.Add((*EGLintˢ)(nil).Class())
registry.Add((*EGLintᵖ)(nil).Class())
registry.Add((*EglCreateContext)(nil).Class())
registry.Add((*EglInitialize)(nil).Class())
registry.Add((*EglMakeCurrent)(nil).Class())
registry.Add((*EglQuerySurface)(nil).Class())
registry.Add((*Voidᵖ)(nil).Class())
registry.Add((*EglSwapBuffers)(nil).Class())
registry.Add((*F32ˢ)(nil).Class())
registry.Add((*F32ᵖ)(nil).Class())
registry.Add((*FlushPostBuffer)(nil).Class())
registry.Add((*FramebufferAttachmentˢ)(nil).Class())
registry.Add((*FramebufferAttachmentᵖ)(nil).Class())
registry.Add((*FramebufferIdˢ)(nil).Class())
registry.Add((*FramebufferIdᵖ)(nil).Class())
registry.Add((*GLXContext)(nil).Class())
registry.Add((*GLXDrawable)(nil).Class())
registry.Add((*GlActiveTexture)(nil).Class())
registry.Add((*GlAttachShader)(nil).Class())
registry.Add((*GlBeginQuery)(nil).Class())
registry.Add((*GlBeginQueryEXT)(nil).Class())
registry.Add((*GlBindAttribLocation)(nil).Class())
registry.Add((*GlBindBuffer)(nil).Class())
registry.Add((*GlBindFramebuffer)(nil).Class())
registry.Add((*GlBindRenderbuffer)(nil).Class())
registry.Add((*GlBindTexture)(nil).Class())
registry.Add((*GlBindVertexArrayOES)(nil).Class())
registry.Add((*GlBlendColor)(nil).Class())
registry.Add((*GlBlendEquation)(nil).Class())
registry.Add((*GlBlendEquationSeparate)(nil).Class())
registry.Add((*GlBlendFunc)(nil).Class())
registry.Add((*GlBlendFuncSeparate)(nil).Class())
registry.Add((*GlBlitFramebuffer)(nil).Class())
registry.Add((*GlBufferData)(nil).Class())
registry.Add((*GlBufferSubData)(nil).Class())
registry.Add((*GlCheckFramebufferStatus)(nil).Class())
registry.Add((*GlClear)(nil).Class())
registry.Add((*GlClearColor)(nil).Class())
registry.Add((*GlClearDepthf)(nil).Class())
registry.Add((*GlClearStencil)(nil).Class())
registry.Add((*GlColorMask)(nil).Class())
registry.Add((*GlCompileShader)(nil).Class())
registry.Add((*TexturePointer)(nil).Class())
registry.Add((*GlCompressedTexImage2D)(nil).Class())
registry.Add((*GlCompressedTexSubImage2D)(nil).Class())
registry.Add((*GlCopyTexImage2D)(nil).Class())
registry.Add((*GlCopyTexSubImage2D)(nil).Class())
registry.Add((*GlCreateProgram)(nil).Class())
registry.Add((*GlCreateShader)(nil).Class())
registry.Add((*GlCullFace)(nil).Class())
registry.Add((*GlDeleteBuffers)(nil).Class())
registry.Add((*GlDeleteFramebuffers)(nil).Class())
registry.Add((*GlDeleteProgram)(nil).Class())
registry.Add((*QueryIdᵖ)(nil).Class())
registry.Add((*GlDeleteQueries)(nil).Class())
registry.Add((*GlDeleteQueriesEXT)(nil).Class())
registry.Add((*RenderbufferIdᵖ)(nil).Class())
registry.Add((*GlDeleteRenderbuffers)(nil).Class())
registry.Add((*GlDeleteShader)(nil).Class())
registry.Add((*TextureIdᵖ)(nil).Class())
registry.Add((*GlDeleteTextures)(nil).Class())
registry.Add((*VertexArrayIdᵖ)(nil).Class())
registry.Add((*GlDeleteVertexArraysOES)(nil).Class())
registry.Add((*GlDepthFunc)(nil).Class())
registry.Add((*GlDepthMask)(nil).Class())
registry.Add((*GlDepthRangef)(nil).Class())
registry.Add((*GlDetachShader)(nil).Class())
registry.Add((*GlDisable)(nil).Class())
registry.Add((*GlDisableClientState)(nil).Class())
registry.Add((*GlDisableVertexAttribArray)(nil).Class())
registry.Add((*GlDiscardFramebufferEXT)(nil).Class())
registry.Add((*GlDrawArrays)(nil).Class())
registry.Add((*IndicesPointer)(nil).Class())
registry.Add((*GlDrawElements)(nil).Class())
registry.Add((*GlEGLImageTargetRenderbufferStorageOES)(nil).Class())
registry.Add((*ImageOES)(nil).Class())
registry.Add((*GlEGLImageTargetTexture2DOES)(nil).Class())
registry.Add((*GlEnable)(nil).Class())
registry.Add((*GlEnableClientState)(nil).Class())
registry.Add((*GlEnableVertexAttribArray)(nil).Class())
registry.Add((*GlEndQuery)(nil).Class())
registry.Add((*GlEndQueryEXT)(nil).Class())
registry.Add((*GlEndTilingQCOM)(nil).Class())
registry.Add((*GlFinish)(nil).Class())
registry.Add((*GlFlush)(nil).Class())
registry.Add((*GlFramebufferRenderbuffer)(nil).Class())
registry.Add((*GlFramebufferTexture2D)(nil).Class())
registry.Add((*GlFrontFace)(nil).Class())
registry.Add((*GlGenBuffers)(nil).Class())
registry.Add((*GlGenFramebuffers)(nil).Class())
registry.Add((*GlGenQueries)(nil).Class())
registry.Add((*GlGenQueriesEXT)(nil).Class())
registry.Add((*GlGenRenderbuffers)(nil).Class())
registry.Add((*GlGenTextures)(nil).Class())
registry.Add((*GlGenVertexArraysOES)(nil).Class())
registry.Add((*GlGenerateMipmap)(nil).Class())
registry.Add((*S32ᵖ)(nil).Class())
registry.Add((*ShaderAttribTypeᵖ)(nil).Class())
registry.Add((*GlGetActiveAttrib)(nil).Class())
registry.Add((*ShaderUniformTypeᵖ)(nil).Class())
registry.Add((*GlGetActiveUniform)(nil).Class())
registry.Add((*ShaderIdᵖ)(nil).Class())
registry.Add((*GlGetAttachedShaders)(nil).Class())
registry.Add((*GlGetAttribLocation)(nil).Class())
registry.Add((*GlGetBooleanv)(nil).Class())
registry.Add((*GlGetBufferParameteriv)(nil).Class())
registry.Add((*GlGetError)(nil).Class())
registry.Add((*GlGetFloatv)(nil).Class())
registry.Add((*GlGetFramebufferAttachmentParameteriv)(nil).Class())
registry.Add((*GlGetGraphicsResetStatusEXT)(nil).Class())
registry.Add((*GlGetIntegerv)(nil).Class())
registry.Add((*U32ᵖ)(nil).Class())
registry.Add((*GlGetProgramBinaryOES)(nil).Class())
registry.Add((*GlGetProgramInfoLog)(nil).Class())
registry.Add((*GlGetProgramiv)(nil).Class())
registry.Add((*S64ᵖ)(nil).Class())
registry.Add((*GlGetQueryObjecti64vEXT)(nil).Class())
registry.Add((*GlGetQueryObjectivEXT)(nil).Class())
registry.Add((*U64ᵖ)(nil).Class())
registry.Add((*GlGetQueryObjectui64vEXT)(nil).Class())
registry.Add((*GlGetQueryObjectuiv)(nil).Class())
registry.Add((*GlGetQueryObjectuivEXT)(nil).Class())
registry.Add((*GlGetQueryiv)(nil).Class())
registry.Add((*GlGetQueryivEXT)(nil).Class())
registry.Add((*GlGetRenderbufferParameteriv)(nil).Class())
registry.Add((*GlGetShaderInfoLog)(nil).Class())
registry.Add((*GlGetShaderPrecisionFormat)(nil).Class())
registry.Add((*GlGetShaderSource)(nil).Class())
registry.Add((*GlGetShaderiv)(nil).Class())
registry.Add((*GlGetString)(nil).Class())
registry.Add((*GlGetTexParameterfv)(nil).Class())
registry.Add((*GlGetTexParameteriv)(nil).Class())
registry.Add((*GlGetUniformLocation)(nil).Class())
registry.Add((*GlGetUniformfv)(nil).Class())
registry.Add((*GlGetUniformiv)(nil).Class())
registry.Add((*GlHint)(nil).Class())
registry.Add((*GlInsertEventMarkerEXT)(nil).Class())
registry.Add((*GlInvalidateFramebuffer)(nil).Class())
registry.Add((*GlIsBuffer)(nil).Class())
registry.Add((*GlIsEnabled)(nil).Class())
registry.Add((*GlIsFramebuffer)(nil).Class())
registry.Add((*GlIsProgram)(nil).Class())
registry.Add((*GlIsQuery)(nil).Class())
registry.Add((*GlIsQueryEXT)(nil).Class())
registry.Add((*GlIsRenderbuffer)(nil).Class())
registry.Add((*GlIsShader)(nil).Class())
registry.Add((*GlIsTexture)(nil).Class())
registry.Add((*GlIsVertexArrayOES)(nil).Class())
registry.Add((*GlLineWidth)(nil).Class())
registry.Add((*GlLinkProgram)(nil).Class())
registry.Add((*GlMapBufferRange)(nil).Class())
registry.Add((*GlPixelStorei)(nil).Class())
registry.Add((*GlPolygonOffset)(nil).Class())
registry.Add((*GlPopGroupMarkerEXT)(nil).Class())
registry.Add((*GlProgramBinaryOES)(nil).Class())
registry.Add((*GlPushGroupMarkerEXT)(nil).Class())
registry.Add((*GlQueryCounterEXT)(nil).Class())
registry.Add((*GlReadPixels)(nil).Class())
registry.Add((*GlReleaseShaderCompiler)(nil).Class())
registry.Add((*GlRenderbufferStorage)(nil).Class())
registry.Add((*GlRenderbufferStorageMultisample)(nil).Class())
registry.Add((*GlSampleCoverage)(nil).Class())
registry.Add((*GlScissor)(nil).Class())
registry.Add((*GlShaderBinary)(nil).Class())
registry.Add((*GlShaderSource)(nil).Class())
registry.Add((*GlStartTilingQCOM)(nil).Class())
registry.Add((*GlStencilFuncSeparate)(nil).Class())
registry.Add((*GlStencilMask)(nil).Class())
registry.Add((*GlStencilMaskSeparate)(nil).Class())
registry.Add((*GlStencilOpSeparate)(nil).Class())
registry.Add((*GlTexImage2D)(nil).Class())
registry.Add((*GlTexParameterf)(nil).Class())
registry.Add((*GlTexParameteri)(nil).Class())
registry.Add((*GlTexStorage1DEXT)(nil).Class())
registry.Add((*GlTexStorage2DEXT)(nil).Class())
registry.Add((*GlTexStorage3DEXT)(nil).Class())
registry.Add((*GlTexSubImage2D)(nil).Class())
registry.Add((*GlTextureStorage1DEXT)(nil).Class())
registry.Add((*GlTextureStorage2DEXT)(nil).Class())
registry.Add((*GlTextureStorage3DEXT)(nil).Class())
registry.Add((*GlUniform1f)(nil).Class())
registry.Add((*GlUniform1fv)(nil).Class())
registry.Add((*GlUniform1i)(nil).Class())
registry.Add((*GlUniform1iv)(nil).Class())
registry.Add((*GlUniform2f)(nil).Class())
registry.Add((*GlUniform2fv)(nil).Class())
registry.Add((*GlUniform2i)(nil).Class())
registry.Add((*GlUniform2iv)(nil).Class())
registry.Add((*GlUniform3f)(nil).Class())
registry.Add((*GlUniform3fv)(nil).Class())
registry.Add((*GlUniform3i)(nil).Class())
registry.Add((*GlUniform3iv)(nil).Class())
registry.Add((*GlUniform4f)(nil).Class())
registry.Add((*GlUniform4fv)(nil).Class())
registry.Add((*GlUniform4i)(nil).Class())
registry.Add((*GlUniform4iv)(nil).Class())
registry.Add((*GlUniformMatrix2fv)(nil).Class())
registry.Add((*GlUniformMatrix3fv)(nil).Class())
registry.Add((*GlUniformMatrix4fv)(nil).Class())
registry.Add((*GlUnmapBuffer)(nil).Class())
registry.Add((*GlUseProgram)(nil).Class())
registry.Add((*GlValidateProgram)(nil).Class())
registry.Add((*GlVertexAttrib1f)(nil).Class())
registry.Add((*GlVertexAttrib1fv)(nil).Class())
registry.Add((*GlVertexAttrib2f)(nil).Class())
registry.Add((*GlVertexAttrib2fv)(nil).Class())
registry.Add((*GlVertexAttrib3f)(nil).Class())
registry.Add((*GlVertexAttrib3fv)(nil).Class())
registry.Add((*GlVertexAttrib4f)(nil).Class())
registry.Add((*GlVertexAttrib4fv)(nil).Class())
registry.Add((*GlVertexAttribPointer)(nil).Class())
registry.Add((*GlViewport)(nil).Class())
registry.Add((*GlXCreateContext)(nil).Class())
registry.Add((*GlXCreateNewContext)(nil).Class())
registry.Add((*GlXMakeContextCurrent)(nil).Class())
registry.Add((*GlXSwapBuffers)(nil).Class())
registry.Add((*HGLRC)(nil).Class())
registry.Add((*Globals)(nil).Class())
registry.Add((*HDC)(nil).Class())
registry.Add((*Intˢ)(nil).Class())
registry.Add((*Intᵖ)(nil).Class())
registry.Add((*QueryIdˢ)(nil).Class())
registry.Add((*RenderbufferIdˢ)(nil).Class())
registry.Add((*ReplayBindRenderer)(nil).Class())
registry.Add((*ReplayCreateRenderer)(nil).Class())
registry.Add((*S32ˢ)(nil).Class())
registry.Add((*S64ˢ)(nil).Class())
registry.Add((*ShaderAttribTypeˢ)(nil).Class())
registry.Add((*ShaderIdˢ)(nil).Class())
registry.Add((*ShaderUniformTypeˢ)(nil).Class())
registry.Add((*StartTimer)(nil).Class())
registry.Add((*StopTimer)(nil).Class())
registry.Add((*TextureIdˢ)(nil).Class())
registry.Add((*U32ˢ)(nil).Class())
registry.Add((*U64ˢ)(nil).Class())
registry.Add((*U8ᵖ)(nil).Class())
registry.Add((*VertexArrayIdˢ)(nil).Class())
registry.Add((*Voidˢ)(nil).Class())
registry.Add((*WglCreateContext)(nil).Class())
registry.Add((*WglCreateContextAttribsARB)(nil).Class())
registry.Add((*WglMakeCurrent)(nil).Class())
registry.Add((*WglSwapBuffers)(nil).Class())
}
var (
binaryIDBackbufferInfo = binary.ID{0x44, 0xeb, 0x57, 0x06, 0xf9, 0xfd, 0x06, 0xab, 0xc2, 0xa7, 0xdc, 0xa2, 0xba, 0xd0, 0xe3, 0x8f, 0x76, 0x7c, 0x81, 0x0f}
binaryIDColor = binary.ID{0xe7, 0x31, 0x0f, 0x05, 0x26, 0x27, 0x37, 0x3a, 0xc4, 0xbb, 0x59, 0xea, 0xc0, 0x41, 0xb0, 0xa7, 0x8f, 0x15, 0x58, 0xb4}
binaryIDBlendState = binary.ID{0x29, 0x77, 0xc4, 0x8b, 0x77, 0xa3, 0x4d, 0x9c, 0x4d, 0x61, 0x12, 0xcf, 0x1f, 0x04, 0x1a, 0x82, 0x82, 0x33, 0xb3, 0xf2}
binaryIDBoolˢ = binary.ID{0xf2, 0x31, 0x4c, 0xf9, 0x86, 0x85, 0x72, 0x97, 0x87, 0x94, 0x51, 0x90, 0x4d, 0x16, 0x83, 0xd3, 0x87, 0xc0, 0xe7, 0x91}
binaryIDBoolᵖ = binary.ID{0x99, 0x14, 0xff, 0xcd, 0xe4, 0x5a, 0xa6, 0x40, 0x28, 0xce, 0x7f, 0x59, 0x66, 0x8e, 0x03, 0x31, 0x08, 0x3e, 0x1b, 0x8a}
binaryIDU8ˢ = binary.ID{0xf9, 0x82, 0x6b, 0xf3, 0x87, 0x60, 0x43, 0xc9, 0x9f, 0x38, 0x49, 0x47, 0xd0, 0x41, 0xc5, 0x84, 0x27, 0x96, 0xfd, 0x24}
binaryIDBuffer = binary.ID{0xcb, 0x13, 0xd8, 0x5c, 0x1e, 0x96, 0x94, 0x10, 0x35, 0x50, 0xc5, 0x56, 0x64, 0xc7, 0xa6, 0x9e, 0x0c, 0xe2, 0x7d, 0x9e}
binaryIDBufferDataPointer = binary.ID{0xec, 0x9b, 0x06, 0x05, 0x8b, 0x40, 0x9b, 0x3e, 0x3b, 0xf2, 0x28, 0x02, 0x1d, 0x73, 0xbb, 0xf2, 0x75, 0x70, 0x0e, 0x69}
binaryIDBufferIdˢ = binary.ID{0x9e, 0xbe, 0xba, 0x6e, 0x12, 0xa1, 0x4b, 0x3b, 0xc1, 0x33, 0xa6, 0xd2, 0x80, 0x9d, 0x7e, 0xf4, 0x4a, 0x72, 0x9a, 0x28}
binaryIDBufferIdᵖ = binary.ID{0x4e, 0x93, 0x7a, 0x49, 0x93, 0xb1, 0x5e, 0x9f, 0x01, 0x00, 0x5f, 0xa1, 0x77, 0xff, 0x03, 0x71, 0x93, 0x81, 0x7a, 0x22}
binaryIDCGLContextObj = binary.ID{0xab, 0x86, 0x6f, 0x74, 0x93, 0x88, 0x54, 0x0f, 0x24, 0x0f, 0x0b, 0xc0, 0x3c, 0x31, 0x13, 0xf7, 0x84, 0x0b, 0xc2, 0x53}
binaryIDCGLContextObjˢ = binary.ID{0x54, 0x66, 0xf0, 0x00, 0xf0, 0x49, 0x85, 0x49, 0xc6, 0x59, 0x2b, 0x56, 0x85, 0xa2, 0x6d, 0xbc, 0xd7, 0x0d, 0xda, 0x14}
binaryIDCGLContextObjᵖ = binary.ID{0xa5, 0xae, 0x0c, 0xd1, 0xe4, 0x8a, 0xce, 0xaa, 0x58, 0x17, 0x44, 0x03, 0x19, 0xcc, 0xf2, 0xea, 0x50, 0x88, 0x53, 0xb9}
binaryIDCGLPixelFormatObj = binary.ID{0x81, 0x5b, 0xcb, 0x83, 0x09, 0xbc, 0x3d, 0x7e, 0x40, 0x9c, 0xdd, 0x21, 0x56, 0xa3, 0x69, 0xef, 0x28, 0xea, 0x84, 0x41}
binaryIDCGLCreateContext = binary.ID{0x87, 0xeb, 0x7f, 0x5e, 0x46, 0xd1, 0x7c, 0xf4, 0x3c, 0x36, 0x44, 0x4b, 0x60, 0x5d, 0xaf, 0xc5, 0x43, 0xc5, 0x2c, 0x61}
binaryIDCGLSetCurrentContext = binary.ID{0x88, 0xc1, 0x83, 0x0a, 0xe8, 0x2c, 0x03, 0xa0, 0x88, 0x20, 0xb9, 0x75, 0xfd, 0xb0, 0x14, 0xca, 0xbd, 0x78, 0x2d, 0x6f}
binaryIDCharˢ = binary.ID{0xb2, 0xde, 0x84, 0xd8, 0x9f, 0x13, 0x4a, 0xfe, 0x30, 0xb6, 0xee, 0x4b, 0x75, 0x23, 0x79, 0x8e, 0xbf, 0x8f, 0xf0, 0xeb}
binaryIDCharᵖ = binary.ID{0x67, 0xe3, 0xfd, 0x6e, 0x09, 0x7e, 0xa7, 0x65, 0x7f, 0x40, 0x8d, 0xd4, 0x35, 0x40, 0xcc, 0x38, 0x25, 0x23, 0x66, 0xdf}
binaryIDCharᵖˢ = binary.ID{0x4d, 0x87, 0xa4, 0x53, 0x04, 0x96, 0x09, 0x70, 0xea, 0xd3, 0xea, 0x46, 0x04, 0x87, 0x25, 0xbc, 0x66, 0xa2, 0x7c, 0xa9}
binaryIDCharᵖᵖ = binary.ID{0x1f, 0x0a, 0x07, 0xb4, 0xda, 0x1f, 0xda, 0x6d, 0x01, 0xbb, 0xd6, 0x9b, 0x33, 0xf9, 0x9c, 0x19, 0xa8, 0x14, 0x5b, 0x5e}
binaryIDClearState = binary.ID{0xd3, 0xbe, 0x8f, 0x85, 0x49, 0x55, 0xe3, 0x17, 0x03, 0xb1, 0x02, 0x1c, 0xe0, 0x2d, 0x25, 0x8c, 0x17, 0x53, 0xc5, 0x62}
binaryIDRect = binary.ID{0x14, 0xc0, 0x01, 0xd8, 0x95, 0xd6, 0x6b, 0xab, 0xce, 0x31, 0x74, 0x35, 0x6b, 0x11, 0x57, 0xb5, 0xc8, 0x6f, 0x52, 0xdc}
binaryIDRasterizerState = binary.ID{0x51, 0x6b, 0x55, 0xed, 0xe3, 0x43, 0x1c, 0xe8, 0x28, 0x3f, 0x1d, 0xeb, 0x3b, 0x37, 0x21, 0x9f, 0x89, 0xbc, 0xdb, 0x28}
binaryIDVertexPointer = binary.ID{0xbb, 0xd9, 0x9d, 0xbc, 0x5d, 0xd2, 0xa9, 0x87, 0x68, 0x91, 0xd2, 0xd2, 0xc2, 0xc9, 0x9d, 0xf6, 0xdd, 0xe2, 0x3c, 0x6c}
binaryIDVertexAttributeArray = binary.ID{0xa4, 0x7d, 0x5e, 0xd9, 0x3b, 0x4e, 0x4e, 0xc2, 0xc4, 0x2b, 0x81, 0xe9, 0xc8, 0x56, 0xf6, 0xf9, 0x63, 0x47, 0xca, 0x11}
binaryIDRenderbuffer = binary.ID{0x84, 0x68, 0xd5, 0xd8, 0xde, 0xfc, 0xbd, 0x62, 0xda, 0xc3, 0x55, 0x74, 0xbf, 0xc5, 0x6c, 0xe8, 0xa5, 0xa3, 0xe7, 0x70}
binaryIDImage = binary.ID{0x0a, 0x10, 0xd1, 0xf9, 0x89, 0x9f, 0x2a, 0xa6, 0xd6, 0xbf, 0x08, 0x1a, 0xf9, 0x7c, 0xb7, 0xa1, 0x48, 0xa1, 0xd8, 0xea}
binaryIDCubemapLevel = binary.ID{0x51, 0xd8, 0xc2, 0xc5, 0x3b, 0xfd, 0x61, 0x52, 0x9f, 0xaa, 0xee, 0x67, 0x5e, 0x16, 0x51, 0xe7, 0x92, 0x04, 0x17, 0xd6}
binaryIDTexture = binary.ID{0xa0, 0xdb, 0xfc, 0x07, 0xdf, 0x4d, 0x1d, 0x3c, 0x05, 0x98, 0x63, 0x48, 0x82, 0xd8, 0xc8, 0x09, 0x24, 0xa9, 0xe4, 0xb7}
binaryIDFramebufferAttachmentInfo = binary.ID{0x28, 0x1b, 0x2d, 0xbd, 0x74, 0xc0, 0x84, 0xc8, 0xe5, 0xe1, 0x3e, 0xe3, 0x46, 0x08, 0xc7, 0xd0, 0x61, 0xb9, 0xa0, 0xb5}
binaryIDFramebuffer = binary.ID{0xb2, 0x34, 0xfe, 0x22, 0x59, 0xe9, 0xe0, 0xaa, 0x31, 0xca, 0xad, 0xc9, 0x51, 0x2a, 0x24, 0x04, 0xb4, 0xfd, 0xa3, 0xa4}
binaryIDShader = binary.ID{0x40, 0x98, 0xcd, 0x17, 0xd2, 0xcf, 0x4f, 0x55, 0x35, 0x5a, 0xb1, 0x03, 0x70, 0x31, 0x41, 0x01, 0x5b, 0x8d, 0x83, 0xf6}
binaryIDVertexAttribute = binary.ID{0x88, 0x44, 0xf7, 0x6b, 0x96, 0x07, 0x99, 0x03, 0xe3, 0x56, 0xab, 0x34, 0x20, 0x80, 0xc6, 0x13, 0xbc, 0xd0, 0x53, 0xe8}
binaryIDVec2f = binary.ID{0x9a, 0x80, 0x74, 0xe4, 0x78, 0x9c, 0x6c, 0x16, 0xc7, 0xc6, 0x4e, 0x4c, 0x66, 0x6a, 0x86, 0x52, 0x06, 0x24, 0x41, 0x5d}
binaryIDVec3f = binary.ID{0x09, 0x06, 0xf7, 0xa9, 0xb3, 0xbf, 0x8f, 0x42, 0x96, 0xf4, 0xd6, 0xff, 0x4f, 0x93, 0x98, 0x44, 0x2e, 0xaf, 0x7b, 0x07}
binaryIDVec4f = binary.ID{0x94, 0x20, 0x1e, 0xeb, 0xde, 0x5b, 0xa9, 0xe1, 0xd7, 0x73, 0xcd, 0x9e, 0x3b, 0x09, 0x01, 0x8a, 0x9a, 0x41, 0xe7, 0x4b}
binaryIDVec2i = binary.ID{0x76, 0x85, 0xad, 0x18, 0xef, 0x9b, 0x0e, 0xea, 0x49, 0x44, 0xf7, 0x89, 0x4e, 0xdb, 0x0d, 0x34, 0xbb, 0x27, 0xb8, 0x43}
binaryIDVec3i = binary.ID{0xc5, 0x31, 0xeb, 0x05, 0xd1, 0xdf, 0x5c, 0xf7, 0xc0, 0x7a, 0x20, 0xc9, 0x91, 0xb0, 0xf0, 0x2e, 0x1e, 0x9d, 0x94, 0xd5}
binaryIDVec4i = binary.ID{0x61, 0x00, 0x31, 0xa3, 0x7a, 0x91, 0x14, 0x17, 0x6e, 0xd2, 0xe2, 0x62, 0x30, 0x92, 0xce, 0x4e, 0x0c, 0x72, 0xd1, 0x9c}
binaryIDMat2f = binary.ID{0x8a, 0xda, 0xb2, 0x20, 0xfa, 0xe4, 0xf7, 0x80, 0x3a, 0x25, 0xf4, 0xbf, 0xbc, 0x97, 0xea, 0x48, 0x14, 0xed, 0xcb, 0x98}
binaryIDMat3f = binary.ID{0x2c, 0xe7, 0xc3, 0x90, 0x92, 0x9b, 0xa6, 0xc1, 0x86, 0x6e, 0x89, 0xc7, 0x16, 0x6d, 0x9f, 0x83, 0x54, 0x64, 0x40, 0x3a}
binaryIDMat4f = binary.ID{0x5c, 0x2f, 0x64, 0xb8, 0x4e, 0xf0, 0xa8, 0x30, 0x10, 0x31, 0x81, 0x75, 0xb7, 0x82, 0xf3, 0x8f, 0x70, 0x68, 0x83, 0xdc}
binaryIDUniformValue = binary.ID{0xab, 0x2c, 0x54, 0x24, 0xdf, 0x48, 0x16, 0xcb, 0x4a, 0x5d, 0x7f, 0x47, 0x42, 0x4b, 0x4e, 0x3e, 0x5d, 0x0e, 0x54, 0x0c}
binaryIDUniform = binary.ID{0x92, 0x24, 0x45, 0xb8, 0x0b, 0xfa, 0x86, 0x62, 0xac, 0x08, 0xfd, 0xbc, 0xbc, 0x95, 0x50, 0x12, 0x22, 0x6e, 0xa5, 0x1d}
binaryIDProgram = binary.ID{0x7f, 0x2e, 0x5d, 0xa3, 0x21, 0x31, 0xb3, 0x68, 0x3a, 0xae, 0x2d, 0x85, 0xc1, 0x89, 0xac, 0xe2, 0xa6, 0x14, 0x42, 0x2d}
binaryIDVertexArray = binary.ID{0x8c, 0x9a, 0x34, 0xfe, 0x61, 0x2a, 0x2d, 0x57, 0x19, 0x43, 0x24, 0x95, 0xf6, 0x1e, 0x79, 0x97, 0x85, 0x3f, 0xee, 0xc4}
binaryIDQuery = binary.ID{0x9e, 0x4e, 0xd0, 0x26, 0x26, 0xf8, 0x9d, 0x8e, 0xb5, 0x02, 0x2f, 0xde, 0x80, 0xb3, 0xe9, 0x09, 0xf5, 0x4c, 0x1e, 0xf2}
binaryIDObjects = binary.ID{0x8a, 0x05, 0xaa, 0xf5, 0xa8, 0x57, 0xb0, 0xf1, 0x13, 0x48, 0x39, 0x76, 0xec, 0x1e, 0x47, 0x0b, 0x6c, 0x3b, 0xf6, 0xe0}
binaryIDContext = binary.ID{0xc6, 0x81, 0x84, 0x13, 0x02, 0x9b, 0x76, 0x8b, 0x5b, 0x09, 0x10, 0xe4, 0x96, 0x22, 0xb2, 0x60, 0x14, 0xbd, 0x65, 0x01}
binaryIDDiscardFramebufferAttachmentˢ = binary.ID{0x94, 0x48, 0xa1, 0x50, 0x59, 0xc0, 0xbd, 0xf5, 0x22, 0x5e, 0xae, 0xf4, 0x8b, 0x3c, 0xd2, 0x74, 0x8c, 0x58, 0x0b, 0x4b}
binaryIDDiscardFramebufferAttachmentᵖ = binary.ID{0x23, 0xd9, 0x67, 0x4f, 0x82, 0x7e, 0x62, 0x8d, 0x54, 0xc3, 0xec, 0x98, 0xc5, 0x3e, 0xba, 0xf5, 0xa6, 0x3f, 0x52, 0x1f}
binaryIDEGLConfig = binary.ID{0x2a, 0xd8, 0x24, 0x8e, 0x95, 0xb5, 0x5d, 0x86, 0xe8, 0x84, 0x21, 0x3a, 0x2c, 0xee, 0xfd, 0x90, 0xd2, 0xab, 0xd8, 0x5c}
binaryIDEGLContext = binary.ID{0x29, 0x18, 0x4c, 0xdb, 0x8b, 0xf5, 0xcf, 0xcc, 0xfc, 0xf8, 0x62, 0x25, 0x1f, 0xf1, 0x45, 0x0e, 0x20, 0x23, 0xce, 0x8e}
binaryIDEGLDisplay = binary.ID{0x85, 0x54, 0x9a, 0x82, 0x0b, 0x08, 0xcc, 0x4c, 0x6b, 0x1c, 0xcc, 0x0e, 0x85, 0x09, 0x68, 0x5c, 0x93, 0x51, 0x24, 0x5e}
binaryIDEGLSurface = binary.ID{0x6b, 0xba, 0xab, 0x4f, 0xa1, 0xaa, 0x01, 0xdb, 0x61, 0xe3, 0xbb, 0x84, 0xf5, 0x1b, 0xf6, 0x39, 0xda, 0x3c, 0xf7, 0xb8}
binaryIDEGLintˢ = binary.ID{0xf7, 0x65, 0x4f, 0x39, 0xbd, 0x9c, 0x8d, 0x4a, 0x66, 0xfa, 0x0a, 0x73, 0x73, 0x6d, 0xd1, 0x2b, 0xa5, 0x60, 0xf9, 0xab}
binaryIDEGLintᵖ = binary.ID{0xcf, 0x1c, 0x9b, 0x06, 0x5a, 0x46, 0x2e, 0x61, 0x7d, 0xe6, 0x2e, 0x95, 0x4e, 0xfb, 0xb4, 0x41, 0x15, 0xf6, 0x9e, 0x0d}
binaryIDEglCreateContext = binary.ID{0xac, 0x3a, 0xa8, 0x3a, 0x28, 0xf3, 0x5a, 0xea, 0x3c, 0x91, 0x79, 0xd2, 0x7b, 0xc6, 0xf8, 0xb6, 0xd4, 0x07, 0x2b, 0x88}
binaryIDEglInitialize = binary.ID{0xa3, 0x4b, 0x10, 0xac, 0xe3, 0x34, 0x97, 0x4e, 0x72, 0xe2, 0x44, 0xc6, 0x21, 0x4b, 0x03, 0x0a, 0x2b, 0x01, 0x6e, 0xae}
binaryIDEglMakeCurrent = binary.ID{0x11, 0xbc, 0xee, 0xf3, 0x15, 0x6b, 0x3c, 0x40, 0x07, 0x40, 0x4c, 0xb3, 0x12, 0x2d, 0x98, 0x0c, 0xd1, 0xf0, 0xb1, 0x1e}
binaryIDEglQuerySurface = binary.ID{0x14, 0x6c, 0x8d, 0x6c, 0x45, 0xd9, 0xcd, 0xde, 0xde, 0xd0, 0x12, 0xea, 0x3f, 0x95, 0xeb, 0x43, 0xc6, 0x33, 0x40, 0x22}
binaryIDVoidᵖ = binary.ID{0xa7, 0x86, 0xcc, 0x23, 0x0b, 0x73, 0x10, 0x9d, 0xda, 0xc6, 0x41, 0xcb, 0xf7, 0xe4, 0x97, 0x87, 0x01, 0x69, 0xc2, 0x2e}
binaryIDEglSwapBuffers = binary.ID{0x57, 0x1f, 0xe4, 0x1b, 0x20, 0xa1, 0x87, 0x17, 0x6c, 0x31, 0x05, 0x59, 0x10, 0x83, 0xb5, 0x3a, 0xb0, 0xa9, 0x3c, 0x39}
binaryIDF32ˢ = binary.ID{0x0f, 0xb3, 0x50, 0xa2, 0xcc, 0xa0, 0x63, 0x8a, 0x12, 0xd5, 0xeb, 0xa7, 0xe9, 0x3e, 0xf5, 0x0e, 0x37, 0xea, 0xce, 0xaa}
binaryIDF32ᵖ = binary.ID{0x25, 0x42, 0x8d, 0x14, 0xfa, 0x29, 0xc8, 0xad, 0xe4, 0x75, 0x2b, 0xfa, 0xf4, 0x35, 0x5b, 0x12, 0x23, 0x97, 0x38, 0x77}
binaryIDFlushPostBuffer = binary.ID{0x26, 0x4e, 0x20, 0xbb, 0xf9, 0x53, 0x75, 0xcd, 0x08, 0x98, 0x6d, 0x82, 0x25, 0x7d, 0xb5, 0xb6, 0x1e, 0xbb, 0xe1, 0xbf}
binaryIDFramebufferAttachmentˢ = binary.ID{0x95, 0x05, 0xe7, 0xe0, 0x6a, 0xc5, 0x9d, 0x9e, 0xdf, 0x18, 0x61, 0x2f, 0xf7, 0x34, 0x79, 0x33, 0xed, 0xc9, 0xa8, 0x7c}
binaryIDFramebufferAttachmentᵖ = binary.ID{0xc1, 0xc1, 0xe5, 0xa2, 0x3a, 0x14, 0xc7, 0x83, 0xf8, 0x0a, 0xf2, 0xc9, 0x7e, 0x42, 0x47, 0x17, 0x34, 0x93, 0x1a, 0x91}
binaryIDFramebufferIdˢ = binary.ID{0xb2, 0x52, 0xd0, 0xde, 0x1a, 0xc2, 0xa8, 0xff, 0x28, 0x4f, 0xe8, 0x17, 0x8e, 0x60, 0xcc, 0x6e, 0x41, 0xcd, 0xcb, 0x0d}
binaryIDFramebufferIdᵖ = binary.ID{0x5a, 0x4f, 0x87, 0xa7, 0xe2, 0xf7, 0x6e, 0xe8, 0x7f, 0xf1, 0x5e, 0x27, 0x8c, 0x71, 0xbc, 0x66, 0x3c, 0xa5, 0x82, 0xce}
binaryIDGLXContext = binary.ID{0x07, 0xef, 0xcc, 0x57, 0xc6, 0x16, 0xf2, 0x83, 0x9d, 0x0f, 0x7c, 0x71, 0xe8, 0xa6, 0xda, 0x1e, 0x45, 0xf1, 0xce, 0xfe}
binaryIDGLXDrawable = binary.ID{0x43, 0x88, 0x91, 0x75, 0x90, 0x61, 0xe4, 0xc9, 0x61, 0xd0, 0x6d, 0xdb, 0x12, 0xae, 0xe1, 0xcb, 0x87, 0x07, 0xb3, 0x05}
binaryIDGlActiveTexture = binary.ID{0x86, 0x43, 0x07, 0xe6, 0xb5, 0x8c, 0x5b, 0x40, 0xd6, 0x5b, 0x88, 0x2a, 0x03, 0x47, 0x22, 0x92, 0x84, 0xd6, 0xd1, 0x71}
binaryIDGlAttachShader = binary.ID{0x25, 0x23, 0xee, 0xce, 0x3c, 0x37, 0xb6, 0x03, 0x61, 0xc4, 0xb6, 0xbf, 0x06, 0x38, 0xb9, 0x7f, 0x78, 0x85, 0xee, 0x77}
binaryIDGlBeginQuery = binary.ID{0x42, 0xe9, 0xe3, 0x0b, 0x3b, 0x9a, 0x1f, 0x86, 0x6f, 0x95, 0xc8, 0x3a, 0x15, 0x06, 0xb2, 0x84, 0x6a, 0x95, 0xd2, 0xf4}
binaryIDGlBeginQueryEXT = binary.ID{0x35, 0x2d, 0x3a, 0x78, 0xe5, 0xf5, 0xbe, 0x4d, 0x23, 0xd9, 0x25, 0xb4, 0x7c, 0xf5, 0x52, 0x5a, 0x7b, 0x3b, 0x51, 0x1b}
binaryIDGlBindAttribLocation = binary.ID{0xab, 0xe2, 0x34, 0x53, 0x26, 0xbc, 0x1d, 0x86, 0xd6, 0x8b, 0xd8, 0xaa, 0xd9, 0x38, 0x2f, 0xca, 0x5a, 0x1d, 0xc0, 0x10}
binaryIDGlBindBuffer = binary.ID{0xb3, 0xb1, 0xb5, 0x5e, 0xc2, 0xe9, 0x44, 0x46, 0x28, 0x6f, 0x55, 0x56, 0xc0, 0xa9, 0x57, 0xc2, 0x09, 0x9f, 0xbb, 0x04}
binaryIDGlBindFramebuffer = binary.ID{0x3b, 0x20, 0x3d, 0xca, 0x34, 0xac, 0x3e, 0x7c, 0x8b, 0xd7, 0xe0, 0xd8, 0x23, 0x84, 0xdb, 0x5b, 0xac, 0x43, 0x56, 0xa2}
binaryIDGlBindRenderbuffer = binary.ID{0xc4, 0xd9, 0xb9, 0x94, 0x42, 0x83, 0xf5, 0x48, 0xd1, 0x68, 0x54, 0x9d, 0x7d, 0x9c, 0x49, 0x6d, 0x0a, 0xcf, 0xdb, 0xa7}
binaryIDGlBindTexture = binary.ID{0xf9, 0x83, 0xaa, 0x55, 0xc0, 0x52, 0xe8, 0x65, 0xb0, 0x66, 0x1c, 0x7a, 0x33, 0xc9, 0x4a, 0xfd, 0xd1, 0xda, 0xf0, 0x69}
binaryIDGlBindVertexArrayOES = binary.ID{0x2c, 0x88, 0xbc, 0x5d, 0x79, 0xf5, 0x34, 0x2a, 0x35, 0xca, 0x72, 0x5c, 0xcf, 0x78, 0xee, 0x4b, 0xe5, 0x5f, 0xc8, 0xb4}
binaryIDGlBlendColor = binary.ID{0x60, 0xbd, 0x6d, 0x61, 0x66, 0xd6, 0x47, 0xea, 0x9c, 0xa7, 0x16, 0xba, 0xf4, 0x59, 0x00, 0x75, 0xaf, 0x03, 0x5a, 0x2b}
binaryIDGlBlendEquation = binary.ID{0xe1, 0x81, 0x90, 0xcf, 0x2b, 0xd7, 0x3e, 0xfc, 0xa7, 0x45, 0x6d, 0xd6, 0x60, 0xa3, 0xbd, 0xbd, 0xbe, 0x14, 0xe5, 0x56}
binaryIDGlBlendEquationSeparate = binary.ID{0x8e, 0x3a, 0xa3, 0x46, 0xe9, 0xaa, 0xb3, 0x99, 0xbc, 0x96, 0x61, 0x40, 0xc8, 0x26, 0x4d, 0xb0, 0xb0, 0xe5, 0x34, 0x0f}
binaryIDGlBlendFunc = binary.ID{0x7a, 0x77, 0xed, 0x51, 0x85, 0x8e, 0x92, 0xde, 0xef, 0x7d, 0x54, 0x4e, 0xf3, 0x38, 0xc1, 0x50, 0x61, 0x2d, 0xc2, 0x10}
binaryIDGlBlendFuncSeparate = binary.ID{0xe5, 0xce, 0xe6, 0x57, 0x98, 0xac, 0x75, 0x43, 0x39, 0xd4, 0xc6, 0xf2, 0xa9, 0xfc, 0xfa, 0x55, 0xe0, 0xb0, 0x67, 0x33}
binaryIDGlBlitFramebuffer = binary.ID{0x1d, 0xc8, 0x10, 0x98, 0x4a, 0x04, 0x29, 0x7d, 0xc7, 0xa9, 0xca, 0xd3, 0x36, 0x40, 0xce, 0xfc, 0x3c, 0x98, 0x21, 0xf0}
binaryIDGlBufferData = binary.ID{0x84, 0x06, 0x18, 0x83, 0xbc, 0x39, 0xac, 0xad, 0x06, 0xb7, 0x9a, 0x64, 0xa2, 0x81, 0x4d, 0x92, 0x3e, 0xf7, 0x11, 0xb0}
binaryIDGlBufferSubData = binary.ID{0x66, 0x8f, 0xae, 0x44, 0x51, 0x99, 0x0d, 0xb8, 0xb1, 0x8c, 0x65, 0x96, 0x3b, 0x3a, 0xec, 0x9a, 0x57, 0xd6, 0x9f, 0x38}
binaryIDGlCheckFramebufferStatus = binary.ID{0x0e, 0x53, 0x9b, 0x07, 0x3d, 0xec, 0x3a, 0x84, 0xf5, 0x1c, 0x0a, 0xfb, 0x31, 0x6a, 0x69, 0x88, 0xed, 0x78, 0x99, 0xba}
binaryIDGlClear = binary.ID{0x4a, 0x0e, 0x2c, 0xc5, 0x7c, 0xbe, 0xd1, 0xa7, 0xeb, 0x57, 0xa1, 0x35, 0xcd, 0xb5, 0x0a, 0x42, 0x71, 0xfc, 0x13, 0xef}
binaryIDGlClearColor = binary.ID{0x3b, 0x2c, 0x7f, 0xdf, 0xca, 0xea, 0x73, 0xe9, 0x9d, 0xaa, 0xb9, 0x94, 0x97, 0xc8, 0xc0, 0x1d, 0x7e, 0x0f, 0xa6, 0xc2}
binaryIDGlClearDepthf = binary.ID{0x64, 0x57, 0xb0, 0xf4, 0x14, 0x5f, 0xfd, 0x32, 0x8a, 0x6d, 0x28, 0xec, 0xb9, 0x33, 0x25, 0xc9, 0x28, 0x9c, 0x97, 0x04}
binaryIDGlClearStencil = binary.ID{0x7c, 0xd3, 0x47, 0x40, 0xf0, 0x5d, 0xcc, 0xec, 0x2e, 0x49, 0xea, 0x0d, 0x3e, 0x90, 0xda, 0xf2, 0x95, 0xb8, 0xcb, 0xe2}
binaryIDGlColorMask = binary.ID{0x0b, 0x72, 0x03, 0xf6, 0x51, 0x6a, 0xe3, 0xca, 0x0c, 0x5d, 0x08, 0x46, 0xf6, 0x8b, 0x71, 0xdf, 0x67, 0xe5, 0xae, 0xf9}
binaryIDGlCompileShader = binary.ID{0xce, 0x1e, 0x7c, 0xbf, 0xf7, 0xb7, 0x95, 0x6d, 0x38, 0x5d, 0x42, 0x6d, 0x1e, 0xba, 0x0e, 0xd5, 0xf4, 0xa9, 0xe7, 0x30}
binaryIDTexturePointer = binary.ID{0xb6, 0x31, 0x39, 0xfa, 0x37, 0x1c, 0x57, 0x16, 0x83, 0x12, 0x2a, 0xe9, 0x1c, 0xa8, 0x0f, 0x9d, 0xaf, 0xcf, 0xb3, 0xa3}
binaryIDGlCompressedTexImage2D = binary.ID{0x88, 0x11, 0xf4, 0x37, 0xd8, 0xc0, 0xe3, 0x49, 0xc1, 0xc3, 0xdd, 0xcf, 0x50, 0xbf, 0xda, 0x61, 0xfb, 0xb4, 0x85, 0x1c}
binaryIDGlCompressedTexSubImage2D = binary.ID{0x4c, 0xe3, 0x8f, 0x52, 0x17, 0x8b, 0x87, 0xa1, 0x2f, 0xd4, 0x8c, 0xb6, 0xc9, 0xbe, 0x9e, 0xe3, 0x0a, 0xb5, 0xc6, 0x77}
binaryIDGlCopyTexImage2D = binary.ID{0x47, 0x75, 0x3a, 0x4b, 0x07, 0x67, 0x51, 0x2b, 0x76, 0xd3, 0xab, 0x41, 0x5d, 0xa3, 0x7a, 0xa6, 0x90, 0x28, 0x7f, 0xc3}
binaryIDGlCopyTexSubImage2D = binary.ID{0x59, 0x01, 0xd8, 0x9f, 0xb0, 0x22, 0x09, 0xff, 0x3a, 0x95, 0x20, 0x68, 0xf8, 0xbf, 0x2c, 0x38, 0x55, 0xac, 0x69, 0x51}
binaryIDGlCreateProgram = binary.ID{0x54, 0xa2, 0x4c, 0x27, 0x9f, 0x12, 0x2c, 0xfb, 0x4f, 0x47, 0x54, 0xd8, 0xfa, 0x4b, 0x69, 0xf6, 0x3e, 0x65, 0x36, 0xc2}
binaryIDGlCreateShader = binary.ID{0xcc, 0x3f, 0x4b, 0x85, 0x80, 0xf2, 0x9f, 0x1d, 0x95, 0x89, 0x7f, 0xcd, 0x2e, 0xd6, 0xc7, 0x9f, 0x0a, 0x4b, 0xbf, 0x01}
binaryIDGlCullFace = binary.ID{0xc3, 0x30, 0x1b, 0x5a, 0x8a, 0x39, 0xc5, 0x2f, 0x95, 0xba, 0x14, 0x8f, 0xdb, 0xf5, 0x16, 0x1f, 0xcb, 0xb9, 0x0a, 0x87}
binaryIDGlDeleteBuffers = binary.ID{0x8f, 0xe2, 0xcc, 0x25, 0x5b, 0xe5, 0xab, 0xa7, 0x6b, 0x93, 0x97, 0x50, 0xd3, 0x52, 0xd4, 0x71, 0x2d, 0x14, 0xb1, 0xc8}
binaryIDGlDeleteFramebuffers = binary.ID{0x0c, 0x58, 0x2e, 0x54, 0x3d, 0x02, 0x09, 0xe4, 0xbc, 0x40, 0x03, 0x55, 0x92, 0x74, 0x8c, 0xab, 0x0b, 0x29, 0x12, 0x09}
binaryIDGlDeleteProgram = binary.ID{0x3d, 0x9f, 0xd2, 0xe3, 0xa2, 0x70, 0x3d, 0x38, 0x17, 0x8a, 0x71, 0xca, 0xbe, 0xb4, 0x8c, 0x97, 0x00, 0x75, 0x9f, 0x2f}
binaryIDQueryIdᵖ = binary.ID{0xbc, 0x1f, 0x91, 0x31, 0xab, 0x23, 0x97, 0xbd, 0x24, 0x4b, 0x69, 0x3f, 0xb9, 0x40, 0xf4, 0xb4, 0xb3, 0x93, 0x43, 0x33}
binaryIDGlDeleteQueries = binary.ID{0xef, 0x66, 0xdb, 0x46, 0x91, 0x9a, 0x79, 0x40, 0x07, 0x4b, 0x18, 0x38, 0x4c, 0x3f, 0x5f, 0x36, 0x65, 0x6b, 0x86, 0x6f}
binaryIDGlDeleteQueriesEXT = binary.ID{0xc1, 0xba, 0x04, 0x28, 0x00, 0x4f, 0x7f, 0x73, 0xae, 0x18, 0x11, 0x19, 0x70, 0xd0, 0xe4, 0xc9, 0x2e, 0x01, 0x80, 0xfa}
binaryIDRenderbufferIdᵖ = binary.ID{0x18, 0xae, 0x51, 0x0d, 0xb7, 0xf3, 0xf8, 0xe7, 0x47, 0x3f, 0x5d, 0x29, 0xf8, 0x43, 0x60, 0xe2, 0x5a, 0x2d, 0xa6, 0x9b}
binaryIDGlDeleteRenderbuffers = binary.ID{0xc7, 0x91, 0x63, 0x48, 0xf4, 0xe3, 0xea, 0x86, 0x4b, 0x3c, 0x40, 0x44, 0x6c, 0x5d, 0x8c, 0x87, 0xb9, 0x7d, 0x26, 0x4b}
binaryIDGlDeleteShader = binary.ID{0x11, 0xd1, 0xa7, 0x92, 0xf4, 0x7b, 0x74, 0x2a, 0xac, 0x29, 0x4f, 0x42, 0x17, 0x9c, 0x3e, 0xb9, 0x03, 0x8d, 0xbd, 0xe7}
binaryIDTextureIdᵖ = binary.ID{0x99, 0x6c, 0x61, 0x83, 0x7a, 0xc0, 0x86, 0x16, 0x1a, 0x93, 0x45, 0x97, 0x32, 0x66, 0x80, 0x91, 0xd1, 0x87, 0xd1, 0x8e}
binaryIDGlDeleteTextures = binary.ID{0x8e, 0x87, 0xbe, 0x83, 0xfc, 0x68, 0xab, 0x65, 0x39, 0x6d, 0x29, 0xe8, 0x91, 0x0a, 0xb4, 0x3b, 0x72, 0x6b, 0x87, 0xdc}
binaryIDVertexArrayIdᵖ = binary.ID{0xfb, 0x13, 0x6e, 0xf5, 0x8d, 0x52, 0xf5, 0xb2, 0xb5, 0x02, 0x1f, 0x10, 0x15, 0x84, 0x51, 0xb2, 0xc6, 0x8b, 0xc5, 0x5f}
binaryIDGlDeleteVertexArraysOES = binary.ID{0xb6, 0xb4, 0x59, 0xf8, 0x46, 0x00, 0x47, 0x2c, 0x12, 0xa7, 0x1a, 0xfe, 0xee, 0xd4, 0xa6, 0x1a, 0xfc, 0x47, 0xef, 0x0c}
binaryIDGlDepthFunc = binary.ID{0xa7, 0x7e, 0x09, 0x94, 0x5c, 0x20, 0x03, 0xac, 0x59, 0x2f, 0xe6, 0xfd, 0x3e, 0xcc, 0x20, 0x33, 0xa8, 0x09, 0xce, 0x0b}
binaryIDGlDepthMask = binary.ID{0xc5, 0x6d, 0x4e, 0x1a, 0x87, 0x06, 0xec, 0xa4, 0xe8, 0xb4, 0x2e, 0x82, 0xff, 0x78, 0x0a, 0x83, 0x79, 0x82, 0xce, 0xf1}
binaryIDGlDepthRangef = binary.ID{0x78, 0x1b, 0x34, 0xe8, 0x78, 0x4e, 0x71, 0xa9, 0xe2, 0x5f, 0x8c, 0xb7, 0x13, 0x10, 0x6f, 0x22, 0xbe, 0x5c, 0x85, 0x96}
binaryIDGlDetachShader = binary.ID{0xd1, 0xf8, 0x03, 0x27, 0x0d, 0xc3, 0xbb, 0x7b, 0x58, 0xa8, 0x8a, 0x4d, 0x7b, 0x24, 0x57, 0xa3, 0x00, 0xcf, 0xc4, 0xce}
binaryIDGlDisable = binary.ID{0x79, 0x79, 0x54, 0xb0, 0x72, 0xfd, 0x82, 0xa8, 0x02, 0x84, 0x02, 0x24, 0xd8, 0x72, 0x8c, 0xf8, 0x1d, 0x1c, 0x4b, 0xc4}
binaryIDGlDisableClientState = binary.ID{0xba, 0x1b, 0xf5, 0xf6, 0x05, 0x90, 0x12, 0x0a, 0xdd, 0x26, 0x72, 0x28, 0xcf, 0xe0, 0xd8, 0x82, 0xbf, 0x60, 0xd6, 0x21}
binaryIDGlDisableVertexAttribArray = binary.ID{0x0e, 0x71, 0x56, 0x6a, 0x0a, 0x8d, 0xc7, 0x6b, 0x76, 0x8f, 0x05, 0xca, 0xeb, 0x95, 0x01, 0x46, 0x44, 0xf6, 0xf3, 0x52}
binaryIDGlDiscardFramebufferEXT = binary.ID{0x70, 0xae, 0x75, 0x3e, 0x8d, 0x47, 0xfa, 0xcd, 0x76, 0x68, 0xa1, 0x25, 0x90, 0x55, 0xb0, 0xd5, 0x30, 0x09, 0x62, 0x27}
binaryIDGlDrawArrays = binary.ID{0x7f, 0xea, 0xee, 0x65, 0x7d, 0xf9, 0x1f, 0x13, 0xae, 0x78, 0x1b, 0x1c, 0xbb, 0x29, 0x62, 0xe6, 0x6a, 0xd4, 0x67, 0x8f}
binaryIDIndicesPointer = binary.ID{0x76, 0x75, 0x96, 0xf7, 0x8e, 0x48, 0x4e, 0x8b, 0x35, 0x9b, 0x75, 0x1f, 0xb2, 0x5a, 0x50, 0xb7, 0x2e, 0x2f, 0xa9, 0xe2}
binaryIDGlDrawElements = binary.ID{0x18, 0xba, 0xb0, 0xb5, 0x2d, 0xca, 0xbb, 0x23, 0xb0, 0x0a, 0xc4, 0x9f, 0xb7, 0xd5, 0xc2, 0xa7, 0xab, 0x41, 0x6b, 0x21}
binaryIDGlEGLImageTargetRenderbufferStorageOES = binary.ID{0x53, 0x5e, 0x99, 0x02, 0x81, 0xd9, 0x2d, 0x36, 0xa1, 0xc6, 0x25, 0xd8, 0x3d, 0x5e, 0xa1, 0xb2, 0xfb, 0xda, 0xb4, 0x8d}
binaryIDImageOES = binary.ID{0x77, 0x91, 0xd9, 0x22, 0x22, 0x46, 0xfa, 0x9b, 0xc5, 0xf0, 0x4f, 0x9b, 0xa6, 0x73, 0xe8, 0xdf, 0x22, 0x6b, 0x06, 0x36}
binaryIDGlEGLImageTargetTexture2DOES = binary.ID{0x56, 0x39, 0x9e, 0x74, 0x52, 0x6e, 0xa3, 0x41, 0xc9, 0xab, 0x03, 0x18, 0x30, 0x25, 0x3a, 0x08, 0x6d, 0xae, 0xe7, 0x35}
binaryIDGlEnable = binary.ID{0x48, 0xaa, 0x9b, 0x21, 0xfc, 0xc7, 0xe6, 0x29, 0xf7, 0xcf, 0xda, 0x40, 0x88, 0x59, 0x9c, 0x23, 0xb4, 0xb0, 0xfe, 0x74}
binaryIDGlEnableClientState = binary.ID{0x82, 0x27, 0xe0, 0xfe, 0xce, 0xe9, 0x44, 0xf2, 0x48, 0x00, 0xc4, 0x51, 0x95, 0x03, 0xe3, 0xe3, 0x97, 0x3e, 0x73, 0x92}
binaryIDGlEnableVertexAttribArray = binary.ID{0xe7, 0x92, 0xb4, 0x99, 0xeb, 0x7e, 0xdc, 0x7a, 0xbb, 0x5b, 0x49, 0x71, 0x82, 0xd3, 0x09, 0x49, 0xb4, 0x0f, 0xfc, 0x66}
binaryIDGlEndQuery = binary.ID{0xb0, 0xc0, 0x56, 0x8b, 0xa4, 0xc3, 0x2b, 0xde, 0xb0, 0xaa, 0x61, 0xa9, 0x06, 0x63, 0x1b, 0xc6, 0xe2, 0x5b, 0xa0, 0x42}
binaryIDGlEndQueryEXT = binary.ID{0x12, 0x04, 0x23, 0x20, 0x96, 0x9c, 0x40, 0xb8, 0x80, 0xfe, 0x76, 0x70, 0x48, 0xdf, 0x81, 0x60, 0xb1, 0x23, 0xab, 0x12}
binaryIDGlEndTilingQCOM = binary.ID{0x51, 0x3b, 0x7d, 0x13, 0xa0, 0xbc, 0xcf, 0x24, 0x84, 0x9a, 0xc3, 0x78, 0x7e, 0x2c, 0xe4, 0x23, 0x6e, 0x23, 0xdd, 0x9a}
binaryIDGlFinish = binary.ID{0x62, 0xe9, 0xca, 0xf4, 0x39, 0xd8, 0x39, 0x1e, 0x49, 0x43, 0x1f, 0x40, 0xbb, 0x3d, 0x1b, 0x11, 0xc9, 0x5c, 0x9a, 0xf9}
binaryIDGlFlush = binary.ID{0x63, 0x83, 0x26, 0x9a, 0x10, 0x6b, 0x68, 0x9f, 0x90, 0x65, 0x54, 0xba, 0x66, 0x25, 0xc8, 0x09, 0x24, 0xe3, 0x21, 0x00}
binaryIDGlFramebufferRenderbuffer = binary.ID{0x08, 0x60, 0xdc, 0xd3, 0x3d, 0xe4, 0xdf, 0xea, 0xb9, 0x9c, 0xa5, 0xd2, 0x51, 0x4b, 0x35, 0x5a, 0xf0, 0xc7, 0xd6, 0xe2}
binaryIDGlFramebufferTexture2D = binary.ID{0x10, 0x30, 0x07, 0x4c, 0xd1, 0xfc, 0x8a, 0xb5, 0xa6, 0x3d, 0x8f, 0x3d, 0xc4, 0x89, 0x04, 0x9d, 0x45, 0x46, 0x4f, 0x08}
binaryIDGlFrontFace = binary.ID{0x1e, 0x28, 0xc7, 0x47, 0x97, 0xc9, 0x1c, 0x7f, 0x57, 0xde, 0x5e, 0x6f, 0xce, 0x21, 0x17, 0xf4, 0xb0, 0xd8, 0xa9, 0x44}
binaryIDGlGenBuffers = binary.ID{0x32, 0x53, 0x4b, 0x2a, 0xe7, 0xc6, 0x48, 0x67, 0xd2, 0x7b, 0x7f, 0x3b, 0x84, 0xa6, 0x7c, 0x78, 0x84, 0x3d, 0xf0, 0xdf}
binaryIDGlGenFramebuffers = binary.ID{0x1f, 0xc4, 0xb4, 0x78, 0xb4, 0x9a, 0xa1, 0x24, 0x35, 0x98, 0x6f, 0x28, 0x1b, 0xbb, 0xea, 0x8f, 0xec, 0x0b, 0xe7, 0xb6}
binaryIDGlGenQueries = binary.ID{0x39, 0x4c, 0xdc, 0xb4, 0x99, 0x69, 0x21, 0x1d, 0x29, 0x7b, 0x63, 0xb9, 0xf3, 0x15, 0xf0, 0x91, 0x19, 0x96, 0x55, 0xfb}
binaryIDGlGenQueriesEXT = binary.ID{0xa9, 0x25, 0x0c, 0x6b, 0x1d, 0x84, 0x28, 0x3b, 0x88, 0xc1, 0xff, 0xc1, 0x76, 0x53, 0x13, 0x2f, 0x27, 0x5e, 0x30, 0x53}
binaryIDGlGenRenderbuffers = binary.ID{0x07, 0x42, 0x56, 0x00, 0xfe, 0x35, 0xc4, 0xa9, 0x57, 0xec, 0x42, 0x13, 0x7f, 0xd4, 0x19, 0xb8, 0xa8, 0xa8, 0x6c, 0x71}
binaryIDGlGenTextures = binary.ID{0x64, 0x29, 0x1a, 0xec, 0x06, 0x04, 0x37, 0x17, 0xd4, 0x7d, 0x2a, 0x05, 0x6a, 0xdc, 0x2d, 0x0f, 0x1e, 0xce, 0x1e, 0x5a}
binaryIDGlGenVertexArraysOES = binary.ID{0xe0, 0x5b, 0x77, 0xc1, 0x67, 0x6d, 0xa5, 0xa2, 0xc7, 0x21, 0x8c, 0x2b, 0x0c, 0xd5, 0xab, 0x25, 0x91, 0xb2, 0x4d, 0x9c}
binaryIDGlGenerateMipmap = binary.ID{0x42, 0xea, 0x5b, 0xaa, 0xcc, 0x26, 0x78, 0xf5, 0xf0, 0x10, 0x98, 0x9f, 0xa8, 0xb6, 0x7b, 0xae, 0xf8, 0xbd, 0x42, 0x3e}
binaryIDS32ᵖ = binary.ID{0x15, 0xd8, 0xda, 0x55, 0xc7, 0x51, 0xdc, 0x13, 0x0e, 0xe6, 0xf3, 0x33, 0x66, 0x41, 0xd6, 0xf1, 0x5f, 0x02, 0x93, 0x41}
binaryIDShaderAttribTypeᵖ = binary.ID{0xae, 0xed, 0x56, 0xf7, 0xb4, 0xb8, 0x0b, 0x47, 0x04, 0xa1, 0xc2, 0x24, 0x58, 0x0d, 0x4b, 0xd2, 0xb8, 0x43, 0xac, 0x6b}
binaryIDGlGetActiveAttrib = binary.ID{0xa6, 0x71, 0x22, 0x04, 0xa2, 0x0e, 0x8a, 0x5b, 0x9e, 0x05, 0x76, 0x4a, 0x54, 0x82, 0x91, 0xce, 0xfb, 0x76, 0x4b, 0x97}
binaryIDShaderUniformTypeᵖ = binary.ID{0xec, 0x33, 0x14, 0x93, 0x2e, 0xbc, 0x9b, 0x5b, 0x66, 0x62, 0x30, 0x7a, 0x5d, 0x8f, 0x13, 0x4e, 0x2b, 0x39, 0xc9, 0x32}
binaryIDGlGetActiveUniform = binary.ID{0xc5, 0x84, 0xd2, 0x9b, 0x13, 0x62, 0x24, 0x78, 0xdb, 0x59, 0x18, 0xa7, 0xca, 0xcf, 0xab, 0xf1, 0x12, 0xf3, 0x1c, 0xcd}
binaryIDShaderIdᵖ = binary.ID{0x08, 0x41, 0x7d, 0x5d, 0x94, 0x16, 0xc5, 0x83, 0xb1, 0x5b, 0x6b, 0x53, 0x78, 0xac, 0x10, 0xbd, 0x1e, 0x59, 0x09, 0x1d}
binaryIDGlGetAttachedShaders = binary.ID{0xc3, 0xf9, 0x1d, 0xd0, 0xcc, 0x89, 0x4c, 0x62, 0xad, 0x92, 0x44, 0x25, 0x6d, 0x63, 0x8b, 0x92, 0x1a, 0x01, 0xeb, 0xb4}
binaryIDGlGetAttribLocation = binary.ID{0x31, 0x3d, 0x4f, 0xb6, 0x80, 0x95, 0xce, 0x6a, 0x65, 0x25, 0x0a, 0xb5, 0xff, 0x15, 0x44, 0x1d, 0x3e, 0x91, 0xc7, 0xef}
binaryIDGlGetBooleanv = binary.ID{0xbf, 0x1d, 0xb7, 0x81, 0xa0, 0x1f, 0x6b, 0x03, 0x21, 0xe3, 0x51, 0x7c, 0x73, 0x4f, 0xf9, 0x9a, 0x62, 0x0a, 0xfd, 0xa4}
binaryIDGlGetBufferParameteriv = binary.ID{0xc3, 0xad, 0xb9, 0xd4, 0x86, 0x78, 0x8e, 0x05, 0x73, 0x0d, 0x21, 0x3e, 0x98, 0xb8, 0x6c, 0x68, 0x13, 0x06, 0xb4, 0x56}
binaryIDGlGetError = binary.ID{0x32, 0xd4, 0xe6, 0xb7, 0x2f, 0x3a, 0x06, 0xc9, 0xe3, 0x7c, 0x56, 0x38, 0x38, 0x95, 0xa4, 0x28, 0x38, 0x57, 0x2c, 0x9e}
binaryIDGlGetFloatv = binary.ID{0x3b, 0xdb, 0xfd, 0xab, 0xa4, 0xad, 0x98, 0xf5, 0x0d, 0x91, 0xdb, 0xe3, 0x45, 0xe3, 0x71, 0xf1, 0x6e, 0xd1, 0x59, 0x11}
binaryIDGlGetFramebufferAttachmentParameteriv = binary.ID{0xea, 0x0f, 0x37, 0x28, 0xa8, 0x59, 0x9e, 0x90, 0x50, 0x4a, 0xa4, 0x6d, 0xa2, 0xe3, 0x43, 0xf2, 0xd2, 0x6d, 0x09, 0x40}
binaryIDGlGetGraphicsResetStatusEXT = binary.ID{0x05, 0xbe, 0x22, 0x49, 0x59, 0x3a, 0x7c, 0x01, 0xa0, 0x5c, 0x5c, 0xf3, 0x08, 0xa2, 0xc6, 0xfa, 0x87, 0x3e, 0xdd, 0x53}
binaryIDGlGetIntegerv = binary.ID{0x93, 0xaa, 0x39, 0x40, 0xc7, 0xf4, 0x20, 0x49, 0x7b, 0x61, 0xfc, 0x8f, 0x9d, 0x2d, 0xe9, 0x9c, 0x8c, 0xb3, 0xc7, 0x62}
binaryIDU32ᵖ = binary.ID{0xbc, 0x9f, 0x1f, 0x59, 0xba, 0xa6, 0x8d, 0xe3, 0x2f, 0x46, 0xe5, 0xf1, 0xde, 0x51, 0x77, 0x45, 0xab, 0x1f, 0xdc, 0x67}
binaryIDGlGetProgramBinaryOES = binary.ID{0x41, 0xe1, 0x61, 0x7a, 0xa2, 0x17, 0x6f, 0x2f, 0xd4, 0xaf, 0x47, 0x68, 0xce, 0x51, 0x64, 0x3a, 0x97, 0xbb, 0xf3, 0xec}
binaryIDGlGetProgramInfoLog = binary.ID{0x7f, 0xd8, 0xe7, 0x8b, 0xf6, 0xa4, 0x9e, 0xe4, 0xcd, 0xbf, 0x72, 0x0d, 0xc9, 0xc0, 0xdc, 0xb0, 0x5e, 0x3c, 0x52, 0x21}
binaryIDGlGetProgramiv = binary.ID{0x0c, 0x30, 0x8a, 0xb8, 0x12, 0x64, 0xb2, 0x25, 0xfe, 0x4c, 0x3e, 0xaf, 0x2c, 0x0d, 0x05, 0x67, 0x8f, 0x95, 0xb2, 0x41}
binaryIDS64ᵖ = binary.ID{0x94, 0xcc, 0x14, 0xe7, 0xe5, 0xaa, 0x45, 0x47, 0x68, 0x47, 0x60, 0x90, 0x4d, 0x40, 0x9e, 0x4e, 0xa3, 0x65, 0x3a, 0x9b}
binaryIDGlGetQueryObjecti64vEXT = binary.ID{0x4d, 0xad, 0xff, 0x92, 0xcd, 0xd0, 0xac, 0xe7, 0x0e, 0x9f, 0xa7, 0x7b, 0x91, 0x31, 0xfb, 0x37, 0xea, 0x2c, 0xbd, 0x9c}
binaryIDGlGetQueryObjectivEXT = binary.ID{0x83, 0xd8, 0xfe, 0x13, 0x5b, 0xce, 0x42, 0x6f, 0x82, 0xbc, 0x0b, 0xfe, 0x33, 0xae, 0xd6, 0x73, 0x87, 0xe4, 0x95, 0xad}
binaryIDU64ᵖ = binary.ID{0x5b, 0xb1, 0xae, 0xc9, 0xd5, 0x8f, 0x30, 0x22, 0xf4, 0x8f, 0x96, 0xf2, 0x6f, 0xb2, 0x65, 0xa7, 0xfd, 0xfb, 0xae, 0x50}
binaryIDGlGetQueryObjectui64vEXT = binary.ID{0x5d, 0x7e, 0xa2, 0xff, 0x4b, 0x0c, 0x64, 0x67, 0xbf, 0x8e, 0xe0, 0x4c, 0x78, 0xd5, 0x6c, 0xb3, 0xf9, 0xc1, 0x47, 0xe5}
binaryIDGlGetQueryObjectuiv = binary.ID{0xac, 0x6d, 0xbf, 0x24, 0x6d, 0xf4, 0xd4, 0x03, 0x1b, 0x6f, 0xfe, 0xc4, 0xa0, 0xa7, 0xf7, 0x21, 0xe9, 0x73, 0x96, 0x06}
binaryIDGlGetQueryObjectuivEXT = binary.ID{0xa5, 0xa4, 0x75, 0x56, 0xa4, 0x9f, 0xc4, 0x89, 0xa3, 0xd6, 0x58, 0x74, 0xfc, 0xd1, 0x52, 0xd7, 0xd0, 0x3e, 0x83, 0x66}
binaryIDGlGetQueryiv = binary.ID{0x0e, 0x7c, 0xf0, 0x23, 0x65, 0x05, 0x0c, 0x47, 0x0f, 0xb0, 0xa1, 0xb5, 0x1b, 0x6a, 0x28, 0x1e, 0x11, 0x0b, 0x6b, 0xbc}
binaryIDGlGetQueryivEXT = binary.ID{0xc5, 0x52, 0xdf, 0xab, 0xb0, 0x07, 0x60, 0x2b, 0x5e, 0x73, 0xc6, 0x30, 0x5b, 0xd4, 0xda, 0x9b, 0xf6, 0xb9, 0x5b, 0x8c}
binaryIDGlGetRenderbufferParameteriv = binary.ID{0x87, 0xc3, 0x18, 0x1d, 0xdb, 0x8c, 0x12, 0xc5, 0x99, 0x36, 0x7d, 0x42, 0xcf, 0x94, 0xfe, 0xa9, 0x7b, 0x98, 0xfe, 0xad}
binaryIDGlGetShaderInfoLog = binary.ID{0x92, 0xca, 0x29, 0xdb, 0xad, 0x52, 0xb1, 0x8f, 0x63, 0xc1, 0xf8, 0x50, 0x9b, 0xd5, 0x22, 0x71, 0x9f, 0x9c, 0xc3, 0x39}
binaryIDGlGetShaderPrecisionFormat = binary.ID{0x5c, 0x87, 0x98, 0x4b, 0x36, 0xe8, 0xc8, 0xff, 0x5f, 0x0d, 0x3c, 0xf7, 0xb0, 0xf6, 0x70, 0x01, 0x07, 0x6c, 0xc2, 0x26}
binaryIDGlGetShaderSource = binary.ID{0x40, 0x17, 0xc7, 0x81, 0x4a, 0xc0, 0x92, 0x81, 0x0b, 0xc7, 0x7e, 0x46, 0x29, 0x90, 0x9a, 0x5f, 0xe8, 0xfc, 0x2c, 0xf4}
binaryIDGlGetShaderiv = binary.ID{0x39, 0x6e, 0x5d, 0xe0, 0x98, 0x44, 0x05, 0xb2, 0x40, 0xc0, 0xbf, 0x6f, 0xec, 0x6b, 0x96, 0x01, 0x70, 0x0c, 0x3b, 0xe9}
binaryIDGlGetString = binary.ID{0x2e, 0xd5, 0x44, 0x37, 0x45, 0x75, 0x0f, 0x8e, 0xd8, 0xf4, 0x41, 0x59, 0x1e, 0xfc, 0x28, 0x21, 0xa8, 0x8d, 0x44, 0x3a}
binaryIDGlGetTexParameterfv = binary.ID{0x37, 0xaf, 0xce, 0x41, 0x14, 0x36, 0xf7, 0x6d, 0xa1, 0xf0, 0x11, 0xe6, 0x33, 0xc2, 0x40, 0x67, 0x66, 0x36, 0x05, 0x57}
binaryIDGlGetTexParameteriv = binary.ID{0xc3, 0x09, 0xc1, 0xba, 0x0d, 0x1b, 0xdb, 0xb2, 0x65, 0x4a, 0xbd, 0x90, 0x70, 0x65, 0x79, 0x08, 0x93, 0x8f, 0x33, 0x28}
binaryIDGlGetUniformLocation = binary.ID{0xd9, 0x4d, 0x1e, 0x3c, 0xe5, 0x99, 0xab, 0xf3, 0x3c, 0x4e, 0x27, 0xad, 0xd6, 0xd0, 0x7c, 0x6d, 0xb9, 0x4b, 0x2d, 0xc4}
binaryIDGlGetUniformfv = binary.ID{0x95, 0xba, 0xf3, 0xa4, 0xd9, 0x80, 0x7e, 0x97, 0x4b, 0x80, 0xaf, 0x3d, 0x8a, 0xec, 0x09, 0x2a, 0x3e, 0xf7, 0xc5, 0xd6}
binaryIDGlGetUniformiv = binary.ID{0xc8, 0x25, 0x82, 0x99, 0x0a, 0x7f, 0x6c, 0x55, 0x72, 0xd0, 0x79, 0xf9, 0xf7, 0xf3, 0x84, 0xb8, 0xdf, 0x96, 0x8f, 0xef}
binaryIDGlHint = binary.ID{0x48, 0xaf, 0x97, 0x70, 0xba, 0x4b, 0xbd, 0x3a, 0x72, 0xc8, 0xd6, 0x25, 0x05, 0x00, 0x7e, 0x86, 0x38, 0x90, 0xd7, 0xff}
binaryIDGlInsertEventMarkerEXT = binary.ID{0xe0, 0x62, 0x82, 0xd3, 0x0a, 0x0c, 0xae, 0xde, 0xf3, 0xac, 0xe6, 0xa9, 0x5f, 0xb5, 0xc7, 0x8b, 0x2c, 0xe1, 0x99, 0xea}
binaryIDGlInvalidateFramebuffer = binary.ID{0xb4, 0x9d, 0xbf, 0x94, 0x4c, 0x3e, 0x3a, 0xf1, 0xfa, 0xbb, 0xed, 0x74, 0xa3, 0x70, 0x2c, 0xfa, 0x16, 0xaa, 0xa7, 0x20}
binaryIDGlIsBuffer = binary.ID{0x25, 0xf9, 0x53, 0xf4, 0x60, 0x55, 0xc5, 0xfe, 0x8a, 0x0f, 0xd4, 0x1a, 0x88, 0xe7, 0xf4, 0x4c, 0xcc, 0x81, 0x3b, 0xb7}
binaryIDGlIsEnabled = binary.ID{0x49, 0x3f, 0xc2, 0x32, 0x2c, 0x37, 0x0c, 0x4c, 0xe9, 0x45, 0x95, 0x51, 0x1c, 0x46, 0x31, 0x20, 0x8d, 0xc2, 0xb6, 0x15}
binaryIDGlIsFramebuffer = binary.ID{0x0b, 0xdd, 0x4e, 0xe8, 0x9f, 0x9d, 0xcc, 0xd2, 0xea, 0x1a, 0xa6, 0xc5, 0xef, 0x65, 0x2e, 0x02, 0x80, 0xe0, 0xc4, 0x63}
binaryIDGlIsProgram = binary.ID{0x62, 0xbd, 0xde, 0xd6, 0x51, 0x60, 0x50, 0x3e, 0x3d, 0x54, 0x0a, 0xec, 0xb2, 0xcd, 0xf5, 0x54, 0xfb, 0x79, 0x3c, 0xdd}
binaryIDGlIsQuery = binary.ID{0x3b, 0x6f, 0x09, 0x4b, 0x89, 0xdc, 0x6b, 0x2f, 0x74, 0xd6, 0x51, 0x3b, 0x3f, 0xfe, 0x6d, 0x60, 0x72, 0x60, 0x61, 0xe2}
binaryIDGlIsQueryEXT = binary.ID{0xb1, 0x6a, 0x0d, 0xdf, 0xb6, 0xea, 0x3d, 0x84, 0xd0, 0x8c, 0x22, 0xf5, 0xf9, 0x82, 0x88, 0xa5, 0x3e, 0xdd, 0x56, 0xea}
binaryIDGlIsRenderbuffer = binary.ID{0xee, 0xfa, 0xeb, 0x17, 0x01, 0xe1, 0xe4, 0xc6, 0x90, 0x90, 0x9c, 0xfa, 0x28, 0x24, 0xad, 0x33, 0xc5, 0xef, 0x2f, 0xe6}
binaryIDGlIsShader = binary.ID{0xb5, 0x7a, 0x83, 0x39, 0x62, 0xa0, 0x1c, 0x3d, 0x08, 0x84, 0x29, 0xda, 0x1a, 0x6a, 0xe2, 0xd6, 0x24, 0x88, 0x4e, 0xe2}
binaryIDGlIsTexture = binary.ID{0xae, 0x84, 0x50, 0xca, 0xe6, 0x83, 0x45, 0x6c, 0x68, 0x8d, 0x96, 0xf2, 0xb2, 0x0f, 0x9c, 0x01, 0x78, 0x1c, 0x12, 0xdd}
binaryIDGlIsVertexArrayOES = binary.ID{0xab, 0xa3, 0xb5, 0xac, 0x9c, 0x32, 0x14, 0xdb, 0x82, 0x00, 0xa7, 0xbd, 0xe0, 0xb2, 0x40, 0x64, 0xac, 0x30, 0xb8, 0xc7}
binaryIDGlLineWidth = binary.ID{0x52, 0x6f, 0x5c, 0x5b, 0xcb, 0xf6, 0xfb, 0xfb, 0x29, 0x3d, 0x64, 0x86, 0x07, 0x05, 0x67, 0x26, 0xba, 0x3c, 0xb8, 0xfb}
binaryIDGlLinkProgram = binary.ID{0x17, 0xf0, 0x30, 0xba, 0x15, 0x5a, 0xf7, 0x20, 0x04, 0x04, 0xea, 0xd7, 0xc3, 0xba, 0x6a, 0x4c, 0x9e, 0x0d, 0x96, 0x41}
binaryIDGlMapBufferRange = binary.ID{0xc0, 0x75, 0x4f, 0x53, 0xa9, 0x4a, 0x24, 0x26, 0x84, 0x2f, 0xfb, 0xf0, 0x64, 0xd3, 0xae, 0xb9, 0x5b, 0xe4, 0xc7, 0xd5}
binaryIDGlPixelStorei = binary.ID{0xdd, 0x40, 0xad, 0x0f, 0xff, 0xb4, 0xf6, 0x1b, 0xef, 0xcf, 0xc3, 0x98, 0x37, 0xed, 0x0f, 0x55, 0x4b, 0x8b, 0x1d, 0x0d}
binaryIDGlPolygonOffset = binary.ID{0xb8, 0xb4, 0x99, 0x5e, 0x5c, 0x92, 0xdf, 0xc5, 0xce, 0xbc, 0x85, 0xd0, 0xad, 0x3e, 0xba, 0x10, 0x0b, 0x50, 0x20, 0x23}
binaryIDGlPopGroupMarkerEXT = binary.ID{0x63, 0xb8, 0xb9, 0x5e, 0x5d, 0xf9, 0x13, 0xbb, 0xc7, 0xce, 0x02, 0x0f, 0xc7, 0x14, 0x03, 0x22, 0xe5, 0x70, 0x9f, 0x87}
binaryIDGlProgramBinaryOES = binary.ID{0xc6, 0x5f, 0x91, 0x9e, 0x1e, 0xfe, 0x8c, 0xfb, 0xdd, 0x3c, 0x9b, 0x02, 0xc6, 0x13, 0xab, 0x58, 0x36, 0xa0, 0xe3, 0x30}
binaryIDGlPushGroupMarkerEXT = binary.ID{0x02, 0x2e, 0x06, 0x0f, 0xcb, 0x78, 0xe3, 0x76, 0x55, 0x1d, 0x6b, 0x9f, 0x57, 0xd2, 0x40, 0x46, 0x1a, 0x0a, 0x70, 0x02}
binaryIDGlQueryCounterEXT = binary.ID{0x24, 0xfc, 0x89, 0xbe, 0x08, 0x35, 0xd1, 0xd7, 0x0f, 0xc7, 0xe4, 0x39, 0x79, 0xb1, 0x22, 0x49, 0x57, 0x58, 0x6e, 0x2b}
binaryIDGlReadPixels = binary.ID{0xbe, 0x23, 0x91, 0x78, 0x3a, 0xe3, 0xb5, 0x9c, 0xe3, 0x88, 0x3a, 0x59, 0xe5, 0x90, 0x43, 0xb3, 0x79, 0x6b, 0xc3, 0x86}
binaryIDGlReleaseShaderCompiler = binary.ID{0x75, 0x57, 0x32, 0x6e, 0x7b, 0x73, 0x9d, 0x61, 0x34, 0xf4, 0xfe, 0x45, 0xb6, 0xb2, 0x1d, 0x6e, 0xd0, 0xab, 0xbb, 0x78}
binaryIDGlRenderbufferStorage = binary.ID{0xb6, 0x7f, 0xe4, 0x65, 0x99, 0x3d, 0xe3, 0x4d, 0x4a, 0x0b, 0x1e, 0x5e, 0x14, 0x7c, 0xb4, 0x0e, 0x0b, 0xa7, 0x49, 0x22}
binaryIDGlRenderbufferStorageMultisample = binary.ID{0x77, 0x47, 0x04, 0xde, 0x5b, 0x64, 0x6b, 0x24, 0x7e, 0x3e, 0x58, 0x82, 0xdf, 0x38, 0x3e, 0xb8, 0xf2, 0x27, 0x15, 0x79}
binaryIDGlSampleCoverage = binary.ID{0xdb, 0x2a, 0x80, 0xc6, 0x8a, 0x74, 0x81, 0x89, 0x6f, 0x52, 0x38, 0xf2, 0x8a, 0x46, 0x7b, 0xf1, 0x67, 0xe3, 0x07, 0x42}
binaryIDGlScissor = binary.ID{0xa5, 0x41, 0xe6, 0x77, 0xf6, 0x30, 0x6c, 0xdc, 0x47, 0x80, 0x42, 0x8d, 0xb6, 0x13, 0x10, 0x30, 0x25, 0xfc, 0xb6, 0xca}
binaryIDGlShaderBinary = binary.ID{0x86, 0xb4, 0x9f, 0x81, 0x21, 0x9f, 0x2f, 0xdf, 0xf5, 0x5c, 0x14, 0x20, 0xac, 0x1b, 0x9d, 0xf1, 0xcb, 0x28, 0x62, 0x43}
binaryIDGlShaderSource = binary.ID{0x07, 0x7d, 0xaf, 0xb9, 0xc9, 0xac, 0x7e, 0xab, 0xc5, 0x97, 0xf6, 0x8e, 0xcc, 0xda, 0x9d, 0x10, 0x1e, 0x4e, 0x81, 0x4b}
binaryIDGlStartTilingQCOM = binary.ID{0x87, 0x76, 0x34, 0xf8, 0x30, 0x7e, 0xb3, 0x9e, 0x0f, 0xed, 0x9e, 0xa4, 0xe4, 0x73, 0x88, 0xbc, 0xa4, 0xed, 0x69, 0x7e}
binaryIDGlStencilFuncSeparate = binary.ID{0x83, 0x37, 0xed, 0xe5, 0xee, 0x51, 0x7b, 0x34, 0x8c, 0xbc, 0x87, 0x0e, 0xa5, 0x6b, 0xfd, 0xfd, 0x06, 0x35, 0x65, 0xfa}
binaryIDGlStencilMask = binary.ID{0x73, 0x1d, 0xc0, 0x01, 0xcf, 0xbe, 0x91, 0x96, 0x36, 0xf2, 0x73, 0xa4, 0xb4, 0x9d, 0xd7, 0xf3, 0x5e, 0xd8, 0x74, 0x37}
binaryIDGlStencilMaskSeparate = binary.ID{0xb7, 0xe8, 0x35, 0x90, 0xf1, 0x79, 0xd9, 0x29, 0xbe, 0xab, 0xf1, 0x2d, 0x31, 0x2e, 0xb8, 0xa4, 0x67, 0x91, 0xa8, 0x0c}
binaryIDGlStencilOpSeparate = binary.ID{0x9d, 0xe2, 0xc4, 0xb4, 0x72, 0x55, 0x3d, 0x06, 0xcd, 0xe7, 0x6d, 0x3c, 0xbc, 0xa6, 0x5b, 0xc1, 0xff, 0x09, 0xec, 0x00}
binaryIDGlTexImage2D = binary.ID{0x75, 0x47, 0xbd, 0xaa, 0x7a, 0xe5, 0xc5, 0x97, 0x9f, 0xe3, 0x56, 0xd0, 0xdc, 0x77, 0xa2, 0x3a, 0xb1, 0xfa, 0x3d, 0x18}
binaryIDGlTexParameterf = binary.ID{0x71, 0x53, 0x54, 0x52, 0xd4, 0xc1, 0x72, 0x77, 0x6e, 0xaa, 0xb4, 0x93, 0xea, 0xb2, 0x95, 0xf2, 0x01, 0xbe, 0xae, 0x06}
binaryIDGlTexParameteri = binary.ID{0xd9, 0xec, 0x83, 0xf4, 0x8a, 0xf8, 0x43, 0xc3, 0xde, 0x41, 0xee, 0xfb, 0x9a, 0x3d, 0xaf, 0xfc, 0xb1, 0xd4, 0xe5, 0xbe}
binaryIDGlTexStorage1DEXT = binary.ID{0x82, 0xe5, 0xba, 0x13, 0x88, 0xf4, 0xc5, 0xdf, 0x67, 0xb6, 0x1f, 0x1c, 0xab, 0x00, 0x8c, 0x18, 0x03, 0x2d, 0x9c, 0x94}
binaryIDGlTexStorage2DEXT = binary.ID{0x22, 0x01, 0xae, 0xf0, 0xdf, 0xef, 0xe7, 0xc1, 0xb8, 0xf9, 0x1a, 0xf1, 0x20, 0xff, 0xbf, 0x8f, 0x28, 0x40, 0x8d, 0xc6}
binaryIDGlTexStorage3DEXT = binary.ID{0x8f, 0xe9, 0x78, 0x84, 0x96, 0x0a, 0x60, 0xdf, 0xf8, 0x7a, 0xc4, 0xe8, 0xf7, 0x93, 0x27, 0xfd, 0x65, 0xed, 0xde, 0xaa}
binaryIDGlTexSubImage2D = binary.ID{0x8e, 0xb2, 0x9e, 0x94, 0xf9, 0xe8, 0xd4, 0xa9, 0x27, 0xf1, 0xe4, 0xa9, 0xa1, 0x25, 0x5a, 0x2b, 0xf8, 0x8a, 0x61, 0x2b}
binaryIDGlTextureStorage1DEXT = binary.ID{0x0a, 0x69, 0xa0, 0xa4, 0xc1, 0xa6, 0x81, 0xd8, 0x94, 0xe3, 0x54, 0xe1, 0xa1, 0xa7, 0x53, 0xc0, 0x6a, 0x55, 0x7e, 0xfb}
binaryIDGlTextureStorage2DEXT = binary.ID{0xaa, 0x63, 0x10, 0x72, 0xaf, 0x48, 0x52, 0xce, 0x02, 0x08, 0x02, 0xac, 0xf5, 0xf9, 0xb8, 0x03, 0x87, 0x02, 0xcc, 0x3a}
binaryIDGlTextureStorage3DEXT = binary.ID{0xc3, 0x4b, 0xb7, 0x25, 0xcd, 0x73, 0x0d, 0x77, 0x57, 0x84, 0xb6, 0xc0, 0x9c, 0x0f, 0x3e, 0xaf, 0x93, 0xd7, 0xc0, 0xe6}
binaryIDGlUniform1f = binary.ID{0xdc, 0x09, 0x5b, 0x59, 0xd2, 0xff, 0x8d, 0xd9, 0xab, 0xf7, 0x80, 0xbb, 0xc4, 0x33, 0xf6, 0x28, 0xf3, 0x93, 0x52, 0x4e}
binaryIDGlUniform1fv = binary.ID{0x6c, 0x24, 0x91, 0x06, 0x3a, 0x75, 0x28, 0xf4, 0xef, 0x98, 0xed, 0xf2, 0x17, 0x37, 0x85, 0xa4, 0xcc, 0x91, 0x2a, 0xc7}
binaryIDGlUniform1i = binary.ID{0xdc, 0xc5, 0xf9, 0x9f, 0xe8, 0xdf, 0x34, 0x63, 0x92, 0x71, 0x0c, 0xc1, 0xb5, 0xa9, 0xed, 0xa0, 0xfb, 0x74, 0x32, 0xd9}
binaryIDGlUniform1iv = binary.ID{0xa4, 0x66, 0xca, 0x9b, 0x82, 0xb9, 0x81, 0x2f, 0xe3, 0x70, 0xa5, 0xf4, 0x7b, 0x3b, 0xc4, 0x40, 0x12, 0xd2, 0x75, 0xba}
binaryIDGlUniform2f = binary.ID{0xfe, 0xb0, 0x7e, 0x45, 0x14, 0x3c, 0xc4, 0xd6, 0x30, 0x6e, 0xae, 0x61, 0x65, 0x50, 0x23, 0x75, 0xa8, 0x21, 0x3e, 0x79}
binaryIDGlUniform2fv = binary.ID{0xe5, 0x71, 0x7a, 0x00, 0x7e, 0xcc, 0x57, 0x43, 0xc2, 0x55, 0x11, 0x21, 0x30, 0xeb, 0x7b, 0x53, 0xeb, 0x16, 0x19, 0xd6}
binaryIDGlUniform2i = binary.ID{0x4c, 0x11, 0x73, 0xaa, 0xef, 0x59, 0xde, 0x41, 0x09, 0x12, 0xd7, 0x30, 0x31, 0x24, 0x6f, 0x29, 0x57, 0x6f, 0x90, 0x65}
binaryIDGlUniform2iv = binary.ID{0x73, 0xaa, 0xfe, 0x04, 0x12, 0x5c, 0xa9, 0x23, 0x5a, 0x84, 0x12, 0x0c, 0x33, 0xdd, 0x7c, 0xe8, 0x34, 0x0e, 0xbe, 0xb8}
binaryIDGlUniform3f = binary.ID{0x15, 0xd9, 0x47, 0x62, 0x1f, 0xf4, 0x8a, 0x57, 0x8d, 0x50, 0x0d, 0xc7, 0x32, 0xda, 0x19, 0x25, 0xe9, 0x27, 0xca, 0x7b}
binaryIDGlUniform3fv = binary.ID{0xf5, 0x0d, 0x86, 0x4d, 0xe7, 0x26, 0x8b, 0xb8, 0xc3, 0xcc, 0x16, 0x99, 0xbd, 0x43, 0x2c, 0x3d, 0x1a, 0x3b, 0xfa, 0x4a}
binaryIDGlUniform3i = binary.ID{0xd2, 0x99, 0x76, 0x0a, 0x2c, 0xb1, 0x75, 0xac, 0x1b, 0xd1, 0x5d, 0xa4, 0x56, 0x1b, 0x90, 0xce, 0x23, 0xf1, 0x4f, 0x65}
binaryIDGlUniform3iv = binary.ID{0x09, 0x38, 0xc6, 0xb0, 0x6a, 0x6a, 0xd1, 0xa2, 0x4f, 0xf5, 0x5c, 0x81, 0xab, 0xf1, 0xc6, 0x75, 0xe9, 0x70, 0x23, 0xa9}
binaryIDGlUniform4f = binary.ID{0x07, 0x94, 0x2a, 0xa5, 0x8e, 0xd5, 0x4b, 0x3f, 0x2b, 0xe3, 0x52, 0xb1, 0x7c, 0x18, 0x9e, 0x23, 0xb1, 0xdb, 0x6f, 0x84}
binaryIDGlUniform4fv = binary.ID{0x99, 0x5e, 0x7c, 0xb3, 0xe9, 0xc3, 0x3b, 0x80, 0x13, 0x0a, 0xb9, 0x71, 0x56, 0x25, 0x5c, 0x5f, 0xac, 0x3a, 0xbf, 0x26}
binaryIDGlUniform4i = binary.ID{0xe2, 0x70, 0x4f, 0xe8, 0xf2, 0xdd, 0xbc, 0xba, 0x90, 0xde, 0x98, 0x18, 0x14, 0x07, 0x29, 0x53, 0xad, 0x3e, 0x18, 0x74}
binaryIDGlUniform4iv = binary.ID{0x7a, 0x46, 0x92, 0x39, 0x56, 0x96, 0x2c, 0x53, 0x0f, 0x88, 0xa5, 0x8f, 0x95, 0xbf, 0xc5, 0x5b, 0xb4, 0xfe, 0xee, 0x2f}
binaryIDGlUniformMatrix2fv = binary.ID{0x92, 0x32, 0x5c, 0x87, 0x66, 0x8a, 0x8e, 0x3e, 0xc5, 0x07, 0x28, 0xbf, 0x42, 0x3c, 0x6a, 0x29, 0x30, 0x8f, 0x6d, 0x1f}
binaryIDGlUniformMatrix3fv = binary.ID{0xfb, 0x5f, 0x49, 0x7f, 0xef, 0x17, 0xfd, 0x81, 0xea, 0x06, 0x70, 0x21, 0x6d, 0xcc, 0x87, 0x33, 0x58, 0xf7, 0x95, 0x94}
binaryIDGlUniformMatrix4fv = binary.ID{0x52, 0x0f, 0x12, 0x1c, 0xe8, 0x4b, 0x78, 0xfd, 0xd9, 0x60, 0x03, 0x9b, 0xb8, 0x66, 0x8e, 0x83, 0x74, 0x7f, 0x9d, 0xae}
binaryIDGlUnmapBuffer = binary.ID{0xb8, 0x33, 0x76, 0xd5, 0x25, 0x8b, 0xf1, 0x9a, 0x95, 0x99, 0x11, 0x51, 0x68, 0x3f, 0x38, 0xaa, 0x42, 0x88, 0x74, 0xd9}
binaryIDGlUseProgram = binary.ID{0x4b, 0x8d, 0xa5, 0x92, 0x0f, 0xae, 0x78, 0xf9, 0xa4, 0xae, 0x29, 0x3c, 0xa1, 0x5b, 0x2c, 0xe4, 0xe2, 0xf6, 0x0b, 0x9b}
binaryIDGlValidateProgram = binary.ID{0x51, 0xe9, 0x87, 0x35, 0x9c, 0x27, 0xef, 0x70, 0xbf, 0xce, 0x08, 0x9c, 0xe0, 0xa7, 0x47, 0xac, 0xab, 0xe5, 0xed, 0xd5}
binaryIDGlVertexAttrib1f = binary.ID{0x7e, 0xf1, 0xf8, 0x90, 0x37, 0x0b, 0x9b, 0xd8, 0x33, 0xb5, 0x36, 0x74, 0x76, 0x55, 0xd1, 0xef, 0x24, 0xe8, 0x95, 0xa7}
binaryIDGlVertexAttrib1fv = binary.ID{0x84, 0xd2, 0x43, 0x86, 0x82, 0x14, 0x9f, 0xe9, 0x5a, 0xa6, 0xa8, 0x55, 0x84, 0xb4, 0xde, 0x41, 0xcc, 0xbc, 0x4a, 0xa2}
binaryIDGlVertexAttrib2f = binary.ID{0x75, 0xa4, 0x82, 0xbe, 0xe7, 0x8c, 0xce, 0xe5, 0xe7, 0x0c, 0xc8, 0x23, 0xf3, 0xbf, 0xd5, 0xf9, 0x67, 0x99, 0x3c, 0x77}
binaryIDGlVertexAttrib2fv = binary.ID{0xcf, 0xa0, 0xde, 0x2f, 0x88, 0xf3, 0xad, 0xa8, 0x05, 0xd9, 0x1a, 0x0d, 0xc6, 0x72, 0xc8, 0xb0, 0xfe, 0x36, 0xb2, 0x69}
binaryIDGlVertexAttrib3f = binary.ID{0x32, 0x55, 0xd8, 0x5b, 0x39, 0xba, 0x65, 0xb7, 0x45, 0x9d, 0xa9, 0x8a, 0x4c, 0x0c, 0x4f, 0x51, 0xa6, 0xd8, 0x0c, 0xbc}
binaryIDGlVertexAttrib3fv = binary.ID{0x75, 0x81, 0x16, 0xb1, 0xbb, 0x41, 0x12, 0x99, 0x23, 0x1b, 0x74, 0x5c, 0x74, 0xf7, 0x9d, 0xc7, 0x59, 0x7e, 0x58, 0x1a}
binaryIDGlVertexAttrib4f = binary.ID{0x26, 0x2d, 0x3c, 0xc8, 0x49, 0x62, 0xf6, 0x27, 0x48, 0xe9, 0x61, 0x1d, 0xcd, 0x09, 0xbd, 0x81, 0x3a, 0xdf, 0x39, 0x76}
binaryIDGlVertexAttrib4fv = binary.ID{0xef, 0xb2, 0x40, 0xe1, 0xb9, 0xd1, 0x42, 0x98, 0x84, 0x6f, 0xa0, 0xeb, 0x0f, 0x22, 0x31, 0x6c, 0x79, 0xb5, 0x22, 0xc9}
binaryIDGlVertexAttribPointer = binary.ID{0x9d, 0xd0, 0xda, 0x47, 0xd9, 0x9e, 0x24, 0x1d, 0x75, 0x48, 0x0f, 0x8d, 0x27, 0x76, 0x63, 0x2d, 0x79, 0x41, 0xb8, 0xca}
binaryIDGlViewport = binary.ID{0x96, 0x41, 0xef, 0xd3, 0x17, 0x6b, 0x50, 0x3c, 0xeb, 0x46, 0x86, 0x49, 0x1c, 0x1b, 0xec, 0x65, 0xe1, 0xe0, 0xa7, 0xcb}
binaryIDGlXCreateContext = binary.ID{0x69, 0xd6, 0x87, 0x67, 0x9c, 0x50, 0x4f, 0xe6, 0x49, 0x6b, 0x1a, 0x51, 0x2f, 0xd7, 0x22, 0x72, 0x8e, 0x01, 0xda, 0x6e}
binaryIDGlXCreateNewContext = binary.ID{0x84, 0x7e, 0x5e, 0x97, 0x8c, 0x27, 0x99, 0x7b, 0x5e, 0xd5, 0x5f, 0xc8, 0xd5, 0xc1, 0x5e, 0x0c, 0x90, 0x64, 0xf7, 0x43}
binaryIDGlXMakeContextCurrent = binary.ID{0x78, 0x1c, 0x13, 0x6d, 0x45, 0x65, 0x07, 0xf2, 0x7d, 0xa0, 0x15, 0xa1, 0x59, 0x22, 0x6d, 0xbe, 0xbd, 0x15, 0xb8, 0x90}
binaryIDGlXSwapBuffers = binary.ID{0x6f, 0x6a, 0xec, 0x59, 0x43, 0x85, 0x4a, 0xf5, 0x61, 0xc7, 0xb1, 0x28, 0x6c, 0x34, 0xa5, 0xb8, 0xbd, 0x25, 0x12, 0xc2}
binaryIDHGLRC = binary.ID{0x95, 0xfc, 0xcf, 0x7f, 0x79, 0x35, 0x44, 0x38, 0xd4, 0x4f, 0x6d, 0xad, 0xae, 0xcd, 0xf0, 0xa5, 0x4d, 0x49, 0x48, 0xc7}
binaryIDGlobals = binary.ID{0x6b, 0xd7, 0xb2, 0xf9, 0x46, 0xfa, 0xb5, 0xa7, 0x8e, 0x26, 0xe5, 0x72, 0xe7, 0x8f, 0x33, 0x91, 0xb4, 0xb9, 0x49, 0x0c}
binaryIDHDC = binary.ID{0x77, 0x14, 0x36, 0x4d, 0x67, 0xdb, 0x2d, 0xd0, 0xcc, 0x8e, 0x01, 0x72, 0xfa, 0x85, 0x42, 0x9c, 0x04, 0x31, 0x53, 0xcc}
binaryIDIntˢ = binary.ID{0xef, 0x04, 0x53, 0x99, 0xc8, 0x30, 0x5d, 0x73, 0xa3, 0x8e, 0xa4, 0x73, 0xdc, 0x4d, 0x29, 0x31, 0x52, 0x04, 0x83, 0x2a}
binaryIDIntᵖ = binary.ID{0x90, 0xa6, 0xad, 0x4c, 0xf7, 0x0c, 0x42, 0xb6, 0xb7, 0x7f, 0xa8, 0xf0, 0xf6, 0xf9, 0xa4, 0x22, 0xd0, 0x36, 0x92, 0x46}
binaryIDQueryIdˢ = binary.ID{0xbf, 0x4b, 0xf7, 0x28, 0xcd, 0x2c, 0xea, 0x7a, 0xa3, 0x91, 0xa4, 0x2e, 0xa1, 0x6d, 0x0e, 0x39, 0x8c, 0x8b, 0x87, 0x70}
binaryIDRenderbufferIdˢ = binary.ID{0x80, 0xaa, 0x20, 0xce, 0x31, 0x49, 0xb2, 0x53, 0x4b, 0x75, 0x77, 0xa5, 0x80, 0x4b, 0x7a, 0x89, 0x19, 0xf1, 0xe0, 0xdf}
binaryIDReplayBindRenderer = binary.ID{0xdb, 0xb2, 0x76, 0x5b, 0xa5, 0x3d, 0xb0, 0xef, 0x04, 0x2a, 0x03, 0xf1, 0x57, 0x07, 0x5a, 0x92, 0x20, 0xa9, 0x0a, 0x8a}
binaryIDReplayCreateRenderer = binary.ID{0xd5, 0x5d, 0xca, 0x28, 0xdc, 0x88, 0xac, 0x79, 0x3a, 0x31, 0xd4, 0xe3, 0x68, 0x68, 0xb9, 0x7a, 0xac, 0x48, 0x7e, 0x52}
binaryIDS32ˢ = binary.ID{0xc5, 0xc7, 0x25, 0x85, 0xea, 0xb4, 0x11, 0x92, 0x58, 0x43, 0x47, 0xab, 0x19, 0xaa, 0x6e, 0xf4, 0x9b, 0x9c, 0x28, 0x5f}
binaryIDS64ˢ = binary.ID{0x05, 0x83, 0x2e, 0xcd, 0x87, 0x87, 0xe8, 0x61, 0x58, 0xf3, 0x93, 0x39, 0xcd, 0xfb, 0x4f, 0xc3, 0xa9, 0xcb, 0xb0, 0x25}
binaryIDShaderAttribTypeˢ = binary.ID{0x49, 0x5c, 0x8a, 0x45, 0x57, 0x49, 0x11, 0x26, 0xe8, 0x13, 0xa3, 0x03, 0xa9, 0xea, 0xc6, 0x93, 0x5a, 0x50, 0x57, 0xf0}
binaryIDShaderIdˢ = binary.ID{0xb8, 0xc6, 0x02, 0x67, 0xe5, 0x56, 0x31, 0x1d, 0x4e, 0x91, 0x3e, 0x62, 0x71, 0x66, 0x96, 0x5c, 0x3a, 0xd9, 0x45, 0x17}
binaryIDShaderUniformTypeˢ = binary.ID{0x28, 0xa8, 0x7d, 0x72, 0x60, 0xb9, 0xc2, 0xbb, 0x57, 0xcb, 0x18, 0x75, 0x20, 0xdf, 0x05, 0x4e, 0x06, 0x46, 0x75, 0x69}
binaryIDStartTimer = binary.ID{0x23, 0x7b, 0x88, 0x65, 0x96, 0xf3, 0x0d, 0x5d, 0x50, 0x56, 0xad, 0x18, 0xc8, 0x0a, 0xe8, 0x57, 0xa0, 0x21, 0x1c, 0x9b}
binaryIDStopTimer = binary.ID{0xe8, 0x9f, 0x7c, 0xb1, 0xa4, 0xf8, 0x37, 0x81, 0x6b, 0x01, 0x71, 0x0e, 0xbc, 0xf2, 0x92, 0xd2, 0x39, 0x2e, 0xca, 0x5f}
binaryIDTextureIdˢ = binary.ID{0x7c, 0x74, 0x2d, 0x21, 0x88, 0x88, 0xbd, 0x80, 0x99, 0xd2, 0x8a, 0x4c, 0x47, 0x2a, 0x0c, 0xed, 0xa5, 0x43, 0x6f, 0x60}
binaryIDU32ˢ = binary.ID{0x47, 0x8d, 0xb4, 0x2f, 0x7e, 0xde, 0x24, 0x93, 0x35, 0xb1, 0xfd, 0xda, 0x67, 0x36, 0xc5, 0x33, 0xcb, 0x3a, 0xbd, 0x6c}
binaryIDU64ˢ = binary.ID{0x03, 0x30, 0x8e, 0xf7, 0x85, 0xac, 0x98, 0x5d, 0x6d, 0xcc, 0xee, 0x49, 0x76, 0x98, 0xdb, 0xbf, 0x9d, 0xd7, 0xed, 0x45}
binaryIDU8ᵖ = binary.ID{0xf6, 0x6e, 0x22, 0xf8, 0x33, 0x69, 0x05, 0xe9, 0x8b, 0xdf, 0xfa, 0x53, 0x75, 0xae, 0x80, 0xcc, 0x2c, 0x27, 0x98, 0x17}
binaryIDVertexArrayIdˢ = binary.ID{0x0c, 0x8b, 0x70, 0x73, 0x00, 0xb5, 0x36, 0x14, 0x66, 0x06, 0x94, 0xa5, 0x4e, 0xaa, 0x01, 0xaf, 0x98, 0x36, 0xd3, 0x12}
binaryIDVoidˢ = binary.ID{0x95, 0x61, 0x52, 0x69, 0x11, 0x55, 0xc2, 0xab, 0x85, 0x8f, 0xce, 0x86, 0x29, 0xd6, 0xbc, 0x17, 0xc5, 0x7a, 0xfe, 0xc6}
binaryIDWglCreateContext = binary.ID{0x8e, 0xe0, 0x9b, 0x8b, 0x3d, 0x3c, 0xc7, 0x22, 0x61, 0xb4, 0xee, 0xa9, 0x75, 0x75, 0xd6, 0x53, 0x0d, 0x31, 0x15, 0xcc}
binaryIDWglCreateContextAttribsARB = binary.ID{0x28, 0x15, 0x85, 0xa3, 0xab, 0x16, 0x84, 0xed, 0xe0, 0xe6, 0xec, 0x92, 0xe8, 0x14, 0x8e, 0xbe, 0x5f, 0x32, 0x72, 0x42}
binaryIDWglMakeCurrent = binary.ID{0x86, 0xd3, 0x02, 0xb5, 0xf6, 0x1b, 0x7f, 0x3e, 0xb1, 0x23, 0x36, 0x2b, 0x9d, 0xa2, 0x13, 0xa6, 0xf6, 0xbc, 0xb3, 0x8a}
binaryIDWglSwapBuffers = binary.ID{0xa1, 0x23, 0xcd, 0xfc, 0xb1, 0x9b, 0xcf, 0x24, 0x77, 0xab, 0x3b, 0xb0, 0x75, 0x58, 0x9b, 0x35, 0x54, 0x11, 0x3f, 0xc8}
)
type binaryClassBackbufferInfo struct{}
func (*BackbufferInfo) Class() binary.Class {
return (*binaryClassBackbufferInfo)(nil)
}
func doEncodeBackbufferInfo(e binary.Encoder, o *BackbufferInfo) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
if err := e.Uint32(uint32(o.ColorFmt)); err != nil {
return err
}
if err := e.Uint32(uint32(o.DepthFmt)); err != nil {
return err
}
if err := e.Uint32(uint32(o.StencilFmt)); err != nil {
return err
}
if err := e.Bool(o.ResetViewportScissor); err != nil {
return err
}
return nil
}
func doDecodeBackbufferInfo(d binary.Decoder, o *BackbufferInfo) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.ColorFmt = RenderbufferFormat(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.DepthFmt = RenderbufferFormat(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.StencilFmt = RenderbufferFormat(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.ResetViewportScissor = bool(obj)
}
return nil
}
func doSkipBackbufferInfo(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassBackbufferInfo) ID() binary.ID { return binaryIDBackbufferInfo }
func (*binaryClassBackbufferInfo) New() binary.Object { return &BackbufferInfo{} }
func (*binaryClassBackbufferInfo) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeBackbufferInfo(e, obj.(*BackbufferInfo))
}
func (*binaryClassBackbufferInfo) Decode(d binary.Decoder) (binary.Object, error) {
obj := &BackbufferInfo{}
return obj, doDecodeBackbufferInfo(d, obj)
}
func (*binaryClassBackbufferInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeBackbufferInfo(d, obj.(*BackbufferInfo))
}
func (*binaryClassBackbufferInfo) Skip(d binary.Decoder) error { return doSkipBackbufferInfo(d) }
func (*binaryClassBackbufferInfo) Schema() *schema.Class { return schemaBackbufferInfo }
var schemaBackbufferInfo = &schema.Class{
TypeID: binaryIDBackbufferInfo,
Name: "BackbufferInfo",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "ColorFmt", Type: &schema.Primitive{Name: "RenderbufferFormat", Method: schema.Uint32}},
schema.Field{Declared: "DepthFmt", Type: &schema.Primitive{Name: "RenderbufferFormat", Method: schema.Uint32}},
schema.Field{Declared: "StencilFmt", Type: &schema.Primitive{Name: "RenderbufferFormat", Method: schema.Uint32}},
schema.Field{Declared: "ResetViewportScissor", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassColor struct{}
func (*Color) Class() binary.Class {
return (*binaryClassColor)(nil)
}
func doEncodeColor(e binary.Encoder, o *Color) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Float32(o.Red); err != nil {
return err
}
if err := e.Float32(o.Green); err != nil {
return err
}
if err := e.Float32(o.Blue); err != nil {
return err
}
if err := e.Float32(o.Alpha); err != nil {
return err
}
return nil
}
func doDecodeColor(d binary.Decoder, o *Color) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Red = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Green = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Blue = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Alpha = float32(obj)
}
return nil
}
func doSkipColor(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassColor) ID() binary.ID { return binaryIDColor }
func (*binaryClassColor) New() binary.Object { return &Color{} }
func (*binaryClassColor) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeColor(e, obj.(*Color))
}
func (*binaryClassColor) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Color{}
return obj, doDecodeColor(d, obj)
}
func (*binaryClassColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeColor(d, obj.(*Color))
}
func (*binaryClassColor) Skip(d binary.Decoder) error { return doSkipColor(d) }
func (*binaryClassColor) Schema() *schema.Class { return schemaColor }
var schemaColor = &schema.Class{
TypeID: binaryIDColor,
Name: "Color",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Red", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Green", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Blue", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Alpha", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassBlendState struct{}
func (*BlendState) Class() binary.Class {
return (*binaryClassBlendState)(nil)
}
func doEncodeBlendState(e binary.Encoder, o *BlendState) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Uint32(uint32(o.SrcRgbBlendFactor)); err != nil {
return err
}
if err := e.Uint32(uint32(o.SrcAlphaBlendFactor)); err != nil {
return err
}
if err := e.Uint32(uint32(o.DstRgbBlendFactor)); err != nil {
return err
}
if err := e.Uint32(uint32(o.DstAlphaBlendFactor)); err != nil {
return err
}
if err := e.Uint32(uint32(o.BlendEquationRgb)); err != nil {
return err
}
if err := e.Uint32(uint32(o.BlendEquationAlpha)); err != nil {
return err
}
if err := e.Value(&o.BlendColor); err != nil {
return err
}
return nil
}
func doDecodeBlendState(d binary.Decoder, o *BlendState) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.SrcRgbBlendFactor = BlendFactor(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.SrcAlphaBlendFactor = BlendFactor(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.DstRgbBlendFactor = BlendFactor(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.DstAlphaBlendFactor = BlendFactor(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.BlendEquationRgb = BlendEquation(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.BlendEquationAlpha = BlendEquation(obj)
}
if err := d.Value(&o.BlendColor); err != nil {
return err
}
return nil
}
func doSkipBlendState(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*Color)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassBlendState) ID() binary.ID { return binaryIDBlendState }
func (*binaryClassBlendState) New() binary.Object { return &BlendState{} }
func (*binaryClassBlendState) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeBlendState(e, obj.(*BlendState))
}
func (*binaryClassBlendState) Decode(d binary.Decoder) (binary.Object, error) {
obj := &BlendState{}
return obj, doDecodeBlendState(d, obj)
}
func (*binaryClassBlendState) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeBlendState(d, obj.(*BlendState))
}
func (*binaryClassBlendState) Skip(d binary.Decoder) error { return doSkipBlendState(d) }
func (*binaryClassBlendState) Schema() *schema.Class { return schemaBlendState }
var schemaBlendState = &schema.Class{
TypeID: binaryIDBlendState,
Name: "BlendState",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "SrcRgbBlendFactor", Type: &schema.Primitive{Name: "BlendFactor", Method: schema.Uint32}},
schema.Field{Declared: "SrcAlphaBlendFactor", Type: &schema.Primitive{Name: "BlendFactor", Method: schema.Uint32}},
schema.Field{Declared: "DstRgbBlendFactor", Type: &schema.Primitive{Name: "BlendFactor", Method: schema.Uint32}},
schema.Field{Declared: "DstAlphaBlendFactor", Type: &schema.Primitive{Name: "BlendFactor", Method: schema.Uint32}},
schema.Field{Declared: "BlendEquationRgb", Type: &schema.Primitive{Name: "BlendEquation", Method: schema.Uint32}},
schema.Field{Declared: "BlendEquationAlpha", Type: &schema.Primitive{Name: "BlendEquation", Method: schema.Uint32}},
schema.Field{Declared: "BlendColor", Type: &schema.Struct{Name: "Color"}},
},
}
type binaryClassBoolˢ struct{}
func (*Boolˢ) Class() binary.Class {
return (*binaryClassBoolˢ)(nil)
}
func doEncodeBoolˢ(e binary.Encoder, o *Boolˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeBoolˢ(d binary.Decoder, o *Boolˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipBoolˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassBoolˢ) ID() binary.ID { return binaryIDBoolˢ }
func (*binaryClassBoolˢ) New() binary.Object { return &Boolˢ{} }
func (*binaryClassBoolˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeBoolˢ(e, obj.(*Boolˢ))
}
func (*binaryClassBoolˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Boolˢ{}
return obj, doDecodeBoolˢ(d, obj)
}
func (*binaryClassBoolˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeBoolˢ(d, obj.(*Boolˢ))
}
func (*binaryClassBoolˢ) Skip(d binary.Decoder) error { return doSkipBoolˢ(d) }
func (*binaryClassBoolˢ) Schema() *schema.Class { return schemaBoolˢ }
var schemaBoolˢ = &schema.Class{
TypeID: binaryIDBoolˢ,
Name: "Boolˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassBoolᵖ struct{}
func (*Boolᵖ) Class() binary.Class {
return (*binaryClassBoolᵖ)(nil)
}
func doEncodeBoolᵖ(e binary.Encoder, o *Boolᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeBoolᵖ(d binary.Decoder, o *Boolᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipBoolᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassBoolᵖ) ID() binary.ID { return binaryIDBoolᵖ }
func (*binaryClassBoolᵖ) New() binary.Object { return &Boolᵖ{} }
func (*binaryClassBoolᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeBoolᵖ(e, obj.(*Boolᵖ))
}
func (*binaryClassBoolᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Boolᵖ{}
return obj, doDecodeBoolᵖ(d, obj)
}
func (*binaryClassBoolᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeBoolᵖ(d, obj.(*Boolᵖ))
}
func (*binaryClassBoolᵖ) Skip(d binary.Decoder) error { return doSkipBoolᵖ(d) }
func (*binaryClassBoolᵖ) Schema() *schema.Class { return schemaBoolᵖ }
var schemaBoolᵖ = &schema.Class{
TypeID: binaryIDBoolᵖ,
Name: "Boolᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassU8ˢ struct{}
func (*U8ˢ) Class() binary.Class {
return (*binaryClassU8ˢ)(nil)
}
func doEncodeU8ˢ(e binary.Encoder, o *U8ˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeU8ˢ(d binary.Decoder, o *U8ˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipU8ˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassU8ˢ) ID() binary.ID { return binaryIDU8ˢ }
func (*binaryClassU8ˢ) New() binary.Object { return &U8ˢ{} }
func (*binaryClassU8ˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeU8ˢ(e, obj.(*U8ˢ))
}
func (*binaryClassU8ˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &U8ˢ{}
return obj, doDecodeU8ˢ(d, obj)
}
func (*binaryClassU8ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeU8ˢ(d, obj.(*U8ˢ))
}
func (*binaryClassU8ˢ) Skip(d binary.Decoder) error { return doSkipU8ˢ(d) }
func (*binaryClassU8ˢ) Schema() *schema.Class { return schemaU8ˢ }
var schemaU8ˢ = &schema.Class{
TypeID: binaryIDU8ˢ,
Name: "U8ˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassBuffer struct{}
func (*Buffer) Class() binary.Class {
return (*binaryClassBuffer)(nil)
}
func doEncodeBuffer(e binary.Encoder, o *Buffer) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Value(&o.Data); err != nil {
return err
}
if err := e.Int32(o.Size); err != nil {
return err
}
if err := e.Uint32(uint32(o.Usage)); err != nil {
return err
}
return nil
}
func doDecodeBuffer(d binary.Decoder, o *Buffer) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if err := d.Value(&o.Data); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Size = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Usage = BufferUsage(obj)
}
return nil
}
func doSkipBuffer(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassBuffer) ID() binary.ID { return binaryIDBuffer }
func (*binaryClassBuffer) New() binary.Object { return &Buffer{} }
func (*binaryClassBuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeBuffer(e, obj.(*Buffer))
}
func (*binaryClassBuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Buffer{}
return obj, doDecodeBuffer(d, obj)
}
func (*binaryClassBuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeBuffer(d, obj.(*Buffer))
}
func (*binaryClassBuffer) Skip(d binary.Decoder) error { return doSkipBuffer(d) }
func (*binaryClassBuffer) Schema() *schema.Class { return schemaBuffer }
var schemaBuffer = &schema.Class{
TypeID: binaryIDBuffer,
Name: "Buffer",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Data", Type: &schema.Struct{Name: "U8ˢ"}},
schema.Field{Declared: "Size", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Usage", Type: &schema.Primitive{Name: "BufferUsage", Method: schema.Uint32}},
},
}
type binaryClassBufferDataPointer struct{}
func (*BufferDataPointer) Class() binary.Class {
return (*binaryClassBufferDataPointer)(nil)
}
func doEncodeBufferDataPointer(e binary.Encoder, o *BufferDataPointer) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeBufferDataPointer(d binary.Decoder, o *BufferDataPointer) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipBufferDataPointer(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassBufferDataPointer) ID() binary.ID { return binaryIDBufferDataPointer }
func (*binaryClassBufferDataPointer) New() binary.Object { return &BufferDataPointer{} }
func (*binaryClassBufferDataPointer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeBufferDataPointer(e, obj.(*BufferDataPointer))
}
func (*binaryClassBufferDataPointer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &BufferDataPointer{}
return obj, doDecodeBufferDataPointer(d, obj)
}
func (*binaryClassBufferDataPointer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeBufferDataPointer(d, obj.(*BufferDataPointer))
}
func (*binaryClassBufferDataPointer) Skip(d binary.Decoder) error { return doSkipBufferDataPointer(d) }
func (*binaryClassBufferDataPointer) Schema() *schema.Class { return schemaBufferDataPointer }
var schemaBufferDataPointer = &schema.Class{
TypeID: binaryIDBufferDataPointer,
Name: "BufferDataPointer",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassBufferIdˢ struct{}
func (*BufferIdˢ) Class() binary.Class {
return (*binaryClassBufferIdˢ)(nil)
}
func doEncodeBufferIdˢ(e binary.Encoder, o *BufferIdˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeBufferIdˢ(d binary.Decoder, o *BufferIdˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipBufferIdˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassBufferIdˢ) ID() binary.ID { return binaryIDBufferIdˢ }
func (*binaryClassBufferIdˢ) New() binary.Object { return &BufferIdˢ{} }
func (*binaryClassBufferIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeBufferIdˢ(e, obj.(*BufferIdˢ))
}
func (*binaryClassBufferIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &BufferIdˢ{}
return obj, doDecodeBufferIdˢ(d, obj)
}
func (*binaryClassBufferIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeBufferIdˢ(d, obj.(*BufferIdˢ))
}
func (*binaryClassBufferIdˢ) Skip(d binary.Decoder) error { return doSkipBufferIdˢ(d) }
func (*binaryClassBufferIdˢ) Schema() *schema.Class { return schemaBufferIdˢ }
var schemaBufferIdˢ = &schema.Class{
TypeID: binaryIDBufferIdˢ,
Name: "BufferIdˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassBufferIdᵖ struct{}
func (*BufferIdᵖ) Class() binary.Class {
return (*binaryClassBufferIdᵖ)(nil)
}
func doEncodeBufferIdᵖ(e binary.Encoder, o *BufferIdᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeBufferIdᵖ(d binary.Decoder, o *BufferIdᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipBufferIdᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassBufferIdᵖ) ID() binary.ID { return binaryIDBufferIdᵖ }
func (*binaryClassBufferIdᵖ) New() binary.Object { return &BufferIdᵖ{} }
func (*binaryClassBufferIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeBufferIdᵖ(e, obj.(*BufferIdᵖ))
}
func (*binaryClassBufferIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &BufferIdᵖ{}
return obj, doDecodeBufferIdᵖ(d, obj)
}
func (*binaryClassBufferIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeBufferIdᵖ(d, obj.(*BufferIdᵖ))
}
func (*binaryClassBufferIdᵖ) Skip(d binary.Decoder) error { return doSkipBufferIdᵖ(d) }
func (*binaryClassBufferIdᵖ) Schema() *schema.Class { return schemaBufferIdᵖ }
var schemaBufferIdᵖ = &schema.Class{
TypeID: binaryIDBufferIdᵖ,
Name: "BufferIdᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassCGLContextObj struct{}
func (*CGLContextObj) Class() binary.Class {
return (*binaryClassCGLContextObj)(nil)
}
func doEncodeCGLContextObj(e binary.Encoder, o *CGLContextObj) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeCGLContextObj(d binary.Decoder, o *CGLContextObj) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipCGLContextObj(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassCGLContextObj) ID() binary.ID { return binaryIDCGLContextObj }
func (*binaryClassCGLContextObj) New() binary.Object { return &CGLContextObj{} }
func (*binaryClassCGLContextObj) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeCGLContextObj(e, obj.(*CGLContextObj))
}
func (*binaryClassCGLContextObj) Decode(d binary.Decoder) (binary.Object, error) {
obj := &CGLContextObj{}
return obj, doDecodeCGLContextObj(d, obj)
}
func (*binaryClassCGLContextObj) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeCGLContextObj(d, obj.(*CGLContextObj))
}
func (*binaryClassCGLContextObj) Skip(d binary.Decoder) error { return doSkipCGLContextObj(d) }
func (*binaryClassCGLContextObj) Schema() *schema.Class { return schemaCGLContextObj }
var schemaCGLContextObj = &schema.Class{
TypeID: binaryIDCGLContextObj,
Name: "CGLContextObj",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassCGLContextObjˢ struct{}
func (*CGLContextObjˢ) Class() binary.Class {
return (*binaryClassCGLContextObjˢ)(nil)
}
func doEncodeCGLContextObjˢ(e binary.Encoder, o *CGLContextObjˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeCGLContextObjˢ(d binary.Decoder, o *CGLContextObjˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipCGLContextObjˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassCGLContextObjˢ) ID() binary.ID { return binaryIDCGLContextObjˢ }
func (*binaryClassCGLContextObjˢ) New() binary.Object { return &CGLContextObjˢ{} }
func (*binaryClassCGLContextObjˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeCGLContextObjˢ(e, obj.(*CGLContextObjˢ))
}
func (*binaryClassCGLContextObjˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &CGLContextObjˢ{}
return obj, doDecodeCGLContextObjˢ(d, obj)
}
func (*binaryClassCGLContextObjˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeCGLContextObjˢ(d, obj.(*CGLContextObjˢ))
}
func (*binaryClassCGLContextObjˢ) Skip(d binary.Decoder) error { return doSkipCGLContextObjˢ(d) }
func (*binaryClassCGLContextObjˢ) Schema() *schema.Class { return schemaCGLContextObjˢ }
var schemaCGLContextObjˢ = &schema.Class{
TypeID: binaryIDCGLContextObjˢ,
Name: "CGLContextObjˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassCGLContextObjᵖ struct{}
func (*CGLContextObjᵖ) Class() binary.Class {
return (*binaryClassCGLContextObjᵖ)(nil)
}
func doEncodeCGLContextObjᵖ(e binary.Encoder, o *CGLContextObjᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeCGLContextObjᵖ(d binary.Decoder, o *CGLContextObjᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipCGLContextObjᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassCGLContextObjᵖ) ID() binary.ID { return binaryIDCGLContextObjᵖ }
func (*binaryClassCGLContextObjᵖ) New() binary.Object { return &CGLContextObjᵖ{} }
func (*binaryClassCGLContextObjᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeCGLContextObjᵖ(e, obj.(*CGLContextObjᵖ))
}
func (*binaryClassCGLContextObjᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &CGLContextObjᵖ{}
return obj, doDecodeCGLContextObjᵖ(d, obj)
}
func (*binaryClassCGLContextObjᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeCGLContextObjᵖ(d, obj.(*CGLContextObjᵖ))
}
func (*binaryClassCGLContextObjᵖ) Skip(d binary.Decoder) error { return doSkipCGLContextObjᵖ(d) }
func (*binaryClassCGLContextObjᵖ) Schema() *schema.Class { return schemaCGLContextObjᵖ }
var schemaCGLContextObjᵖ = &schema.Class{
TypeID: binaryIDCGLContextObjᵖ,
Name: "CGLContextObjᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassCGLPixelFormatObj struct{}
func (*CGLPixelFormatObj) Class() binary.Class {
return (*binaryClassCGLPixelFormatObj)(nil)
}
func doEncodeCGLPixelFormatObj(e binary.Encoder, o *CGLPixelFormatObj) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeCGLPixelFormatObj(d binary.Decoder, o *CGLPixelFormatObj) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipCGLPixelFormatObj(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassCGLPixelFormatObj) ID() binary.ID { return binaryIDCGLPixelFormatObj }
func (*binaryClassCGLPixelFormatObj) New() binary.Object { return &CGLPixelFormatObj{} }
func (*binaryClassCGLPixelFormatObj) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeCGLPixelFormatObj(e, obj.(*CGLPixelFormatObj))
}
func (*binaryClassCGLPixelFormatObj) Decode(d binary.Decoder) (binary.Object, error) {
obj := &CGLPixelFormatObj{}
return obj, doDecodeCGLPixelFormatObj(d, obj)
}
func (*binaryClassCGLPixelFormatObj) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeCGLPixelFormatObj(d, obj.(*CGLPixelFormatObj))
}
func (*binaryClassCGLPixelFormatObj) Skip(d binary.Decoder) error { return doSkipCGLPixelFormatObj(d) }
func (*binaryClassCGLPixelFormatObj) Schema() *schema.Class { return schemaCGLPixelFormatObj }
var schemaCGLPixelFormatObj = &schema.Class{
TypeID: binaryIDCGLPixelFormatObj,
Name: "CGLPixelFormatObj",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassCGLCreateContext struct{}
func (*CGLCreateContext) Class() binary.Class {
return (*binaryClassCGLCreateContext)(nil)
}
func doEncodeCGLCreateContext(e binary.Encoder, o *CGLCreateContext) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Pix); err != nil {
return err
}
if err := e.Value(&o.Share); err != nil {
return err
}
if err := e.Value(&o.Ctx); err != nil {
return err
}
if err := e.Int64(int64(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeCGLCreateContext(d binary.Decoder, o *CGLCreateContext) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Pix); err != nil {
return err
}
if err := d.Value(&o.Share); err != nil {
return err
}
if err := d.Value(&o.Ctx); err != nil {
return err
}
if obj, err := d.Int64(); err != nil {
return err
} else {
o.Result = CGLError(obj)
}
return nil
}
func doSkipCGLCreateContext(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*CGLPixelFormatObj)(nil)); err != nil {
return err
}
if err := d.SkipValue((*CGLContextObj)(nil)); err != nil {
return err
}
if err := d.SkipValue((*CGLContextObjᵖ)(nil)); err != nil {
return err
}
if _, err := d.Int64(); err != nil {
return err
}
return nil
}
func (*binaryClassCGLCreateContext) ID() binary.ID { return binaryIDCGLCreateContext }
func (*binaryClassCGLCreateContext) New() binary.Object { return &CGLCreateContext{} }
func (*binaryClassCGLCreateContext) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeCGLCreateContext(e, obj.(*CGLCreateContext))
}
func (*binaryClassCGLCreateContext) Decode(d binary.Decoder) (binary.Object, error) {
obj := &CGLCreateContext{}
return obj, doDecodeCGLCreateContext(d, obj)
}
func (*binaryClassCGLCreateContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeCGLCreateContext(d, obj.(*CGLCreateContext))
}
func (*binaryClassCGLCreateContext) Skip(d binary.Decoder) error { return doSkipCGLCreateContext(d) }
func (*binaryClassCGLCreateContext) Schema() *schema.Class { return schemaCGLCreateContext }
var schemaCGLCreateContext = &schema.Class{
TypeID: binaryIDCGLCreateContext,
Name: "CGLCreateContext",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Pix", Type: &schema.Struct{Name: "CGLPixelFormatObj"}},
schema.Field{Declared: "Share", Type: &schema.Struct{Name: "CGLContextObj"}},
schema.Field{Declared: "Ctx", Type: &schema.Struct{Name: "CGLContextObjᵖ"}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "CGLError", Method: schema.Int64}},
},
}
type binaryClassCGLSetCurrentContext struct{}
func (*CGLSetCurrentContext) Class() binary.Class {
return (*binaryClassCGLSetCurrentContext)(nil)
}
func doEncodeCGLSetCurrentContext(e binary.Encoder, o *CGLSetCurrentContext) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Ctx); err != nil {
return err
}
if err := e.Int64(int64(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeCGLSetCurrentContext(d binary.Decoder, o *CGLSetCurrentContext) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Ctx); err != nil {
return err
}
if obj, err := d.Int64(); err != nil {
return err
} else {
o.Result = CGLError(obj)
}
return nil
}
func doSkipCGLSetCurrentContext(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*CGLContextObj)(nil)); err != nil {
return err
}
if _, err := d.Int64(); err != nil {
return err
}
return nil
}
func (*binaryClassCGLSetCurrentContext) ID() binary.ID { return binaryIDCGLSetCurrentContext }
func (*binaryClassCGLSetCurrentContext) New() binary.Object { return &CGLSetCurrentContext{} }
func (*binaryClassCGLSetCurrentContext) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeCGLSetCurrentContext(e, obj.(*CGLSetCurrentContext))
}
func (*binaryClassCGLSetCurrentContext) Decode(d binary.Decoder) (binary.Object, error) {
obj := &CGLSetCurrentContext{}
return obj, doDecodeCGLSetCurrentContext(d, obj)
}
func (*binaryClassCGLSetCurrentContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeCGLSetCurrentContext(d, obj.(*CGLSetCurrentContext))
}
func (*binaryClassCGLSetCurrentContext) Skip(d binary.Decoder) error {
return doSkipCGLSetCurrentContext(d)
}
func (*binaryClassCGLSetCurrentContext) Schema() *schema.Class { return schemaCGLSetCurrentContext }
var schemaCGLSetCurrentContext = &schema.Class{
TypeID: binaryIDCGLSetCurrentContext,
Name: "CGLSetCurrentContext",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Ctx", Type: &schema.Struct{Name: "CGLContextObj"}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "CGLError", Method: schema.Int64}},
},
}
type binaryClassCharˢ struct{}
func (*Charˢ) Class() binary.Class {
return (*binaryClassCharˢ)(nil)
}
func doEncodeCharˢ(e binary.Encoder, o *Charˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeCharˢ(d binary.Decoder, o *Charˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipCharˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassCharˢ) ID() binary.ID { return binaryIDCharˢ }
func (*binaryClassCharˢ) New() binary.Object { return &Charˢ{} }
func (*binaryClassCharˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeCharˢ(e, obj.(*Charˢ))
}
func (*binaryClassCharˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Charˢ{}
return obj, doDecodeCharˢ(d, obj)
}
func (*binaryClassCharˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeCharˢ(d, obj.(*Charˢ))
}
func (*binaryClassCharˢ) Skip(d binary.Decoder) error { return doSkipCharˢ(d) }
func (*binaryClassCharˢ) Schema() *schema.Class { return schemaCharˢ }
var schemaCharˢ = &schema.Class{
TypeID: binaryIDCharˢ,
Name: "Charˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassCharᵖ struct{}
func (*Charᵖ) Class() binary.Class {
return (*binaryClassCharᵖ)(nil)
}
func doEncodeCharᵖ(e binary.Encoder, o *Charᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeCharᵖ(d binary.Decoder, o *Charᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipCharᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassCharᵖ) ID() binary.ID { return binaryIDCharᵖ }
func (*binaryClassCharᵖ) New() binary.Object { return &Charᵖ{} }
func (*binaryClassCharᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeCharᵖ(e, obj.(*Charᵖ))
}
func (*binaryClassCharᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Charᵖ{}
return obj, doDecodeCharᵖ(d, obj)
}
func (*binaryClassCharᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeCharᵖ(d, obj.(*Charᵖ))
}
func (*binaryClassCharᵖ) Skip(d binary.Decoder) error { return doSkipCharᵖ(d) }
func (*binaryClassCharᵖ) Schema() *schema.Class { return schemaCharᵖ }
var schemaCharᵖ = &schema.Class{
TypeID: binaryIDCharᵖ,
Name: "Charᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassCharᵖˢ struct{}
func (*Charᵖˢ) Class() binary.Class {
return (*binaryClassCharᵖˢ)(nil)
}
func doEncodeCharᵖˢ(e binary.Encoder, o *Charᵖˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeCharᵖˢ(d binary.Decoder, o *Charᵖˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipCharᵖˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassCharᵖˢ) ID() binary.ID { return binaryIDCharᵖˢ }
func (*binaryClassCharᵖˢ) New() binary.Object { return &Charᵖˢ{} }
func (*binaryClassCharᵖˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeCharᵖˢ(e, obj.(*Charᵖˢ))
}
func (*binaryClassCharᵖˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Charᵖˢ{}
return obj, doDecodeCharᵖˢ(d, obj)
}
func (*binaryClassCharᵖˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeCharᵖˢ(d, obj.(*Charᵖˢ))
}
func (*binaryClassCharᵖˢ) Skip(d binary.Decoder) error { return doSkipCharᵖˢ(d) }
func (*binaryClassCharᵖˢ) Schema() *schema.Class { return schemaCharᵖˢ }
var schemaCharᵖˢ = &schema.Class{
TypeID: binaryIDCharᵖˢ,
Name: "Charᵖˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassCharᵖᵖ struct{}
func (*Charᵖᵖ) Class() binary.Class {
return (*binaryClassCharᵖᵖ)(nil)
}
func doEncodeCharᵖᵖ(e binary.Encoder, o *Charᵖᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeCharᵖᵖ(d binary.Decoder, o *Charᵖᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipCharᵖᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassCharᵖᵖ) ID() binary.ID { return binaryIDCharᵖᵖ }
func (*binaryClassCharᵖᵖ) New() binary.Object { return &Charᵖᵖ{} }
func (*binaryClassCharᵖᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeCharᵖᵖ(e, obj.(*Charᵖᵖ))
}
func (*binaryClassCharᵖᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Charᵖᵖ{}
return obj, doDecodeCharᵖᵖ(d, obj)
}
func (*binaryClassCharᵖᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeCharᵖᵖ(d, obj.(*Charᵖᵖ))
}
func (*binaryClassCharᵖᵖ) Skip(d binary.Decoder) error { return doSkipCharᵖᵖ(d) }
func (*binaryClassCharᵖᵖ) Schema() *schema.Class { return schemaCharᵖᵖ }
var schemaCharᵖᵖ = &schema.Class{
TypeID: binaryIDCharᵖᵖ,
Name: "Charᵖᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassClearState struct{}
func (*ClearState) Class() binary.Class {
return (*binaryClassClearState)(nil)
}
func doEncodeClearState(e binary.Encoder, o *ClearState) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Value(&o.ClearColor); err != nil {
return err
}
if err := e.Float32(o.ClearDepth); err != nil {
return err
}
if err := e.Int32(o.ClearStencil); err != nil {
return err
}
return nil
}
func doDecodeClearState(d binary.Decoder, o *ClearState) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if err := d.Value(&o.ClearColor); err != nil {
return err
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.ClearDepth = float32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.ClearStencil = int32(obj)
}
return nil
}
func doSkipClearState(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if err := d.SkipValue((*Color)(nil)); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassClearState) ID() binary.ID { return binaryIDClearState }
func (*binaryClassClearState) New() binary.Object { return &ClearState{} }
func (*binaryClassClearState) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeClearState(e, obj.(*ClearState))
}
func (*binaryClassClearState) Decode(d binary.Decoder) (binary.Object, error) {
obj := &ClearState{}
return obj, doDecodeClearState(d, obj)
}
func (*binaryClassClearState) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeClearState(d, obj.(*ClearState))
}
func (*binaryClassClearState) Skip(d binary.Decoder) error { return doSkipClearState(d) }
func (*binaryClassClearState) Schema() *schema.Class { return schemaClearState }
var schemaClearState = &schema.Class{
TypeID: binaryIDClearState,
Name: "ClearState",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "ClearColor", Type: &schema.Struct{Name: "Color"}},
schema.Field{Declared: "ClearDepth", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "ClearStencil", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassRect struct{}
func (*Rect) Class() binary.Class {
return (*binaryClassRect)(nil)
}
func doEncodeRect(e binary.Encoder, o *Rect) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Int32(o.X); err != nil {
return err
}
if err := e.Int32(o.Y); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
return nil
}
func doDecodeRect(d binary.Decoder, o *Rect) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.X = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Y = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
return nil
}
func doSkipRect(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassRect) ID() binary.ID { return binaryIDRect }
func (*binaryClassRect) New() binary.Object { return &Rect{} }
func (*binaryClassRect) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeRect(e, obj.(*Rect))
}
func (*binaryClassRect) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Rect{}
return obj, doDecodeRect(d, obj)
}
func (*binaryClassRect) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeRect(d, obj.(*Rect))
}
func (*binaryClassRect) Skip(d binary.Decoder) error { return doSkipRect(d) }
func (*binaryClassRect) Schema() *schema.Class { return schemaRect }
var schemaRect = &schema.Class{
TypeID: binaryIDRect,
Name: "Rect",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassRasterizerState struct{}
func (*RasterizerState) Class() binary.Class {
return (*binaryClassRasterizerState)(nil)
}
func doEncodeRasterizerState(e binary.Encoder, o *RasterizerState) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Bool(o.DepthMask); err != nil {
return err
}
if err := e.Uint32(uint32(o.DepthTestFunction)); err != nil {
return err
}
if err := e.Float32(o.DepthNear); err != nil {
return err
}
if err := e.Float32(o.DepthFar); err != nil {
return err
}
if err := e.Bool(o.ColorMaskRed); err != nil {
return err
}
if err := e.Bool(o.ColorMaskGreen); err != nil {
return err
}
if err := e.Bool(o.ColorMaskBlue); err != nil {
return err
}
if err := e.Bool(o.ColorMaskAlpha); err != nil {
return err
}
if err := e.Uint32(uint32(len(o.StencilMask))); err != nil {
return err
}
for k, v := range o.StencilMask {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if err := e.Uint32(v); err != nil {
return err
}
}
if err := e.Value(&o.Viewport); err != nil {
return err
}
if err := e.Value(&o.Scissor); err != nil {
return err
}
if err := e.Uint32(uint32(o.FrontFace)); err != nil {
return err
}
if err := e.Uint32(uint32(o.CullFace)); err != nil {
return err
}
if err := e.Float32(o.LineWidth); err != nil {
return err
}
if err := e.Float32(o.PolygonOffsetFactor); err != nil {
return err
}
if err := e.Float32(o.PolygonOffsetUnits); err != nil {
return err
}
if err := e.Float32(o.SampleCoverageValue); err != nil {
return err
}
if err := e.Bool(o.SampleCoverageInvert); err != nil {
return err
}
return nil
}
func doDecodeRasterizerState(d binary.Decoder, o *RasterizerState) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.DepthMask = bool(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.DepthTestFunction = TestFunction(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.DepthNear = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.DepthFar = float32(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.ColorMaskRed = bool(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.ColorMaskGreen = bool(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.ColorMaskBlue = bool(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.ColorMaskAlpha = bool(obj)
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.StencilMask = make(FaceModeːu32ᵐ, count)
m := o.StencilMask
for i := uint32(0); i < count; i++ {
var k FaceMode
var v uint32
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = FaceMode(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
v = uint32(obj)
}
m[k] = v
}
}
if err := d.Value(&o.Viewport); err != nil {
return err
}
if err := d.Value(&o.Scissor); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.FrontFace = FaceOrientation(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.CullFace = FaceMode(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.LineWidth = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.PolygonOffsetFactor = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.PolygonOffsetUnits = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.SampleCoverageValue = float32(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.SampleCoverageInvert = bool(obj)
}
return nil
}
func doSkipRasterizerState(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
}
}
if err := d.SkipValue((*Rect)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Rect)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassRasterizerState) ID() binary.ID { return binaryIDRasterizerState }
func (*binaryClassRasterizerState) New() binary.Object { return &RasterizerState{} }
func (*binaryClassRasterizerState) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeRasterizerState(e, obj.(*RasterizerState))
}
func (*binaryClassRasterizerState) Decode(d binary.Decoder) (binary.Object, error) {
obj := &RasterizerState{}
return obj, doDecodeRasterizerState(d, obj)
}
func (*binaryClassRasterizerState) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeRasterizerState(d, obj.(*RasterizerState))
}
func (*binaryClassRasterizerState) Skip(d binary.Decoder) error { return doSkipRasterizerState(d) }
func (*binaryClassRasterizerState) Schema() *schema.Class { return schemaRasterizerState }
var schemaRasterizerState = &schema.Class{
TypeID: binaryIDRasterizerState,
Name: "RasterizerState",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "DepthMask", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "DepthTestFunction", Type: &schema.Primitive{Name: "TestFunction", Method: schema.Uint32}},
schema.Field{Declared: "DepthNear", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "DepthFar", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "ColorMaskRed", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "ColorMaskGreen", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "ColorMaskBlue", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "ColorMaskAlpha", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "StencilMask", Type: &schema.Map{Alias: "FaceModeːu32ᵐ", KeyType: &schema.Primitive{Name: "FaceMode", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "uint32", Method: schema.Uint32}}},
schema.Field{Declared: "Viewport", Type: &schema.Struct{Name: "Rect"}},
schema.Field{Declared: "Scissor", Type: &schema.Struct{Name: "Rect"}},
schema.Field{Declared: "FrontFace", Type: &schema.Primitive{Name: "FaceOrientation", Method: schema.Uint32}},
schema.Field{Declared: "CullFace", Type: &schema.Primitive{Name: "FaceMode", Method: schema.Uint32}},
schema.Field{Declared: "LineWidth", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "PolygonOffsetFactor", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "PolygonOffsetUnits", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "SampleCoverageValue", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "SampleCoverageInvert", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassVertexPointer struct{}
func (*VertexPointer) Class() binary.Class {
return (*binaryClassVertexPointer)(nil)
}
func doEncodeVertexPointer(e binary.Encoder, o *VertexPointer) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeVertexPointer(d binary.Decoder, o *VertexPointer) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipVertexPointer(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassVertexPointer) ID() binary.ID { return binaryIDVertexPointer }
func (*binaryClassVertexPointer) New() binary.Object { return &VertexPointer{} }
func (*binaryClassVertexPointer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVertexPointer(e, obj.(*VertexPointer))
}
func (*binaryClassVertexPointer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &VertexPointer{}
return obj, doDecodeVertexPointer(d, obj)
}
func (*binaryClassVertexPointer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVertexPointer(d, obj.(*VertexPointer))
}
func (*binaryClassVertexPointer) Skip(d binary.Decoder) error { return doSkipVertexPointer(d) }
func (*binaryClassVertexPointer) Schema() *schema.Class { return schemaVertexPointer }
var schemaVertexPointer = &schema.Class{
TypeID: binaryIDVertexPointer,
Name: "VertexPointer",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassVertexAttributeArray struct{}
func (*VertexAttributeArray) Class() binary.Class {
return (*binaryClassVertexAttributeArray)(nil)
}
func doEncodeVertexAttributeArray(e binary.Encoder, o *VertexAttributeArray) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Bool(o.Enabled); err != nil {
return err
}
if err := e.Uint32(o.Size); err != nil {
return err
}
if err := e.Uint32(uint32(o.Type)); err != nil {
return err
}
if err := e.Bool(o.Normalized); err != nil {
return err
}
if err := e.Int32(o.Stride); err != nil {
return err
}
if err := e.Uint32(uint32(o.Buffer)); err != nil {
return err
}
if err := e.Value(&o.Pointer); err != nil {
return err
}
return nil
}
func doDecodeVertexAttributeArray(d binary.Decoder, o *VertexAttributeArray) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Enabled = bool(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Size = uint32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = VertexAttribType(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Normalized = bool(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Stride = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Buffer = BufferId(obj)
}
if err := d.Value(&o.Pointer); err != nil {
return err
}
return nil
}
func doSkipVertexAttributeArray(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*VertexPointer)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassVertexAttributeArray) ID() binary.ID { return binaryIDVertexAttributeArray }
func (*binaryClassVertexAttributeArray) New() binary.Object { return &VertexAttributeArray{} }
func (*binaryClassVertexAttributeArray) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVertexAttributeArray(e, obj.(*VertexAttributeArray))
}
func (*binaryClassVertexAttributeArray) Decode(d binary.Decoder) (binary.Object, error) {
obj := &VertexAttributeArray{}
return obj, doDecodeVertexAttributeArray(d, obj)
}
func (*binaryClassVertexAttributeArray) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVertexAttributeArray(d, obj.(*VertexAttributeArray))
}
func (*binaryClassVertexAttributeArray) Skip(d binary.Decoder) error {
return doSkipVertexAttributeArray(d)
}
func (*binaryClassVertexAttributeArray) Schema() *schema.Class { return schemaVertexAttributeArray }
var schemaVertexAttributeArray = &schema.Class{
TypeID: binaryIDVertexAttributeArray,
Name: "VertexAttributeArray",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Enabled", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Size", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "VertexAttribType", Method: schema.Uint32}},
schema.Field{Declared: "Normalized", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Stride", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
schema.Field{Declared: "Pointer", Type: &schema.Struct{Name: "VertexPointer"}},
},
}
type binaryClassRenderbuffer struct{}
func (*Renderbuffer) Class() binary.Class {
return (*binaryClassRenderbuffer)(nil)
}
func doEncodeRenderbuffer(e binary.Encoder, o *Renderbuffer) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
if err := e.Value(&o.Data); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
return nil
}
func doDecodeRenderbuffer(d binary.Decoder, o *Renderbuffer) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
if err := d.Value(&o.Data); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = RenderbufferFormat(obj)
}
return nil
}
func doSkipRenderbuffer(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassRenderbuffer) ID() binary.ID { return binaryIDRenderbuffer }
func (*binaryClassRenderbuffer) New() binary.Object { return &Renderbuffer{} }
func (*binaryClassRenderbuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeRenderbuffer(e, obj.(*Renderbuffer))
}
func (*binaryClassRenderbuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Renderbuffer{}
return obj, doDecodeRenderbuffer(d, obj)
}
func (*binaryClassRenderbuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeRenderbuffer(d, obj.(*Renderbuffer))
}
func (*binaryClassRenderbuffer) Skip(d binary.Decoder) error { return doSkipRenderbuffer(d) }
func (*binaryClassRenderbuffer) Schema() *schema.Class { return schemaRenderbuffer }
var schemaRenderbuffer = &schema.Class{
TypeID: binaryIDRenderbuffer,
Name: "Renderbuffer",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Data", Type: &schema.Struct{Name: "U8ˢ"}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "RenderbufferFormat", Method: schema.Uint32}},
},
}
type binaryClassImage struct{}
func (*Image) Class() binary.Class {
return (*binaryClassImage)(nil)
}
func doEncodeImage(e binary.Encoder, o *Image) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
if err := e.Value(&o.Data); err != nil {
return err
}
if err := e.Uint32(o.Size); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
return nil
}
func doDecodeImage(d binary.Decoder, o *Image) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
if err := d.Value(&o.Data); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Size = uint32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = ImageTexelFormat(obj)
}
return nil
}
func doSkipImage(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassImage) ID() binary.ID { return binaryIDImage }
func (*binaryClassImage) New() binary.Object { return &Image{} }
func (*binaryClassImage) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeImage(e, obj.(*Image))
}
func (*binaryClassImage) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Image{}
return obj, doDecodeImage(d, obj)
}
func (*binaryClassImage) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeImage(d, obj.(*Image))
}
func (*binaryClassImage) Skip(d binary.Decoder) error { return doSkipImage(d) }
func (*binaryClassImage) Schema() *schema.Class { return schemaImage }
var schemaImage = &schema.Class{
TypeID: binaryIDImage,
Name: "Image",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Data", Type: &schema.Struct{Name: "U8ˢ"}},
schema.Field{Declared: "Size", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "ImageTexelFormat", Method: schema.Uint32}},
},
}
type binaryClassCubemapLevel struct{}
func (*CubemapLevel) Class() binary.Class {
return (*binaryClassCubemapLevel)(nil)
}
func doEncodeCubemapLevel(e binary.Encoder, o *CubemapLevel) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Uint32(uint32(len(o.Faces))); err != nil {
return err
}
for k, v := range o.Faces {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if err := e.Value(&v); err != nil {
return err
}
}
return nil
}
func doDecodeCubemapLevel(d binary.Decoder, o *CubemapLevel) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Faces = make(CubeMapImageTargetːImageᵐ, count)
m := o.Faces
for i := uint32(0); i < count; i++ {
var k CubeMapImageTarget
var v Image
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = CubeMapImageTarget(obj)
}
if err := d.Value(&v); err != nil {
return err
}
m[k] = v
}
}
return nil
}
func doSkipCubemapLevel(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*Image)(nil)); err != nil {
return err
}
}
}
return nil
}
func (*binaryClassCubemapLevel) ID() binary.ID { return binaryIDCubemapLevel }
func (*binaryClassCubemapLevel) New() binary.Object { return &CubemapLevel{} }
func (*binaryClassCubemapLevel) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeCubemapLevel(e, obj.(*CubemapLevel))
}
func (*binaryClassCubemapLevel) Decode(d binary.Decoder) (binary.Object, error) {
obj := &CubemapLevel{}
return obj, doDecodeCubemapLevel(d, obj)
}
func (*binaryClassCubemapLevel) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeCubemapLevel(d, obj.(*CubemapLevel))
}
func (*binaryClassCubemapLevel) Skip(d binary.Decoder) error { return doSkipCubemapLevel(d) }
func (*binaryClassCubemapLevel) Schema() *schema.Class { return schemaCubemapLevel }
var schemaCubemapLevel = &schema.Class{
TypeID: binaryIDCubemapLevel,
Name: "CubemapLevel",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Faces", Type: &schema.Map{Alias: "CubeMapImageTargetːImageᵐ", KeyType: &schema.Primitive{Name: "CubeMapImageTarget", Method: schema.Uint32}, ValueType: &schema.Struct{Name: "Image"}}},
},
}
type binaryClassTexture struct{}
func (*Texture) Class() binary.Class {
return (*binaryClassTexture)(nil)
}
func doEncodeTexture(e binary.Encoder, o *Texture) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Kind)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Uint32(uint32(len(o.Texture2D))); err != nil {
return err
}
for k, v := range o.Texture2D {
if err := e.Int32(k); err != nil {
return err
}
if err := e.Value(&v); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.Cubemap))); err != nil {
return err
}
for k, v := range o.Cubemap {
if err := e.Int32(k); err != nil {
return err
}
if err := e.Value(&v); err != nil {
return err
}
}
if err := e.Uint32(uint32(o.MagFilter)); err != nil {
return err
}
if err := e.Uint32(uint32(o.MinFilter)); err != nil {
return err
}
if err := e.Uint32(uint32(o.WrapS)); err != nil {
return err
}
if err := e.Uint32(uint32(o.WrapT)); err != nil {
return err
}
if err := e.Uint32(uint32(o.SwizzleR)); err != nil {
return err
}
if err := e.Uint32(uint32(o.SwizzleG)); err != nil {
return err
}
if err := e.Uint32(uint32(o.SwizzleB)); err != nil {
return err
}
if err := e.Uint32(uint32(o.SwizzleA)); err != nil {
return err
}
if err := e.Float32(o.MaxAnisotropy); err != nil {
return err
}
return nil
}
func doDecodeTexture(d binary.Decoder, o *Texture) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Kind = TextureKind(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = ImageTexelFormat(obj)
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Texture2D = make(S32ːImageᵐ, count)
m := o.Texture2D
for i := uint32(0); i < count; i++ {
var k int32
var v Image
if obj, err := d.Int32(); err != nil {
return err
} else {
k = int32(obj)
}
if err := d.Value(&v); err != nil {
return err
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Cubemap = make(S32ːCubemapLevelᵐ, count)
m := o.Cubemap
for i := uint32(0); i < count; i++ {
var k int32
var v CubemapLevel
if obj, err := d.Int32(); err != nil {
return err
} else {
k = int32(obj)
}
if err := d.Value(&v); err != nil {
return err
}
m[k] = v
}
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.MagFilter = TextureFilterMode(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.MinFilter = TextureFilterMode(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.WrapS = TextureWrapMode(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.WrapT = TextureWrapMode(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.SwizzleR = TexelComponent(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.SwizzleG = TexelComponent(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.SwizzleB = TexelComponent(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.SwizzleA = TexelComponent(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.MaxAnisotropy = float32(obj)
}
return nil
}
func doSkipTexture(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*Image)(nil)); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*CubemapLevel)(nil)); err != nil {
return err
}
}
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassTexture) ID() binary.ID { return binaryIDTexture }
func (*binaryClassTexture) New() binary.Object { return &Texture{} }
func (*binaryClassTexture) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeTexture(e, obj.(*Texture))
}
func (*binaryClassTexture) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Texture{}
return obj, doDecodeTexture(d, obj)
}
func (*binaryClassTexture) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeTexture(d, obj.(*Texture))
}
func (*binaryClassTexture) Skip(d binary.Decoder) error { return doSkipTexture(d) }
func (*binaryClassTexture) Schema() *schema.Class { return schemaTexture }
var schemaTexture = &schema.Class{
TypeID: binaryIDTexture,
Name: "Texture",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TextureKind", Method: schema.Uint32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "ImageTexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "Texture2D", Type: &schema.Map{Alias: "S32ːImageᵐ", KeyType: &schema.Primitive{Name: "int32", Method: schema.Int32}, ValueType: &schema.Struct{Name: "Image"}}},
schema.Field{Declared: "Cubemap", Type: &schema.Map{Alias: "S32ːCubemapLevelᵐ", KeyType: &schema.Primitive{Name: "int32", Method: schema.Int32}, ValueType: &schema.Struct{Name: "CubemapLevel"}}},
schema.Field{Declared: "MagFilter", Type: &schema.Primitive{Name: "TextureFilterMode", Method: schema.Uint32}},
schema.Field{Declared: "MinFilter", Type: &schema.Primitive{Name: "TextureFilterMode", Method: schema.Uint32}},
schema.Field{Declared: "WrapS", Type: &schema.Primitive{Name: "TextureWrapMode", Method: schema.Uint32}},
schema.Field{Declared: "WrapT", Type: &schema.Primitive{Name: "TextureWrapMode", Method: schema.Uint32}},
schema.Field{Declared: "SwizzleR", Type: &schema.Primitive{Name: "TexelComponent", Method: schema.Uint32}},
schema.Field{Declared: "SwizzleG", Type: &schema.Primitive{Name: "TexelComponent", Method: schema.Uint32}},
schema.Field{Declared: "SwizzleB", Type: &schema.Primitive{Name: "TexelComponent", Method: schema.Uint32}},
schema.Field{Declared: "SwizzleA", Type: &schema.Primitive{Name: "TexelComponent", Method: schema.Uint32}},
schema.Field{Declared: "MaxAnisotropy", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassFramebufferAttachmentInfo struct{}
func (*FramebufferAttachmentInfo) Class() binary.Class {
return (*binaryClassFramebufferAttachmentInfo)(nil)
}
func doEncodeFramebufferAttachmentInfo(e binary.Encoder, o *FramebufferAttachmentInfo) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Uint32(o.Object); err != nil {
return err
}
if err := e.Uint32(uint32(o.Type)); err != nil {
return err
}
if err := e.Int32(o.TextureLevel); err != nil {
return err
}
if err := e.Uint32(uint32(o.CubeMapFace)); err != nil {
return err
}
return nil
}
func doDecodeFramebufferAttachmentInfo(d binary.Decoder, o *FramebufferAttachmentInfo) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Object = uint32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = FramebufferAttachmentType(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.TextureLevel = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.CubeMapFace = CubeMapImageTarget(obj)
}
return nil
}
func doSkipFramebufferAttachmentInfo(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassFramebufferAttachmentInfo) ID() binary.ID { return binaryIDFramebufferAttachmentInfo }
func (*binaryClassFramebufferAttachmentInfo) New() binary.Object { return &FramebufferAttachmentInfo{} }
func (*binaryClassFramebufferAttachmentInfo) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeFramebufferAttachmentInfo(e, obj.(*FramebufferAttachmentInfo))
}
func (*binaryClassFramebufferAttachmentInfo) Decode(d binary.Decoder) (binary.Object, error) {
obj := &FramebufferAttachmentInfo{}
return obj, doDecodeFramebufferAttachmentInfo(d, obj)
}
func (*binaryClassFramebufferAttachmentInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeFramebufferAttachmentInfo(d, obj.(*FramebufferAttachmentInfo))
}
func (*binaryClassFramebufferAttachmentInfo) Skip(d binary.Decoder) error {
return doSkipFramebufferAttachmentInfo(d)
}
func (*binaryClassFramebufferAttachmentInfo) Schema() *schema.Class {
return schemaFramebufferAttachmentInfo
}
var schemaFramebufferAttachmentInfo = &schema.Class{
TypeID: binaryIDFramebufferAttachmentInfo,
Name: "FramebufferAttachmentInfo",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Object", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "FramebufferAttachmentType", Method: schema.Uint32}},
schema.Field{Declared: "TextureLevel", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "CubeMapFace", Type: &schema.Primitive{Name: "CubeMapImageTarget", Method: schema.Uint32}},
},
}
type binaryClassFramebuffer struct{}
func (*Framebuffer) Class() binary.Class {
return (*binaryClassFramebuffer)(nil)
}
func doEncodeFramebuffer(e binary.Encoder, o *Framebuffer) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Uint32(uint32(len(o.Attachments))); err != nil {
return err
}
for k, v := range o.Attachments {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if err := e.Value(&v); err != nil {
return err
}
}
return nil
}
func doDecodeFramebuffer(d binary.Decoder, o *Framebuffer) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Attachments = make(FramebufferAttachmentːFramebufferAttachmentInfoᵐ, count)
m := o.Attachments
for i := uint32(0); i < count; i++ {
var k FramebufferAttachment
var v FramebufferAttachmentInfo
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = FramebufferAttachment(obj)
}
if err := d.Value(&v); err != nil {
return err
}
m[k] = v
}
}
return nil
}
func doSkipFramebuffer(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*FramebufferAttachmentInfo)(nil)); err != nil {
return err
}
}
}
return nil
}
func (*binaryClassFramebuffer) ID() binary.ID { return binaryIDFramebuffer }
func (*binaryClassFramebuffer) New() binary.Object { return &Framebuffer{} }
func (*binaryClassFramebuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeFramebuffer(e, obj.(*Framebuffer))
}
func (*binaryClassFramebuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Framebuffer{}
return obj, doDecodeFramebuffer(d, obj)
}
func (*binaryClassFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeFramebuffer(d, obj.(*Framebuffer))
}
func (*binaryClassFramebuffer) Skip(d binary.Decoder) error { return doSkipFramebuffer(d) }
func (*binaryClassFramebuffer) Schema() *schema.Class { return schemaFramebuffer }
var schemaFramebuffer = &schema.Class{
TypeID: binaryIDFramebuffer,
Name: "Framebuffer",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Attachments", Type: &schema.Map{Alias: "FramebufferAttachmentːFramebufferAttachmentInfoᵐ", KeyType: &schema.Primitive{Name: "FramebufferAttachment", Method: schema.Uint32}, ValueType: &schema.Struct{Name: "FramebufferAttachmentInfo"}}},
},
}
type binaryClassShader struct{}
func (*Shader) Class() binary.Class {
return (*binaryClassShader)(nil)
}
func doEncodeShader(e binary.Encoder, o *Shader) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Value(&o.Binary); err != nil {
return err
}
if err := e.Bool(o.Compiled); err != nil {
return err
}
if err := e.Bool(o.Deletable); err != nil {
return err
}
if err := e.Value(&o.InfoLog); err != nil {
return err
}
if err := e.String(o.Source); err != nil {
return err
}
if err := e.Uint32(uint32(o.Type)); err != nil {
return err
}
return nil
}
func doDecodeShader(d binary.Decoder, o *Shader) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if err := d.Value(&o.Binary); err != nil {
return err
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Compiled = bool(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Deletable = bool(obj)
}
if err := d.Value(&o.InfoLog); err != nil {
return err
}
if obj, err := d.String(); err != nil {
return err
} else {
o.Source = string(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = ShaderType(obj)
}
return nil
}
func doSkipShader(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if err := d.SkipValue((*Charˢ)(nil)); err != nil {
return err
}
if err := d.SkipString(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassShader) ID() binary.ID { return binaryIDShader }
func (*binaryClassShader) New() binary.Object { return &Shader{} }
func (*binaryClassShader) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeShader(e, obj.(*Shader))
}
func (*binaryClassShader) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Shader{}
return obj, doDecodeShader(d, obj)
}
func (*binaryClassShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeShader(d, obj.(*Shader))
}
func (*binaryClassShader) Skip(d binary.Decoder) error { return doSkipShader(d) }
func (*binaryClassShader) Schema() *schema.Class { return schemaShader }
var schemaShader = &schema.Class{
TypeID: binaryIDShader,
Name: "Shader",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Binary", Type: &schema.Struct{Name: "U8ˢ"}},
schema.Field{Declared: "Compiled", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Deletable", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "InfoLog", Type: &schema.Struct{Name: "Charˢ"}},
schema.Field{Declared: "Source", Type: &schema.Primitive{Name: "string", Method: schema.String}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "ShaderType", Method: schema.Uint32}},
},
}
type binaryClassVertexAttribute struct{}
func (*VertexAttribute) Class() binary.Class {
return (*binaryClassVertexAttribute)(nil)
}
func doEncodeVertexAttribute(e binary.Encoder, o *VertexAttribute) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Value(&o.Name); err != nil {
return err
}
if err := e.Int32(o.VectorCount); err != nil {
return err
}
if err := e.Uint32(uint32(o.Type)); err != nil {
return err
}
return nil
}
func doDecodeVertexAttribute(d binary.Decoder, o *VertexAttribute) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if err := d.Value(&o.Name); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.VectorCount = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = ShaderAttribType(obj)
}
return nil
}
func doSkipVertexAttribute(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if err := d.SkipValue((*Charˢ)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassVertexAttribute) ID() binary.ID { return binaryIDVertexAttribute }
func (*binaryClassVertexAttribute) New() binary.Object { return &VertexAttribute{} }
func (*binaryClassVertexAttribute) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVertexAttribute(e, obj.(*VertexAttribute))
}
func (*binaryClassVertexAttribute) Decode(d binary.Decoder) (binary.Object, error) {
obj := &VertexAttribute{}
return obj, doDecodeVertexAttribute(d, obj)
}
func (*binaryClassVertexAttribute) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVertexAttribute(d, obj.(*VertexAttribute))
}
func (*binaryClassVertexAttribute) Skip(d binary.Decoder) error { return doSkipVertexAttribute(d) }
func (*binaryClassVertexAttribute) Schema() *schema.Class { return schemaVertexAttribute }
var schemaVertexAttribute = &schema.Class{
TypeID: binaryIDVertexAttribute,
Name: "VertexAttribute",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Name", Type: &schema.Struct{Name: "Charˢ"}},
schema.Field{Declared: "VectorCount", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "ShaderAttribType", Method: schema.Uint32}},
},
}
type binaryClassVec2f struct{}
func (*Vec2f) Class() binary.Class {
return (*binaryClassVec2f)(nil)
}
func doEncodeVec2f(e binary.Encoder, o *Vec2f) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Float32(o.X); err != nil {
return err
}
if err := e.Float32(o.Y); err != nil {
return err
}
return nil
}
func doDecodeVec2f(d binary.Decoder, o *Vec2f) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.X = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Y = float32(obj)
}
return nil
}
func doSkipVec2f(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassVec2f) ID() binary.ID { return binaryIDVec2f }
func (*binaryClassVec2f) New() binary.Object { return &Vec2f{} }
func (*binaryClassVec2f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVec2f(e, obj.(*Vec2f))
}
func (*binaryClassVec2f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Vec2f{}
return obj, doDecodeVec2f(d, obj)
}
func (*binaryClassVec2f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVec2f(d, obj.(*Vec2f))
}
func (*binaryClassVec2f) Skip(d binary.Decoder) error { return doSkipVec2f(d) }
func (*binaryClassVec2f) Schema() *schema.Class { return schemaVec2f }
var schemaVec2f = &schema.Class{
TypeID: binaryIDVec2f,
Name: "Vec2f",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassVec3f struct{}
func (*Vec3f) Class() binary.Class {
return (*binaryClassVec3f)(nil)
}
func doEncodeVec3f(e binary.Encoder, o *Vec3f) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Float32(o.X); err != nil {
return err
}
if err := e.Float32(o.Y); err != nil {
return err
}
if err := e.Float32(o.Z); err != nil {
return err
}
return nil
}
func doDecodeVec3f(d binary.Decoder, o *Vec3f) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.X = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Y = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Z = float32(obj)
}
return nil
}
func doSkipVec3f(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassVec3f) ID() binary.ID { return binaryIDVec3f }
func (*binaryClassVec3f) New() binary.Object { return &Vec3f{} }
func (*binaryClassVec3f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVec3f(e, obj.(*Vec3f))
}
func (*binaryClassVec3f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Vec3f{}
return obj, doDecodeVec3f(d, obj)
}
func (*binaryClassVec3f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVec3f(d, obj.(*Vec3f))
}
func (*binaryClassVec3f) Skip(d binary.Decoder) error { return doSkipVec3f(d) }
func (*binaryClassVec3f) Schema() *schema.Class { return schemaVec3f }
var schemaVec3f = &schema.Class{
TypeID: binaryIDVec3f,
Name: "Vec3f",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Z", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassVec4f struct{}
func (*Vec4f) Class() binary.Class {
return (*binaryClassVec4f)(nil)
}
func doEncodeVec4f(e binary.Encoder, o *Vec4f) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Float32(o.X); err != nil {
return err
}
if err := e.Float32(o.Y); err != nil {
return err
}
if err := e.Float32(o.Z); err != nil {
return err
}
if err := e.Float32(o.W); err != nil {
return err
}
return nil
}
func doDecodeVec4f(d binary.Decoder, o *Vec4f) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.X = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Y = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Z = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.W = float32(obj)
}
return nil
}
func doSkipVec4f(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassVec4f) ID() binary.ID { return binaryIDVec4f }
func (*binaryClassVec4f) New() binary.Object { return &Vec4f{} }
func (*binaryClassVec4f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVec4f(e, obj.(*Vec4f))
}
func (*binaryClassVec4f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Vec4f{}
return obj, doDecodeVec4f(d, obj)
}
func (*binaryClassVec4f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVec4f(d, obj.(*Vec4f))
}
func (*binaryClassVec4f) Skip(d binary.Decoder) error { return doSkipVec4f(d) }
func (*binaryClassVec4f) Schema() *schema.Class { return schemaVec4f }
var schemaVec4f = &schema.Class{
TypeID: binaryIDVec4f,
Name: "Vec4f",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Z", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "W", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassVec2i struct{}
func (*Vec2i) Class() binary.Class {
return (*binaryClassVec2i)(nil)
}
func doEncodeVec2i(e binary.Encoder, o *Vec2i) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Int32(o.X); err != nil {
return err
}
if err := e.Int32(o.Y); err != nil {
return err
}
return nil
}
func doDecodeVec2i(d binary.Decoder, o *Vec2i) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.X = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Y = int32(obj)
}
return nil
}
func doSkipVec2i(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassVec2i) ID() binary.ID { return binaryIDVec2i }
func (*binaryClassVec2i) New() binary.Object { return &Vec2i{} }
func (*binaryClassVec2i) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVec2i(e, obj.(*Vec2i))
}
func (*binaryClassVec2i) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Vec2i{}
return obj, doDecodeVec2i(d, obj)
}
func (*binaryClassVec2i) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVec2i(d, obj.(*Vec2i))
}
func (*binaryClassVec2i) Skip(d binary.Decoder) error { return doSkipVec2i(d) }
func (*binaryClassVec2i) Schema() *schema.Class { return schemaVec2i }
var schemaVec2i = &schema.Class{
TypeID: binaryIDVec2i,
Name: "Vec2i",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassVec3i struct{}
func (*Vec3i) Class() binary.Class {
return (*binaryClassVec3i)(nil)
}
func doEncodeVec3i(e binary.Encoder, o *Vec3i) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Int32(o.X); err != nil {
return err
}
if err := e.Int32(o.Y); err != nil {
return err
}
if err := e.Int32(o.Z); err != nil {
return err
}
return nil
}
func doDecodeVec3i(d binary.Decoder, o *Vec3i) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.X = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Y = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Z = int32(obj)
}
return nil
}
func doSkipVec3i(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassVec3i) ID() binary.ID { return binaryIDVec3i }
func (*binaryClassVec3i) New() binary.Object { return &Vec3i{} }
func (*binaryClassVec3i) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVec3i(e, obj.(*Vec3i))
}
func (*binaryClassVec3i) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Vec3i{}
return obj, doDecodeVec3i(d, obj)
}
func (*binaryClassVec3i) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVec3i(d, obj.(*Vec3i))
}
func (*binaryClassVec3i) Skip(d binary.Decoder) error { return doSkipVec3i(d) }
func (*binaryClassVec3i) Schema() *schema.Class { return schemaVec3i }
var schemaVec3i = &schema.Class{
TypeID: binaryIDVec3i,
Name: "Vec3i",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Z", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassVec4i struct{}
func (*Vec4i) Class() binary.Class {
return (*binaryClassVec4i)(nil)
}
func doEncodeVec4i(e binary.Encoder, o *Vec4i) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Int32(o.X); err != nil {
return err
}
if err := e.Int32(o.Y); err != nil {
return err
}
if err := e.Int32(o.Z); err != nil {
return err
}
if err := e.Int32(o.W); err != nil {
return err
}
return nil
}
func doDecodeVec4i(d binary.Decoder, o *Vec4i) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.X = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Y = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Z = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.W = int32(obj)
}
return nil
}
func doSkipVec4i(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassVec4i) ID() binary.ID { return binaryIDVec4i }
func (*binaryClassVec4i) New() binary.Object { return &Vec4i{} }
func (*binaryClassVec4i) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVec4i(e, obj.(*Vec4i))
}
func (*binaryClassVec4i) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Vec4i{}
return obj, doDecodeVec4i(d, obj)
}
func (*binaryClassVec4i) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVec4i(d, obj.(*Vec4i))
}
func (*binaryClassVec4i) Skip(d binary.Decoder) error { return doSkipVec4i(d) }
func (*binaryClassVec4i) Schema() *schema.Class { return schemaVec4i }
var schemaVec4i = &schema.Class{
TypeID: binaryIDVec4i,
Name: "Vec4i",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Z", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "W", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassMat2f struct{}
func (*Mat2f) Class() binary.Class {
return (*binaryClassMat2f)(nil)
}
func doEncodeMat2f(e binary.Encoder, o *Mat2f) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Value(&o.Col0); err != nil {
return err
}
if err := e.Value(&o.Col1); err != nil {
return err
}
return nil
}
func doDecodeMat2f(d binary.Decoder, o *Mat2f) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if err := d.Value(&o.Col0); err != nil {
return err
}
if err := d.Value(&o.Col1); err != nil {
return err
}
return nil
}
func doSkipMat2f(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if err := d.SkipValue((*Vec2f)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Vec2f)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassMat2f) ID() binary.ID { return binaryIDMat2f }
func (*binaryClassMat2f) New() binary.Object { return &Mat2f{} }
func (*binaryClassMat2f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeMat2f(e, obj.(*Mat2f))
}
func (*binaryClassMat2f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Mat2f{}
return obj, doDecodeMat2f(d, obj)
}
func (*binaryClassMat2f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeMat2f(d, obj.(*Mat2f))
}
func (*binaryClassMat2f) Skip(d binary.Decoder) error { return doSkipMat2f(d) }
func (*binaryClassMat2f) Schema() *schema.Class { return schemaMat2f }
var schemaMat2f = &schema.Class{
TypeID: binaryIDMat2f,
Name: "Mat2f",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Col0", Type: &schema.Struct{Name: "Vec2f"}},
schema.Field{Declared: "Col1", Type: &schema.Struct{Name: "Vec2f"}},
},
}
type binaryClassMat3f struct{}
func (*Mat3f) Class() binary.Class {
return (*binaryClassMat3f)(nil)
}
func doEncodeMat3f(e binary.Encoder, o *Mat3f) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Value(&o.Col0); err != nil {
return err
}
if err := e.Value(&o.Col1); err != nil {
return err
}
if err := e.Value(&o.Col2); err != nil {
return err
}
return nil
}
func doDecodeMat3f(d binary.Decoder, o *Mat3f) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if err := d.Value(&o.Col0); err != nil {
return err
}
if err := d.Value(&o.Col1); err != nil {
return err
}
if err := d.Value(&o.Col2); err != nil {
return err
}
return nil
}
func doSkipMat3f(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if err := d.SkipValue((*Vec3f)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Vec3f)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Vec3f)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassMat3f) ID() binary.ID { return binaryIDMat3f }
func (*binaryClassMat3f) New() binary.Object { return &Mat3f{} }
func (*binaryClassMat3f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeMat3f(e, obj.(*Mat3f))
}
func (*binaryClassMat3f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Mat3f{}
return obj, doDecodeMat3f(d, obj)
}
func (*binaryClassMat3f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeMat3f(d, obj.(*Mat3f))
}
func (*binaryClassMat3f) Skip(d binary.Decoder) error { return doSkipMat3f(d) }
func (*binaryClassMat3f) Schema() *schema.Class { return schemaMat3f }
var schemaMat3f = &schema.Class{
TypeID: binaryIDMat3f,
Name: "Mat3f",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Col0", Type: &schema.Struct{Name: "Vec3f"}},
schema.Field{Declared: "Col1", Type: &schema.Struct{Name: "Vec3f"}},
schema.Field{Declared: "Col2", Type: &schema.Struct{Name: "Vec3f"}},
},
}
type binaryClassMat4f struct{}
func (*Mat4f) Class() binary.Class {
return (*binaryClassMat4f)(nil)
}
func doEncodeMat4f(e binary.Encoder, o *Mat4f) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Value(&o.Col0); err != nil {
return err
}
if err := e.Value(&o.Col1); err != nil {
return err
}
if err := e.Value(&o.Col2); err != nil {
return err
}
if err := e.Value(&o.Col3); err != nil {
return err
}
return nil
}
func doDecodeMat4f(d binary.Decoder, o *Mat4f) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if err := d.Value(&o.Col0); err != nil {
return err
}
if err := d.Value(&o.Col1); err != nil {
return err
}
if err := d.Value(&o.Col2); err != nil {
return err
}
if err := d.Value(&o.Col3); err != nil {
return err
}
return nil
}
func doSkipMat4f(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if err := d.SkipValue((*Vec4f)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Vec4f)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Vec4f)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Vec4f)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassMat4f) ID() binary.ID { return binaryIDMat4f }
func (*binaryClassMat4f) New() binary.Object { return &Mat4f{} }
func (*binaryClassMat4f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeMat4f(e, obj.(*Mat4f))
}
func (*binaryClassMat4f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Mat4f{}
return obj, doDecodeMat4f(d, obj)
}
func (*binaryClassMat4f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeMat4f(d, obj.(*Mat4f))
}
func (*binaryClassMat4f) Skip(d binary.Decoder) error { return doSkipMat4f(d) }
func (*binaryClassMat4f) Schema() *schema.Class { return schemaMat4f }
var schemaMat4f = &schema.Class{
TypeID: binaryIDMat4f,
Name: "Mat4f",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Col0", Type: &schema.Struct{Name: "Vec4f"}},
schema.Field{Declared: "Col1", Type: &schema.Struct{Name: "Vec4f"}},
schema.Field{Declared: "Col2", Type: &schema.Struct{Name: "Vec4f"}},
schema.Field{Declared: "Col3", Type: &schema.Struct{Name: "Vec4f"}},
},
}
type binaryClassUniformValue struct{}
func (*UniformValue) Class() binary.Class {
return (*binaryClassUniformValue)(nil)
}
func doEncodeUniformValue(e binary.Encoder, o *UniformValue) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Float32(o.F32); err != nil {
return err
}
if err := e.Value(&o.Vec2f); err != nil {
return err
}
if err := e.Value(&o.Vec3f); err != nil {
return err
}
if err := e.Value(&o.Vec4f); err != nil {
return err
}
if err := e.Int32(o.S32); err != nil {
return err
}
if err := e.Value(&o.Vec2i); err != nil {
return err
}
if err := e.Value(&o.Vec3i); err != nil {
return err
}
if err := e.Value(&o.Vec4i); err != nil {
return err
}
if err := e.Value(&o.Mat2f); err != nil {
return err
}
if err := e.Value(&o.Mat3f); err != nil {
return err
}
if err := e.Value(&o.Mat4f); err != nil {
return err
}
return nil
}
func doDecodeUniformValue(d binary.Decoder, o *UniformValue) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.F32 = float32(obj)
}
if err := d.Value(&o.Vec2f); err != nil {
return err
}
if err := d.Value(&o.Vec3f); err != nil {
return err
}
if err := d.Value(&o.Vec4f); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.S32 = int32(obj)
}
if err := d.Value(&o.Vec2i); err != nil {
return err
}
if err := d.Value(&o.Vec3i); err != nil {
return err
}
if err := d.Value(&o.Vec4i); err != nil {
return err
}
if err := d.Value(&o.Mat2f); err != nil {
return err
}
if err := d.Value(&o.Mat3f); err != nil {
return err
}
if err := d.Value(&o.Mat4f); err != nil {
return err
}
return nil
}
func doSkipUniformValue(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if err := d.SkipValue((*Vec2f)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Vec3f)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Vec4f)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*Vec2i)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Vec3i)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Vec4i)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Mat2f)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Mat3f)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Mat4f)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassUniformValue) ID() binary.ID { return binaryIDUniformValue }
func (*binaryClassUniformValue) New() binary.Object { return &UniformValue{} }
func (*binaryClassUniformValue) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeUniformValue(e, obj.(*UniformValue))
}
func (*binaryClassUniformValue) Decode(d binary.Decoder) (binary.Object, error) {
obj := &UniformValue{}
return obj, doDecodeUniformValue(d, obj)
}
func (*binaryClassUniformValue) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeUniformValue(d, obj.(*UniformValue))
}
func (*binaryClassUniformValue) Skip(d binary.Decoder) error { return doSkipUniformValue(d) }
func (*binaryClassUniformValue) Schema() *schema.Class { return schemaUniformValue }
var schemaUniformValue = &schema.Class{
TypeID: binaryIDUniformValue,
Name: "UniformValue",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "F32", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Vec2f", Type: &schema.Struct{Name: "Vec2f"}},
schema.Field{Declared: "Vec3f", Type: &schema.Struct{Name: "Vec3f"}},
schema.Field{Declared: "Vec4f", Type: &schema.Struct{Name: "Vec4f"}},
schema.Field{Declared: "S32", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Vec2i", Type: &schema.Struct{Name: "Vec2i"}},
schema.Field{Declared: "Vec3i", Type: &schema.Struct{Name: "Vec3i"}},
schema.Field{Declared: "Vec4i", Type: &schema.Struct{Name: "Vec4i"}},
schema.Field{Declared: "Mat2f", Type: &schema.Struct{Name: "Mat2f"}},
schema.Field{Declared: "Mat3f", Type: &schema.Struct{Name: "Mat3f"}},
schema.Field{Declared: "Mat4f", Type: &schema.Struct{Name: "Mat4f"}},
},
}
type binaryClassUniform struct{}
func (*Uniform) Class() binary.Class {
return (*binaryClassUniform)(nil)
}
func doEncodeUniform(e binary.Encoder, o *Uniform) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.String(o.Name); err != nil {
return err
}
if err := e.Uint32(uint32(o.Type)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeUniform(d binary.Decoder, o *Uniform) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.String(); err != nil {
return err
} else {
o.Name = string(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = ShaderUniformType(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipUniform(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if err := d.SkipString(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*UniformValue)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassUniform) ID() binary.ID { return binaryIDUniform }
func (*binaryClassUniform) New() binary.Object { return &Uniform{} }
func (*binaryClassUniform) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeUniform(e, obj.(*Uniform))
}
func (*binaryClassUniform) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Uniform{}
return obj, doDecodeUniform(d, obj)
}
func (*binaryClassUniform) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeUniform(d, obj.(*Uniform))
}
func (*binaryClassUniform) Skip(d binary.Decoder) error { return doSkipUniform(d) }
func (*binaryClassUniform) Schema() *schema.Class { return schemaUniform }
var schemaUniform = &schema.Class{
TypeID: binaryIDUniform,
Name: "Uniform",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "ShaderUniformType", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "UniformValue"}},
},
}
type binaryClassProgram struct{}
func (*Program) Class() binary.Class {
return (*binaryClassProgram)(nil)
}
func doEncodeProgram(e binary.Encoder, o *Program) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Uint32(uint32(len(o.Shaders))); err != nil {
return err
}
for k, v := range o.Shaders {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if err := e.Uint32(uint32(v)); err != nil {
return err
}
}
if err := e.Bool(o.Linked); err != nil {
return err
}
if err := e.Value(&o.Binary); err != nil {
return err
}
if err := e.Uint32(uint32(len(o.AttributeBindings))); err != nil {
return err
}
for k, v := range o.AttributeBindings {
if err := e.String(k); err != nil {
return err
}
if err := e.Uint32(uint32(v)); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.Attributes))); err != nil {
return err
}
for k, v := range o.Attributes {
if err := e.Int32(k); err != nil {
return err
}
if err := e.Value(&v); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.Uniforms))); err != nil {
return err
}
for k, v := range o.Uniforms {
if err := e.Int32(int32(k)); err != nil {
return err
}
if err := e.Value(&v); err != nil {
return err
}
}
if err := e.Value(&o.InfoLog); err != nil {
return err
}
return nil
}
func doDecodeProgram(d binary.Decoder, o *Program) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Shaders = make(ShaderTypeːShaderIdᵐ, count)
m := o.Shaders
for i := uint32(0); i < count; i++ {
var k ShaderType
var v ShaderId
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = ShaderType(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
v = ShaderId(obj)
}
m[k] = v
}
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Linked = bool(obj)
}
if err := d.Value(&o.Binary); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.AttributeBindings = make(StringːAttributeLocationᵐ, count)
m := o.AttributeBindings
for i := uint32(0); i < count; i++ {
var k string
var v AttributeLocation
if obj, err := d.String(); err != nil {
return err
} else {
k = string(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
v = AttributeLocation(obj)
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Attributes = make(S32ːVertexAttributeᵐ, count)
m := o.Attributes
for i := uint32(0); i < count; i++ {
var k int32
var v VertexAttribute
if obj, err := d.Int32(); err != nil {
return err
} else {
k = int32(obj)
}
if err := d.Value(&v); err != nil {
return err
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Uniforms = make(UniformLocationːUniformᵐ, count)
m := o.Uniforms
for i := uint32(0); i < count; i++ {
var k UniformLocation
var v Uniform
if obj, err := d.Int32(); err != nil {
return err
} else {
k = UniformLocation(obj)
}
if err := d.Value(&v); err != nil {
return err
}
m[k] = v
}
}
if err := d.Value(&o.InfoLog); err != nil {
return err
}
return nil
}
func doSkipProgram(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
}
}
if _, err := d.Bool(); err != nil {
return err
}
if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if err := d.SkipString(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*VertexAttribute)(nil)); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*Uniform)(nil)); err != nil {
return err
}
}
}
if err := d.SkipValue((*Charˢ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassProgram) ID() binary.ID { return binaryIDProgram }
func (*binaryClassProgram) New() binary.Object { return &Program{} }
func (*binaryClassProgram) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeProgram(e, obj.(*Program))
}
func (*binaryClassProgram) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Program{}
return obj, doDecodeProgram(d, obj)
}
func (*binaryClassProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeProgram(d, obj.(*Program))
}
func (*binaryClassProgram) Skip(d binary.Decoder) error { return doSkipProgram(d) }
func (*binaryClassProgram) Schema() *schema.Class { return schemaProgram }
var schemaProgram = &schema.Class{
TypeID: binaryIDProgram,
Name: "Program",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Shaders", Type: &schema.Map{Alias: "ShaderTypeːShaderIdᵐ", KeyType: &schema.Primitive{Name: "ShaderType", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}}},
schema.Field{Declared: "Linked", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Binary", Type: &schema.Struct{Name: "U8ˢ"}},
schema.Field{Declared: "AttributeBindings", Type: &schema.Map{Alias: "StringːAttributeLocationᵐ", KeyType: &schema.Primitive{Name: "string", Method: schema.String}, ValueType: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}}},
schema.Field{Declared: "Attributes", Type: &schema.Map{Alias: "S32ːVertexAttributeᵐ", KeyType: &schema.Primitive{Name: "int32", Method: schema.Int32}, ValueType: &schema.Struct{Name: "VertexAttribute"}}},
schema.Field{Declared: "Uniforms", Type: &schema.Map{Alias: "UniformLocationːUniformᵐ", KeyType: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}, ValueType: &schema.Struct{Name: "Uniform"}}},
schema.Field{Declared: "InfoLog", Type: &schema.Struct{Name: "Charˢ"}},
},
}
type binaryClassVertexArray struct{}
func (*VertexArray) Class() binary.Class {
return (*binaryClassVertexArray)(nil)
}
func doEncodeVertexArray(e binary.Encoder, o *VertexArray) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
return nil
}
func doDecodeVertexArray(d binary.Decoder, o *VertexArray) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
return nil
}
func doSkipVertexArray(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
return nil
}
func (*binaryClassVertexArray) ID() binary.ID { return binaryIDVertexArray }
func (*binaryClassVertexArray) New() binary.Object { return &VertexArray{} }
func (*binaryClassVertexArray) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVertexArray(e, obj.(*VertexArray))
}
func (*binaryClassVertexArray) Decode(d binary.Decoder) (binary.Object, error) {
obj := &VertexArray{}
return obj, doDecodeVertexArray(d, obj)
}
func (*binaryClassVertexArray) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVertexArray(d, obj.(*VertexArray))
}
func (*binaryClassVertexArray) Skip(d binary.Decoder) error { return doSkipVertexArray(d) }
func (*binaryClassVertexArray) Schema() *schema.Class { return schemaVertexArray }
var schemaVertexArray = &schema.Class{
TypeID: binaryIDVertexArray,
Name: "VertexArray",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
},
}
type binaryClassQuery struct{}
func (*Query) Class() binary.Class {
return (*binaryClassQuery)(nil)
}
func doEncodeQuery(e binary.Encoder, o *Query) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
return nil
}
func doDecodeQuery(d binary.Decoder, o *Query) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
return nil
}
func doSkipQuery(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
return nil
}
func (*binaryClassQuery) ID() binary.ID { return binaryIDQuery }
func (*binaryClassQuery) New() binary.Object { return &Query{} }
func (*binaryClassQuery) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeQuery(e, obj.(*Query))
}
func (*binaryClassQuery) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Query{}
return obj, doDecodeQuery(d, obj)
}
func (*binaryClassQuery) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeQuery(d, obj.(*Query))
}
func (*binaryClassQuery) Skip(d binary.Decoder) error { return doSkipQuery(d) }
func (*binaryClassQuery) Schema() *schema.Class { return schemaQuery }
var schemaQuery = &schema.Class{
TypeID: binaryIDQuery,
Name: "Query",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
},
}
type binaryClassObjects struct{}
func (*Objects) Class() binary.Class {
return (*binaryClassObjects)(nil)
}
func doEncodeObjects(e binary.Encoder, o *Objects) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Uint32(uint32(len(o.Renderbuffers))); err != nil {
return err
}
for k, v := range o.Renderbuffers {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.Textures))); err != nil {
return err
}
for k, v := range o.Textures {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.Framebuffers))); err != nil {
return err
}
for k, v := range o.Framebuffers {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.Buffers))); err != nil {
return err
}
for k, v := range o.Buffers {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.Shaders))); err != nil {
return err
}
for k, v := range o.Shaders {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.Programs))); err != nil {
return err
}
for k, v := range o.Programs {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.VertexArrays))); err != nil {
return err
}
for k, v := range o.VertexArrays {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.Queries))); err != nil {
return err
}
for k, v := range o.Queries {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
return nil
}
func doDecodeObjects(d binary.Decoder, o *Objects) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Renderbuffers = make(RenderbufferIdːRenderbufferʳᵐ, count)
m := o.Renderbuffers
for i := uint32(0); i < count; i++ {
var k RenderbufferId
var v *Renderbuffer
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = RenderbufferId(obj)
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*Renderbuffer)
} else {
v = nil
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Textures = make(TextureIdːTextureʳᵐ, count)
m := o.Textures
for i := uint32(0); i < count; i++ {
var k TextureId
var v *Texture
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = TextureId(obj)
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*Texture)
} else {
v = nil
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Framebuffers = make(FramebufferIdːFramebufferʳᵐ, count)
m := o.Framebuffers
for i := uint32(0); i < count; i++ {
var k FramebufferId
var v *Framebuffer
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = FramebufferId(obj)
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*Framebuffer)
} else {
v = nil
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Buffers = make(BufferIdːBufferʳᵐ, count)
m := o.Buffers
for i := uint32(0); i < count; i++ {
var k BufferId
var v *Buffer
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = BufferId(obj)
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*Buffer)
} else {
v = nil
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Shaders = make(ShaderIdːShaderʳᵐ, count)
m := o.Shaders
for i := uint32(0); i < count; i++ {
var k ShaderId
var v *Shader
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = ShaderId(obj)
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*Shader)
} else {
v = nil
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Programs = make(ProgramIdːProgramʳᵐ, count)
m := o.Programs
for i := uint32(0); i < count; i++ {
var k ProgramId
var v *Program
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = ProgramId(obj)
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*Program)
} else {
v = nil
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.VertexArrays = make(VertexArrayIdːVertexArrayʳᵐ, count)
m := o.VertexArrays
for i := uint32(0); i < count; i++ {
var k VertexArrayId
var v *VertexArray
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = VertexArrayId(obj)
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*VertexArray)
} else {
v = nil
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Queries = make(QueryIdːQueryʳᵐ, count)
m := o.Queries
for i := uint32(0); i < count; i++ {
var k QueryId
var v *Query
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = QueryId(obj)
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*Query)
} else {
v = nil
}
m[k] = v
}
}
return nil
}
func doSkipObjects(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
return nil
}
func (*binaryClassObjects) ID() binary.ID { return binaryIDObjects }
func (*binaryClassObjects) New() binary.Object { return &Objects{} }
func (*binaryClassObjects) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeObjects(e, obj.(*Objects))
}
func (*binaryClassObjects) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Objects{}
return obj, doDecodeObjects(d, obj)
}
func (*binaryClassObjects) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeObjects(d, obj.(*Objects))
}
func (*binaryClassObjects) Skip(d binary.Decoder) error { return doSkipObjects(d) }
func (*binaryClassObjects) Schema() *schema.Class { return schemaObjects }
var schemaObjects = &schema.Class{
TypeID: binaryIDObjects,
Name: "Objects",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Renderbuffers", Type: &schema.Map{Alias: "RenderbufferIdːRenderbufferʳᵐ", KeyType: &schema.Primitive{Name: "RenderbufferId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Renderbuffer"}}}},
schema.Field{Declared: "Textures", Type: &schema.Map{Alias: "TextureIdːTextureʳᵐ", KeyType: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Texture"}}}},
schema.Field{Declared: "Framebuffers", Type: &schema.Map{Alias: "FramebufferIdːFramebufferʳᵐ", KeyType: &schema.Primitive{Name: "FramebufferId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Framebuffer"}}}},
schema.Field{Declared: "Buffers", Type: &schema.Map{Alias: "BufferIdːBufferʳᵐ", KeyType: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Buffer"}}}},
schema.Field{Declared: "Shaders", Type: &schema.Map{Alias: "ShaderIdːShaderʳᵐ", KeyType: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Shader"}}}},
schema.Field{Declared: "Programs", Type: &schema.Map{Alias: "ProgramIdːProgramʳᵐ", KeyType: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Program"}}}},
schema.Field{Declared: "VertexArrays", Type: &schema.Map{Alias: "VertexArrayIdːVertexArrayʳᵐ", KeyType: &schema.Primitive{Name: "VertexArrayId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "VertexArray"}}}},
schema.Field{Declared: "Queries", Type: &schema.Map{Alias: "QueryIdːQueryʳᵐ", KeyType: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Query"}}}},
},
}
type binaryClassContext struct{}
func (*Context) Class() binary.Class {
return (*binaryClassContext)(nil)
}
func doEncodeContext(e binary.Encoder, o *Context) error {
if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Identifier)); err != nil {
return err
}
if err := e.Value(&o.Blending); err != nil {
return err
}
if err := e.Value(&o.Rasterizing); err != nil {
return err
}
if err := e.Value(&o.Clearing); err != nil {
return err
}
if err := e.Uint32(uint32(len(o.BoundFramebuffers))); err != nil {
return err
}
for k, v := range o.BoundFramebuffers {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if err := e.Uint32(uint32(v)); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.BoundRenderbuffers))); err != nil {
return err
}
for k, v := range o.BoundRenderbuffers {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if err := e.Uint32(uint32(v)); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.BoundBuffers))); err != nil {
return err
}
for k, v := range o.BoundBuffers {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if err := e.Uint32(uint32(v)); err != nil {
return err
}
}
if err := e.Uint32(uint32(o.BoundProgram)); err != nil {
return err
}
if err := e.Uint32(uint32(o.BoundVertexArray)); err != nil {
return err
}
if err := e.Uint32(uint32(len(o.VertexAttributeArrays))); err != nil {
return err
}
for k, v := range o.VertexAttributeArrays {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.TextureUnits))); err != nil {
return err
}
for k, v := range o.TextureUnits {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if err := e.Uint32(uint32(len(v))); err != nil {
return err
}
for k, v := range v {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if err := e.Uint32(uint32(v)); err != nil {
return err
}
}
}
if err := e.Uint32(uint32(o.ActiveTextureUnit)); err != nil {
return err
}
if err := e.Uint32(uint32(len(o.Capabilities))); err != nil {
return err
}
for k, v := range o.Capabilities {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if err := e.Bool(v); err != nil {
return err
}
}
if err := e.Uint32(uint32(o.GenerateMipmapHint)); err != nil {
return err
}
if err := e.Uint32(uint32(len(o.PixelStorage))); err != nil {
return err
}
for k, v := range o.PixelStorage {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if err := e.Int32(v); err != nil {
return err
}
}
if err := e.Value(&o.Instances); err != nil {
return err
}
return nil
}
func doDecodeContext(d binary.Decoder, o *Context) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.CreatedAt = atom.ID(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Identifier = ContextID(obj)
}
if err := d.Value(&o.Blending); err != nil {
return err
}
if err := d.Value(&o.Rasterizing); err != nil {
return err
}
if err := d.Value(&o.Clearing); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.BoundFramebuffers = make(FramebufferTargetːFramebufferIdᵐ, count)
m := o.BoundFramebuffers
for i := uint32(0); i < count; i++ {
var k FramebufferTarget
var v FramebufferId
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = FramebufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
v = FramebufferId(obj)
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.BoundRenderbuffers = make(RenderbufferTargetːRenderbufferIdᵐ, count)
m := o.BoundRenderbuffers
for i := uint32(0); i < count; i++ {
var k RenderbufferTarget
var v RenderbufferId
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = RenderbufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
v = RenderbufferId(obj)
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.BoundBuffers = make(BufferTargetːBufferIdᵐ, count)
m := o.BoundBuffers
for i := uint32(0); i < count; i++ {
var k BufferTarget
var v BufferId
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = BufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
v = BufferId(obj)
}
m[k] = v
}
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.BoundProgram = ProgramId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.BoundVertexArray = VertexArrayId(obj)
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.VertexAttributeArrays = make(AttributeLocationːVertexAttributeArrayʳᵐ, count)
m := o.VertexAttributeArrays
for i := uint32(0); i < count; i++ {
var k AttributeLocation
var v *VertexAttributeArray
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = AttributeLocation(obj)
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*VertexAttributeArray)
} else {
v = nil
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.TextureUnits = make(TextureUnitːTextureTargetːTextureIdᵐᵐ, count)
m := o.TextureUnits
for i := uint32(0); i < count; i++ {
var k TextureUnit
var v TextureTargetːTextureIdᵐ
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = TextureUnit(obj)
}
if count, err := d.Uint32(); err != nil {
return err
} else {
v = make(TextureTargetːTextureIdᵐ, count)
m := v
for i := uint32(0); i < count; i++ {
var k TextureTarget
var v TextureId
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = TextureTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
v = TextureId(obj)
}
m[k] = v
}
}
m[k] = v
}
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.ActiveTextureUnit = TextureUnit(obj)
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Capabilities = make(Capabilityːboolᵐ, count)
m := o.Capabilities
for i := uint32(0); i < count; i++ {
var k Capability
var v bool
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = Capability(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
v = bool(obj)
}
m[k] = v
}
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.GenerateMipmapHint = HintMode(obj)
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.PixelStorage = make(PixelStoreParameterːs32ᵐ, count)
m := o.PixelStorage
for i := uint32(0); i < count; i++ {
var k PixelStoreParameter
var v int32
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = PixelStoreParameter(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
v = int32(obj)
}
m[k] = v
}
}
if err := d.Value(&o.Instances); err != nil {
return err
}
return nil
}
func doSkipContext(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*BlendState)(nil)); err != nil {
return err
}
if err := d.SkipValue((*RasterizerState)(nil)); err != nil {
return err
}
if err := d.SkipValue((*ClearState)(nil)); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
}
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
}
}
}
}
if _, err := d.Uint32(); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
}
}
if _, err := d.Uint32(); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
}
}
if err := d.SkipValue((*Objects)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassContext) ID() binary.ID { return binaryIDContext }
func (*binaryClassContext) New() binary.Object { return &Context{} }
func (*binaryClassContext) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeContext(e, obj.(*Context))
}
func (*binaryClassContext) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Context{}
return obj, doDecodeContext(d, obj)
}
func (*binaryClassContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeContext(d, obj.(*Context))
}
func (*binaryClassContext) Skip(d binary.Decoder) error { return doSkipContext(d) }
func (*binaryClassContext) Schema() *schema.Class { return schemaContext }
var schemaContext = &schema.Class{
TypeID: binaryIDContext,
Name: "Context",
Fields: []schema.Field{
schema.Field{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
schema.Field{Declared: "Identifier", Type: &schema.Primitive{Name: "ContextID", Method: schema.Uint32}},
schema.Field{Declared: "Blending", Type: &schema.Struct{Name: "BlendState"}},
schema.Field{Declared: "Rasterizing", Type: &schema.Struct{Name: "RasterizerState"}},
schema.Field{Declared: "Clearing", Type: &schema.Struct{Name: "ClearState"}},
schema.Field{Declared: "BoundFramebuffers", Type: &schema.Map{Alias: "FramebufferTargetːFramebufferIdᵐ", KeyType: &schema.Primitive{Name: "FramebufferTarget", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "FramebufferId", Method: schema.Uint32}}},
schema.Field{Declared: "BoundRenderbuffers", Type: &schema.Map{Alias: "RenderbufferTargetːRenderbufferIdᵐ", KeyType: &schema.Primitive{Name: "RenderbufferTarget", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "RenderbufferId", Method: schema.Uint32}}},
schema.Field{Declared: "BoundBuffers", Type: &schema.Map{Alias: "BufferTargetːBufferIdᵐ", KeyType: &schema.Primitive{Name: "BufferTarget", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}}},
schema.Field{Declared: "BoundProgram", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "BoundVertexArray", Type: &schema.Primitive{Name: "VertexArrayId", Method: schema.Uint32}},
schema.Field{Declared: "VertexAttributeArrays", Type: &schema.Map{Alias: "AttributeLocationːVertexAttributeArrayʳᵐ", KeyType: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "VertexAttributeArray"}}}},
schema.Field{Declared: "TextureUnits", Type: &schema.Map{Alias: "TextureUnitːTextureTargetːTextureIdᵐᵐ", KeyType: &schema.Primitive{Name: "TextureUnit", Method: schema.Uint32}, ValueType: &schema.Map{Alias: "TextureTargetːTextureIdᵐ", KeyType: &schema.Primitive{Name: "TextureTarget", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}}}},
schema.Field{Declared: "ActiveTextureUnit", Type: &schema.Primitive{Name: "TextureUnit", Method: schema.Uint32}},
schema.Field{Declared: "Capabilities", Type: &schema.Map{Alias: "Capabilityːboolᵐ", KeyType: &schema.Primitive{Name: "Capability", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "bool", Method: schema.Bool}}},
schema.Field{Declared: "GenerateMipmapHint", Type: &schema.Primitive{Name: "HintMode", Method: schema.Uint32}},
schema.Field{Declared: "PixelStorage", Type: &schema.Map{Alias: "PixelStoreParameterːs32ᵐ", KeyType: &schema.Primitive{Name: "PixelStoreParameter", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "int32", Method: schema.Int32}}},
schema.Field{Declared: "Instances", Type: &schema.Struct{Name: "Objects"}},
},
}
type binaryClassDiscardFramebufferAttachmentˢ struct{}
func (*DiscardFramebufferAttachmentˢ) Class() binary.Class {
return (*binaryClassDiscardFramebufferAttachmentˢ)(nil)
}
func doEncodeDiscardFramebufferAttachmentˢ(e binary.Encoder, o *DiscardFramebufferAttachmentˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeDiscardFramebufferAttachmentˢ(d binary.Decoder, o *DiscardFramebufferAttachmentˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipDiscardFramebufferAttachmentˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassDiscardFramebufferAttachmentˢ) ID() binary.ID {
return binaryIDDiscardFramebufferAttachmentˢ
}
func (*binaryClassDiscardFramebufferAttachmentˢ) New() binary.Object {
return &DiscardFramebufferAttachmentˢ{}
}
func (*binaryClassDiscardFramebufferAttachmentˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeDiscardFramebufferAttachmentˢ(e, obj.(*DiscardFramebufferAttachmentˢ))
}
func (*binaryClassDiscardFramebufferAttachmentˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &DiscardFramebufferAttachmentˢ{}
return obj, doDecodeDiscardFramebufferAttachmentˢ(d, obj)
}
func (*binaryClassDiscardFramebufferAttachmentˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeDiscardFramebufferAttachmentˢ(d, obj.(*DiscardFramebufferAttachmentˢ))
}
func (*binaryClassDiscardFramebufferAttachmentˢ) Skip(d binary.Decoder) error {
return doSkipDiscardFramebufferAttachmentˢ(d)
}
func (*binaryClassDiscardFramebufferAttachmentˢ) Schema() *schema.Class {
return schemaDiscardFramebufferAttachmentˢ
}
var schemaDiscardFramebufferAttachmentˢ = &schema.Class{
TypeID: binaryIDDiscardFramebufferAttachmentˢ,
Name: "DiscardFramebufferAttachmentˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassDiscardFramebufferAttachmentᵖ struct{}
func (*DiscardFramebufferAttachmentᵖ) Class() binary.Class {
return (*binaryClassDiscardFramebufferAttachmentᵖ)(nil)
}
func doEncodeDiscardFramebufferAttachmentᵖ(e binary.Encoder, o *DiscardFramebufferAttachmentᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeDiscardFramebufferAttachmentᵖ(d binary.Decoder, o *DiscardFramebufferAttachmentᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipDiscardFramebufferAttachmentᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassDiscardFramebufferAttachmentᵖ) ID() binary.ID {
return binaryIDDiscardFramebufferAttachmentᵖ
}
func (*binaryClassDiscardFramebufferAttachmentᵖ) New() binary.Object {
return &DiscardFramebufferAttachmentᵖ{}
}
func (*binaryClassDiscardFramebufferAttachmentᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeDiscardFramebufferAttachmentᵖ(e, obj.(*DiscardFramebufferAttachmentᵖ))
}
func (*binaryClassDiscardFramebufferAttachmentᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &DiscardFramebufferAttachmentᵖ{}
return obj, doDecodeDiscardFramebufferAttachmentᵖ(d, obj)
}
func (*binaryClassDiscardFramebufferAttachmentᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeDiscardFramebufferAttachmentᵖ(d, obj.(*DiscardFramebufferAttachmentᵖ))
}
func (*binaryClassDiscardFramebufferAttachmentᵖ) Skip(d binary.Decoder) error {
return doSkipDiscardFramebufferAttachmentᵖ(d)
}
func (*binaryClassDiscardFramebufferAttachmentᵖ) Schema() *schema.Class {
return schemaDiscardFramebufferAttachmentᵖ
}
var schemaDiscardFramebufferAttachmentᵖ = &schema.Class{
TypeID: binaryIDDiscardFramebufferAttachmentᵖ,
Name: "DiscardFramebufferAttachmentᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassEGLConfig struct{}
func (*EGLConfig) Class() binary.Class {
return (*binaryClassEGLConfig)(nil)
}
func doEncodeEGLConfig(e binary.Encoder, o *EGLConfig) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeEGLConfig(d binary.Decoder, o *EGLConfig) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipEGLConfig(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassEGLConfig) ID() binary.ID { return binaryIDEGLConfig }
func (*binaryClassEGLConfig) New() binary.Object { return &EGLConfig{} }
func (*binaryClassEGLConfig) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeEGLConfig(e, obj.(*EGLConfig))
}
func (*binaryClassEGLConfig) Decode(d binary.Decoder) (binary.Object, error) {
obj := &EGLConfig{}
return obj, doDecodeEGLConfig(d, obj)
}
func (*binaryClassEGLConfig) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeEGLConfig(d, obj.(*EGLConfig))
}
func (*binaryClassEGLConfig) Skip(d binary.Decoder) error { return doSkipEGLConfig(d) }
func (*binaryClassEGLConfig) Schema() *schema.Class { return schemaEGLConfig }
var schemaEGLConfig = &schema.Class{
TypeID: binaryIDEGLConfig,
Name: "EGLConfig",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassEGLContext struct{}
func (*EGLContext) Class() binary.Class {
return (*binaryClassEGLContext)(nil)
}
func doEncodeEGLContext(e binary.Encoder, o *EGLContext) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeEGLContext(d binary.Decoder, o *EGLContext) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipEGLContext(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassEGLContext) ID() binary.ID { return binaryIDEGLContext }
func (*binaryClassEGLContext) New() binary.Object { return &EGLContext{} }
func (*binaryClassEGLContext) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeEGLContext(e, obj.(*EGLContext))
}
func (*binaryClassEGLContext) Decode(d binary.Decoder) (binary.Object, error) {
obj := &EGLContext{}
return obj, doDecodeEGLContext(d, obj)
}
func (*binaryClassEGLContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeEGLContext(d, obj.(*EGLContext))
}
func (*binaryClassEGLContext) Skip(d binary.Decoder) error { return doSkipEGLContext(d) }
func (*binaryClassEGLContext) Schema() *schema.Class { return schemaEGLContext }
var schemaEGLContext = &schema.Class{
TypeID: binaryIDEGLContext,
Name: "EGLContext",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassEGLDisplay struct{}
func (*EGLDisplay) Class() binary.Class {
return (*binaryClassEGLDisplay)(nil)
}
func doEncodeEGLDisplay(e binary.Encoder, o *EGLDisplay) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeEGLDisplay(d binary.Decoder, o *EGLDisplay) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipEGLDisplay(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassEGLDisplay) ID() binary.ID { return binaryIDEGLDisplay }
func (*binaryClassEGLDisplay) New() binary.Object { return &EGLDisplay{} }
func (*binaryClassEGLDisplay) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeEGLDisplay(e, obj.(*EGLDisplay))
}
func (*binaryClassEGLDisplay) Decode(d binary.Decoder) (binary.Object, error) {
obj := &EGLDisplay{}
return obj, doDecodeEGLDisplay(d, obj)
}
func (*binaryClassEGLDisplay) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeEGLDisplay(d, obj.(*EGLDisplay))
}
func (*binaryClassEGLDisplay) Skip(d binary.Decoder) error { return doSkipEGLDisplay(d) }
func (*binaryClassEGLDisplay) Schema() *schema.Class { return schemaEGLDisplay }
var schemaEGLDisplay = &schema.Class{
TypeID: binaryIDEGLDisplay,
Name: "EGLDisplay",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassEGLSurface struct{}
func (*EGLSurface) Class() binary.Class {
return (*binaryClassEGLSurface)(nil)
}
func doEncodeEGLSurface(e binary.Encoder, o *EGLSurface) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeEGLSurface(d binary.Decoder, o *EGLSurface) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipEGLSurface(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassEGLSurface) ID() binary.ID { return binaryIDEGLSurface }
func (*binaryClassEGLSurface) New() binary.Object { return &EGLSurface{} }
func (*binaryClassEGLSurface) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeEGLSurface(e, obj.(*EGLSurface))
}
func (*binaryClassEGLSurface) Decode(d binary.Decoder) (binary.Object, error) {
obj := &EGLSurface{}
return obj, doDecodeEGLSurface(d, obj)
}
func (*binaryClassEGLSurface) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeEGLSurface(d, obj.(*EGLSurface))
}
func (*binaryClassEGLSurface) Skip(d binary.Decoder) error { return doSkipEGLSurface(d) }
func (*binaryClassEGLSurface) Schema() *schema.Class { return schemaEGLSurface }
var schemaEGLSurface = &schema.Class{
TypeID: binaryIDEGLSurface,
Name: "EGLSurface",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassEGLintˢ struct{}
func (*EGLintˢ) Class() binary.Class {
return (*binaryClassEGLintˢ)(nil)
}
func doEncodeEGLintˢ(e binary.Encoder, o *EGLintˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeEGLintˢ(d binary.Decoder, o *EGLintˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipEGLintˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassEGLintˢ) ID() binary.ID { return binaryIDEGLintˢ }
func (*binaryClassEGLintˢ) New() binary.Object { return &EGLintˢ{} }
func (*binaryClassEGLintˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeEGLintˢ(e, obj.(*EGLintˢ))
}
func (*binaryClassEGLintˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &EGLintˢ{}
return obj, doDecodeEGLintˢ(d, obj)
}
func (*binaryClassEGLintˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeEGLintˢ(d, obj.(*EGLintˢ))
}
func (*binaryClassEGLintˢ) Skip(d binary.Decoder) error { return doSkipEGLintˢ(d) }
func (*binaryClassEGLintˢ) Schema() *schema.Class { return schemaEGLintˢ }
var schemaEGLintˢ = &schema.Class{
TypeID: binaryIDEGLintˢ,
Name: "EGLintˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassEGLintᵖ struct{}
func (*EGLintᵖ) Class() binary.Class {
return (*binaryClassEGLintᵖ)(nil)
}
func doEncodeEGLintᵖ(e binary.Encoder, o *EGLintᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeEGLintᵖ(d binary.Decoder, o *EGLintᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipEGLintᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassEGLintᵖ) ID() binary.ID { return binaryIDEGLintᵖ }
func (*binaryClassEGLintᵖ) New() binary.Object { return &EGLintᵖ{} }
func (*binaryClassEGLintᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeEGLintᵖ(e, obj.(*EGLintᵖ))
}
func (*binaryClassEGLintᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &EGLintᵖ{}
return obj, doDecodeEGLintᵖ(d, obj)
}
func (*binaryClassEGLintᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeEGLintᵖ(d, obj.(*EGLintᵖ))
}
func (*binaryClassEGLintᵖ) Skip(d binary.Decoder) error { return doSkipEGLintᵖ(d) }
func (*binaryClassEGLintᵖ) Schema() *schema.Class { return schemaEGLintᵖ }
var schemaEGLintᵖ = &schema.Class{
TypeID: binaryIDEGLintᵖ,
Name: "EGLintᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassEglCreateContext struct{}
func (*EglCreateContext) Class() binary.Class {
return (*binaryClassEglCreateContext)(nil)
}
func doEncodeEglCreateContext(e binary.Encoder, o *EglCreateContext) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Display); err != nil {
return err
}
if err := e.Value(&o.Config); err != nil {
return err
}
if err := e.Value(&o.ShareContext); err != nil {
return err
}
if err := e.Value(&o.AttribList); err != nil {
return err
}
if err := e.Value(&o.Result); err != nil {
return err
}
return nil
}
func doDecodeEglCreateContext(d binary.Decoder, o *EglCreateContext) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Display); err != nil {
return err
}
if err := d.Value(&o.Config); err != nil {
return err
}
if err := d.Value(&o.ShareContext); err != nil {
return err
}
if err := d.Value(&o.AttribList); err != nil {
return err
}
if err := d.Value(&o.Result); err != nil {
return err
}
return nil
}
func doSkipEglCreateContext(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLDisplay)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLConfig)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLContext)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLintᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLContext)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassEglCreateContext) ID() binary.ID { return binaryIDEglCreateContext }
func (*binaryClassEglCreateContext) New() binary.Object { return &EglCreateContext{} }
func (*binaryClassEglCreateContext) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeEglCreateContext(e, obj.(*EglCreateContext))
}
func (*binaryClassEglCreateContext) Decode(d binary.Decoder) (binary.Object, error) {
obj := &EglCreateContext{}
return obj, doDecodeEglCreateContext(d, obj)
}
func (*binaryClassEglCreateContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeEglCreateContext(d, obj.(*EglCreateContext))
}
func (*binaryClassEglCreateContext) Skip(d binary.Decoder) error { return doSkipEglCreateContext(d) }
func (*binaryClassEglCreateContext) Schema() *schema.Class { return schemaEglCreateContext }
var schemaEglCreateContext = &schema.Class{
TypeID: binaryIDEglCreateContext,
Name: "EglCreateContext",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Display", Type: &schema.Struct{Name: "EGLDisplay"}},
schema.Field{Declared: "Config", Type: &schema.Struct{Name: "EGLConfig"}},
schema.Field{Declared: "ShareContext", Type: &schema.Struct{Name: "EGLContext"}},
schema.Field{Declared: "AttribList", Type: &schema.Struct{Name: "EGLintᵖ"}},
schema.Field{Declared: "Result", Type: &schema.Struct{Name: "EGLContext"}},
},
}
type binaryClassEglInitialize struct{}
func (*EglInitialize) Class() binary.Class {
return (*binaryClassEglInitialize)(nil)
}
func doEncodeEglInitialize(e binary.Encoder, o *EglInitialize) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Dpy); err != nil {
return err
}
if err := e.Value(&o.Major); err != nil {
return err
}
if err := e.Value(&o.Minor); err != nil {
return err
}
if err := e.Int64(int64(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeEglInitialize(d binary.Decoder, o *EglInitialize) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Dpy); err != nil {
return err
}
if err := d.Value(&o.Major); err != nil {
return err
}
if err := d.Value(&o.Minor); err != nil {
return err
}
if obj, err := d.Int64(); err != nil {
return err
} else {
o.Result = EGLBoolean(obj)
}
return nil
}
func doSkipEglInitialize(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLDisplay)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLintᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLintᵖ)(nil)); err != nil {
return err
}
if _, err := d.Int64(); err != nil {
return err
}
return nil
}
func (*binaryClassEglInitialize) ID() binary.ID { return binaryIDEglInitialize }
func (*binaryClassEglInitialize) New() binary.Object { return &EglInitialize{} }
func (*binaryClassEglInitialize) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeEglInitialize(e, obj.(*EglInitialize))
}
func (*binaryClassEglInitialize) Decode(d binary.Decoder) (binary.Object, error) {
obj := &EglInitialize{}
return obj, doDecodeEglInitialize(d, obj)
}
func (*binaryClassEglInitialize) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeEglInitialize(d, obj.(*EglInitialize))
}
func (*binaryClassEglInitialize) Skip(d binary.Decoder) error { return doSkipEglInitialize(d) }
func (*binaryClassEglInitialize) Schema() *schema.Class { return schemaEglInitialize }
var schemaEglInitialize = &schema.Class{
TypeID: binaryIDEglInitialize,
Name: "EglInitialize",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Dpy", Type: &schema.Struct{Name: "EGLDisplay"}},
schema.Field{Declared: "Major", Type: &schema.Struct{Name: "EGLintᵖ"}},
schema.Field{Declared: "Minor", Type: &schema.Struct{Name: "EGLintᵖ"}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "EGLBoolean", Method: schema.Int64}},
},
}
type binaryClassEglMakeCurrent struct{}
func (*EglMakeCurrent) Class() binary.Class {
return (*binaryClassEglMakeCurrent)(nil)
}
func doEncodeEglMakeCurrent(e binary.Encoder, o *EglMakeCurrent) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Display); err != nil {
return err
}
if err := e.Value(&o.Draw); err != nil {
return err
}
if err := e.Value(&o.Read); err != nil {
return err
}
if err := e.Value(&o.Context); err != nil {
return err
}
if err := e.Int64(int64(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeEglMakeCurrent(d binary.Decoder, o *EglMakeCurrent) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Display); err != nil {
return err
}
if err := d.Value(&o.Draw); err != nil {
return err
}
if err := d.Value(&o.Read); err != nil {
return err
}
if err := d.Value(&o.Context); err != nil {
return err
}
if obj, err := d.Int64(); err != nil {
return err
} else {
o.Result = EGLBoolean(obj)
}
return nil
}
func doSkipEglMakeCurrent(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLDisplay)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLSurface)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLSurface)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLContext)(nil)); err != nil {
return err
}
if _, err := d.Int64(); err != nil {
return err
}
return nil
}
func (*binaryClassEglMakeCurrent) ID() binary.ID { return binaryIDEglMakeCurrent }
func (*binaryClassEglMakeCurrent) New() binary.Object { return &EglMakeCurrent{} }
func (*binaryClassEglMakeCurrent) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeEglMakeCurrent(e, obj.(*EglMakeCurrent))
}
func (*binaryClassEglMakeCurrent) Decode(d binary.Decoder) (binary.Object, error) {
obj := &EglMakeCurrent{}
return obj, doDecodeEglMakeCurrent(d, obj)
}
func (*binaryClassEglMakeCurrent) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeEglMakeCurrent(d, obj.(*EglMakeCurrent))
}
func (*binaryClassEglMakeCurrent) Skip(d binary.Decoder) error { return doSkipEglMakeCurrent(d) }
func (*binaryClassEglMakeCurrent) Schema() *schema.Class { return schemaEglMakeCurrent }
var schemaEglMakeCurrent = &schema.Class{
TypeID: binaryIDEglMakeCurrent,
Name: "EglMakeCurrent",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Display", Type: &schema.Struct{Name: "EGLDisplay"}},
schema.Field{Declared: "Draw", Type: &schema.Struct{Name: "EGLSurface"}},
schema.Field{Declared: "Read", Type: &schema.Struct{Name: "EGLSurface"}},
schema.Field{Declared: "Context", Type: &schema.Struct{Name: "EGLContext"}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "EGLBoolean", Method: schema.Int64}},
},
}
type binaryClassEglQuerySurface struct{}
func (*EglQuerySurface) Class() binary.Class {
return (*binaryClassEglQuerySurface)(nil)
}
func doEncodeEglQuerySurface(e binary.Encoder, o *EglQuerySurface) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Display); err != nil {
return err
}
if err := e.Value(&o.Surface); err != nil {
return err
}
if err := e.Int64(int64(o.Attribute)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
if err := e.Int64(int64(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeEglQuerySurface(d binary.Decoder, o *EglQuerySurface) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Display); err != nil {
return err
}
if err := d.Value(&o.Surface); err != nil {
return err
}
if obj, err := d.Int64(); err != nil {
return err
} else {
o.Attribute = EGLint(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
if obj, err := d.Int64(); err != nil {
return err
} else {
o.Result = EGLBoolean(obj)
}
return nil
}
func doSkipEglQuerySurface(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLDisplay)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLSurface)(nil)); err != nil {
return err
}
if _, err := d.Int64(); err != nil {
return err
}
if err := d.SkipValue((*EGLintᵖ)(nil)); err != nil {
return err
}
if _, err := d.Int64(); err != nil {
return err
}
return nil
}
func (*binaryClassEglQuerySurface) ID() binary.ID { return binaryIDEglQuerySurface }
func (*binaryClassEglQuerySurface) New() binary.Object { return &EglQuerySurface{} }
func (*binaryClassEglQuerySurface) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeEglQuerySurface(e, obj.(*EglQuerySurface))
}
func (*binaryClassEglQuerySurface) Decode(d binary.Decoder) (binary.Object, error) {
obj := &EglQuerySurface{}
return obj, doDecodeEglQuerySurface(d, obj)
}
func (*binaryClassEglQuerySurface) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeEglQuerySurface(d, obj.(*EglQuerySurface))
}
func (*binaryClassEglQuerySurface) Skip(d binary.Decoder) error { return doSkipEglQuerySurface(d) }
func (*binaryClassEglQuerySurface) Schema() *schema.Class { return schemaEglQuerySurface }
var schemaEglQuerySurface = &schema.Class{
TypeID: binaryIDEglQuerySurface,
Name: "EglQuerySurface",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Display", Type: &schema.Struct{Name: "EGLDisplay"}},
schema.Field{Declared: "Surface", Type: &schema.Struct{Name: "EGLSurface"}},
schema.Field{Declared: "Attribute", Type: &schema.Primitive{Name: "EGLint", Method: schema.Int64}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "EGLintᵖ"}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "EGLBoolean", Method: schema.Int64}},
},
}
type binaryClassVoidᵖ struct{}
func (*Voidᵖ) Class() binary.Class {
return (*binaryClassVoidᵖ)(nil)
}
func doEncodeVoidᵖ(e binary.Encoder, o *Voidᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeVoidᵖ(d binary.Decoder, o *Voidᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipVoidᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassVoidᵖ) ID() binary.ID { return binaryIDVoidᵖ }
func (*binaryClassVoidᵖ) New() binary.Object { return &Voidᵖ{} }
func (*binaryClassVoidᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVoidᵖ(e, obj.(*Voidᵖ))
}
func (*binaryClassVoidᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Voidᵖ{}
return obj, doDecodeVoidᵖ(d, obj)
}
func (*binaryClassVoidᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVoidᵖ(d, obj.(*Voidᵖ))
}
func (*binaryClassVoidᵖ) Skip(d binary.Decoder) error { return doSkipVoidᵖ(d) }
func (*binaryClassVoidᵖ) Schema() *schema.Class { return schemaVoidᵖ }
var schemaVoidᵖ = &schema.Class{
TypeID: binaryIDVoidᵖ,
Name: "Voidᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassEglSwapBuffers struct{}
func (*EglSwapBuffers) Class() binary.Class {
return (*binaryClassEglSwapBuffers)(nil)
}
func doEncodeEglSwapBuffers(e binary.Encoder, o *EglSwapBuffers) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Display); err != nil {
return err
}
if err := e.Value(&o.Surface); err != nil {
return err
}
if err := e.Int64(int64(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeEglSwapBuffers(d binary.Decoder, o *EglSwapBuffers) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Display); err != nil {
return err
}
if err := d.Value(&o.Surface); err != nil {
return err
}
if obj, err := d.Int64(); err != nil {
return err
} else {
o.Result = EGLBoolean(obj)
}
return nil
}
func doSkipEglSwapBuffers(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*EGLDisplay)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
if _, err := d.Int64(); err != nil {
return err
}
return nil
}
func (*binaryClassEglSwapBuffers) ID() binary.ID { return binaryIDEglSwapBuffers }
func (*binaryClassEglSwapBuffers) New() binary.Object { return &EglSwapBuffers{} }
func (*binaryClassEglSwapBuffers) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeEglSwapBuffers(e, obj.(*EglSwapBuffers))
}
func (*binaryClassEglSwapBuffers) Decode(d binary.Decoder) (binary.Object, error) {
obj := &EglSwapBuffers{}
return obj, doDecodeEglSwapBuffers(d, obj)
}
func (*binaryClassEglSwapBuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeEglSwapBuffers(d, obj.(*EglSwapBuffers))
}
func (*binaryClassEglSwapBuffers) Skip(d binary.Decoder) error { return doSkipEglSwapBuffers(d) }
func (*binaryClassEglSwapBuffers) Schema() *schema.Class { return schemaEglSwapBuffers }
var schemaEglSwapBuffers = &schema.Class{
TypeID: binaryIDEglSwapBuffers,
Name: "EglSwapBuffers",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Display", Type: &schema.Struct{Name: "EGLDisplay"}},
schema.Field{Declared: "Surface", Type: &schema.Struct{Name: "Voidᵖ"}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "EGLBoolean", Method: schema.Int64}},
},
}
type binaryClassF32ˢ struct{}
func (*F32ˢ) Class() binary.Class {
return (*binaryClassF32ˢ)(nil)
}
func doEncodeF32ˢ(e binary.Encoder, o *F32ˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeF32ˢ(d binary.Decoder, o *F32ˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipF32ˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassF32ˢ) ID() binary.ID { return binaryIDF32ˢ }
func (*binaryClassF32ˢ) New() binary.Object { return &F32ˢ{} }
func (*binaryClassF32ˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeF32ˢ(e, obj.(*F32ˢ))
}
func (*binaryClassF32ˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &F32ˢ{}
return obj, doDecodeF32ˢ(d, obj)
}
func (*binaryClassF32ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeF32ˢ(d, obj.(*F32ˢ))
}
func (*binaryClassF32ˢ) Skip(d binary.Decoder) error { return doSkipF32ˢ(d) }
func (*binaryClassF32ˢ) Schema() *schema.Class { return schemaF32ˢ }
var schemaF32ˢ = &schema.Class{
TypeID: binaryIDF32ˢ,
Name: "F32ˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassF32ᵖ struct{}
func (*F32ᵖ) Class() binary.Class {
return (*binaryClassF32ᵖ)(nil)
}
func doEncodeF32ᵖ(e binary.Encoder, o *F32ᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeF32ᵖ(d binary.Decoder, o *F32ᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipF32ᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassF32ᵖ) ID() binary.ID { return binaryIDF32ᵖ }
func (*binaryClassF32ᵖ) New() binary.Object { return &F32ᵖ{} }
func (*binaryClassF32ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeF32ᵖ(e, obj.(*F32ᵖ))
}
func (*binaryClassF32ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &F32ᵖ{}
return obj, doDecodeF32ᵖ(d, obj)
}
func (*binaryClassF32ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeF32ᵖ(d, obj.(*F32ᵖ))
}
func (*binaryClassF32ᵖ) Skip(d binary.Decoder) error { return doSkipF32ᵖ(d) }
func (*binaryClassF32ᵖ) Schema() *schema.Class { return schemaF32ᵖ }
var schemaF32ᵖ = &schema.Class{
TypeID: binaryIDF32ᵖ,
Name: "F32ᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassFlushPostBuffer struct{}
func (*FlushPostBuffer) Class() binary.Class {
return (*binaryClassFlushPostBuffer)(nil)
}
func doEncodeFlushPostBuffer(e binary.Encoder, o *FlushPostBuffer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
return nil
}
func doDecodeFlushPostBuffer(d binary.Decoder, o *FlushPostBuffer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
return nil
}
func doSkipFlushPostBuffer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassFlushPostBuffer) ID() binary.ID { return binaryIDFlushPostBuffer }
func (*binaryClassFlushPostBuffer) New() binary.Object { return &FlushPostBuffer{} }
func (*binaryClassFlushPostBuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeFlushPostBuffer(e, obj.(*FlushPostBuffer))
}
func (*binaryClassFlushPostBuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &FlushPostBuffer{}
return obj, doDecodeFlushPostBuffer(d, obj)
}
func (*binaryClassFlushPostBuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeFlushPostBuffer(d, obj.(*FlushPostBuffer))
}
func (*binaryClassFlushPostBuffer) Skip(d binary.Decoder) error { return doSkipFlushPostBuffer(d) }
func (*binaryClassFlushPostBuffer) Schema() *schema.Class { return schemaFlushPostBuffer }
var schemaFlushPostBuffer = &schema.Class{
TypeID: binaryIDFlushPostBuffer,
Name: "FlushPostBuffer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
},
}
type binaryClassFramebufferAttachmentˢ struct{}
func (*FramebufferAttachmentˢ) Class() binary.Class {
return (*binaryClassFramebufferAttachmentˢ)(nil)
}
func doEncodeFramebufferAttachmentˢ(e binary.Encoder, o *FramebufferAttachmentˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeFramebufferAttachmentˢ(d binary.Decoder, o *FramebufferAttachmentˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipFramebufferAttachmentˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassFramebufferAttachmentˢ) ID() binary.ID { return binaryIDFramebufferAttachmentˢ }
func (*binaryClassFramebufferAttachmentˢ) New() binary.Object { return &FramebufferAttachmentˢ{} }
func (*binaryClassFramebufferAttachmentˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeFramebufferAttachmentˢ(e, obj.(*FramebufferAttachmentˢ))
}
func (*binaryClassFramebufferAttachmentˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &FramebufferAttachmentˢ{}
return obj, doDecodeFramebufferAttachmentˢ(d, obj)
}
func (*binaryClassFramebufferAttachmentˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeFramebufferAttachmentˢ(d, obj.(*FramebufferAttachmentˢ))
}
func (*binaryClassFramebufferAttachmentˢ) Skip(d binary.Decoder) error {
return doSkipFramebufferAttachmentˢ(d)
}
func (*binaryClassFramebufferAttachmentˢ) Schema() *schema.Class {
return schemaFramebufferAttachmentˢ
}
var schemaFramebufferAttachmentˢ = &schema.Class{
TypeID: binaryIDFramebufferAttachmentˢ,
Name: "FramebufferAttachmentˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassFramebufferAttachmentᵖ struct{}
func (*FramebufferAttachmentᵖ) Class() binary.Class {
return (*binaryClassFramebufferAttachmentᵖ)(nil)
}
func doEncodeFramebufferAttachmentᵖ(e binary.Encoder, o *FramebufferAttachmentᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeFramebufferAttachmentᵖ(d binary.Decoder, o *FramebufferAttachmentᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipFramebufferAttachmentᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassFramebufferAttachmentᵖ) ID() binary.ID { return binaryIDFramebufferAttachmentᵖ }
func (*binaryClassFramebufferAttachmentᵖ) New() binary.Object { return &FramebufferAttachmentᵖ{} }
func (*binaryClassFramebufferAttachmentᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeFramebufferAttachmentᵖ(e, obj.(*FramebufferAttachmentᵖ))
}
func (*binaryClassFramebufferAttachmentᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &FramebufferAttachmentᵖ{}
return obj, doDecodeFramebufferAttachmentᵖ(d, obj)
}
func (*binaryClassFramebufferAttachmentᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeFramebufferAttachmentᵖ(d, obj.(*FramebufferAttachmentᵖ))
}
func (*binaryClassFramebufferAttachmentᵖ) Skip(d binary.Decoder) error {
return doSkipFramebufferAttachmentᵖ(d)
}
func (*binaryClassFramebufferAttachmentᵖ) Schema() *schema.Class {
return schemaFramebufferAttachmentᵖ
}
var schemaFramebufferAttachmentᵖ = &schema.Class{
TypeID: binaryIDFramebufferAttachmentᵖ,
Name: "FramebufferAttachmentᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassFramebufferIdˢ struct{}
func (*FramebufferIdˢ) Class() binary.Class {
return (*binaryClassFramebufferIdˢ)(nil)
}
func doEncodeFramebufferIdˢ(e binary.Encoder, o *FramebufferIdˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeFramebufferIdˢ(d binary.Decoder, o *FramebufferIdˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipFramebufferIdˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassFramebufferIdˢ) ID() binary.ID { return binaryIDFramebufferIdˢ }
func (*binaryClassFramebufferIdˢ) New() binary.Object { return &FramebufferIdˢ{} }
func (*binaryClassFramebufferIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeFramebufferIdˢ(e, obj.(*FramebufferIdˢ))
}
func (*binaryClassFramebufferIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &FramebufferIdˢ{}
return obj, doDecodeFramebufferIdˢ(d, obj)
}
func (*binaryClassFramebufferIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeFramebufferIdˢ(d, obj.(*FramebufferIdˢ))
}
func (*binaryClassFramebufferIdˢ) Skip(d binary.Decoder) error { return doSkipFramebufferIdˢ(d) }
func (*binaryClassFramebufferIdˢ) Schema() *schema.Class { return schemaFramebufferIdˢ }
var schemaFramebufferIdˢ = &schema.Class{
TypeID: binaryIDFramebufferIdˢ,
Name: "FramebufferIdˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassFramebufferIdᵖ struct{}
func (*FramebufferIdᵖ) Class() binary.Class {
return (*binaryClassFramebufferIdᵖ)(nil)
}
func doEncodeFramebufferIdᵖ(e binary.Encoder, o *FramebufferIdᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeFramebufferIdᵖ(d binary.Decoder, o *FramebufferIdᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipFramebufferIdᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassFramebufferIdᵖ) ID() binary.ID { return binaryIDFramebufferIdᵖ }
func (*binaryClassFramebufferIdᵖ) New() binary.Object { return &FramebufferIdᵖ{} }
func (*binaryClassFramebufferIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeFramebufferIdᵖ(e, obj.(*FramebufferIdᵖ))
}
func (*binaryClassFramebufferIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &FramebufferIdᵖ{}
return obj, doDecodeFramebufferIdᵖ(d, obj)
}
func (*binaryClassFramebufferIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeFramebufferIdᵖ(d, obj.(*FramebufferIdᵖ))
}
func (*binaryClassFramebufferIdᵖ) Skip(d binary.Decoder) error { return doSkipFramebufferIdᵖ(d) }
func (*binaryClassFramebufferIdᵖ) Schema() *schema.Class { return schemaFramebufferIdᵖ }
var schemaFramebufferIdᵖ = &schema.Class{
TypeID: binaryIDFramebufferIdᵖ,
Name: "FramebufferIdᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGLXContext struct{}
func (*GLXContext) Class() binary.Class {
return (*binaryClassGLXContext)(nil)
}
func doEncodeGLXContext(e binary.Encoder, o *GLXContext) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeGLXContext(d binary.Decoder, o *GLXContext) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipGLXContext(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGLXContext) ID() binary.ID { return binaryIDGLXContext }
func (*binaryClassGLXContext) New() binary.Object { return &GLXContext{} }
func (*binaryClassGLXContext) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGLXContext(e, obj.(*GLXContext))
}
func (*binaryClassGLXContext) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GLXContext{}
return obj, doDecodeGLXContext(d, obj)
}
func (*binaryClassGLXContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGLXContext(d, obj.(*GLXContext))
}
func (*binaryClassGLXContext) Skip(d binary.Decoder) error { return doSkipGLXContext(d) }
func (*binaryClassGLXContext) Schema() *schema.Class { return schemaGLXContext }
var schemaGLXContext = &schema.Class{
TypeID: binaryIDGLXContext,
Name: "GLXContext",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGLXDrawable struct{}
func (*GLXDrawable) Class() binary.Class {
return (*binaryClassGLXDrawable)(nil)
}
func doEncodeGLXDrawable(e binary.Encoder, o *GLXDrawable) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeGLXDrawable(d binary.Decoder, o *GLXDrawable) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipGLXDrawable(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGLXDrawable) ID() binary.ID { return binaryIDGLXDrawable }
func (*binaryClassGLXDrawable) New() binary.Object { return &GLXDrawable{} }
func (*binaryClassGLXDrawable) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGLXDrawable(e, obj.(*GLXDrawable))
}
func (*binaryClassGLXDrawable) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GLXDrawable{}
return obj, doDecodeGLXDrawable(d, obj)
}
func (*binaryClassGLXDrawable) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGLXDrawable(d, obj.(*GLXDrawable))
}
func (*binaryClassGLXDrawable) Skip(d binary.Decoder) error { return doSkipGLXDrawable(d) }
func (*binaryClassGLXDrawable) Schema() *schema.Class { return schemaGLXDrawable }
var schemaGLXDrawable = &schema.Class{
TypeID: binaryIDGLXDrawable,
Name: "GLXDrawable",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlActiveTexture struct{}
func (*GlActiveTexture) Class() binary.Class {
return (*binaryClassGlActiveTexture)(nil)
}
func doEncodeGlActiveTexture(e binary.Encoder, o *GlActiveTexture) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Unit)); err != nil {
return err
}
return nil
}
func doDecodeGlActiveTexture(d binary.Decoder, o *GlActiveTexture) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Unit = TextureUnit(obj)
}
return nil
}
func doSkipGlActiveTexture(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlActiveTexture) ID() binary.ID { return binaryIDGlActiveTexture }
func (*binaryClassGlActiveTexture) New() binary.Object { return &GlActiveTexture{} }
func (*binaryClassGlActiveTexture) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlActiveTexture(e, obj.(*GlActiveTexture))
}
func (*binaryClassGlActiveTexture) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlActiveTexture{}
return obj, doDecodeGlActiveTexture(d, obj)
}
func (*binaryClassGlActiveTexture) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlActiveTexture(d, obj.(*GlActiveTexture))
}
func (*binaryClassGlActiveTexture) Skip(d binary.Decoder) error { return doSkipGlActiveTexture(d) }
func (*binaryClassGlActiveTexture) Schema() *schema.Class { return schemaGlActiveTexture }
var schemaGlActiveTexture = &schema.Class{
TypeID: binaryIDGlActiveTexture,
Name: "GlActiveTexture",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Unit", Type: &schema.Primitive{Name: "TextureUnit", Method: schema.Uint32}},
},
}
type binaryClassGlAttachShader struct{}
func (*GlAttachShader) Class() binary.Class {
return (*binaryClassGlAttachShader)(nil)
}
func doEncodeGlAttachShader(e binary.Encoder, o *GlAttachShader) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Shader)); err != nil {
return err
}
return nil
}
func doDecodeGlAttachShader(d binary.Decoder, o *GlAttachShader) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Shader = ShaderId(obj)
}
return nil
}
func doSkipGlAttachShader(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlAttachShader) ID() binary.ID { return binaryIDGlAttachShader }
func (*binaryClassGlAttachShader) New() binary.Object { return &GlAttachShader{} }
func (*binaryClassGlAttachShader) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlAttachShader(e, obj.(*GlAttachShader))
}
func (*binaryClassGlAttachShader) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlAttachShader{}
return obj, doDecodeGlAttachShader(d, obj)
}
func (*binaryClassGlAttachShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlAttachShader(d, obj.(*GlAttachShader))
}
func (*binaryClassGlAttachShader) Skip(d binary.Decoder) error { return doSkipGlAttachShader(d) }
func (*binaryClassGlAttachShader) Schema() *schema.Class { return schemaGlAttachShader }
var schemaGlAttachShader = &schema.Class{
TypeID: binaryIDGlAttachShader,
Name: "GlAttachShader",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
},
}
type binaryClassGlBeginQuery struct{}
func (*GlBeginQuery) Class() binary.Class {
return (*binaryClassGlBeginQuery)(nil)
}
func doEncodeGlBeginQuery(e binary.Encoder, o *GlBeginQuery) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Query)); err != nil {
return err
}
return nil
}
func doDecodeGlBeginQuery(d binary.Decoder, o *GlBeginQuery) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = QueryTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Query = QueryId(obj)
}
return nil
}
func doSkipGlBeginQuery(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBeginQuery) ID() binary.ID { return binaryIDGlBeginQuery }
func (*binaryClassGlBeginQuery) New() binary.Object { return &GlBeginQuery{} }
func (*binaryClassGlBeginQuery) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBeginQuery(e, obj.(*GlBeginQuery))
}
func (*binaryClassGlBeginQuery) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBeginQuery{}
return obj, doDecodeGlBeginQuery(d, obj)
}
func (*binaryClassGlBeginQuery) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBeginQuery(d, obj.(*GlBeginQuery))
}
func (*binaryClassGlBeginQuery) Skip(d binary.Decoder) error { return doSkipGlBeginQuery(d) }
func (*binaryClassGlBeginQuery) Schema() *schema.Class { return schemaGlBeginQuery }
var schemaGlBeginQuery = &schema.Class{
TypeID: binaryIDGlBeginQuery,
Name: "GlBeginQuery",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "QueryTarget", Method: schema.Uint32}},
schema.Field{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
},
}
type binaryClassGlBeginQueryEXT struct{}
func (*GlBeginQueryEXT) Class() binary.Class {
return (*binaryClassGlBeginQueryEXT)(nil)
}
func doEncodeGlBeginQueryEXT(e binary.Encoder, o *GlBeginQueryEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Query)); err != nil {
return err
}
return nil
}
func doDecodeGlBeginQueryEXT(d binary.Decoder, o *GlBeginQueryEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = QueryTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Query = QueryId(obj)
}
return nil
}
func doSkipGlBeginQueryEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBeginQueryEXT) ID() binary.ID { return binaryIDGlBeginQueryEXT }
func (*binaryClassGlBeginQueryEXT) New() binary.Object { return &GlBeginQueryEXT{} }
func (*binaryClassGlBeginQueryEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBeginQueryEXT(e, obj.(*GlBeginQueryEXT))
}
func (*binaryClassGlBeginQueryEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBeginQueryEXT{}
return obj, doDecodeGlBeginQueryEXT(d, obj)
}
func (*binaryClassGlBeginQueryEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBeginQueryEXT(d, obj.(*GlBeginQueryEXT))
}
func (*binaryClassGlBeginQueryEXT) Skip(d binary.Decoder) error { return doSkipGlBeginQueryEXT(d) }
func (*binaryClassGlBeginQueryEXT) Schema() *schema.Class { return schemaGlBeginQueryEXT }
var schemaGlBeginQueryEXT = &schema.Class{
TypeID: binaryIDGlBeginQueryEXT,
Name: "GlBeginQueryEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "QueryTarget", Method: schema.Uint32}},
schema.Field{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
},
}
type binaryClassGlBindAttribLocation struct{}
func (*GlBindAttribLocation) Class() binary.Class {
return (*binaryClassGlBindAttribLocation)(nil)
}
func doEncodeGlBindAttribLocation(e binary.Encoder, o *GlBindAttribLocation) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
if err := e.String(o.Name); err != nil {
return err
}
return nil
}
func doDecodeGlBindAttribLocation(d binary.Decoder, o *GlBindAttribLocation) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
if obj, err := d.String(); err != nil {
return err
} else {
o.Name = string(obj)
}
return nil
}
func doSkipGlBindAttribLocation(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipString(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBindAttribLocation) ID() binary.ID { return binaryIDGlBindAttribLocation }
func (*binaryClassGlBindAttribLocation) New() binary.Object { return &GlBindAttribLocation{} }
func (*binaryClassGlBindAttribLocation) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBindAttribLocation(e, obj.(*GlBindAttribLocation))
}
func (*binaryClassGlBindAttribLocation) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBindAttribLocation{}
return obj, doDecodeGlBindAttribLocation(d, obj)
}
func (*binaryClassGlBindAttribLocation) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBindAttribLocation(d, obj.(*GlBindAttribLocation))
}
func (*binaryClassGlBindAttribLocation) Skip(d binary.Decoder) error {
return doSkipGlBindAttribLocation(d)
}
func (*binaryClassGlBindAttribLocation) Schema() *schema.Class { return schemaGlBindAttribLocation }
var schemaGlBindAttribLocation = &schema.Class{
TypeID: binaryIDGlBindAttribLocation,
Name: "GlBindAttribLocation",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
},
}
type binaryClassGlBindBuffer struct{}
func (*GlBindBuffer) Class() binary.Class {
return (*binaryClassGlBindBuffer)(nil)
}
func doEncodeGlBindBuffer(e binary.Encoder, o *GlBindBuffer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Buffer)); err != nil {
return err
}
return nil
}
func doDecodeGlBindBuffer(d binary.Decoder, o *GlBindBuffer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = BufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Buffer = BufferId(obj)
}
return nil
}
func doSkipGlBindBuffer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBindBuffer) ID() binary.ID { return binaryIDGlBindBuffer }
func (*binaryClassGlBindBuffer) New() binary.Object { return &GlBindBuffer{} }
func (*binaryClassGlBindBuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBindBuffer(e, obj.(*GlBindBuffer))
}
func (*binaryClassGlBindBuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBindBuffer{}
return obj, doDecodeGlBindBuffer(d, obj)
}
func (*binaryClassGlBindBuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBindBuffer(d, obj.(*GlBindBuffer))
}
func (*binaryClassGlBindBuffer) Skip(d binary.Decoder) error { return doSkipGlBindBuffer(d) }
func (*binaryClassGlBindBuffer) Schema() *schema.Class { return schemaGlBindBuffer }
var schemaGlBindBuffer = &schema.Class{
TypeID: binaryIDGlBindBuffer,
Name: "GlBindBuffer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "BufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
},
}
type binaryClassGlBindFramebuffer struct{}
func (*GlBindFramebuffer) Class() binary.Class {
return (*binaryClassGlBindFramebuffer)(nil)
}
func doEncodeGlBindFramebuffer(e binary.Encoder, o *GlBindFramebuffer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Framebuffer)); err != nil {
return err
}
return nil
}
func doDecodeGlBindFramebuffer(d binary.Decoder, o *GlBindFramebuffer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = FramebufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Framebuffer = FramebufferId(obj)
}
return nil
}
func doSkipGlBindFramebuffer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBindFramebuffer) ID() binary.ID { return binaryIDGlBindFramebuffer }
func (*binaryClassGlBindFramebuffer) New() binary.Object { return &GlBindFramebuffer{} }
func (*binaryClassGlBindFramebuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBindFramebuffer(e, obj.(*GlBindFramebuffer))
}
func (*binaryClassGlBindFramebuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBindFramebuffer{}
return obj, doDecodeGlBindFramebuffer(d, obj)
}
func (*binaryClassGlBindFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBindFramebuffer(d, obj.(*GlBindFramebuffer))
}
func (*binaryClassGlBindFramebuffer) Skip(d binary.Decoder) error { return doSkipGlBindFramebuffer(d) }
func (*binaryClassGlBindFramebuffer) Schema() *schema.Class { return schemaGlBindFramebuffer }
var schemaGlBindFramebuffer = &schema.Class{
TypeID: binaryIDGlBindFramebuffer,
Name: "GlBindFramebuffer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "FramebufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Framebuffer", Type: &schema.Primitive{Name: "FramebufferId", Method: schema.Uint32}},
},
}
type binaryClassGlBindRenderbuffer struct{}
func (*GlBindRenderbuffer) Class() binary.Class {
return (*binaryClassGlBindRenderbuffer)(nil)
}
func doEncodeGlBindRenderbuffer(e binary.Encoder, o *GlBindRenderbuffer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Renderbuffer)); err != nil {
return err
}
return nil
}
func doDecodeGlBindRenderbuffer(d binary.Decoder, o *GlBindRenderbuffer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = RenderbufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Renderbuffer = RenderbufferId(obj)
}
return nil
}
func doSkipGlBindRenderbuffer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBindRenderbuffer) ID() binary.ID { return binaryIDGlBindRenderbuffer }
func (*binaryClassGlBindRenderbuffer) New() binary.Object { return &GlBindRenderbuffer{} }
func (*binaryClassGlBindRenderbuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBindRenderbuffer(e, obj.(*GlBindRenderbuffer))
}
func (*binaryClassGlBindRenderbuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBindRenderbuffer{}
return obj, doDecodeGlBindRenderbuffer(d, obj)
}
func (*binaryClassGlBindRenderbuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBindRenderbuffer(d, obj.(*GlBindRenderbuffer))
}
func (*binaryClassGlBindRenderbuffer) Skip(d binary.Decoder) error { return doSkipGlBindRenderbuffer(d) }
func (*binaryClassGlBindRenderbuffer) Schema() *schema.Class { return schemaGlBindRenderbuffer }
var schemaGlBindRenderbuffer = &schema.Class{
TypeID: binaryIDGlBindRenderbuffer,
Name: "GlBindRenderbuffer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "RenderbufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Renderbuffer", Type: &schema.Primitive{Name: "RenderbufferId", Method: schema.Uint32}},
},
}
type binaryClassGlBindTexture struct{}
func (*GlBindTexture) Class() binary.Class {
return (*binaryClassGlBindTexture)(nil)
}
func doEncodeGlBindTexture(e binary.Encoder, o *GlBindTexture) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Texture)); err != nil {
return err
}
return nil
}
func doDecodeGlBindTexture(d binary.Decoder, o *GlBindTexture) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Texture = TextureId(obj)
}
return nil
}
func doSkipGlBindTexture(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBindTexture) ID() binary.ID { return binaryIDGlBindTexture }
func (*binaryClassGlBindTexture) New() binary.Object { return &GlBindTexture{} }
func (*binaryClassGlBindTexture) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBindTexture(e, obj.(*GlBindTexture))
}
func (*binaryClassGlBindTexture) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBindTexture{}
return obj, doDecodeGlBindTexture(d, obj)
}
func (*binaryClassGlBindTexture) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBindTexture(d, obj.(*GlBindTexture))
}
func (*binaryClassGlBindTexture) Skip(d binary.Decoder) error { return doSkipGlBindTexture(d) }
func (*binaryClassGlBindTexture) Schema() *schema.Class { return schemaGlBindTexture }
var schemaGlBindTexture = &schema.Class{
TypeID: binaryIDGlBindTexture,
Name: "GlBindTexture",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureTarget", Method: schema.Uint32}},
schema.Field{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
},
}
type binaryClassGlBindVertexArrayOES struct{}
func (*GlBindVertexArrayOES) Class() binary.Class {
return (*binaryClassGlBindVertexArrayOES)(nil)
}
func doEncodeGlBindVertexArrayOES(e binary.Encoder, o *GlBindVertexArrayOES) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Array)); err != nil {
return err
}
return nil
}
func doDecodeGlBindVertexArrayOES(d binary.Decoder, o *GlBindVertexArrayOES) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Array = VertexArrayId(obj)
}
return nil
}
func doSkipGlBindVertexArrayOES(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBindVertexArrayOES) ID() binary.ID { return binaryIDGlBindVertexArrayOES }
func (*binaryClassGlBindVertexArrayOES) New() binary.Object { return &GlBindVertexArrayOES{} }
func (*binaryClassGlBindVertexArrayOES) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBindVertexArrayOES(e, obj.(*GlBindVertexArrayOES))
}
func (*binaryClassGlBindVertexArrayOES) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBindVertexArrayOES{}
return obj, doDecodeGlBindVertexArrayOES(d, obj)
}
func (*binaryClassGlBindVertexArrayOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBindVertexArrayOES(d, obj.(*GlBindVertexArrayOES))
}
func (*binaryClassGlBindVertexArrayOES) Skip(d binary.Decoder) error {
return doSkipGlBindVertexArrayOES(d)
}
func (*binaryClassGlBindVertexArrayOES) Schema() *schema.Class { return schemaGlBindVertexArrayOES }
var schemaGlBindVertexArrayOES = &schema.Class{
TypeID: binaryIDGlBindVertexArrayOES,
Name: "GlBindVertexArrayOES",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Array", Type: &schema.Primitive{Name: "VertexArrayId", Method: schema.Uint32}},
},
}
type binaryClassGlBlendColor struct{}
func (*GlBlendColor) Class() binary.Class {
return (*binaryClassGlBlendColor)(nil)
}
func doEncodeGlBlendColor(e binary.Encoder, o *GlBlendColor) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Float32(o.Red); err != nil {
return err
}
if err := e.Float32(o.Green); err != nil {
return err
}
if err := e.Float32(o.Blue); err != nil {
return err
}
if err := e.Float32(o.Alpha); err != nil {
return err
}
return nil
}
func doDecodeGlBlendColor(d binary.Decoder, o *GlBlendColor) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Red = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Green = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Blue = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Alpha = float32(obj)
}
return nil
}
func doSkipGlBlendColor(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBlendColor) ID() binary.ID { return binaryIDGlBlendColor }
func (*binaryClassGlBlendColor) New() binary.Object { return &GlBlendColor{} }
func (*binaryClassGlBlendColor) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBlendColor(e, obj.(*GlBlendColor))
}
func (*binaryClassGlBlendColor) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBlendColor{}
return obj, doDecodeGlBlendColor(d, obj)
}
func (*binaryClassGlBlendColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBlendColor(d, obj.(*GlBlendColor))
}
func (*binaryClassGlBlendColor) Skip(d binary.Decoder) error { return doSkipGlBlendColor(d) }
func (*binaryClassGlBlendColor) Schema() *schema.Class { return schemaGlBlendColor }
var schemaGlBlendColor = &schema.Class{
TypeID: binaryIDGlBlendColor,
Name: "GlBlendColor",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Red", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Green", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Blue", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Alpha", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlBlendEquation struct{}
func (*GlBlendEquation) Class() binary.Class {
return (*binaryClassGlBlendEquation)(nil)
}
func doEncodeGlBlendEquation(e binary.Encoder, o *GlBlendEquation) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Equation)); err != nil {
return err
}
return nil
}
func doDecodeGlBlendEquation(d binary.Decoder, o *GlBlendEquation) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Equation = BlendEquation(obj)
}
return nil
}
func doSkipGlBlendEquation(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBlendEquation) ID() binary.ID { return binaryIDGlBlendEquation }
func (*binaryClassGlBlendEquation) New() binary.Object { return &GlBlendEquation{} }
func (*binaryClassGlBlendEquation) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBlendEquation(e, obj.(*GlBlendEquation))
}
func (*binaryClassGlBlendEquation) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBlendEquation{}
return obj, doDecodeGlBlendEquation(d, obj)
}
func (*binaryClassGlBlendEquation) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBlendEquation(d, obj.(*GlBlendEquation))
}
func (*binaryClassGlBlendEquation) Skip(d binary.Decoder) error { return doSkipGlBlendEquation(d) }
func (*binaryClassGlBlendEquation) Schema() *schema.Class { return schemaGlBlendEquation }
var schemaGlBlendEquation = &schema.Class{
TypeID: binaryIDGlBlendEquation,
Name: "GlBlendEquation",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Equation", Type: &schema.Primitive{Name: "BlendEquation", Method: schema.Uint32}},
},
}
type binaryClassGlBlendEquationSeparate struct{}
func (*GlBlendEquationSeparate) Class() binary.Class {
return (*binaryClassGlBlendEquationSeparate)(nil)
}
func doEncodeGlBlendEquationSeparate(e binary.Encoder, o *GlBlendEquationSeparate) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Rgb)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Alpha)); err != nil {
return err
}
return nil
}
func doDecodeGlBlendEquationSeparate(d binary.Decoder, o *GlBlendEquationSeparate) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Rgb = BlendEquation(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Alpha = BlendEquation(obj)
}
return nil
}
func doSkipGlBlendEquationSeparate(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBlendEquationSeparate) ID() binary.ID { return binaryIDGlBlendEquationSeparate }
func (*binaryClassGlBlendEquationSeparate) New() binary.Object { return &GlBlendEquationSeparate{} }
func (*binaryClassGlBlendEquationSeparate) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBlendEquationSeparate(e, obj.(*GlBlendEquationSeparate))
}
func (*binaryClassGlBlendEquationSeparate) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBlendEquationSeparate{}
return obj, doDecodeGlBlendEquationSeparate(d, obj)
}
func (*binaryClassGlBlendEquationSeparate) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBlendEquationSeparate(d, obj.(*GlBlendEquationSeparate))
}
func (*binaryClassGlBlendEquationSeparate) Skip(d binary.Decoder) error {
return doSkipGlBlendEquationSeparate(d)
}
func (*binaryClassGlBlendEquationSeparate) Schema() *schema.Class {
return schemaGlBlendEquationSeparate
}
var schemaGlBlendEquationSeparate = &schema.Class{
TypeID: binaryIDGlBlendEquationSeparate,
Name: "GlBlendEquationSeparate",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Rgb", Type: &schema.Primitive{Name: "BlendEquation", Method: schema.Uint32}},
schema.Field{Declared: "Alpha", Type: &schema.Primitive{Name: "BlendEquation", Method: schema.Uint32}},
},
}
type binaryClassGlBlendFunc struct{}
func (*GlBlendFunc) Class() binary.Class {
return (*binaryClassGlBlendFunc)(nil)
}
func doEncodeGlBlendFunc(e binary.Encoder, o *GlBlendFunc) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.SrcFactor)); err != nil {
return err
}
if err := e.Uint32(uint32(o.DstFactor)); err != nil {
return err
}
return nil
}
func doDecodeGlBlendFunc(d binary.Decoder, o *GlBlendFunc) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.SrcFactor = BlendFactor(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.DstFactor = BlendFactor(obj)
}
return nil
}
func doSkipGlBlendFunc(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBlendFunc) ID() binary.ID { return binaryIDGlBlendFunc }
func (*binaryClassGlBlendFunc) New() binary.Object { return &GlBlendFunc{} }
func (*binaryClassGlBlendFunc) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBlendFunc(e, obj.(*GlBlendFunc))
}
func (*binaryClassGlBlendFunc) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBlendFunc{}
return obj, doDecodeGlBlendFunc(d, obj)
}
func (*binaryClassGlBlendFunc) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBlendFunc(d, obj.(*GlBlendFunc))
}
func (*binaryClassGlBlendFunc) Skip(d binary.Decoder) error { return doSkipGlBlendFunc(d) }
func (*binaryClassGlBlendFunc) Schema() *schema.Class { return schemaGlBlendFunc }
var schemaGlBlendFunc = &schema.Class{
TypeID: binaryIDGlBlendFunc,
Name: "GlBlendFunc",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "SrcFactor", Type: &schema.Primitive{Name: "BlendFactor", Method: schema.Uint32}},
schema.Field{Declared: "DstFactor", Type: &schema.Primitive{Name: "BlendFactor", Method: schema.Uint32}},
},
}
type binaryClassGlBlendFuncSeparate struct{}
func (*GlBlendFuncSeparate) Class() binary.Class {
return (*binaryClassGlBlendFuncSeparate)(nil)
}
func doEncodeGlBlendFuncSeparate(e binary.Encoder, o *GlBlendFuncSeparate) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.SrcFactorRgb)); err != nil {
return err
}
if err := e.Uint32(uint32(o.DstFactorRgb)); err != nil {
return err
}
if err := e.Uint32(uint32(o.SrcFactorAlpha)); err != nil {
return err
}
if err := e.Uint32(uint32(o.DstFactorAlpha)); err != nil {
return err
}
return nil
}
func doDecodeGlBlendFuncSeparate(d binary.Decoder, o *GlBlendFuncSeparate) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.SrcFactorRgb = BlendFactor(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.DstFactorRgb = BlendFactor(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.SrcFactorAlpha = BlendFactor(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.DstFactorAlpha = BlendFactor(obj)
}
return nil
}
func doSkipGlBlendFuncSeparate(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBlendFuncSeparate) ID() binary.ID { return binaryIDGlBlendFuncSeparate }
func (*binaryClassGlBlendFuncSeparate) New() binary.Object { return &GlBlendFuncSeparate{} }
func (*binaryClassGlBlendFuncSeparate) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBlendFuncSeparate(e, obj.(*GlBlendFuncSeparate))
}
func (*binaryClassGlBlendFuncSeparate) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBlendFuncSeparate{}
return obj, doDecodeGlBlendFuncSeparate(d, obj)
}
func (*binaryClassGlBlendFuncSeparate) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBlendFuncSeparate(d, obj.(*GlBlendFuncSeparate))
}
func (*binaryClassGlBlendFuncSeparate) Skip(d binary.Decoder) error {
return doSkipGlBlendFuncSeparate(d)
}
func (*binaryClassGlBlendFuncSeparate) Schema() *schema.Class { return schemaGlBlendFuncSeparate }
var schemaGlBlendFuncSeparate = &schema.Class{
TypeID: binaryIDGlBlendFuncSeparate,
Name: "GlBlendFuncSeparate",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "SrcFactorRgb", Type: &schema.Primitive{Name: "BlendFactor", Method: schema.Uint32}},
schema.Field{Declared: "DstFactorRgb", Type: &schema.Primitive{Name: "BlendFactor", Method: schema.Uint32}},
schema.Field{Declared: "SrcFactorAlpha", Type: &schema.Primitive{Name: "BlendFactor", Method: schema.Uint32}},
schema.Field{Declared: "DstFactorAlpha", Type: &schema.Primitive{Name: "BlendFactor", Method: schema.Uint32}},
},
}
type binaryClassGlBlitFramebuffer struct{}
func (*GlBlitFramebuffer) Class() binary.Class {
return (*binaryClassGlBlitFramebuffer)(nil)
}
func doEncodeGlBlitFramebuffer(e binary.Encoder, o *GlBlitFramebuffer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.SrcX0); err != nil {
return err
}
if err := e.Int32(o.SrcY0); err != nil {
return err
}
if err := e.Int32(o.SrcX1); err != nil {
return err
}
if err := e.Int32(o.SrcY1); err != nil {
return err
}
if err := e.Int32(o.DstX0); err != nil {
return err
}
if err := e.Int32(o.DstY0); err != nil {
return err
}
if err := e.Int32(o.DstX1); err != nil {
return err
}
if err := e.Int32(o.DstY1); err != nil {
return err
}
if err := e.Uint32(uint32(o.Mask)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Filter)); err != nil {
return err
}
return nil
}
func doDecodeGlBlitFramebuffer(d binary.Decoder, o *GlBlitFramebuffer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.SrcX0 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.SrcY0 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.SrcX1 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.SrcY1 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.DstX0 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.DstY0 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.DstX1 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.DstY1 = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Mask = ClearMask(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Filter = TextureFilterMode(obj)
}
return nil
}
func doSkipGlBlitFramebuffer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBlitFramebuffer) ID() binary.ID { return binaryIDGlBlitFramebuffer }
func (*binaryClassGlBlitFramebuffer) New() binary.Object { return &GlBlitFramebuffer{} }
func (*binaryClassGlBlitFramebuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBlitFramebuffer(e, obj.(*GlBlitFramebuffer))
}
func (*binaryClassGlBlitFramebuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBlitFramebuffer{}
return obj, doDecodeGlBlitFramebuffer(d, obj)
}
func (*binaryClassGlBlitFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBlitFramebuffer(d, obj.(*GlBlitFramebuffer))
}
func (*binaryClassGlBlitFramebuffer) Skip(d binary.Decoder) error { return doSkipGlBlitFramebuffer(d) }
func (*binaryClassGlBlitFramebuffer) Schema() *schema.Class { return schemaGlBlitFramebuffer }
var schemaGlBlitFramebuffer = &schema.Class{
TypeID: binaryIDGlBlitFramebuffer,
Name: "GlBlitFramebuffer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "SrcX0", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "SrcY0", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "SrcX1", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "SrcY1", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "DstX0", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "DstY0", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "DstX1", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "DstY1", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Mask", Type: &schema.Primitive{Name: "ClearMask", Method: schema.Uint32}},
schema.Field{Declared: "Filter", Type: &schema.Primitive{Name: "TextureFilterMode", Method: schema.Uint32}},
},
}
type binaryClassGlBufferData struct{}
func (*GlBufferData) Class() binary.Class {
return (*binaryClassGlBufferData)(nil)
}
func doEncodeGlBufferData(e binary.Encoder, o *GlBufferData) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Size); err != nil {
return err
}
if err := e.Value(&o.Data); err != nil {
return err
}
if err := e.Uint32(uint32(o.Usage)); err != nil {
return err
}
return nil
}
func doDecodeGlBufferData(d binary.Decoder, o *GlBufferData) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = BufferTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Size = int32(obj)
}
if err := d.Value(&o.Data); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Usage = BufferUsage(obj)
}
return nil
}
func doSkipGlBufferData(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*BufferDataPointer)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlBufferData) ID() binary.ID { return binaryIDGlBufferData }
func (*binaryClassGlBufferData) New() binary.Object { return &GlBufferData{} }
func (*binaryClassGlBufferData) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBufferData(e, obj.(*GlBufferData))
}
func (*binaryClassGlBufferData) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBufferData{}
return obj, doDecodeGlBufferData(d, obj)
}
func (*binaryClassGlBufferData) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBufferData(d, obj.(*GlBufferData))
}
func (*binaryClassGlBufferData) Skip(d binary.Decoder) error { return doSkipGlBufferData(d) }
func (*binaryClassGlBufferData) Schema() *schema.Class { return schemaGlBufferData }
var schemaGlBufferData = &schema.Class{
TypeID: binaryIDGlBufferData,
Name: "GlBufferData",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "BufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Size", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Data", Type: &schema.Struct{Name: "BufferDataPointer"}},
schema.Field{Declared: "Usage", Type: &schema.Primitive{Name: "BufferUsage", Method: schema.Uint32}},
},
}
type binaryClassGlBufferSubData struct{}
func (*GlBufferSubData) Class() binary.Class {
return (*binaryClassGlBufferSubData)(nil)
}
func doEncodeGlBufferSubData(e binary.Encoder, o *GlBufferSubData) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Offset); err != nil {
return err
}
if err := e.Int32(o.Size); err != nil {
return err
}
if err := e.Value(&o.Data); err != nil {
return err
}
return nil
}
func doDecodeGlBufferSubData(d binary.Decoder, o *GlBufferSubData) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = BufferTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Offset = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Size = int32(obj)
}
if err := d.Value(&o.Data); err != nil {
return err
}
return nil
}
func doSkipGlBufferSubData(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlBufferSubData) ID() binary.ID { return binaryIDGlBufferSubData }
func (*binaryClassGlBufferSubData) New() binary.Object { return &GlBufferSubData{} }
func (*binaryClassGlBufferSubData) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlBufferSubData(e, obj.(*GlBufferSubData))
}
func (*binaryClassGlBufferSubData) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlBufferSubData{}
return obj, doDecodeGlBufferSubData(d, obj)
}
func (*binaryClassGlBufferSubData) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlBufferSubData(d, obj.(*GlBufferSubData))
}
func (*binaryClassGlBufferSubData) Skip(d binary.Decoder) error { return doSkipGlBufferSubData(d) }
func (*binaryClassGlBufferSubData) Schema() *schema.Class { return schemaGlBufferSubData }
var schemaGlBufferSubData = &schema.Class{
TypeID: binaryIDGlBufferSubData,
Name: "GlBufferSubData",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "BufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Offset", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Size", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Data", Type: &schema.Struct{Name: "Voidᵖ"}},
},
}
type binaryClassGlCheckFramebufferStatus struct{}
func (*GlCheckFramebufferStatus) Class() binary.Class {
return (*binaryClassGlCheckFramebufferStatus)(nil)
}
func doEncodeGlCheckFramebufferStatus(e binary.Encoder, o *GlCheckFramebufferStatus) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeGlCheckFramebufferStatus(d binary.Decoder, o *GlCheckFramebufferStatus) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = FramebufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Result = FramebufferStatus(obj)
}
return nil
}
func doSkipGlCheckFramebufferStatus(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlCheckFramebufferStatus) ID() binary.ID { return binaryIDGlCheckFramebufferStatus }
func (*binaryClassGlCheckFramebufferStatus) New() binary.Object { return &GlCheckFramebufferStatus{} }
func (*binaryClassGlCheckFramebufferStatus) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlCheckFramebufferStatus(e, obj.(*GlCheckFramebufferStatus))
}
func (*binaryClassGlCheckFramebufferStatus) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlCheckFramebufferStatus{}
return obj, doDecodeGlCheckFramebufferStatus(d, obj)
}
func (*binaryClassGlCheckFramebufferStatus) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlCheckFramebufferStatus(d, obj.(*GlCheckFramebufferStatus))
}
func (*binaryClassGlCheckFramebufferStatus) Skip(d binary.Decoder) error {
return doSkipGlCheckFramebufferStatus(d)
}
func (*binaryClassGlCheckFramebufferStatus) Schema() *schema.Class {
return schemaGlCheckFramebufferStatus
}
var schemaGlCheckFramebufferStatus = &schema.Class{
TypeID: binaryIDGlCheckFramebufferStatus,
Name: "GlCheckFramebufferStatus",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "FramebufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "FramebufferStatus", Method: schema.Uint32}},
},
}
type binaryClassGlClear struct{}
func (*GlClear) Class() binary.Class {
return (*binaryClassGlClear)(nil)
}
func doEncodeGlClear(e binary.Encoder, o *GlClear) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Mask)); err != nil {
return err
}
return nil
}
func doDecodeGlClear(d binary.Decoder, o *GlClear) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Mask = ClearMask(obj)
}
return nil
}
func doSkipGlClear(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlClear) ID() binary.ID { return binaryIDGlClear }
func (*binaryClassGlClear) New() binary.Object { return &GlClear{} }
func (*binaryClassGlClear) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlClear(e, obj.(*GlClear))
}
func (*binaryClassGlClear) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlClear{}
return obj, doDecodeGlClear(d, obj)
}
func (*binaryClassGlClear) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlClear(d, obj.(*GlClear))
}
func (*binaryClassGlClear) Skip(d binary.Decoder) error { return doSkipGlClear(d) }
func (*binaryClassGlClear) Schema() *schema.Class { return schemaGlClear }
var schemaGlClear = &schema.Class{
TypeID: binaryIDGlClear,
Name: "GlClear",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Mask", Type: &schema.Primitive{Name: "ClearMask", Method: schema.Uint32}},
},
}
type binaryClassGlClearColor struct{}
func (*GlClearColor) Class() binary.Class {
return (*binaryClassGlClearColor)(nil)
}
func doEncodeGlClearColor(e binary.Encoder, o *GlClearColor) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Float32(o.R); err != nil {
return err
}
if err := e.Float32(o.G); err != nil {
return err
}
if err := e.Float32(o.B); err != nil {
return err
}
if err := e.Float32(o.A); err != nil {
return err
}
return nil
}
func doDecodeGlClearColor(d binary.Decoder, o *GlClearColor) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.R = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.G = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.B = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.A = float32(obj)
}
return nil
}
func doSkipGlClearColor(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlClearColor) ID() binary.ID { return binaryIDGlClearColor }
func (*binaryClassGlClearColor) New() binary.Object { return &GlClearColor{} }
func (*binaryClassGlClearColor) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlClearColor(e, obj.(*GlClearColor))
}
func (*binaryClassGlClearColor) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlClearColor{}
return obj, doDecodeGlClearColor(d, obj)
}
func (*binaryClassGlClearColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlClearColor(d, obj.(*GlClearColor))
}
func (*binaryClassGlClearColor) Skip(d binary.Decoder) error { return doSkipGlClearColor(d) }
func (*binaryClassGlClearColor) Schema() *schema.Class { return schemaGlClearColor }
var schemaGlClearColor = &schema.Class{
TypeID: binaryIDGlClearColor,
Name: "GlClearColor",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "R", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "G", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "B", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "A", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlClearDepthf struct{}
func (*GlClearDepthf) Class() binary.Class {
return (*binaryClassGlClearDepthf)(nil)
}
func doEncodeGlClearDepthf(e binary.Encoder, o *GlClearDepthf) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Float32(o.Depth); err != nil {
return err
}
return nil
}
func doDecodeGlClearDepthf(d binary.Decoder, o *GlClearDepthf) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Depth = float32(obj)
}
return nil
}
func doSkipGlClearDepthf(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlClearDepthf) ID() binary.ID { return binaryIDGlClearDepthf }
func (*binaryClassGlClearDepthf) New() binary.Object { return &GlClearDepthf{} }
func (*binaryClassGlClearDepthf) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlClearDepthf(e, obj.(*GlClearDepthf))
}
func (*binaryClassGlClearDepthf) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlClearDepthf{}
return obj, doDecodeGlClearDepthf(d, obj)
}
func (*binaryClassGlClearDepthf) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlClearDepthf(d, obj.(*GlClearDepthf))
}
func (*binaryClassGlClearDepthf) Skip(d binary.Decoder) error { return doSkipGlClearDepthf(d) }
func (*binaryClassGlClearDepthf) Schema() *schema.Class { return schemaGlClearDepthf }
var schemaGlClearDepthf = &schema.Class{
TypeID: binaryIDGlClearDepthf,
Name: "GlClearDepthf",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Depth", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlClearStencil struct{}
func (*GlClearStencil) Class() binary.Class {
return (*binaryClassGlClearStencil)(nil)
}
func doEncodeGlClearStencil(e binary.Encoder, o *GlClearStencil) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Stencil); err != nil {
return err
}
return nil
}
func doDecodeGlClearStencil(d binary.Decoder, o *GlClearStencil) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Stencil = int32(obj)
}
return nil
}
func doSkipGlClearStencil(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlClearStencil) ID() binary.ID { return binaryIDGlClearStencil }
func (*binaryClassGlClearStencil) New() binary.Object { return &GlClearStencil{} }
func (*binaryClassGlClearStencil) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlClearStencil(e, obj.(*GlClearStencil))
}
func (*binaryClassGlClearStencil) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlClearStencil{}
return obj, doDecodeGlClearStencil(d, obj)
}
func (*binaryClassGlClearStencil) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlClearStencil(d, obj.(*GlClearStencil))
}
func (*binaryClassGlClearStencil) Skip(d binary.Decoder) error { return doSkipGlClearStencil(d) }
func (*binaryClassGlClearStencil) Schema() *schema.Class { return schemaGlClearStencil }
var schemaGlClearStencil = &schema.Class{
TypeID: binaryIDGlClearStencil,
Name: "GlClearStencil",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Stencil", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlColorMask struct{}
func (*GlColorMask) Class() binary.Class {
return (*binaryClassGlColorMask)(nil)
}
func doEncodeGlColorMask(e binary.Encoder, o *GlColorMask) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Bool(o.Red); err != nil {
return err
}
if err := e.Bool(o.Green); err != nil {
return err
}
if err := e.Bool(o.Blue); err != nil {
return err
}
if err := e.Bool(o.Alpha); err != nil {
return err
}
return nil
}
func doDecodeGlColorMask(d binary.Decoder, o *GlColorMask) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Red = bool(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Green = bool(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Blue = bool(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Alpha = bool(obj)
}
return nil
}
func doSkipGlColorMask(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlColorMask) ID() binary.ID { return binaryIDGlColorMask }
func (*binaryClassGlColorMask) New() binary.Object { return &GlColorMask{} }
func (*binaryClassGlColorMask) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlColorMask(e, obj.(*GlColorMask))
}
func (*binaryClassGlColorMask) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlColorMask{}
return obj, doDecodeGlColorMask(d, obj)
}
func (*binaryClassGlColorMask) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlColorMask(d, obj.(*GlColorMask))
}
func (*binaryClassGlColorMask) Skip(d binary.Decoder) error { return doSkipGlColorMask(d) }
func (*binaryClassGlColorMask) Schema() *schema.Class { return schemaGlColorMask }
var schemaGlColorMask = &schema.Class{
TypeID: binaryIDGlColorMask,
Name: "GlColorMask",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Red", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Green", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Blue", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Alpha", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlCompileShader struct{}
func (*GlCompileShader) Class() binary.Class {
return (*binaryClassGlCompileShader)(nil)
}
func doEncodeGlCompileShader(e binary.Encoder, o *GlCompileShader) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Shader)); err != nil {
return err
}
return nil
}
func doDecodeGlCompileShader(d binary.Decoder, o *GlCompileShader) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Shader = ShaderId(obj)
}
return nil
}
func doSkipGlCompileShader(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlCompileShader) ID() binary.ID { return binaryIDGlCompileShader }
func (*binaryClassGlCompileShader) New() binary.Object { return &GlCompileShader{} }
func (*binaryClassGlCompileShader) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlCompileShader(e, obj.(*GlCompileShader))
}
func (*binaryClassGlCompileShader) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlCompileShader{}
return obj, doDecodeGlCompileShader(d, obj)
}
func (*binaryClassGlCompileShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlCompileShader(d, obj.(*GlCompileShader))
}
func (*binaryClassGlCompileShader) Skip(d binary.Decoder) error { return doSkipGlCompileShader(d) }
func (*binaryClassGlCompileShader) Schema() *schema.Class { return schemaGlCompileShader }
var schemaGlCompileShader = &schema.Class{
TypeID: binaryIDGlCompileShader,
Name: "GlCompileShader",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
},
}
type binaryClassTexturePointer struct{}
func (*TexturePointer) Class() binary.Class {
return (*binaryClassTexturePointer)(nil)
}
func doEncodeTexturePointer(e binary.Encoder, o *TexturePointer) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeTexturePointer(d binary.Decoder, o *TexturePointer) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipTexturePointer(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassTexturePointer) ID() binary.ID { return binaryIDTexturePointer }
func (*binaryClassTexturePointer) New() binary.Object { return &TexturePointer{} }
func (*binaryClassTexturePointer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeTexturePointer(e, obj.(*TexturePointer))
}
func (*binaryClassTexturePointer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &TexturePointer{}
return obj, doDecodeTexturePointer(d, obj)
}
func (*binaryClassTexturePointer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeTexturePointer(d, obj.(*TexturePointer))
}
func (*binaryClassTexturePointer) Skip(d binary.Decoder) error { return doSkipTexturePointer(d) }
func (*binaryClassTexturePointer) Schema() *schema.Class { return schemaTexturePointer }
var schemaTexturePointer = &schema.Class{
TypeID: binaryIDTexturePointer,
Name: "TexturePointer",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlCompressedTexImage2D struct{}
func (*GlCompressedTexImage2D) Class() binary.Class {
return (*binaryClassGlCompressedTexImage2D)(nil)
}
func doEncodeGlCompressedTexImage2D(e binary.Encoder, o *GlCompressedTexImage2D) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Level); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
if err := e.Int32(o.Border); err != nil {
return err
}
if err := e.Int32(o.ImageSize); err != nil {
return err
}
if err := e.Value(&o.Data); err != nil {
return err
}
return nil
}
func doDecodeGlCompressedTexImage2D(d binary.Decoder, o *GlCompressedTexImage2D) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureImageTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Level = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = CompressedTexelFormat(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Border = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.ImageSize = int32(obj)
}
if err := d.Value(&o.Data); err != nil {
return err
}
return nil
}
func doSkipGlCompressedTexImage2D(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*TexturePointer)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlCompressedTexImage2D) ID() binary.ID { return binaryIDGlCompressedTexImage2D }
func (*binaryClassGlCompressedTexImage2D) New() binary.Object { return &GlCompressedTexImage2D{} }
func (*binaryClassGlCompressedTexImage2D) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlCompressedTexImage2D(e, obj.(*GlCompressedTexImage2D))
}
func (*binaryClassGlCompressedTexImage2D) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlCompressedTexImage2D{}
return obj, doDecodeGlCompressedTexImage2D(d, obj)
}
func (*binaryClassGlCompressedTexImage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlCompressedTexImage2D(d, obj.(*GlCompressedTexImage2D))
}
func (*binaryClassGlCompressedTexImage2D) Skip(d binary.Decoder) error {
return doSkipGlCompressedTexImage2D(d)
}
func (*binaryClassGlCompressedTexImage2D) Schema() *schema.Class { return schemaGlCompressedTexImage2D }
var schemaGlCompressedTexImage2D = &schema.Class{
TypeID: binaryIDGlCompressedTexImage2D,
Name: "GlCompressedTexImage2D",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureImageTarget", Method: schema.Uint32}},
schema.Field{Declared: "Level", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "CompressedTexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Border", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "ImageSize", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Data", Type: &schema.Struct{Name: "TexturePointer"}},
},
}
type binaryClassGlCompressedTexSubImage2D struct{}
func (*GlCompressedTexSubImage2D) Class() binary.Class {
return (*binaryClassGlCompressedTexSubImage2D)(nil)
}
func doEncodeGlCompressedTexSubImage2D(e binary.Encoder, o *GlCompressedTexSubImage2D) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Level); err != nil {
return err
}
if err := e.Int32(o.Xoffset); err != nil {
return err
}
if err := e.Int32(o.Yoffset); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Int32(o.ImageSize); err != nil {
return err
}
if err := e.Value(&o.Data); err != nil {
return err
}
return nil
}
func doDecodeGlCompressedTexSubImage2D(d binary.Decoder, o *GlCompressedTexSubImage2D) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureImageTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Level = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Xoffset = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Yoffset = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = CompressedTexelFormat(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.ImageSize = int32(obj)
}
if err := d.Value(&o.Data); err != nil {
return err
}
return nil
}
func doSkipGlCompressedTexSubImage2D(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*TexturePointer)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlCompressedTexSubImage2D) ID() binary.ID { return binaryIDGlCompressedTexSubImage2D }
func (*binaryClassGlCompressedTexSubImage2D) New() binary.Object { return &GlCompressedTexSubImage2D{} }
func (*binaryClassGlCompressedTexSubImage2D) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlCompressedTexSubImage2D(e, obj.(*GlCompressedTexSubImage2D))
}
func (*binaryClassGlCompressedTexSubImage2D) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlCompressedTexSubImage2D{}
return obj, doDecodeGlCompressedTexSubImage2D(d, obj)
}
func (*binaryClassGlCompressedTexSubImage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlCompressedTexSubImage2D(d, obj.(*GlCompressedTexSubImage2D))
}
func (*binaryClassGlCompressedTexSubImage2D) Skip(d binary.Decoder) error {
return doSkipGlCompressedTexSubImage2D(d)
}
func (*binaryClassGlCompressedTexSubImage2D) Schema() *schema.Class {
return schemaGlCompressedTexSubImage2D
}
var schemaGlCompressedTexSubImage2D = &schema.Class{
TypeID: binaryIDGlCompressedTexSubImage2D,
Name: "GlCompressedTexSubImage2D",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureImageTarget", Method: schema.Uint32}},
schema.Field{Declared: "Level", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Xoffset", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Yoffset", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "CompressedTexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "ImageSize", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Data", Type: &schema.Struct{Name: "TexturePointer"}},
},
}
type binaryClassGlCopyTexImage2D struct{}
func (*GlCopyTexImage2D) Class() binary.Class {
return (*binaryClassGlCopyTexImage2D)(nil)
}
func doEncodeGlCopyTexImage2D(e binary.Encoder, o *GlCopyTexImage2D) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Level); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Int32(o.X); err != nil {
return err
}
if err := e.Int32(o.Y); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
if err := e.Int32(o.Border); err != nil {
return err
}
return nil
}
func doDecodeGlCopyTexImage2D(d binary.Decoder, o *GlCopyTexImage2D) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureImageTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Level = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = TexelFormat(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.X = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Y = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Border = int32(obj)
}
return nil
}
func doSkipGlCopyTexImage2D(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlCopyTexImage2D) ID() binary.ID { return binaryIDGlCopyTexImage2D }
func (*binaryClassGlCopyTexImage2D) New() binary.Object { return &GlCopyTexImage2D{} }
func (*binaryClassGlCopyTexImage2D) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlCopyTexImage2D(e, obj.(*GlCopyTexImage2D))
}
func (*binaryClassGlCopyTexImage2D) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlCopyTexImage2D{}
return obj, doDecodeGlCopyTexImage2D(d, obj)
}
func (*binaryClassGlCopyTexImage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlCopyTexImage2D(d, obj.(*GlCopyTexImage2D))
}
func (*binaryClassGlCopyTexImage2D) Skip(d binary.Decoder) error { return doSkipGlCopyTexImage2D(d) }
func (*binaryClassGlCopyTexImage2D) Schema() *schema.Class { return schemaGlCopyTexImage2D }
var schemaGlCopyTexImage2D = &schema.Class{
TypeID: binaryIDGlCopyTexImage2D,
Name: "GlCopyTexImage2D",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureImageTarget", Method: schema.Uint32}},
schema.Field{Declared: "Level", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "TexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Border", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlCopyTexSubImage2D struct{}
func (*GlCopyTexSubImage2D) Class() binary.Class {
return (*binaryClassGlCopyTexSubImage2D)(nil)
}
func doEncodeGlCopyTexSubImage2D(e binary.Encoder, o *GlCopyTexSubImage2D) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Level); err != nil {
return err
}
if err := e.Int32(o.Xoffset); err != nil {
return err
}
if err := e.Int32(o.Yoffset); err != nil {
return err
}
if err := e.Int32(o.X); err != nil {
return err
}
if err := e.Int32(o.Y); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
return nil
}
func doDecodeGlCopyTexSubImage2D(d binary.Decoder, o *GlCopyTexSubImage2D) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureImageTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Level = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Xoffset = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Yoffset = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.X = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Y = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
return nil
}
func doSkipGlCopyTexSubImage2D(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlCopyTexSubImage2D) ID() binary.ID { return binaryIDGlCopyTexSubImage2D }
func (*binaryClassGlCopyTexSubImage2D) New() binary.Object { return &GlCopyTexSubImage2D{} }
func (*binaryClassGlCopyTexSubImage2D) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlCopyTexSubImage2D(e, obj.(*GlCopyTexSubImage2D))
}
func (*binaryClassGlCopyTexSubImage2D) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlCopyTexSubImage2D{}
return obj, doDecodeGlCopyTexSubImage2D(d, obj)
}
func (*binaryClassGlCopyTexSubImage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlCopyTexSubImage2D(d, obj.(*GlCopyTexSubImage2D))
}
func (*binaryClassGlCopyTexSubImage2D) Skip(d binary.Decoder) error {
return doSkipGlCopyTexSubImage2D(d)
}
func (*binaryClassGlCopyTexSubImage2D) Schema() *schema.Class { return schemaGlCopyTexSubImage2D }
var schemaGlCopyTexSubImage2D = &schema.Class{
TypeID: binaryIDGlCopyTexSubImage2D,
Name: "GlCopyTexSubImage2D",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureImageTarget", Method: schema.Uint32}},
schema.Field{Declared: "Level", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Xoffset", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Yoffset", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlCreateProgram struct{}
func (*GlCreateProgram) Class() binary.Class {
return (*binaryClassGlCreateProgram)(nil)
}
func doEncodeGlCreateProgram(e binary.Encoder, o *GlCreateProgram) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeGlCreateProgram(d binary.Decoder, o *GlCreateProgram) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Result = ProgramId(obj)
}
return nil
}
func doSkipGlCreateProgram(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlCreateProgram) ID() binary.ID { return binaryIDGlCreateProgram }
func (*binaryClassGlCreateProgram) New() binary.Object { return &GlCreateProgram{} }
func (*binaryClassGlCreateProgram) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlCreateProgram(e, obj.(*GlCreateProgram))
}
func (*binaryClassGlCreateProgram) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlCreateProgram{}
return obj, doDecodeGlCreateProgram(d, obj)
}
func (*binaryClassGlCreateProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlCreateProgram(d, obj.(*GlCreateProgram))
}
func (*binaryClassGlCreateProgram) Skip(d binary.Decoder) error { return doSkipGlCreateProgram(d) }
func (*binaryClassGlCreateProgram) Schema() *schema.Class { return schemaGlCreateProgram }
var schemaGlCreateProgram = &schema.Class{
TypeID: binaryIDGlCreateProgram,
Name: "GlCreateProgram",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
},
}
type binaryClassGlCreateShader struct{}
func (*GlCreateShader) Class() binary.Class {
return (*binaryClassGlCreateShader)(nil)
}
func doEncodeGlCreateShader(e binary.Encoder, o *GlCreateShader) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Type)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeGlCreateShader(d binary.Decoder, o *GlCreateShader) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = ShaderType(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Result = ShaderId(obj)
}
return nil
}
func doSkipGlCreateShader(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlCreateShader) ID() binary.ID { return binaryIDGlCreateShader }
func (*binaryClassGlCreateShader) New() binary.Object { return &GlCreateShader{} }
func (*binaryClassGlCreateShader) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlCreateShader(e, obj.(*GlCreateShader))
}
func (*binaryClassGlCreateShader) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlCreateShader{}
return obj, doDecodeGlCreateShader(d, obj)
}
func (*binaryClassGlCreateShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlCreateShader(d, obj.(*GlCreateShader))
}
func (*binaryClassGlCreateShader) Skip(d binary.Decoder) error { return doSkipGlCreateShader(d) }
func (*binaryClassGlCreateShader) Schema() *schema.Class { return schemaGlCreateShader }
var schemaGlCreateShader = &schema.Class{
TypeID: binaryIDGlCreateShader,
Name: "GlCreateShader",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "ShaderType", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
},
}
type binaryClassGlCullFace struct{}
func (*GlCullFace) Class() binary.Class {
return (*binaryClassGlCullFace)(nil)
}
func doEncodeGlCullFace(e binary.Encoder, o *GlCullFace) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Mode)); err != nil {
return err
}
return nil
}
func doDecodeGlCullFace(d binary.Decoder, o *GlCullFace) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Mode = FaceMode(obj)
}
return nil
}
func doSkipGlCullFace(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlCullFace) ID() binary.ID { return binaryIDGlCullFace }
func (*binaryClassGlCullFace) New() binary.Object { return &GlCullFace{} }
func (*binaryClassGlCullFace) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlCullFace(e, obj.(*GlCullFace))
}
func (*binaryClassGlCullFace) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlCullFace{}
return obj, doDecodeGlCullFace(d, obj)
}
func (*binaryClassGlCullFace) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlCullFace(d, obj.(*GlCullFace))
}
func (*binaryClassGlCullFace) Skip(d binary.Decoder) error { return doSkipGlCullFace(d) }
func (*binaryClassGlCullFace) Schema() *schema.Class { return schemaGlCullFace }
var schemaGlCullFace = &schema.Class{
TypeID: binaryIDGlCullFace,
Name: "GlCullFace",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Mode", Type: &schema.Primitive{Name: "FaceMode", Method: schema.Uint32}},
},
}
type binaryClassGlDeleteBuffers struct{}
func (*GlDeleteBuffers) Class() binary.Class {
return (*binaryClassGlDeleteBuffers)(nil)
}
func doEncodeGlDeleteBuffers(e binary.Encoder, o *GlDeleteBuffers) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Buffers); err != nil {
return err
}
return nil
}
func doDecodeGlDeleteBuffers(d binary.Decoder, o *GlDeleteBuffers) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Buffers); err != nil {
return err
}
return nil
}
func doSkipGlDeleteBuffers(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*BufferIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlDeleteBuffers) ID() binary.ID { return binaryIDGlDeleteBuffers }
func (*binaryClassGlDeleteBuffers) New() binary.Object { return &GlDeleteBuffers{} }
func (*binaryClassGlDeleteBuffers) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDeleteBuffers(e, obj.(*GlDeleteBuffers))
}
func (*binaryClassGlDeleteBuffers) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDeleteBuffers{}
return obj, doDecodeGlDeleteBuffers(d, obj)
}
func (*binaryClassGlDeleteBuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDeleteBuffers(d, obj.(*GlDeleteBuffers))
}
func (*binaryClassGlDeleteBuffers) Skip(d binary.Decoder) error { return doSkipGlDeleteBuffers(d) }
func (*binaryClassGlDeleteBuffers) Schema() *schema.Class { return schemaGlDeleteBuffers }
var schemaGlDeleteBuffers = &schema.Class{
TypeID: binaryIDGlDeleteBuffers,
Name: "GlDeleteBuffers",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Buffers", Type: &schema.Struct{Name: "BufferIdᵖ"}},
},
}
type binaryClassGlDeleteFramebuffers struct{}
func (*GlDeleteFramebuffers) Class() binary.Class {
return (*binaryClassGlDeleteFramebuffers)(nil)
}
func doEncodeGlDeleteFramebuffers(e binary.Encoder, o *GlDeleteFramebuffers) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Framebuffers); err != nil {
return err
}
return nil
}
func doDecodeGlDeleteFramebuffers(d binary.Decoder, o *GlDeleteFramebuffers) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Framebuffers); err != nil {
return err
}
return nil
}
func doSkipGlDeleteFramebuffers(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*FramebufferIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlDeleteFramebuffers) ID() binary.ID { return binaryIDGlDeleteFramebuffers }
func (*binaryClassGlDeleteFramebuffers) New() binary.Object { return &GlDeleteFramebuffers{} }
func (*binaryClassGlDeleteFramebuffers) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDeleteFramebuffers(e, obj.(*GlDeleteFramebuffers))
}
func (*binaryClassGlDeleteFramebuffers) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDeleteFramebuffers{}
return obj, doDecodeGlDeleteFramebuffers(d, obj)
}
func (*binaryClassGlDeleteFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDeleteFramebuffers(d, obj.(*GlDeleteFramebuffers))
}
func (*binaryClassGlDeleteFramebuffers) Skip(d binary.Decoder) error {
return doSkipGlDeleteFramebuffers(d)
}
func (*binaryClassGlDeleteFramebuffers) Schema() *schema.Class { return schemaGlDeleteFramebuffers }
var schemaGlDeleteFramebuffers = &schema.Class{
TypeID: binaryIDGlDeleteFramebuffers,
Name: "GlDeleteFramebuffers",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Framebuffers", Type: &schema.Struct{Name: "FramebufferIdᵖ"}},
},
}
type binaryClassGlDeleteProgram struct{}
func (*GlDeleteProgram) Class() binary.Class {
return (*binaryClassGlDeleteProgram)(nil)
}
func doEncodeGlDeleteProgram(e binary.Encoder, o *GlDeleteProgram) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
return nil
}
func doDecodeGlDeleteProgram(d binary.Decoder, o *GlDeleteProgram) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
return nil
}
func doSkipGlDeleteProgram(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlDeleteProgram) ID() binary.ID { return binaryIDGlDeleteProgram }
func (*binaryClassGlDeleteProgram) New() binary.Object { return &GlDeleteProgram{} }
func (*binaryClassGlDeleteProgram) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDeleteProgram(e, obj.(*GlDeleteProgram))
}
func (*binaryClassGlDeleteProgram) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDeleteProgram{}
return obj, doDecodeGlDeleteProgram(d, obj)
}
func (*binaryClassGlDeleteProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDeleteProgram(d, obj.(*GlDeleteProgram))
}
func (*binaryClassGlDeleteProgram) Skip(d binary.Decoder) error { return doSkipGlDeleteProgram(d) }
func (*binaryClassGlDeleteProgram) Schema() *schema.Class { return schemaGlDeleteProgram }
var schemaGlDeleteProgram = &schema.Class{
TypeID: binaryIDGlDeleteProgram,
Name: "GlDeleteProgram",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
},
}
type binaryClassQueryIdᵖ struct{}
func (*QueryIdᵖ) Class() binary.Class {
return (*binaryClassQueryIdᵖ)(nil)
}
func doEncodeQueryIdᵖ(e binary.Encoder, o *QueryIdᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeQueryIdᵖ(d binary.Decoder, o *QueryIdᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipQueryIdᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassQueryIdᵖ) ID() binary.ID { return binaryIDQueryIdᵖ }
func (*binaryClassQueryIdᵖ) New() binary.Object { return &QueryIdᵖ{} }
func (*binaryClassQueryIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeQueryIdᵖ(e, obj.(*QueryIdᵖ))
}
func (*binaryClassQueryIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &QueryIdᵖ{}
return obj, doDecodeQueryIdᵖ(d, obj)
}
func (*binaryClassQueryIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeQueryIdᵖ(d, obj.(*QueryIdᵖ))
}
func (*binaryClassQueryIdᵖ) Skip(d binary.Decoder) error { return doSkipQueryIdᵖ(d) }
func (*binaryClassQueryIdᵖ) Schema() *schema.Class { return schemaQueryIdᵖ }
var schemaQueryIdᵖ = &schema.Class{
TypeID: binaryIDQueryIdᵖ,
Name: "QueryIdᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlDeleteQueries struct{}
func (*GlDeleteQueries) Class() binary.Class {
return (*binaryClassGlDeleteQueries)(nil)
}
func doEncodeGlDeleteQueries(e binary.Encoder, o *GlDeleteQueries) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Queries); err != nil {
return err
}
return nil
}
func doDecodeGlDeleteQueries(d binary.Decoder, o *GlDeleteQueries) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Queries); err != nil {
return err
}
return nil
}
func doSkipGlDeleteQueries(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*QueryIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlDeleteQueries) ID() binary.ID { return binaryIDGlDeleteQueries }
func (*binaryClassGlDeleteQueries) New() binary.Object { return &GlDeleteQueries{} }
func (*binaryClassGlDeleteQueries) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDeleteQueries(e, obj.(*GlDeleteQueries))
}
func (*binaryClassGlDeleteQueries) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDeleteQueries{}
return obj, doDecodeGlDeleteQueries(d, obj)
}
func (*binaryClassGlDeleteQueries) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDeleteQueries(d, obj.(*GlDeleteQueries))
}
func (*binaryClassGlDeleteQueries) Skip(d binary.Decoder) error { return doSkipGlDeleteQueries(d) }
func (*binaryClassGlDeleteQueries) Schema() *schema.Class { return schemaGlDeleteQueries }
var schemaGlDeleteQueries = &schema.Class{
TypeID: binaryIDGlDeleteQueries,
Name: "GlDeleteQueries",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Queries", Type: &schema.Struct{Name: "QueryIdᵖ"}},
},
}
type binaryClassGlDeleteQueriesEXT struct{}
func (*GlDeleteQueriesEXT) Class() binary.Class {
return (*binaryClassGlDeleteQueriesEXT)(nil)
}
func doEncodeGlDeleteQueriesEXT(e binary.Encoder, o *GlDeleteQueriesEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Queries); err != nil {
return err
}
return nil
}
func doDecodeGlDeleteQueriesEXT(d binary.Decoder, o *GlDeleteQueriesEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Queries); err != nil {
return err
}
return nil
}
func doSkipGlDeleteQueriesEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*QueryIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlDeleteQueriesEXT) ID() binary.ID { return binaryIDGlDeleteQueriesEXT }
func (*binaryClassGlDeleteQueriesEXT) New() binary.Object { return &GlDeleteQueriesEXT{} }
func (*binaryClassGlDeleteQueriesEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDeleteQueriesEXT(e, obj.(*GlDeleteQueriesEXT))
}
func (*binaryClassGlDeleteQueriesEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDeleteQueriesEXT{}
return obj, doDecodeGlDeleteQueriesEXT(d, obj)
}
func (*binaryClassGlDeleteQueriesEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDeleteQueriesEXT(d, obj.(*GlDeleteQueriesEXT))
}
func (*binaryClassGlDeleteQueriesEXT) Skip(d binary.Decoder) error { return doSkipGlDeleteQueriesEXT(d) }
func (*binaryClassGlDeleteQueriesEXT) Schema() *schema.Class { return schemaGlDeleteQueriesEXT }
var schemaGlDeleteQueriesEXT = &schema.Class{
TypeID: binaryIDGlDeleteQueriesEXT,
Name: "GlDeleteQueriesEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Queries", Type: &schema.Struct{Name: "QueryIdᵖ"}},
},
}
type binaryClassRenderbufferIdᵖ struct{}
func (*RenderbufferIdᵖ) Class() binary.Class {
return (*binaryClassRenderbufferIdᵖ)(nil)
}
func doEncodeRenderbufferIdᵖ(e binary.Encoder, o *RenderbufferIdᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeRenderbufferIdᵖ(d binary.Decoder, o *RenderbufferIdᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipRenderbufferIdᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassRenderbufferIdᵖ) ID() binary.ID { return binaryIDRenderbufferIdᵖ }
func (*binaryClassRenderbufferIdᵖ) New() binary.Object { return &RenderbufferIdᵖ{} }
func (*binaryClassRenderbufferIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeRenderbufferIdᵖ(e, obj.(*RenderbufferIdᵖ))
}
func (*binaryClassRenderbufferIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &RenderbufferIdᵖ{}
return obj, doDecodeRenderbufferIdᵖ(d, obj)
}
func (*binaryClassRenderbufferIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeRenderbufferIdᵖ(d, obj.(*RenderbufferIdᵖ))
}
func (*binaryClassRenderbufferIdᵖ) Skip(d binary.Decoder) error { return doSkipRenderbufferIdᵖ(d) }
func (*binaryClassRenderbufferIdᵖ) Schema() *schema.Class { return schemaRenderbufferIdᵖ }
var schemaRenderbufferIdᵖ = &schema.Class{
TypeID: binaryIDRenderbufferIdᵖ,
Name: "RenderbufferIdᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlDeleteRenderbuffers struct{}
func (*GlDeleteRenderbuffers) Class() binary.Class {
return (*binaryClassGlDeleteRenderbuffers)(nil)
}
func doEncodeGlDeleteRenderbuffers(e binary.Encoder, o *GlDeleteRenderbuffers) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Renderbuffers); err != nil {
return err
}
return nil
}
func doDecodeGlDeleteRenderbuffers(d binary.Decoder, o *GlDeleteRenderbuffers) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Renderbuffers); err != nil {
return err
}
return nil
}
func doSkipGlDeleteRenderbuffers(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*RenderbufferIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlDeleteRenderbuffers) ID() binary.ID { return binaryIDGlDeleteRenderbuffers }
func (*binaryClassGlDeleteRenderbuffers) New() binary.Object { return &GlDeleteRenderbuffers{} }
func (*binaryClassGlDeleteRenderbuffers) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDeleteRenderbuffers(e, obj.(*GlDeleteRenderbuffers))
}
func (*binaryClassGlDeleteRenderbuffers) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDeleteRenderbuffers{}
return obj, doDecodeGlDeleteRenderbuffers(d, obj)
}
func (*binaryClassGlDeleteRenderbuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDeleteRenderbuffers(d, obj.(*GlDeleteRenderbuffers))
}
func (*binaryClassGlDeleteRenderbuffers) Skip(d binary.Decoder) error {
return doSkipGlDeleteRenderbuffers(d)
}
func (*binaryClassGlDeleteRenderbuffers) Schema() *schema.Class { return schemaGlDeleteRenderbuffers }
var schemaGlDeleteRenderbuffers = &schema.Class{
TypeID: binaryIDGlDeleteRenderbuffers,
Name: "GlDeleteRenderbuffers",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Renderbuffers", Type: &schema.Struct{Name: "RenderbufferIdᵖ"}},
},
}
type binaryClassGlDeleteShader struct{}
func (*GlDeleteShader) Class() binary.Class {
return (*binaryClassGlDeleteShader)(nil)
}
func doEncodeGlDeleteShader(e binary.Encoder, o *GlDeleteShader) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Shader)); err != nil {
return err
}
return nil
}
func doDecodeGlDeleteShader(d binary.Decoder, o *GlDeleteShader) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Shader = ShaderId(obj)
}
return nil
}
func doSkipGlDeleteShader(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlDeleteShader) ID() binary.ID { return binaryIDGlDeleteShader }
func (*binaryClassGlDeleteShader) New() binary.Object { return &GlDeleteShader{} }
func (*binaryClassGlDeleteShader) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDeleteShader(e, obj.(*GlDeleteShader))
}
func (*binaryClassGlDeleteShader) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDeleteShader{}
return obj, doDecodeGlDeleteShader(d, obj)
}
func (*binaryClassGlDeleteShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDeleteShader(d, obj.(*GlDeleteShader))
}
func (*binaryClassGlDeleteShader) Skip(d binary.Decoder) error { return doSkipGlDeleteShader(d) }
func (*binaryClassGlDeleteShader) Schema() *schema.Class { return schemaGlDeleteShader }
var schemaGlDeleteShader = &schema.Class{
TypeID: binaryIDGlDeleteShader,
Name: "GlDeleteShader",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
},
}
type binaryClassTextureIdᵖ struct{}
func (*TextureIdᵖ) Class() binary.Class {
return (*binaryClassTextureIdᵖ)(nil)
}
func doEncodeTextureIdᵖ(e binary.Encoder, o *TextureIdᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeTextureIdᵖ(d binary.Decoder, o *TextureIdᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipTextureIdᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassTextureIdᵖ) ID() binary.ID { return binaryIDTextureIdᵖ }
func (*binaryClassTextureIdᵖ) New() binary.Object { return &TextureIdᵖ{} }
func (*binaryClassTextureIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeTextureIdᵖ(e, obj.(*TextureIdᵖ))
}
func (*binaryClassTextureIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &TextureIdᵖ{}
return obj, doDecodeTextureIdᵖ(d, obj)
}
func (*binaryClassTextureIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeTextureIdᵖ(d, obj.(*TextureIdᵖ))
}
func (*binaryClassTextureIdᵖ) Skip(d binary.Decoder) error { return doSkipTextureIdᵖ(d) }
func (*binaryClassTextureIdᵖ) Schema() *schema.Class { return schemaTextureIdᵖ }
var schemaTextureIdᵖ = &schema.Class{
TypeID: binaryIDTextureIdᵖ,
Name: "TextureIdᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlDeleteTextures struct{}
func (*GlDeleteTextures) Class() binary.Class {
return (*binaryClassGlDeleteTextures)(nil)
}
func doEncodeGlDeleteTextures(e binary.Encoder, o *GlDeleteTextures) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Textures); err != nil {
return err
}
return nil
}
func doDecodeGlDeleteTextures(d binary.Decoder, o *GlDeleteTextures) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Textures); err != nil {
return err
}
return nil
}
func doSkipGlDeleteTextures(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*TextureIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlDeleteTextures) ID() binary.ID { return binaryIDGlDeleteTextures }
func (*binaryClassGlDeleteTextures) New() binary.Object { return &GlDeleteTextures{} }
func (*binaryClassGlDeleteTextures) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDeleteTextures(e, obj.(*GlDeleteTextures))
}
func (*binaryClassGlDeleteTextures) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDeleteTextures{}
return obj, doDecodeGlDeleteTextures(d, obj)
}
func (*binaryClassGlDeleteTextures) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDeleteTextures(d, obj.(*GlDeleteTextures))
}
func (*binaryClassGlDeleteTextures) Skip(d binary.Decoder) error { return doSkipGlDeleteTextures(d) }
func (*binaryClassGlDeleteTextures) Schema() *schema.Class { return schemaGlDeleteTextures }
var schemaGlDeleteTextures = &schema.Class{
TypeID: binaryIDGlDeleteTextures,
Name: "GlDeleteTextures",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Textures", Type: &schema.Struct{Name: "TextureIdᵖ"}},
},
}
type binaryClassVertexArrayIdᵖ struct{}
func (*VertexArrayIdᵖ) Class() binary.Class {
return (*binaryClassVertexArrayIdᵖ)(nil)
}
func doEncodeVertexArrayIdᵖ(e binary.Encoder, o *VertexArrayIdᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeVertexArrayIdᵖ(d binary.Decoder, o *VertexArrayIdᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipVertexArrayIdᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassVertexArrayIdᵖ) ID() binary.ID { return binaryIDVertexArrayIdᵖ }
func (*binaryClassVertexArrayIdᵖ) New() binary.Object { return &VertexArrayIdᵖ{} }
func (*binaryClassVertexArrayIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVertexArrayIdᵖ(e, obj.(*VertexArrayIdᵖ))
}
func (*binaryClassVertexArrayIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &VertexArrayIdᵖ{}
return obj, doDecodeVertexArrayIdᵖ(d, obj)
}
func (*binaryClassVertexArrayIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVertexArrayIdᵖ(d, obj.(*VertexArrayIdᵖ))
}
func (*binaryClassVertexArrayIdᵖ) Skip(d binary.Decoder) error { return doSkipVertexArrayIdᵖ(d) }
func (*binaryClassVertexArrayIdᵖ) Schema() *schema.Class { return schemaVertexArrayIdᵖ }
var schemaVertexArrayIdᵖ = &schema.Class{
TypeID: binaryIDVertexArrayIdᵖ,
Name: "VertexArrayIdᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlDeleteVertexArraysOES struct{}
func (*GlDeleteVertexArraysOES) Class() binary.Class {
return (*binaryClassGlDeleteVertexArraysOES)(nil)
}
func doEncodeGlDeleteVertexArraysOES(e binary.Encoder, o *GlDeleteVertexArraysOES) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Arrays); err != nil {
return err
}
return nil
}
func doDecodeGlDeleteVertexArraysOES(d binary.Decoder, o *GlDeleteVertexArraysOES) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Arrays); err != nil {
return err
}
return nil
}
func doSkipGlDeleteVertexArraysOES(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*VertexArrayIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlDeleteVertexArraysOES) ID() binary.ID { return binaryIDGlDeleteVertexArraysOES }
func (*binaryClassGlDeleteVertexArraysOES) New() binary.Object { return &GlDeleteVertexArraysOES{} }
func (*binaryClassGlDeleteVertexArraysOES) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDeleteVertexArraysOES(e, obj.(*GlDeleteVertexArraysOES))
}
func (*binaryClassGlDeleteVertexArraysOES) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDeleteVertexArraysOES{}
return obj, doDecodeGlDeleteVertexArraysOES(d, obj)
}
func (*binaryClassGlDeleteVertexArraysOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDeleteVertexArraysOES(d, obj.(*GlDeleteVertexArraysOES))
}
func (*binaryClassGlDeleteVertexArraysOES) Skip(d binary.Decoder) error {
return doSkipGlDeleteVertexArraysOES(d)
}
func (*binaryClassGlDeleteVertexArraysOES) Schema() *schema.Class {
return schemaGlDeleteVertexArraysOES
}
var schemaGlDeleteVertexArraysOES = &schema.Class{
TypeID: binaryIDGlDeleteVertexArraysOES,
Name: "GlDeleteVertexArraysOES",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Arrays", Type: &schema.Struct{Name: "VertexArrayIdᵖ"}},
},
}
type binaryClassGlDepthFunc struct{}
func (*GlDepthFunc) Class() binary.Class {
return (*binaryClassGlDepthFunc)(nil)
}
func doEncodeGlDepthFunc(e binary.Encoder, o *GlDepthFunc) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Function)); err != nil {
return err
}
return nil
}
func doDecodeGlDepthFunc(d binary.Decoder, o *GlDepthFunc) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Function = TestFunction(obj)
}
return nil
}
func doSkipGlDepthFunc(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlDepthFunc) ID() binary.ID { return binaryIDGlDepthFunc }
func (*binaryClassGlDepthFunc) New() binary.Object { return &GlDepthFunc{} }
func (*binaryClassGlDepthFunc) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDepthFunc(e, obj.(*GlDepthFunc))
}
func (*binaryClassGlDepthFunc) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDepthFunc{}
return obj, doDecodeGlDepthFunc(d, obj)
}
func (*binaryClassGlDepthFunc) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDepthFunc(d, obj.(*GlDepthFunc))
}
func (*binaryClassGlDepthFunc) Skip(d binary.Decoder) error { return doSkipGlDepthFunc(d) }
func (*binaryClassGlDepthFunc) Schema() *schema.Class { return schemaGlDepthFunc }
var schemaGlDepthFunc = &schema.Class{
TypeID: binaryIDGlDepthFunc,
Name: "GlDepthFunc",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Function", Type: &schema.Primitive{Name: "TestFunction", Method: schema.Uint32}},
},
}
type binaryClassGlDepthMask struct{}
func (*GlDepthMask) Class() binary.Class {
return (*binaryClassGlDepthMask)(nil)
}
func doEncodeGlDepthMask(e binary.Encoder, o *GlDepthMask) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Bool(o.Enabled); err != nil {
return err
}
return nil
}
func doDecodeGlDepthMask(d binary.Decoder, o *GlDepthMask) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Enabled = bool(obj)
}
return nil
}
func doSkipGlDepthMask(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlDepthMask) ID() binary.ID { return binaryIDGlDepthMask }
func (*binaryClassGlDepthMask) New() binary.Object { return &GlDepthMask{} }
func (*binaryClassGlDepthMask) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDepthMask(e, obj.(*GlDepthMask))
}
func (*binaryClassGlDepthMask) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDepthMask{}
return obj, doDecodeGlDepthMask(d, obj)
}
func (*binaryClassGlDepthMask) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDepthMask(d, obj.(*GlDepthMask))
}
func (*binaryClassGlDepthMask) Skip(d binary.Decoder) error { return doSkipGlDepthMask(d) }
func (*binaryClassGlDepthMask) Schema() *schema.Class { return schemaGlDepthMask }
var schemaGlDepthMask = &schema.Class{
TypeID: binaryIDGlDepthMask,
Name: "GlDepthMask",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Enabled", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlDepthRangef struct{}
func (*GlDepthRangef) Class() binary.Class {
return (*binaryClassGlDepthRangef)(nil)
}
func doEncodeGlDepthRangef(e binary.Encoder, o *GlDepthRangef) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Float32(o.Near); err != nil {
return err
}
if err := e.Float32(o.Far); err != nil {
return err
}
return nil
}
func doDecodeGlDepthRangef(d binary.Decoder, o *GlDepthRangef) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Near = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Far = float32(obj)
}
return nil
}
func doSkipGlDepthRangef(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlDepthRangef) ID() binary.ID { return binaryIDGlDepthRangef }
func (*binaryClassGlDepthRangef) New() binary.Object { return &GlDepthRangef{} }
func (*binaryClassGlDepthRangef) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDepthRangef(e, obj.(*GlDepthRangef))
}
func (*binaryClassGlDepthRangef) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDepthRangef{}
return obj, doDecodeGlDepthRangef(d, obj)
}
func (*binaryClassGlDepthRangef) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDepthRangef(d, obj.(*GlDepthRangef))
}
func (*binaryClassGlDepthRangef) Skip(d binary.Decoder) error { return doSkipGlDepthRangef(d) }
func (*binaryClassGlDepthRangef) Schema() *schema.Class { return schemaGlDepthRangef }
var schemaGlDepthRangef = &schema.Class{
TypeID: binaryIDGlDepthRangef,
Name: "GlDepthRangef",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Near", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Far", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlDetachShader struct{}
func (*GlDetachShader) Class() binary.Class {
return (*binaryClassGlDetachShader)(nil)
}
func doEncodeGlDetachShader(e binary.Encoder, o *GlDetachShader) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Shader)); err != nil {
return err
}
return nil
}
func doDecodeGlDetachShader(d binary.Decoder, o *GlDetachShader) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Shader = ShaderId(obj)
}
return nil
}
func doSkipGlDetachShader(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlDetachShader) ID() binary.ID { return binaryIDGlDetachShader }
func (*binaryClassGlDetachShader) New() binary.Object { return &GlDetachShader{} }
func (*binaryClassGlDetachShader) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDetachShader(e, obj.(*GlDetachShader))
}
func (*binaryClassGlDetachShader) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDetachShader{}
return obj, doDecodeGlDetachShader(d, obj)
}
func (*binaryClassGlDetachShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDetachShader(d, obj.(*GlDetachShader))
}
func (*binaryClassGlDetachShader) Skip(d binary.Decoder) error { return doSkipGlDetachShader(d) }
func (*binaryClassGlDetachShader) Schema() *schema.Class { return schemaGlDetachShader }
var schemaGlDetachShader = &schema.Class{
TypeID: binaryIDGlDetachShader,
Name: "GlDetachShader",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
},
}
type binaryClassGlDisable struct{}
func (*GlDisable) Class() binary.Class {
return (*binaryClassGlDisable)(nil)
}
func doEncodeGlDisable(e binary.Encoder, o *GlDisable) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Capability)); err != nil {
return err
}
return nil
}
func doDecodeGlDisable(d binary.Decoder, o *GlDisable) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Capability = Capability(obj)
}
return nil
}
func doSkipGlDisable(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlDisable) ID() binary.ID { return binaryIDGlDisable }
func (*binaryClassGlDisable) New() binary.Object { return &GlDisable{} }
func (*binaryClassGlDisable) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDisable(e, obj.(*GlDisable))
}
func (*binaryClassGlDisable) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDisable{}
return obj, doDecodeGlDisable(d, obj)
}
func (*binaryClassGlDisable) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDisable(d, obj.(*GlDisable))
}
func (*binaryClassGlDisable) Skip(d binary.Decoder) error { return doSkipGlDisable(d) }
func (*binaryClassGlDisable) Schema() *schema.Class { return schemaGlDisable }
var schemaGlDisable = &schema.Class{
TypeID: binaryIDGlDisable,
Name: "GlDisable",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Capability", Type: &schema.Primitive{Name: "Capability", Method: schema.Uint32}},
},
}
type binaryClassGlDisableClientState struct{}
func (*GlDisableClientState) Class() binary.Class {
return (*binaryClassGlDisableClientState)(nil)
}
func doEncodeGlDisableClientState(e binary.Encoder, o *GlDisableClientState) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Type)); err != nil {
return err
}
return nil
}
func doDecodeGlDisableClientState(d binary.Decoder, o *GlDisableClientState) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = ArrayType(obj)
}
return nil
}
func doSkipGlDisableClientState(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlDisableClientState) ID() binary.ID { return binaryIDGlDisableClientState }
func (*binaryClassGlDisableClientState) New() binary.Object { return &GlDisableClientState{} }
func (*binaryClassGlDisableClientState) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDisableClientState(e, obj.(*GlDisableClientState))
}
func (*binaryClassGlDisableClientState) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDisableClientState{}
return obj, doDecodeGlDisableClientState(d, obj)
}
func (*binaryClassGlDisableClientState) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDisableClientState(d, obj.(*GlDisableClientState))
}
func (*binaryClassGlDisableClientState) Skip(d binary.Decoder) error {
return doSkipGlDisableClientState(d)
}
func (*binaryClassGlDisableClientState) Schema() *schema.Class { return schemaGlDisableClientState }
var schemaGlDisableClientState = &schema.Class{
TypeID: binaryIDGlDisableClientState,
Name: "GlDisableClientState",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "ArrayType", Method: schema.Uint32}},
},
}
type binaryClassGlDisableVertexAttribArray struct{}
func (*GlDisableVertexAttribArray) Class() binary.Class {
return (*binaryClassGlDisableVertexAttribArray)(nil)
}
func doEncodeGlDisableVertexAttribArray(e binary.Encoder, o *GlDisableVertexAttribArray) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
return nil
}
func doDecodeGlDisableVertexAttribArray(d binary.Decoder, o *GlDisableVertexAttribArray) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
return nil
}
func doSkipGlDisableVertexAttribArray(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlDisableVertexAttribArray) ID() binary.ID {
return binaryIDGlDisableVertexAttribArray
}
func (*binaryClassGlDisableVertexAttribArray) New() binary.Object {
return &GlDisableVertexAttribArray{}
}
func (*binaryClassGlDisableVertexAttribArray) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDisableVertexAttribArray(e, obj.(*GlDisableVertexAttribArray))
}
func (*binaryClassGlDisableVertexAttribArray) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDisableVertexAttribArray{}
return obj, doDecodeGlDisableVertexAttribArray(d, obj)
}
func (*binaryClassGlDisableVertexAttribArray) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDisableVertexAttribArray(d, obj.(*GlDisableVertexAttribArray))
}
func (*binaryClassGlDisableVertexAttribArray) Skip(d binary.Decoder) error {
return doSkipGlDisableVertexAttribArray(d)
}
func (*binaryClassGlDisableVertexAttribArray) Schema() *schema.Class {
return schemaGlDisableVertexAttribArray
}
var schemaGlDisableVertexAttribArray = &schema.Class{
TypeID: binaryIDGlDisableVertexAttribArray,
Name: "GlDisableVertexAttribArray",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
},
}
type binaryClassGlDiscardFramebufferEXT struct{}
func (*GlDiscardFramebufferEXT) Class() binary.Class {
return (*binaryClassGlDiscardFramebufferEXT)(nil)
}
func doEncodeGlDiscardFramebufferEXT(e binary.Encoder, o *GlDiscardFramebufferEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.NumAttachments); err != nil {
return err
}
if err := e.Value(&o.Attachments); err != nil {
return err
}
return nil
}
func doDecodeGlDiscardFramebufferEXT(d binary.Decoder, o *GlDiscardFramebufferEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = FramebufferTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.NumAttachments = int32(obj)
}
if err := d.Value(&o.Attachments); err != nil {
return err
}
return nil
}
func doSkipGlDiscardFramebufferEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*DiscardFramebufferAttachmentᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlDiscardFramebufferEXT) ID() binary.ID { return binaryIDGlDiscardFramebufferEXT }
func (*binaryClassGlDiscardFramebufferEXT) New() binary.Object { return &GlDiscardFramebufferEXT{} }
func (*binaryClassGlDiscardFramebufferEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDiscardFramebufferEXT(e, obj.(*GlDiscardFramebufferEXT))
}
func (*binaryClassGlDiscardFramebufferEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDiscardFramebufferEXT{}
return obj, doDecodeGlDiscardFramebufferEXT(d, obj)
}
func (*binaryClassGlDiscardFramebufferEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDiscardFramebufferEXT(d, obj.(*GlDiscardFramebufferEXT))
}
func (*binaryClassGlDiscardFramebufferEXT) Skip(d binary.Decoder) error {
return doSkipGlDiscardFramebufferEXT(d)
}
func (*binaryClassGlDiscardFramebufferEXT) Schema() *schema.Class {
return schemaGlDiscardFramebufferEXT
}
var schemaGlDiscardFramebufferEXT = &schema.Class{
TypeID: binaryIDGlDiscardFramebufferEXT,
Name: "GlDiscardFramebufferEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "FramebufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "NumAttachments", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Attachments", Type: &schema.Struct{Name: "DiscardFramebufferAttachmentᵖ"}},
},
}
type binaryClassGlDrawArrays struct{}
func (*GlDrawArrays) Class() binary.Class {
return (*binaryClassGlDrawArrays)(nil)
}
func doEncodeGlDrawArrays(e binary.Encoder, o *GlDrawArrays) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.DrawMode)); err != nil {
return err
}
if err := e.Int32(o.FirstIndex); err != nil {
return err
}
if err := e.Int32(o.IndexCount); err != nil {
return err
}
return nil
}
func doDecodeGlDrawArrays(d binary.Decoder, o *GlDrawArrays) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.DrawMode = DrawMode(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.FirstIndex = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.IndexCount = int32(obj)
}
return nil
}
func doSkipGlDrawArrays(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlDrawArrays) ID() binary.ID { return binaryIDGlDrawArrays }
func (*binaryClassGlDrawArrays) New() binary.Object { return &GlDrawArrays{} }
func (*binaryClassGlDrawArrays) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDrawArrays(e, obj.(*GlDrawArrays))
}
func (*binaryClassGlDrawArrays) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDrawArrays{}
return obj, doDecodeGlDrawArrays(d, obj)
}
func (*binaryClassGlDrawArrays) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDrawArrays(d, obj.(*GlDrawArrays))
}
func (*binaryClassGlDrawArrays) Skip(d binary.Decoder) error { return doSkipGlDrawArrays(d) }
func (*binaryClassGlDrawArrays) Schema() *schema.Class { return schemaGlDrawArrays }
var schemaGlDrawArrays = &schema.Class{
TypeID: binaryIDGlDrawArrays,
Name: "GlDrawArrays",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "DrawMode", Type: &schema.Primitive{Name: "DrawMode", Method: schema.Uint32}},
schema.Field{Declared: "FirstIndex", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "IndexCount", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassIndicesPointer struct{}
func (*IndicesPointer) Class() binary.Class {
return (*binaryClassIndicesPointer)(nil)
}
func doEncodeIndicesPointer(e binary.Encoder, o *IndicesPointer) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeIndicesPointer(d binary.Decoder, o *IndicesPointer) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipIndicesPointer(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassIndicesPointer) ID() binary.ID { return binaryIDIndicesPointer }
func (*binaryClassIndicesPointer) New() binary.Object { return &IndicesPointer{} }
func (*binaryClassIndicesPointer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeIndicesPointer(e, obj.(*IndicesPointer))
}
func (*binaryClassIndicesPointer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &IndicesPointer{}
return obj, doDecodeIndicesPointer(d, obj)
}
func (*binaryClassIndicesPointer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeIndicesPointer(d, obj.(*IndicesPointer))
}
func (*binaryClassIndicesPointer) Skip(d binary.Decoder) error { return doSkipIndicesPointer(d) }
func (*binaryClassIndicesPointer) Schema() *schema.Class { return schemaIndicesPointer }
var schemaIndicesPointer = &schema.Class{
TypeID: binaryIDIndicesPointer,
Name: "IndicesPointer",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlDrawElements struct{}
func (*GlDrawElements) Class() binary.Class {
return (*binaryClassGlDrawElements)(nil)
}
func doEncodeGlDrawElements(e binary.Encoder, o *GlDrawElements) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.DrawMode)); err != nil {
return err
}
if err := e.Int32(o.ElementCount); err != nil {
return err
}
if err := e.Uint32(uint32(o.IndicesType)); err != nil {
return err
}
if err := e.Value(&o.Indices); err != nil {
return err
}
return nil
}
func doDecodeGlDrawElements(d binary.Decoder, o *GlDrawElements) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.DrawMode = DrawMode(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.ElementCount = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.IndicesType = IndicesType(obj)
}
if err := d.Value(&o.Indices); err != nil {
return err
}
return nil
}
func doSkipGlDrawElements(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*IndicesPointer)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlDrawElements) ID() binary.ID { return binaryIDGlDrawElements }
func (*binaryClassGlDrawElements) New() binary.Object { return &GlDrawElements{} }
func (*binaryClassGlDrawElements) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlDrawElements(e, obj.(*GlDrawElements))
}
func (*binaryClassGlDrawElements) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlDrawElements{}
return obj, doDecodeGlDrawElements(d, obj)
}
func (*binaryClassGlDrawElements) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlDrawElements(d, obj.(*GlDrawElements))
}
func (*binaryClassGlDrawElements) Skip(d binary.Decoder) error { return doSkipGlDrawElements(d) }
func (*binaryClassGlDrawElements) Schema() *schema.Class { return schemaGlDrawElements }
var schemaGlDrawElements = &schema.Class{
TypeID: binaryIDGlDrawElements,
Name: "GlDrawElements",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "DrawMode", Type: &schema.Primitive{Name: "DrawMode", Method: schema.Uint32}},
schema.Field{Declared: "ElementCount", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "IndicesType", Type: &schema.Primitive{Name: "IndicesType", Method: schema.Uint32}},
schema.Field{Declared: "Indices", Type: &schema.Struct{Name: "IndicesPointer"}},
},
}
type binaryClassGlEGLImageTargetRenderbufferStorageOES struct{}
func (*GlEGLImageTargetRenderbufferStorageOES) Class() binary.Class {
return (*binaryClassGlEGLImageTargetRenderbufferStorageOES)(nil)
}
func doEncodeGlEGLImageTargetRenderbufferStorageOES(e binary.Encoder, o *GlEGLImageTargetRenderbufferStorageOES) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Value(&o.Image); err != nil {
return err
}
return nil
}
func doDecodeGlEGLImageTargetRenderbufferStorageOES(d binary.Decoder, o *GlEGLImageTargetRenderbufferStorageOES) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = ImageTargetRenderbufferStorage(obj)
}
if err := d.Value(&o.Image); err != nil {
return err
}
return nil
}
func doSkipGlEGLImageTargetRenderbufferStorageOES(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*TexturePointer)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) ID() binary.ID {
return binaryIDGlEGLImageTargetRenderbufferStorageOES
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) New() binary.Object {
return &GlEGLImageTargetRenderbufferStorageOES{}
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlEGLImageTargetRenderbufferStorageOES(e, obj.(*GlEGLImageTargetRenderbufferStorageOES))
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlEGLImageTargetRenderbufferStorageOES{}
return obj, doDecodeGlEGLImageTargetRenderbufferStorageOES(d, obj)
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlEGLImageTargetRenderbufferStorageOES(d, obj.(*GlEGLImageTargetRenderbufferStorageOES))
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) Skip(d binary.Decoder) error {
return doSkipGlEGLImageTargetRenderbufferStorageOES(d)
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) Schema() *schema.Class {
return schemaGlEGLImageTargetRenderbufferStorageOES
}
var schemaGlEGLImageTargetRenderbufferStorageOES = &schema.Class{
TypeID: binaryIDGlEGLImageTargetRenderbufferStorageOES,
Name: "GlEGLImageTargetRenderbufferStorageOES",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "ImageTargetRenderbufferStorage", Method: schema.Uint32}},
schema.Field{Declared: "Image", Type: &schema.Struct{Name: "TexturePointer"}},
},
}
type binaryClassImageOES struct{}
func (*ImageOES) Class() binary.Class {
return (*binaryClassImageOES)(nil)
}
func doEncodeImageOES(e binary.Encoder, o *ImageOES) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeImageOES(d binary.Decoder, o *ImageOES) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipImageOES(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassImageOES) ID() binary.ID { return binaryIDImageOES }
func (*binaryClassImageOES) New() binary.Object { return &ImageOES{} }
func (*binaryClassImageOES) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeImageOES(e, obj.(*ImageOES))
}
func (*binaryClassImageOES) Decode(d binary.Decoder) (binary.Object, error) {
obj := &ImageOES{}
return obj, doDecodeImageOES(d, obj)
}
func (*binaryClassImageOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeImageOES(d, obj.(*ImageOES))
}
func (*binaryClassImageOES) Skip(d binary.Decoder) error { return doSkipImageOES(d) }
func (*binaryClassImageOES) Schema() *schema.Class { return schemaImageOES }
var schemaImageOES = &schema.Class{
TypeID: binaryIDImageOES,
Name: "ImageOES",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlEGLImageTargetTexture2DOES struct{}
func (*GlEGLImageTargetTexture2DOES) Class() binary.Class {
return (*binaryClassGlEGLImageTargetTexture2DOES)(nil)
}
func doEncodeGlEGLImageTargetTexture2DOES(e binary.Encoder, o *GlEGLImageTargetTexture2DOES) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Value(&o.Image); err != nil {
return err
}
return nil
}
func doDecodeGlEGLImageTargetTexture2DOES(d binary.Decoder, o *GlEGLImageTargetTexture2DOES) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = ImageTargetTexture(obj)
}
if err := d.Value(&o.Image); err != nil {
return err
}
return nil
}
func doSkipGlEGLImageTargetTexture2DOES(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*ImageOES)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlEGLImageTargetTexture2DOES) ID() binary.ID {
return binaryIDGlEGLImageTargetTexture2DOES
}
func (*binaryClassGlEGLImageTargetTexture2DOES) New() binary.Object {
return &GlEGLImageTargetTexture2DOES{}
}
func (*binaryClassGlEGLImageTargetTexture2DOES) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlEGLImageTargetTexture2DOES(e, obj.(*GlEGLImageTargetTexture2DOES))
}
func (*binaryClassGlEGLImageTargetTexture2DOES) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlEGLImageTargetTexture2DOES{}
return obj, doDecodeGlEGLImageTargetTexture2DOES(d, obj)
}
func (*binaryClassGlEGLImageTargetTexture2DOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlEGLImageTargetTexture2DOES(d, obj.(*GlEGLImageTargetTexture2DOES))
}
func (*binaryClassGlEGLImageTargetTexture2DOES) Skip(d binary.Decoder) error {
return doSkipGlEGLImageTargetTexture2DOES(d)
}
func (*binaryClassGlEGLImageTargetTexture2DOES) Schema() *schema.Class {
return schemaGlEGLImageTargetTexture2DOES
}
var schemaGlEGLImageTargetTexture2DOES = &schema.Class{
TypeID: binaryIDGlEGLImageTargetTexture2DOES,
Name: "GlEGLImageTargetTexture2DOES",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "ImageTargetTexture", Method: schema.Uint32}},
schema.Field{Declared: "Image", Type: &schema.Struct{Name: "ImageOES"}},
},
}
type binaryClassGlEnable struct{}
func (*GlEnable) Class() binary.Class {
return (*binaryClassGlEnable)(nil)
}
func doEncodeGlEnable(e binary.Encoder, o *GlEnable) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Capability)); err != nil {
return err
}
return nil
}
func doDecodeGlEnable(d binary.Decoder, o *GlEnable) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Capability = Capability(obj)
}
return nil
}
func doSkipGlEnable(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlEnable) ID() binary.ID { return binaryIDGlEnable }
func (*binaryClassGlEnable) New() binary.Object { return &GlEnable{} }
func (*binaryClassGlEnable) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlEnable(e, obj.(*GlEnable))
}
func (*binaryClassGlEnable) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlEnable{}
return obj, doDecodeGlEnable(d, obj)
}
func (*binaryClassGlEnable) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlEnable(d, obj.(*GlEnable))
}
func (*binaryClassGlEnable) Skip(d binary.Decoder) error { return doSkipGlEnable(d) }
func (*binaryClassGlEnable) Schema() *schema.Class { return schemaGlEnable }
var schemaGlEnable = &schema.Class{
TypeID: binaryIDGlEnable,
Name: "GlEnable",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Capability", Type: &schema.Primitive{Name: "Capability", Method: schema.Uint32}},
},
}
type binaryClassGlEnableClientState struct{}
func (*GlEnableClientState) Class() binary.Class {
return (*binaryClassGlEnableClientState)(nil)
}
func doEncodeGlEnableClientState(e binary.Encoder, o *GlEnableClientState) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Type)); err != nil {
return err
}
return nil
}
func doDecodeGlEnableClientState(d binary.Decoder, o *GlEnableClientState) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = ArrayType(obj)
}
return nil
}
func doSkipGlEnableClientState(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlEnableClientState) ID() binary.ID { return binaryIDGlEnableClientState }
func (*binaryClassGlEnableClientState) New() binary.Object { return &GlEnableClientState{} }
func (*binaryClassGlEnableClientState) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlEnableClientState(e, obj.(*GlEnableClientState))
}
func (*binaryClassGlEnableClientState) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlEnableClientState{}
return obj, doDecodeGlEnableClientState(d, obj)
}
func (*binaryClassGlEnableClientState) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlEnableClientState(d, obj.(*GlEnableClientState))
}
func (*binaryClassGlEnableClientState) Skip(d binary.Decoder) error {
return doSkipGlEnableClientState(d)
}
func (*binaryClassGlEnableClientState) Schema() *schema.Class { return schemaGlEnableClientState }
var schemaGlEnableClientState = &schema.Class{
TypeID: binaryIDGlEnableClientState,
Name: "GlEnableClientState",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "ArrayType", Method: schema.Uint32}},
},
}
type binaryClassGlEnableVertexAttribArray struct{}
func (*GlEnableVertexAttribArray) Class() binary.Class {
return (*binaryClassGlEnableVertexAttribArray)(nil)
}
func doEncodeGlEnableVertexAttribArray(e binary.Encoder, o *GlEnableVertexAttribArray) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
return nil
}
func doDecodeGlEnableVertexAttribArray(d binary.Decoder, o *GlEnableVertexAttribArray) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
return nil
}
func doSkipGlEnableVertexAttribArray(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlEnableVertexAttribArray) ID() binary.ID { return binaryIDGlEnableVertexAttribArray }
func (*binaryClassGlEnableVertexAttribArray) New() binary.Object { return &GlEnableVertexAttribArray{} }
func (*binaryClassGlEnableVertexAttribArray) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlEnableVertexAttribArray(e, obj.(*GlEnableVertexAttribArray))
}
func (*binaryClassGlEnableVertexAttribArray) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlEnableVertexAttribArray{}
return obj, doDecodeGlEnableVertexAttribArray(d, obj)
}
func (*binaryClassGlEnableVertexAttribArray) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlEnableVertexAttribArray(d, obj.(*GlEnableVertexAttribArray))
}
func (*binaryClassGlEnableVertexAttribArray) Skip(d binary.Decoder) error {
return doSkipGlEnableVertexAttribArray(d)
}
func (*binaryClassGlEnableVertexAttribArray) Schema() *schema.Class {
return schemaGlEnableVertexAttribArray
}
var schemaGlEnableVertexAttribArray = &schema.Class{
TypeID: binaryIDGlEnableVertexAttribArray,
Name: "GlEnableVertexAttribArray",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
},
}
type binaryClassGlEndQuery struct{}
func (*GlEndQuery) Class() binary.Class {
return (*binaryClassGlEndQuery)(nil)
}
func doEncodeGlEndQuery(e binary.Encoder, o *GlEndQuery) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
return nil
}
func doDecodeGlEndQuery(d binary.Decoder, o *GlEndQuery) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = QueryTarget(obj)
}
return nil
}
func doSkipGlEndQuery(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlEndQuery) ID() binary.ID { return binaryIDGlEndQuery }
func (*binaryClassGlEndQuery) New() binary.Object { return &GlEndQuery{} }
func (*binaryClassGlEndQuery) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlEndQuery(e, obj.(*GlEndQuery))
}
func (*binaryClassGlEndQuery) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlEndQuery{}
return obj, doDecodeGlEndQuery(d, obj)
}
func (*binaryClassGlEndQuery) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlEndQuery(d, obj.(*GlEndQuery))
}
func (*binaryClassGlEndQuery) Skip(d binary.Decoder) error { return doSkipGlEndQuery(d) }
func (*binaryClassGlEndQuery) Schema() *schema.Class { return schemaGlEndQuery }
var schemaGlEndQuery = &schema.Class{
TypeID: binaryIDGlEndQuery,
Name: "GlEndQuery",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "QueryTarget", Method: schema.Uint32}},
},
}
type binaryClassGlEndQueryEXT struct{}
func (*GlEndQueryEXT) Class() binary.Class {
return (*binaryClassGlEndQueryEXT)(nil)
}
func doEncodeGlEndQueryEXT(e binary.Encoder, o *GlEndQueryEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
return nil
}
func doDecodeGlEndQueryEXT(d binary.Decoder, o *GlEndQueryEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = QueryTarget(obj)
}
return nil
}
func doSkipGlEndQueryEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlEndQueryEXT) ID() binary.ID { return binaryIDGlEndQueryEXT }
func (*binaryClassGlEndQueryEXT) New() binary.Object { return &GlEndQueryEXT{} }
func (*binaryClassGlEndQueryEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlEndQueryEXT(e, obj.(*GlEndQueryEXT))
}
func (*binaryClassGlEndQueryEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlEndQueryEXT{}
return obj, doDecodeGlEndQueryEXT(d, obj)
}
func (*binaryClassGlEndQueryEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlEndQueryEXT(d, obj.(*GlEndQueryEXT))
}
func (*binaryClassGlEndQueryEXT) Skip(d binary.Decoder) error { return doSkipGlEndQueryEXT(d) }
func (*binaryClassGlEndQueryEXT) Schema() *schema.Class { return schemaGlEndQueryEXT }
var schemaGlEndQueryEXT = &schema.Class{
TypeID: binaryIDGlEndQueryEXT,
Name: "GlEndQueryEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "QueryTarget", Method: schema.Uint32}},
},
}
type binaryClassGlEndTilingQCOM struct{}
func (*GlEndTilingQCOM) Class() binary.Class {
return (*binaryClassGlEndTilingQCOM)(nil)
}
func doEncodeGlEndTilingQCOM(e binary.Encoder, o *GlEndTilingQCOM) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.PreserveMask)); err != nil {
return err
}
return nil
}
func doDecodeGlEndTilingQCOM(d binary.Decoder, o *GlEndTilingQCOM) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.PreserveMask = TilePreserveMaskQCOM(obj)
}
return nil
}
func doSkipGlEndTilingQCOM(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlEndTilingQCOM) ID() binary.ID { return binaryIDGlEndTilingQCOM }
func (*binaryClassGlEndTilingQCOM) New() binary.Object { return &GlEndTilingQCOM{} }
func (*binaryClassGlEndTilingQCOM) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlEndTilingQCOM(e, obj.(*GlEndTilingQCOM))
}
func (*binaryClassGlEndTilingQCOM) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlEndTilingQCOM{}
return obj, doDecodeGlEndTilingQCOM(d, obj)
}
func (*binaryClassGlEndTilingQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlEndTilingQCOM(d, obj.(*GlEndTilingQCOM))
}
func (*binaryClassGlEndTilingQCOM) Skip(d binary.Decoder) error { return doSkipGlEndTilingQCOM(d) }
func (*binaryClassGlEndTilingQCOM) Schema() *schema.Class { return schemaGlEndTilingQCOM }
var schemaGlEndTilingQCOM = &schema.Class{
TypeID: binaryIDGlEndTilingQCOM,
Name: "GlEndTilingQCOM",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "PreserveMask", Type: &schema.Primitive{Name: "TilePreserveMaskQCOM", Method: schema.Uint32}},
},
}
type binaryClassGlFinish struct{}
func (*GlFinish) Class() binary.Class {
return (*binaryClassGlFinish)(nil)
}
func doEncodeGlFinish(e binary.Encoder, o *GlFinish) error {
if err := e.Value(&o.observations); err != nil {
return err
}
return nil
}
func doDecodeGlFinish(d binary.Decoder, o *GlFinish) error {
if err := d.Value(&o.observations); err != nil {
return err
}
return nil
}
func doSkipGlFinish(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlFinish) ID() binary.ID { return binaryIDGlFinish }
func (*binaryClassGlFinish) New() binary.Object { return &GlFinish{} }
func (*binaryClassGlFinish) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlFinish(e, obj.(*GlFinish))
}
func (*binaryClassGlFinish) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlFinish{}
return obj, doDecodeGlFinish(d, obj)
}
func (*binaryClassGlFinish) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlFinish(d, obj.(*GlFinish))
}
func (*binaryClassGlFinish) Skip(d binary.Decoder) error { return doSkipGlFinish(d) }
func (*binaryClassGlFinish) Schema() *schema.Class { return schemaGlFinish }
var schemaGlFinish = &schema.Class{
TypeID: binaryIDGlFinish,
Name: "GlFinish",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
},
}
type binaryClassGlFlush struct{}
func (*GlFlush) Class() binary.Class {
return (*binaryClassGlFlush)(nil)
}
func doEncodeGlFlush(e binary.Encoder, o *GlFlush) error {
if err := e.Value(&o.observations); err != nil {
return err
}
return nil
}
func doDecodeGlFlush(d binary.Decoder, o *GlFlush) error {
if err := d.Value(&o.observations); err != nil {
return err
}
return nil
}
func doSkipGlFlush(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlFlush) ID() binary.ID { return binaryIDGlFlush }
func (*binaryClassGlFlush) New() binary.Object { return &GlFlush{} }
func (*binaryClassGlFlush) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlFlush(e, obj.(*GlFlush))
}
func (*binaryClassGlFlush) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlFlush{}
return obj, doDecodeGlFlush(d, obj)
}
func (*binaryClassGlFlush) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlFlush(d, obj.(*GlFlush))
}
func (*binaryClassGlFlush) Skip(d binary.Decoder) error { return doSkipGlFlush(d) }
func (*binaryClassGlFlush) Schema() *schema.Class { return schemaGlFlush }
var schemaGlFlush = &schema.Class{
TypeID: binaryIDGlFlush,
Name: "GlFlush",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
},
}
type binaryClassGlFramebufferRenderbuffer struct{}
func (*GlFramebufferRenderbuffer) Class() binary.Class {
return (*binaryClassGlFramebufferRenderbuffer)(nil)
}
func doEncodeGlFramebufferRenderbuffer(e binary.Encoder, o *GlFramebufferRenderbuffer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.FramebufferTarget)); err != nil {
return err
}
if err := e.Uint32(uint32(o.FramebufferAttachment)); err != nil {
return err
}
if err := e.Uint32(uint32(o.RenderbufferTarget)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Renderbuffer)); err != nil {
return err
}
return nil
}
func doDecodeGlFramebufferRenderbuffer(d binary.Decoder, o *GlFramebufferRenderbuffer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.FramebufferTarget = FramebufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.FramebufferAttachment = FramebufferAttachment(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.RenderbufferTarget = RenderbufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Renderbuffer = RenderbufferId(obj)
}
return nil
}
func doSkipGlFramebufferRenderbuffer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlFramebufferRenderbuffer) ID() binary.ID { return binaryIDGlFramebufferRenderbuffer }
func (*binaryClassGlFramebufferRenderbuffer) New() binary.Object { return &GlFramebufferRenderbuffer{} }
func (*binaryClassGlFramebufferRenderbuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlFramebufferRenderbuffer(e, obj.(*GlFramebufferRenderbuffer))
}
func (*binaryClassGlFramebufferRenderbuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlFramebufferRenderbuffer{}
return obj, doDecodeGlFramebufferRenderbuffer(d, obj)
}
func (*binaryClassGlFramebufferRenderbuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlFramebufferRenderbuffer(d, obj.(*GlFramebufferRenderbuffer))
}
func (*binaryClassGlFramebufferRenderbuffer) Skip(d binary.Decoder) error {
return doSkipGlFramebufferRenderbuffer(d)
}
func (*binaryClassGlFramebufferRenderbuffer) Schema() *schema.Class {
return schemaGlFramebufferRenderbuffer
}
var schemaGlFramebufferRenderbuffer = &schema.Class{
TypeID: binaryIDGlFramebufferRenderbuffer,
Name: "GlFramebufferRenderbuffer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "FramebufferTarget", Type: &schema.Primitive{Name: "FramebufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "FramebufferAttachment", Type: &schema.Primitive{Name: "FramebufferAttachment", Method: schema.Uint32}},
schema.Field{Declared: "RenderbufferTarget", Type: &schema.Primitive{Name: "RenderbufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Renderbuffer", Type: &schema.Primitive{Name: "RenderbufferId", Method: schema.Uint32}},
},
}
type binaryClassGlFramebufferTexture2D struct{}
func (*GlFramebufferTexture2D) Class() binary.Class {
return (*binaryClassGlFramebufferTexture2D)(nil)
}
func doEncodeGlFramebufferTexture2D(e binary.Encoder, o *GlFramebufferTexture2D) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.FramebufferTarget)); err != nil {
return err
}
if err := e.Uint32(uint32(o.FramebufferAttachment)); err != nil {
return err
}
if err := e.Uint32(uint32(o.TextureTarget)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Texture)); err != nil {
return err
}
if err := e.Int32(o.Level); err != nil {
return err
}
return nil
}
func doDecodeGlFramebufferTexture2D(d binary.Decoder, o *GlFramebufferTexture2D) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.FramebufferTarget = FramebufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.FramebufferAttachment = FramebufferAttachment(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.TextureTarget = TextureImageTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Texture = TextureId(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Level = int32(obj)
}
return nil
}
func doSkipGlFramebufferTexture2D(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlFramebufferTexture2D) ID() binary.ID { return binaryIDGlFramebufferTexture2D }
func (*binaryClassGlFramebufferTexture2D) New() binary.Object { return &GlFramebufferTexture2D{} }
func (*binaryClassGlFramebufferTexture2D) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlFramebufferTexture2D(e, obj.(*GlFramebufferTexture2D))
}
func (*binaryClassGlFramebufferTexture2D) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlFramebufferTexture2D{}
return obj, doDecodeGlFramebufferTexture2D(d, obj)
}
func (*binaryClassGlFramebufferTexture2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlFramebufferTexture2D(d, obj.(*GlFramebufferTexture2D))
}
func (*binaryClassGlFramebufferTexture2D) Skip(d binary.Decoder) error {
return doSkipGlFramebufferTexture2D(d)
}
func (*binaryClassGlFramebufferTexture2D) Schema() *schema.Class { return schemaGlFramebufferTexture2D }
var schemaGlFramebufferTexture2D = &schema.Class{
TypeID: binaryIDGlFramebufferTexture2D,
Name: "GlFramebufferTexture2D",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "FramebufferTarget", Type: &schema.Primitive{Name: "FramebufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "FramebufferAttachment", Type: &schema.Primitive{Name: "FramebufferAttachment", Method: schema.Uint32}},
schema.Field{Declared: "TextureTarget", Type: &schema.Primitive{Name: "TextureImageTarget", Method: schema.Uint32}},
schema.Field{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
schema.Field{Declared: "Level", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlFrontFace struct{}
func (*GlFrontFace) Class() binary.Class {
return (*binaryClassGlFrontFace)(nil)
}
func doEncodeGlFrontFace(e binary.Encoder, o *GlFrontFace) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Orientation)); err != nil {
return err
}
return nil
}
func doDecodeGlFrontFace(d binary.Decoder, o *GlFrontFace) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Orientation = FaceOrientation(obj)
}
return nil
}
func doSkipGlFrontFace(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlFrontFace) ID() binary.ID { return binaryIDGlFrontFace }
func (*binaryClassGlFrontFace) New() binary.Object { return &GlFrontFace{} }
func (*binaryClassGlFrontFace) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlFrontFace(e, obj.(*GlFrontFace))
}
func (*binaryClassGlFrontFace) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlFrontFace{}
return obj, doDecodeGlFrontFace(d, obj)
}
func (*binaryClassGlFrontFace) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlFrontFace(d, obj.(*GlFrontFace))
}
func (*binaryClassGlFrontFace) Skip(d binary.Decoder) error { return doSkipGlFrontFace(d) }
func (*binaryClassGlFrontFace) Schema() *schema.Class { return schemaGlFrontFace }
var schemaGlFrontFace = &schema.Class{
TypeID: binaryIDGlFrontFace,
Name: "GlFrontFace",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Orientation", Type: &schema.Primitive{Name: "FaceOrientation", Method: schema.Uint32}},
},
}
type binaryClassGlGenBuffers struct{}
func (*GlGenBuffers) Class() binary.Class {
return (*binaryClassGlGenBuffers)(nil)
}
func doEncodeGlGenBuffers(e binary.Encoder, o *GlGenBuffers) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Buffers); err != nil {
return err
}
return nil
}
func doDecodeGlGenBuffers(d binary.Decoder, o *GlGenBuffers) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Buffers); err != nil {
return err
}
return nil
}
func doSkipGlGenBuffers(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*BufferIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGenBuffers) ID() binary.ID { return binaryIDGlGenBuffers }
func (*binaryClassGlGenBuffers) New() binary.Object { return &GlGenBuffers{} }
func (*binaryClassGlGenBuffers) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGenBuffers(e, obj.(*GlGenBuffers))
}
func (*binaryClassGlGenBuffers) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGenBuffers{}
return obj, doDecodeGlGenBuffers(d, obj)
}
func (*binaryClassGlGenBuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGenBuffers(d, obj.(*GlGenBuffers))
}
func (*binaryClassGlGenBuffers) Skip(d binary.Decoder) error { return doSkipGlGenBuffers(d) }
func (*binaryClassGlGenBuffers) Schema() *schema.Class { return schemaGlGenBuffers }
var schemaGlGenBuffers = &schema.Class{
TypeID: binaryIDGlGenBuffers,
Name: "GlGenBuffers",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Buffers", Type: &schema.Struct{Name: "BufferIdᵖ"}},
},
}
type binaryClassGlGenFramebuffers struct{}
func (*GlGenFramebuffers) Class() binary.Class {
return (*binaryClassGlGenFramebuffers)(nil)
}
func doEncodeGlGenFramebuffers(e binary.Encoder, o *GlGenFramebuffers) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Framebuffers); err != nil {
return err
}
return nil
}
func doDecodeGlGenFramebuffers(d binary.Decoder, o *GlGenFramebuffers) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Framebuffers); err != nil {
return err
}
return nil
}
func doSkipGlGenFramebuffers(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*FramebufferIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGenFramebuffers) ID() binary.ID { return binaryIDGlGenFramebuffers }
func (*binaryClassGlGenFramebuffers) New() binary.Object { return &GlGenFramebuffers{} }
func (*binaryClassGlGenFramebuffers) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGenFramebuffers(e, obj.(*GlGenFramebuffers))
}
func (*binaryClassGlGenFramebuffers) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGenFramebuffers{}
return obj, doDecodeGlGenFramebuffers(d, obj)
}
func (*binaryClassGlGenFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGenFramebuffers(d, obj.(*GlGenFramebuffers))
}
func (*binaryClassGlGenFramebuffers) Skip(d binary.Decoder) error { return doSkipGlGenFramebuffers(d) }
func (*binaryClassGlGenFramebuffers) Schema() *schema.Class { return schemaGlGenFramebuffers }
var schemaGlGenFramebuffers = &schema.Class{
TypeID: binaryIDGlGenFramebuffers,
Name: "GlGenFramebuffers",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Framebuffers", Type: &schema.Struct{Name: "FramebufferIdᵖ"}},
},
}
type binaryClassGlGenQueries struct{}
func (*GlGenQueries) Class() binary.Class {
return (*binaryClassGlGenQueries)(nil)
}
func doEncodeGlGenQueries(e binary.Encoder, o *GlGenQueries) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Queries); err != nil {
return err
}
return nil
}
func doDecodeGlGenQueries(d binary.Decoder, o *GlGenQueries) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Queries); err != nil {
return err
}
return nil
}
func doSkipGlGenQueries(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*QueryIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGenQueries) ID() binary.ID { return binaryIDGlGenQueries }
func (*binaryClassGlGenQueries) New() binary.Object { return &GlGenQueries{} }
func (*binaryClassGlGenQueries) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGenQueries(e, obj.(*GlGenQueries))
}
func (*binaryClassGlGenQueries) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGenQueries{}
return obj, doDecodeGlGenQueries(d, obj)
}
func (*binaryClassGlGenQueries) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGenQueries(d, obj.(*GlGenQueries))
}
func (*binaryClassGlGenQueries) Skip(d binary.Decoder) error { return doSkipGlGenQueries(d) }
func (*binaryClassGlGenQueries) Schema() *schema.Class { return schemaGlGenQueries }
var schemaGlGenQueries = &schema.Class{
TypeID: binaryIDGlGenQueries,
Name: "GlGenQueries",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Queries", Type: &schema.Struct{Name: "QueryIdᵖ"}},
},
}
type binaryClassGlGenQueriesEXT struct{}
func (*GlGenQueriesEXT) Class() binary.Class {
return (*binaryClassGlGenQueriesEXT)(nil)
}
func doEncodeGlGenQueriesEXT(e binary.Encoder, o *GlGenQueriesEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Queries); err != nil {
return err
}
return nil
}
func doDecodeGlGenQueriesEXT(d binary.Decoder, o *GlGenQueriesEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Queries); err != nil {
return err
}
return nil
}
func doSkipGlGenQueriesEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*QueryIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGenQueriesEXT) ID() binary.ID { return binaryIDGlGenQueriesEXT }
func (*binaryClassGlGenQueriesEXT) New() binary.Object { return &GlGenQueriesEXT{} }
func (*binaryClassGlGenQueriesEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGenQueriesEXT(e, obj.(*GlGenQueriesEXT))
}
func (*binaryClassGlGenQueriesEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGenQueriesEXT{}
return obj, doDecodeGlGenQueriesEXT(d, obj)
}
func (*binaryClassGlGenQueriesEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGenQueriesEXT(d, obj.(*GlGenQueriesEXT))
}
func (*binaryClassGlGenQueriesEXT) Skip(d binary.Decoder) error { return doSkipGlGenQueriesEXT(d) }
func (*binaryClassGlGenQueriesEXT) Schema() *schema.Class { return schemaGlGenQueriesEXT }
var schemaGlGenQueriesEXT = &schema.Class{
TypeID: binaryIDGlGenQueriesEXT,
Name: "GlGenQueriesEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Queries", Type: &schema.Struct{Name: "QueryIdᵖ"}},
},
}
type binaryClassGlGenRenderbuffers struct{}
func (*GlGenRenderbuffers) Class() binary.Class {
return (*binaryClassGlGenRenderbuffers)(nil)
}
func doEncodeGlGenRenderbuffers(e binary.Encoder, o *GlGenRenderbuffers) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Renderbuffers); err != nil {
return err
}
return nil
}
func doDecodeGlGenRenderbuffers(d binary.Decoder, o *GlGenRenderbuffers) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Renderbuffers); err != nil {
return err
}
return nil
}
func doSkipGlGenRenderbuffers(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*RenderbufferIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGenRenderbuffers) ID() binary.ID { return binaryIDGlGenRenderbuffers }
func (*binaryClassGlGenRenderbuffers) New() binary.Object { return &GlGenRenderbuffers{} }
func (*binaryClassGlGenRenderbuffers) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGenRenderbuffers(e, obj.(*GlGenRenderbuffers))
}
func (*binaryClassGlGenRenderbuffers) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGenRenderbuffers{}
return obj, doDecodeGlGenRenderbuffers(d, obj)
}
func (*binaryClassGlGenRenderbuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGenRenderbuffers(d, obj.(*GlGenRenderbuffers))
}
func (*binaryClassGlGenRenderbuffers) Skip(d binary.Decoder) error { return doSkipGlGenRenderbuffers(d) }
func (*binaryClassGlGenRenderbuffers) Schema() *schema.Class { return schemaGlGenRenderbuffers }
var schemaGlGenRenderbuffers = &schema.Class{
TypeID: binaryIDGlGenRenderbuffers,
Name: "GlGenRenderbuffers",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Renderbuffers", Type: &schema.Struct{Name: "RenderbufferIdᵖ"}},
},
}
type binaryClassGlGenTextures struct{}
func (*GlGenTextures) Class() binary.Class {
return (*binaryClassGlGenTextures)(nil)
}
func doEncodeGlGenTextures(e binary.Encoder, o *GlGenTextures) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Textures); err != nil {
return err
}
return nil
}
func doDecodeGlGenTextures(d binary.Decoder, o *GlGenTextures) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Textures); err != nil {
return err
}
return nil
}
func doSkipGlGenTextures(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*TextureIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGenTextures) ID() binary.ID { return binaryIDGlGenTextures }
func (*binaryClassGlGenTextures) New() binary.Object { return &GlGenTextures{} }
func (*binaryClassGlGenTextures) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGenTextures(e, obj.(*GlGenTextures))
}
func (*binaryClassGlGenTextures) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGenTextures{}
return obj, doDecodeGlGenTextures(d, obj)
}
func (*binaryClassGlGenTextures) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGenTextures(d, obj.(*GlGenTextures))
}
func (*binaryClassGlGenTextures) Skip(d binary.Decoder) error { return doSkipGlGenTextures(d) }
func (*binaryClassGlGenTextures) Schema() *schema.Class { return schemaGlGenTextures }
var schemaGlGenTextures = &schema.Class{
TypeID: binaryIDGlGenTextures,
Name: "GlGenTextures",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Textures", Type: &schema.Struct{Name: "TextureIdᵖ"}},
},
}
type binaryClassGlGenVertexArraysOES struct{}
func (*GlGenVertexArraysOES) Class() binary.Class {
return (*binaryClassGlGenVertexArraysOES)(nil)
}
func doEncodeGlGenVertexArraysOES(e binary.Encoder, o *GlGenVertexArraysOES) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Arrays); err != nil {
return err
}
return nil
}
func doDecodeGlGenVertexArraysOES(d binary.Decoder, o *GlGenVertexArraysOES) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Arrays); err != nil {
return err
}
return nil
}
func doSkipGlGenVertexArraysOES(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*VertexArrayIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGenVertexArraysOES) ID() binary.ID { return binaryIDGlGenVertexArraysOES }
func (*binaryClassGlGenVertexArraysOES) New() binary.Object { return &GlGenVertexArraysOES{} }
func (*binaryClassGlGenVertexArraysOES) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGenVertexArraysOES(e, obj.(*GlGenVertexArraysOES))
}
func (*binaryClassGlGenVertexArraysOES) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGenVertexArraysOES{}
return obj, doDecodeGlGenVertexArraysOES(d, obj)
}
func (*binaryClassGlGenVertexArraysOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGenVertexArraysOES(d, obj.(*GlGenVertexArraysOES))
}
func (*binaryClassGlGenVertexArraysOES) Skip(d binary.Decoder) error {
return doSkipGlGenVertexArraysOES(d)
}
func (*binaryClassGlGenVertexArraysOES) Schema() *schema.Class { return schemaGlGenVertexArraysOES }
var schemaGlGenVertexArraysOES = &schema.Class{
TypeID: binaryIDGlGenVertexArraysOES,
Name: "GlGenVertexArraysOES",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Arrays", Type: &schema.Struct{Name: "VertexArrayIdᵖ"}},
},
}
type binaryClassGlGenerateMipmap struct{}
func (*GlGenerateMipmap) Class() binary.Class {
return (*binaryClassGlGenerateMipmap)(nil)
}
func doEncodeGlGenerateMipmap(e binary.Encoder, o *GlGenerateMipmap) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
return nil
}
func doDecodeGlGenerateMipmap(d binary.Decoder, o *GlGenerateMipmap) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureImageTarget(obj)
}
return nil
}
func doSkipGlGenerateMipmap(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlGenerateMipmap) ID() binary.ID { return binaryIDGlGenerateMipmap }
func (*binaryClassGlGenerateMipmap) New() binary.Object { return &GlGenerateMipmap{} }
func (*binaryClassGlGenerateMipmap) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGenerateMipmap(e, obj.(*GlGenerateMipmap))
}
func (*binaryClassGlGenerateMipmap) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGenerateMipmap{}
return obj, doDecodeGlGenerateMipmap(d, obj)
}
func (*binaryClassGlGenerateMipmap) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGenerateMipmap(d, obj.(*GlGenerateMipmap))
}
func (*binaryClassGlGenerateMipmap) Skip(d binary.Decoder) error { return doSkipGlGenerateMipmap(d) }
func (*binaryClassGlGenerateMipmap) Schema() *schema.Class { return schemaGlGenerateMipmap }
var schemaGlGenerateMipmap = &schema.Class{
TypeID: binaryIDGlGenerateMipmap,
Name: "GlGenerateMipmap",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureImageTarget", Method: schema.Uint32}},
},
}
type binaryClassS32ᵖ struct{}
func (*S32ᵖ) Class() binary.Class {
return (*binaryClassS32ᵖ)(nil)
}
func doEncodeS32ᵖ(e binary.Encoder, o *S32ᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeS32ᵖ(d binary.Decoder, o *S32ᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipS32ᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassS32ᵖ) ID() binary.ID { return binaryIDS32ᵖ }
func (*binaryClassS32ᵖ) New() binary.Object { return &S32ᵖ{} }
func (*binaryClassS32ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeS32ᵖ(e, obj.(*S32ᵖ))
}
func (*binaryClassS32ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &S32ᵖ{}
return obj, doDecodeS32ᵖ(d, obj)
}
func (*binaryClassS32ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeS32ᵖ(d, obj.(*S32ᵖ))
}
func (*binaryClassS32ᵖ) Skip(d binary.Decoder) error { return doSkipS32ᵖ(d) }
func (*binaryClassS32ᵖ) Schema() *schema.Class { return schemaS32ᵖ }
var schemaS32ᵖ = &schema.Class{
TypeID: binaryIDS32ᵖ,
Name: "S32ᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassShaderAttribTypeᵖ struct{}
func (*ShaderAttribTypeᵖ) Class() binary.Class {
return (*binaryClassShaderAttribTypeᵖ)(nil)
}
func doEncodeShaderAttribTypeᵖ(e binary.Encoder, o *ShaderAttribTypeᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeShaderAttribTypeᵖ(d binary.Decoder, o *ShaderAttribTypeᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipShaderAttribTypeᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassShaderAttribTypeᵖ) ID() binary.ID { return binaryIDShaderAttribTypeᵖ }
func (*binaryClassShaderAttribTypeᵖ) New() binary.Object { return &ShaderAttribTypeᵖ{} }
func (*binaryClassShaderAttribTypeᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeShaderAttribTypeᵖ(e, obj.(*ShaderAttribTypeᵖ))
}
func (*binaryClassShaderAttribTypeᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &ShaderAttribTypeᵖ{}
return obj, doDecodeShaderAttribTypeᵖ(d, obj)
}
func (*binaryClassShaderAttribTypeᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeShaderAttribTypeᵖ(d, obj.(*ShaderAttribTypeᵖ))
}
func (*binaryClassShaderAttribTypeᵖ) Skip(d binary.Decoder) error {
return doSkipShaderAttribTypeᵖ(d)
}
func (*binaryClassShaderAttribTypeᵖ) Schema() *schema.Class { return schemaShaderAttribTypeᵖ }
var schemaShaderAttribTypeᵖ = &schema.Class{
TypeID: binaryIDShaderAttribTypeᵖ,
Name: "ShaderAttribTypeᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlGetActiveAttrib struct{}
func (*GlGetActiveAttrib) Class() binary.Class {
return (*binaryClassGlGetActiveAttrib)(nil)
}
func doEncodeGlGetActiveAttrib(e binary.Encoder, o *GlGetActiveAttrib) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.BufferSize); err != nil {
return err
}
if err := e.Value(&o.BufferBytesWritten); err != nil {
return err
}
if err := e.Value(&o.VectorCount); err != nil {
return err
}
if err := e.Value(&o.Type); err != nil {
return err
}
if err := e.Value(&o.Name); err != nil {
return err
}
return nil
}
func doDecodeGlGetActiveAttrib(d binary.Decoder, o *GlGetActiveAttrib) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.BufferSize = int32(obj)
}
if err := d.Value(&o.BufferBytesWritten); err != nil {
return err
}
if err := d.Value(&o.VectorCount); err != nil {
return err
}
if err := d.Value(&o.Type); err != nil {
return err
}
if err := d.Value(&o.Name); err != nil {
return err
}
return nil
}
func doSkipGlGetActiveAttrib(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*ShaderAttribTypeᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Charᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetActiveAttrib) ID() binary.ID { return binaryIDGlGetActiveAttrib }
func (*binaryClassGlGetActiveAttrib) New() binary.Object { return &GlGetActiveAttrib{} }
func (*binaryClassGlGetActiveAttrib) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetActiveAttrib(e, obj.(*GlGetActiveAttrib))
}
func (*binaryClassGlGetActiveAttrib) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetActiveAttrib{}
return obj, doDecodeGlGetActiveAttrib(d, obj)
}
func (*binaryClassGlGetActiveAttrib) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetActiveAttrib(d, obj.(*GlGetActiveAttrib))
}
func (*binaryClassGlGetActiveAttrib) Skip(d binary.Decoder) error { return doSkipGlGetActiveAttrib(d) }
func (*binaryClassGlGetActiveAttrib) Schema() *schema.Class { return schemaGlGetActiveAttrib }
var schemaGlGetActiveAttrib = &schema.Class{
TypeID: binaryIDGlGetActiveAttrib,
Name: "GlGetActiveAttrib",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
schema.Field{Declared: "BufferSize", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "BufferBytesWritten", Type: &schema.Struct{Name: "S32ᵖ"}},
schema.Field{Declared: "VectorCount", Type: &schema.Struct{Name: "S32ᵖ"}},
schema.Field{Declared: "Type", Type: &schema.Struct{Name: "ShaderAttribTypeᵖ"}},
schema.Field{Declared: "Name", Type: &schema.Struct{Name: "Charᵖ"}},
},
}
type binaryClassShaderUniformTypeᵖ struct{}
func (*ShaderUniformTypeᵖ) Class() binary.Class {
return (*binaryClassShaderUniformTypeᵖ)(nil)
}
func doEncodeShaderUniformTypeᵖ(e binary.Encoder, o *ShaderUniformTypeᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeShaderUniformTypeᵖ(d binary.Decoder, o *ShaderUniformTypeᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipShaderUniformTypeᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassShaderUniformTypeᵖ) ID() binary.ID { return binaryIDShaderUniformTypeᵖ }
func (*binaryClassShaderUniformTypeᵖ) New() binary.Object { return &ShaderUniformTypeᵖ{} }
func (*binaryClassShaderUniformTypeᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeShaderUniformTypeᵖ(e, obj.(*ShaderUniformTypeᵖ))
}
func (*binaryClassShaderUniformTypeᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &ShaderUniformTypeᵖ{}
return obj, doDecodeShaderUniformTypeᵖ(d, obj)
}
func (*binaryClassShaderUniformTypeᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeShaderUniformTypeᵖ(d, obj.(*ShaderUniformTypeᵖ))
}
func (*binaryClassShaderUniformTypeᵖ) Skip(d binary.Decoder) error {
return doSkipShaderUniformTypeᵖ(d)
}
func (*binaryClassShaderUniformTypeᵖ) Schema() *schema.Class { return schemaShaderUniformTypeᵖ }
var schemaShaderUniformTypeᵖ = &schema.Class{
TypeID: binaryIDShaderUniformTypeᵖ,
Name: "ShaderUniformTypeᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlGetActiveUniform struct{}
func (*GlGetActiveUniform) Class() binary.Class {
return (*binaryClassGlGetActiveUniform)(nil)
}
func doEncodeGlGetActiveUniform(e binary.Encoder, o *GlGetActiveUniform) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Int32(o.Location); err != nil {
return err
}
if err := e.Int32(o.BufferSize); err != nil {
return err
}
if err := e.Value(&o.BufferBytesWritten); err != nil {
return err
}
if err := e.Value(&o.Size); err != nil {
return err
}
if err := e.Value(&o.Type); err != nil {
return err
}
if err := e.Value(&o.Name); err != nil {
return err
}
return nil
}
func doDecodeGlGetActiveUniform(d binary.Decoder, o *GlGetActiveUniform) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.BufferSize = int32(obj)
}
if err := d.Value(&o.BufferBytesWritten); err != nil {
return err
}
if err := d.Value(&o.Size); err != nil {
return err
}
if err := d.Value(&o.Type); err != nil {
return err
}
if err := d.Value(&o.Name); err != nil {
return err
}
return nil
}
func doSkipGlGetActiveUniform(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*ShaderUniformTypeᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Charᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetActiveUniform) ID() binary.ID { return binaryIDGlGetActiveUniform }
func (*binaryClassGlGetActiveUniform) New() binary.Object { return &GlGetActiveUniform{} }
func (*binaryClassGlGetActiveUniform) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetActiveUniform(e, obj.(*GlGetActiveUniform))
}
func (*binaryClassGlGetActiveUniform) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetActiveUniform{}
return obj, doDecodeGlGetActiveUniform(d, obj)
}
func (*binaryClassGlGetActiveUniform) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetActiveUniform(d, obj.(*GlGetActiveUniform))
}
func (*binaryClassGlGetActiveUniform) Skip(d binary.Decoder) error { return doSkipGlGetActiveUniform(d) }
func (*binaryClassGlGetActiveUniform) Schema() *schema.Class { return schemaGlGetActiveUniform }
var schemaGlGetActiveUniform = &schema.Class{
TypeID: binaryIDGlGetActiveUniform,
Name: "GlGetActiveUniform",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "BufferSize", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "BufferBytesWritten", Type: &schema.Struct{Name: "S32ᵖ"}},
schema.Field{Declared: "Size", Type: &schema.Struct{Name: "S32ᵖ"}},
schema.Field{Declared: "Type", Type: &schema.Struct{Name: "ShaderUniformTypeᵖ"}},
schema.Field{Declared: "Name", Type: &schema.Struct{Name: "Charᵖ"}},
},
}
type binaryClassShaderIdᵖ struct{}
func (*ShaderIdᵖ) Class() binary.Class {
return (*binaryClassShaderIdᵖ)(nil)
}
func doEncodeShaderIdᵖ(e binary.Encoder, o *ShaderIdᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeShaderIdᵖ(d binary.Decoder, o *ShaderIdᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipShaderIdᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassShaderIdᵖ) ID() binary.ID { return binaryIDShaderIdᵖ }
func (*binaryClassShaderIdᵖ) New() binary.Object { return &ShaderIdᵖ{} }
func (*binaryClassShaderIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeShaderIdᵖ(e, obj.(*ShaderIdᵖ))
}
func (*binaryClassShaderIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &ShaderIdᵖ{}
return obj, doDecodeShaderIdᵖ(d, obj)
}
func (*binaryClassShaderIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeShaderIdᵖ(d, obj.(*ShaderIdᵖ))
}
func (*binaryClassShaderIdᵖ) Skip(d binary.Decoder) error { return doSkipShaderIdᵖ(d) }
func (*binaryClassShaderIdᵖ) Schema() *schema.Class { return schemaShaderIdᵖ }
var schemaShaderIdᵖ = &schema.Class{
TypeID: binaryIDShaderIdᵖ,
Name: "ShaderIdᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlGetAttachedShaders struct{}
func (*GlGetAttachedShaders) Class() binary.Class {
return (*binaryClassGlGetAttachedShaders)(nil)
}
func doEncodeGlGetAttachedShaders(e binary.Encoder, o *GlGetAttachedShaders) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Int32(o.BufferLength); err != nil {
return err
}
if err := e.Value(&o.ShadersLengthWritten); err != nil {
return err
}
if err := e.Value(&o.Shaders); err != nil {
return err
}
return nil
}
func doDecodeGlGetAttachedShaders(d binary.Decoder, o *GlGetAttachedShaders) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.BufferLength = int32(obj)
}
if err := d.Value(&o.ShadersLengthWritten); err != nil {
return err
}
if err := d.Value(&o.Shaders); err != nil {
return err
}
return nil
}
func doSkipGlGetAttachedShaders(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*ShaderIdᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetAttachedShaders) ID() binary.ID { return binaryIDGlGetAttachedShaders }
func (*binaryClassGlGetAttachedShaders) New() binary.Object { return &GlGetAttachedShaders{} }
func (*binaryClassGlGetAttachedShaders) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetAttachedShaders(e, obj.(*GlGetAttachedShaders))
}
func (*binaryClassGlGetAttachedShaders) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetAttachedShaders{}
return obj, doDecodeGlGetAttachedShaders(d, obj)
}
func (*binaryClassGlGetAttachedShaders) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetAttachedShaders(d, obj.(*GlGetAttachedShaders))
}
func (*binaryClassGlGetAttachedShaders) Skip(d binary.Decoder) error {
return doSkipGlGetAttachedShaders(d)
}
func (*binaryClassGlGetAttachedShaders) Schema() *schema.Class { return schemaGlGetAttachedShaders }
var schemaGlGetAttachedShaders = &schema.Class{
TypeID: binaryIDGlGetAttachedShaders,
Name: "GlGetAttachedShaders",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "BufferLength", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "ShadersLengthWritten", Type: &schema.Struct{Name: "S32ᵖ"}},
schema.Field{Declared: "Shaders", Type: &schema.Struct{Name: "ShaderIdᵖ"}},
},
}
type binaryClassGlGetAttribLocation struct{}
func (*GlGetAttribLocation) Class() binary.Class {
return (*binaryClassGlGetAttribLocation)(nil)
}
func doEncodeGlGetAttribLocation(e binary.Encoder, o *GlGetAttribLocation) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.String(o.Name); err != nil {
return err
}
if err := e.Uint32(uint32(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeGlGetAttribLocation(d binary.Decoder, o *GlGetAttribLocation) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.String(); err != nil {
return err
} else {
o.Name = string(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Result = AttributeLocation(obj)
}
return nil
}
func doSkipGlGetAttribLocation(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipString(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetAttribLocation) ID() binary.ID { return binaryIDGlGetAttribLocation }
func (*binaryClassGlGetAttribLocation) New() binary.Object { return &GlGetAttribLocation{} }
func (*binaryClassGlGetAttribLocation) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetAttribLocation(e, obj.(*GlGetAttribLocation))
}
func (*binaryClassGlGetAttribLocation) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetAttribLocation{}
return obj, doDecodeGlGetAttribLocation(d, obj)
}
func (*binaryClassGlGetAttribLocation) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetAttribLocation(d, obj.(*GlGetAttribLocation))
}
func (*binaryClassGlGetAttribLocation) Skip(d binary.Decoder) error {
return doSkipGlGetAttribLocation(d)
}
func (*binaryClassGlGetAttribLocation) Schema() *schema.Class { return schemaGlGetAttribLocation }
var schemaGlGetAttribLocation = &schema.Class{
TypeID: binaryIDGlGetAttribLocation,
Name: "GlGetAttribLocation",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
},
}
type binaryClassGlGetBooleanv struct{}
func (*GlGetBooleanv) Class() binary.Class {
return (*binaryClassGlGetBooleanv)(nil)
}
func doEncodeGlGetBooleanv(e binary.Encoder, o *GlGetBooleanv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Param)); err != nil {
return err
}
if err := e.Value(&o.Values); err != nil {
return err
}
return nil
}
func doDecodeGlGetBooleanv(d binary.Decoder, o *GlGetBooleanv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Param = StateVariable(obj)
}
if err := d.Value(&o.Values); err != nil {
return err
}
return nil
}
func doSkipGlGetBooleanv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*Boolᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetBooleanv) ID() binary.ID { return binaryIDGlGetBooleanv }
func (*binaryClassGlGetBooleanv) New() binary.Object { return &GlGetBooleanv{} }
func (*binaryClassGlGetBooleanv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetBooleanv(e, obj.(*GlGetBooleanv))
}
func (*binaryClassGlGetBooleanv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetBooleanv{}
return obj, doDecodeGlGetBooleanv(d, obj)
}
func (*binaryClassGlGetBooleanv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetBooleanv(d, obj.(*GlGetBooleanv))
}
func (*binaryClassGlGetBooleanv) Skip(d binary.Decoder) error { return doSkipGlGetBooleanv(d) }
func (*binaryClassGlGetBooleanv) Schema() *schema.Class { return schemaGlGetBooleanv }
var schemaGlGetBooleanv = &schema.Class{
TypeID: binaryIDGlGetBooleanv,
Name: "GlGetBooleanv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Param", Type: &schema.Primitive{Name: "StateVariable", Method: schema.Uint32}},
schema.Field{Declared: "Values", Type: &schema.Struct{Name: "Boolᵖ"}},
},
}
type binaryClassGlGetBufferParameteriv struct{}
func (*GlGetBufferParameteriv) Class() binary.Class {
return (*binaryClassGlGetBufferParameteriv)(nil)
}
func doEncodeGlGetBufferParameteriv(e binary.Encoder, o *GlGetBufferParameteriv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlGetBufferParameteriv(d binary.Decoder, o *GlGetBufferParameteriv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = BufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = BufferParameter(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlGetBufferParameteriv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetBufferParameteriv) ID() binary.ID { return binaryIDGlGetBufferParameteriv }
func (*binaryClassGlGetBufferParameteriv) New() binary.Object { return &GlGetBufferParameteriv{} }
func (*binaryClassGlGetBufferParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetBufferParameteriv(e, obj.(*GlGetBufferParameteriv))
}
func (*binaryClassGlGetBufferParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetBufferParameteriv{}
return obj, doDecodeGlGetBufferParameteriv(d, obj)
}
func (*binaryClassGlGetBufferParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetBufferParameteriv(d, obj.(*GlGetBufferParameteriv))
}
func (*binaryClassGlGetBufferParameteriv) Skip(d binary.Decoder) error {
return doSkipGlGetBufferParameteriv(d)
}
func (*binaryClassGlGetBufferParameteriv) Schema() *schema.Class { return schemaGlGetBufferParameteriv }
var schemaGlGetBufferParameteriv = &schema.Class{
TypeID: binaryIDGlGetBufferParameteriv,
Name: "GlGetBufferParameteriv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "BufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "BufferParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlGetError struct{}
func (*GlGetError) Class() binary.Class {
return (*binaryClassGlGetError)(nil)
}
func doEncodeGlGetError(e binary.Encoder, o *GlGetError) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeGlGetError(d binary.Decoder, o *GlGetError) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Result = Error(obj)
}
return nil
}
func doSkipGlGetError(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetError) ID() binary.ID { return binaryIDGlGetError }
func (*binaryClassGlGetError) New() binary.Object { return &GlGetError{} }
func (*binaryClassGlGetError) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetError(e, obj.(*GlGetError))
}
func (*binaryClassGlGetError) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetError{}
return obj, doDecodeGlGetError(d, obj)
}
func (*binaryClassGlGetError) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetError(d, obj.(*GlGetError))
}
func (*binaryClassGlGetError) Skip(d binary.Decoder) error { return doSkipGlGetError(d) }
func (*binaryClassGlGetError) Schema() *schema.Class { return schemaGlGetError }
var schemaGlGetError = &schema.Class{
TypeID: binaryIDGlGetError,
Name: "GlGetError",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "Error", Method: schema.Uint32}},
},
}
type binaryClassGlGetFloatv struct{}
func (*GlGetFloatv) Class() binary.Class {
return (*binaryClassGlGetFloatv)(nil)
}
func doEncodeGlGetFloatv(e binary.Encoder, o *GlGetFloatv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Param)); err != nil {
return err
}
if err := e.Value(&o.Values); err != nil {
return err
}
return nil
}
func doDecodeGlGetFloatv(d binary.Decoder, o *GlGetFloatv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Param = StateVariable(obj)
}
if err := d.Value(&o.Values); err != nil {
return err
}
return nil
}
func doSkipGlGetFloatv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetFloatv) ID() binary.ID { return binaryIDGlGetFloatv }
func (*binaryClassGlGetFloatv) New() binary.Object { return &GlGetFloatv{} }
func (*binaryClassGlGetFloatv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetFloatv(e, obj.(*GlGetFloatv))
}
func (*binaryClassGlGetFloatv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetFloatv{}
return obj, doDecodeGlGetFloatv(d, obj)
}
func (*binaryClassGlGetFloatv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetFloatv(d, obj.(*GlGetFloatv))
}
func (*binaryClassGlGetFloatv) Skip(d binary.Decoder) error { return doSkipGlGetFloatv(d) }
func (*binaryClassGlGetFloatv) Schema() *schema.Class { return schemaGlGetFloatv }
var schemaGlGetFloatv = &schema.Class{
TypeID: binaryIDGlGetFloatv,
Name: "GlGetFloatv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Param", Type: &schema.Primitive{Name: "StateVariable", Method: schema.Uint32}},
schema.Field{Declared: "Values", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlGetFramebufferAttachmentParameteriv struct{}
func (*GlGetFramebufferAttachmentParameteriv) Class() binary.Class {
return (*binaryClassGlGetFramebufferAttachmentParameteriv)(nil)
}
func doEncodeGlGetFramebufferAttachmentParameteriv(e binary.Encoder, o *GlGetFramebufferAttachmentParameteriv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.FramebufferTarget)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Attachment)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlGetFramebufferAttachmentParameteriv(d binary.Decoder, o *GlGetFramebufferAttachmentParameteriv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.FramebufferTarget = FramebufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Attachment = FramebufferAttachment(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = FramebufferAttachmentParameter(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlGetFramebufferAttachmentParameteriv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) ID() binary.ID {
return binaryIDGlGetFramebufferAttachmentParameteriv
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) New() binary.Object {
return &GlGetFramebufferAttachmentParameteriv{}
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetFramebufferAttachmentParameteriv(e, obj.(*GlGetFramebufferAttachmentParameteriv))
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetFramebufferAttachmentParameteriv{}
return obj, doDecodeGlGetFramebufferAttachmentParameteriv(d, obj)
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetFramebufferAttachmentParameteriv(d, obj.(*GlGetFramebufferAttachmentParameteriv))
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) Skip(d binary.Decoder) error {
return doSkipGlGetFramebufferAttachmentParameteriv(d)
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) Schema() *schema.Class {
return schemaGlGetFramebufferAttachmentParameteriv
}
var schemaGlGetFramebufferAttachmentParameteriv = &schema.Class{
TypeID: binaryIDGlGetFramebufferAttachmentParameteriv,
Name: "GlGetFramebufferAttachmentParameteriv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "FramebufferTarget", Type: &schema.Primitive{Name: "FramebufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Attachment", Type: &schema.Primitive{Name: "FramebufferAttachment", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "FramebufferAttachmentParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlGetGraphicsResetStatusEXT struct{}
func (*GlGetGraphicsResetStatusEXT) Class() binary.Class {
return (*binaryClassGlGetGraphicsResetStatusEXT)(nil)
}
func doEncodeGlGetGraphicsResetStatusEXT(e binary.Encoder, o *GlGetGraphicsResetStatusEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeGlGetGraphicsResetStatusEXT(d binary.Decoder, o *GlGetGraphicsResetStatusEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Result = ResetStatus(obj)
}
return nil
}
func doSkipGlGetGraphicsResetStatusEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetGraphicsResetStatusEXT) ID() binary.ID {
return binaryIDGlGetGraphicsResetStatusEXT
}
func (*binaryClassGlGetGraphicsResetStatusEXT) New() binary.Object {
return &GlGetGraphicsResetStatusEXT{}
}
func (*binaryClassGlGetGraphicsResetStatusEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetGraphicsResetStatusEXT(e, obj.(*GlGetGraphicsResetStatusEXT))
}
func (*binaryClassGlGetGraphicsResetStatusEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetGraphicsResetStatusEXT{}
return obj, doDecodeGlGetGraphicsResetStatusEXT(d, obj)
}
func (*binaryClassGlGetGraphicsResetStatusEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetGraphicsResetStatusEXT(d, obj.(*GlGetGraphicsResetStatusEXT))
}
func (*binaryClassGlGetGraphicsResetStatusEXT) Skip(d binary.Decoder) error {
return doSkipGlGetGraphicsResetStatusEXT(d)
}
func (*binaryClassGlGetGraphicsResetStatusEXT) Schema() *schema.Class {
return schemaGlGetGraphicsResetStatusEXT
}
var schemaGlGetGraphicsResetStatusEXT = &schema.Class{
TypeID: binaryIDGlGetGraphicsResetStatusEXT,
Name: "GlGetGraphicsResetStatusEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "ResetStatus", Method: schema.Uint32}},
},
}
type binaryClassGlGetIntegerv struct{}
func (*GlGetIntegerv) Class() binary.Class {
return (*binaryClassGlGetIntegerv)(nil)
}
func doEncodeGlGetIntegerv(e binary.Encoder, o *GlGetIntegerv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Param)); err != nil {
return err
}
if err := e.Value(&o.Values); err != nil {
return err
}
return nil
}
func doDecodeGlGetIntegerv(d binary.Decoder, o *GlGetIntegerv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Param = StateVariable(obj)
}
if err := d.Value(&o.Values); err != nil {
return err
}
return nil
}
func doSkipGlGetIntegerv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetIntegerv) ID() binary.ID { return binaryIDGlGetIntegerv }
func (*binaryClassGlGetIntegerv) New() binary.Object { return &GlGetIntegerv{} }
func (*binaryClassGlGetIntegerv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetIntegerv(e, obj.(*GlGetIntegerv))
}
func (*binaryClassGlGetIntegerv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetIntegerv{}
return obj, doDecodeGlGetIntegerv(d, obj)
}
func (*binaryClassGlGetIntegerv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetIntegerv(d, obj.(*GlGetIntegerv))
}
func (*binaryClassGlGetIntegerv) Skip(d binary.Decoder) error { return doSkipGlGetIntegerv(d) }
func (*binaryClassGlGetIntegerv) Schema() *schema.Class { return schemaGlGetIntegerv }
var schemaGlGetIntegerv = &schema.Class{
TypeID: binaryIDGlGetIntegerv,
Name: "GlGetIntegerv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Param", Type: &schema.Primitive{Name: "StateVariable", Method: schema.Uint32}},
schema.Field{Declared: "Values", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassU32ᵖ struct{}
func (*U32ᵖ) Class() binary.Class {
return (*binaryClassU32ᵖ)(nil)
}
func doEncodeU32ᵖ(e binary.Encoder, o *U32ᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeU32ᵖ(d binary.Decoder, o *U32ᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipU32ᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassU32ᵖ) ID() binary.ID { return binaryIDU32ᵖ }
func (*binaryClassU32ᵖ) New() binary.Object { return &U32ᵖ{} }
func (*binaryClassU32ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeU32ᵖ(e, obj.(*U32ᵖ))
}
func (*binaryClassU32ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &U32ᵖ{}
return obj, doDecodeU32ᵖ(d, obj)
}
func (*binaryClassU32ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeU32ᵖ(d, obj.(*U32ᵖ))
}
func (*binaryClassU32ᵖ) Skip(d binary.Decoder) error { return doSkipU32ᵖ(d) }
func (*binaryClassU32ᵖ) Schema() *schema.Class { return schemaU32ᵖ }
var schemaU32ᵖ = &schema.Class{
TypeID: binaryIDU32ᵖ,
Name: "U32ᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlGetProgramBinaryOES struct{}
func (*GlGetProgramBinaryOES) Class() binary.Class {
return (*binaryClassGlGetProgramBinaryOES)(nil)
}
func doEncodeGlGetProgramBinaryOES(e binary.Encoder, o *GlGetProgramBinaryOES) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Int32(o.BufferSize); err != nil {
return err
}
if err := e.Value(&o.BytesWritten); err != nil {
return err
}
if err := e.Value(&o.BinaryFormat); err != nil {
return err
}
if err := e.Value(&o.Binary); err != nil {
return err
}
return nil
}
func doDecodeGlGetProgramBinaryOES(d binary.Decoder, o *GlGetProgramBinaryOES) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.BufferSize = int32(obj)
}
if err := d.Value(&o.BytesWritten); err != nil {
return err
}
if err := d.Value(&o.BinaryFormat); err != nil {
return err
}
if err := d.Value(&o.Binary); err != nil {
return err
}
return nil
}
func doSkipGlGetProgramBinaryOES(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*U32ᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetProgramBinaryOES) ID() binary.ID { return binaryIDGlGetProgramBinaryOES }
func (*binaryClassGlGetProgramBinaryOES) New() binary.Object { return &GlGetProgramBinaryOES{} }
func (*binaryClassGlGetProgramBinaryOES) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetProgramBinaryOES(e, obj.(*GlGetProgramBinaryOES))
}
func (*binaryClassGlGetProgramBinaryOES) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetProgramBinaryOES{}
return obj, doDecodeGlGetProgramBinaryOES(d, obj)
}
func (*binaryClassGlGetProgramBinaryOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetProgramBinaryOES(d, obj.(*GlGetProgramBinaryOES))
}
func (*binaryClassGlGetProgramBinaryOES) Skip(d binary.Decoder) error {
return doSkipGlGetProgramBinaryOES(d)
}
func (*binaryClassGlGetProgramBinaryOES) Schema() *schema.Class { return schemaGlGetProgramBinaryOES }
var schemaGlGetProgramBinaryOES = &schema.Class{
TypeID: binaryIDGlGetProgramBinaryOES,
Name: "GlGetProgramBinaryOES",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "BufferSize", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "BytesWritten", Type: &schema.Struct{Name: "S32ᵖ"}},
schema.Field{Declared: "BinaryFormat", Type: &schema.Struct{Name: "U32ᵖ"}},
schema.Field{Declared: "Binary", Type: &schema.Struct{Name: "Voidᵖ"}},
},
}
type binaryClassGlGetProgramInfoLog struct{}
func (*GlGetProgramInfoLog) Class() binary.Class {
return (*binaryClassGlGetProgramInfoLog)(nil)
}
func doEncodeGlGetProgramInfoLog(e binary.Encoder, o *GlGetProgramInfoLog) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Int32(o.BufferLength); err != nil {
return err
}
if err := e.Value(&o.StringLengthWritten); err != nil {
return err
}
if err := e.Value(&o.Info); err != nil {
return err
}
return nil
}
func doDecodeGlGetProgramInfoLog(d binary.Decoder, o *GlGetProgramInfoLog) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.BufferLength = int32(obj)
}
if err := d.Value(&o.StringLengthWritten); err != nil {
return err
}
if err := d.Value(&o.Info); err != nil {
return err
}
return nil
}
func doSkipGlGetProgramInfoLog(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Charᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetProgramInfoLog) ID() binary.ID { return binaryIDGlGetProgramInfoLog }
func (*binaryClassGlGetProgramInfoLog) New() binary.Object { return &GlGetProgramInfoLog{} }
func (*binaryClassGlGetProgramInfoLog) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetProgramInfoLog(e, obj.(*GlGetProgramInfoLog))
}
func (*binaryClassGlGetProgramInfoLog) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetProgramInfoLog{}
return obj, doDecodeGlGetProgramInfoLog(d, obj)
}
func (*binaryClassGlGetProgramInfoLog) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetProgramInfoLog(d, obj.(*GlGetProgramInfoLog))
}
func (*binaryClassGlGetProgramInfoLog) Skip(d binary.Decoder) error {
return doSkipGlGetProgramInfoLog(d)
}
func (*binaryClassGlGetProgramInfoLog) Schema() *schema.Class { return schemaGlGetProgramInfoLog }
var schemaGlGetProgramInfoLog = &schema.Class{
TypeID: binaryIDGlGetProgramInfoLog,
Name: "GlGetProgramInfoLog",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "BufferLength", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "StringLengthWritten", Type: &schema.Struct{Name: "S32ᵖ"}},
schema.Field{Declared: "Info", Type: &schema.Struct{Name: "Charᵖ"}},
},
}
type binaryClassGlGetProgramiv struct{}
func (*GlGetProgramiv) Class() binary.Class {
return (*binaryClassGlGetProgramiv)(nil)
}
func doEncodeGlGetProgramiv(e binary.Encoder, o *GlGetProgramiv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlGetProgramiv(d binary.Decoder, o *GlGetProgramiv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = ProgramParameter(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlGetProgramiv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetProgramiv) ID() binary.ID { return binaryIDGlGetProgramiv }
func (*binaryClassGlGetProgramiv) New() binary.Object { return &GlGetProgramiv{} }
func (*binaryClassGlGetProgramiv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetProgramiv(e, obj.(*GlGetProgramiv))
}
func (*binaryClassGlGetProgramiv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetProgramiv{}
return obj, doDecodeGlGetProgramiv(d, obj)
}
func (*binaryClassGlGetProgramiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetProgramiv(d, obj.(*GlGetProgramiv))
}
func (*binaryClassGlGetProgramiv) Skip(d binary.Decoder) error { return doSkipGlGetProgramiv(d) }
func (*binaryClassGlGetProgramiv) Schema() *schema.Class { return schemaGlGetProgramiv }
var schemaGlGetProgramiv = &schema.Class{
TypeID: binaryIDGlGetProgramiv,
Name: "GlGetProgramiv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "ProgramParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassS64ᵖ struct{}
func (*S64ᵖ) Class() binary.Class {
return (*binaryClassS64ᵖ)(nil)
}
func doEncodeS64ᵖ(e binary.Encoder, o *S64ᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeS64ᵖ(d binary.Decoder, o *S64ᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipS64ᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassS64ᵖ) ID() binary.ID { return binaryIDS64ᵖ }
func (*binaryClassS64ᵖ) New() binary.Object { return &S64ᵖ{} }
func (*binaryClassS64ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeS64ᵖ(e, obj.(*S64ᵖ))
}
func (*binaryClassS64ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &S64ᵖ{}
return obj, doDecodeS64ᵖ(d, obj)
}
func (*binaryClassS64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeS64ᵖ(d, obj.(*S64ᵖ))
}
func (*binaryClassS64ᵖ) Skip(d binary.Decoder) error { return doSkipS64ᵖ(d) }
func (*binaryClassS64ᵖ) Schema() *schema.Class { return schemaS64ᵖ }
var schemaS64ᵖ = &schema.Class{
TypeID: binaryIDS64ᵖ,
Name: "S64ᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlGetQueryObjecti64vEXT struct{}
func (*GlGetQueryObjecti64vEXT) Class() binary.Class {
return (*binaryClassGlGetQueryObjecti64vEXT)(nil)
}
func doEncodeGlGetQueryObjecti64vEXT(e binary.Encoder, o *GlGetQueryObjecti64vEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Query)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlGetQueryObjecti64vEXT(d binary.Decoder, o *GlGetQueryObjecti64vEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Query = QueryId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = QueryObjectParameter(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlGetQueryObjecti64vEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*S64ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetQueryObjecti64vEXT) ID() binary.ID { return binaryIDGlGetQueryObjecti64vEXT }
func (*binaryClassGlGetQueryObjecti64vEXT) New() binary.Object { return &GlGetQueryObjecti64vEXT{} }
func (*binaryClassGlGetQueryObjecti64vEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetQueryObjecti64vEXT(e, obj.(*GlGetQueryObjecti64vEXT))
}
func (*binaryClassGlGetQueryObjecti64vEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetQueryObjecti64vEXT{}
return obj, doDecodeGlGetQueryObjecti64vEXT(d, obj)
}
func (*binaryClassGlGetQueryObjecti64vEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetQueryObjecti64vEXT(d, obj.(*GlGetQueryObjecti64vEXT))
}
func (*binaryClassGlGetQueryObjecti64vEXT) Skip(d binary.Decoder) error {
return doSkipGlGetQueryObjecti64vEXT(d)
}
func (*binaryClassGlGetQueryObjecti64vEXT) Schema() *schema.Class {
return schemaGlGetQueryObjecti64vEXT
}
var schemaGlGetQueryObjecti64vEXT = &schema.Class{
TypeID: binaryIDGlGetQueryObjecti64vEXT,
Name: "GlGetQueryObjecti64vEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "QueryObjectParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "S64ᵖ"}},
},
}
type binaryClassGlGetQueryObjectivEXT struct{}
func (*GlGetQueryObjectivEXT) Class() binary.Class {
return (*binaryClassGlGetQueryObjectivEXT)(nil)
}
func doEncodeGlGetQueryObjectivEXT(e binary.Encoder, o *GlGetQueryObjectivEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Query)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlGetQueryObjectivEXT(d binary.Decoder, o *GlGetQueryObjectivEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Query = QueryId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = QueryObjectParameter(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlGetQueryObjectivEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetQueryObjectivEXT) ID() binary.ID { return binaryIDGlGetQueryObjectivEXT }
func (*binaryClassGlGetQueryObjectivEXT) New() binary.Object { return &GlGetQueryObjectivEXT{} }
func (*binaryClassGlGetQueryObjectivEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetQueryObjectivEXT(e, obj.(*GlGetQueryObjectivEXT))
}
func (*binaryClassGlGetQueryObjectivEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetQueryObjectivEXT{}
return obj, doDecodeGlGetQueryObjectivEXT(d, obj)
}
func (*binaryClassGlGetQueryObjectivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetQueryObjectivEXT(d, obj.(*GlGetQueryObjectivEXT))
}
func (*binaryClassGlGetQueryObjectivEXT) Skip(d binary.Decoder) error {
return doSkipGlGetQueryObjectivEXT(d)
}
func (*binaryClassGlGetQueryObjectivEXT) Schema() *schema.Class { return schemaGlGetQueryObjectivEXT }
var schemaGlGetQueryObjectivEXT = &schema.Class{
TypeID: binaryIDGlGetQueryObjectivEXT,
Name: "GlGetQueryObjectivEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "QueryObjectParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassU64ᵖ struct{}
func (*U64ᵖ) Class() binary.Class {
return (*binaryClassU64ᵖ)(nil)
}
func doEncodeU64ᵖ(e binary.Encoder, o *U64ᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeU64ᵖ(d binary.Decoder, o *U64ᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipU64ᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassU64ᵖ) ID() binary.ID { return binaryIDU64ᵖ }
func (*binaryClassU64ᵖ) New() binary.Object { return &U64ᵖ{} }
func (*binaryClassU64ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeU64ᵖ(e, obj.(*U64ᵖ))
}
func (*binaryClassU64ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &U64ᵖ{}
return obj, doDecodeU64ᵖ(d, obj)
}
func (*binaryClassU64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeU64ᵖ(d, obj.(*U64ᵖ))
}
func (*binaryClassU64ᵖ) Skip(d binary.Decoder) error { return doSkipU64ᵖ(d) }
func (*binaryClassU64ᵖ) Schema() *schema.Class { return schemaU64ᵖ }
var schemaU64ᵖ = &schema.Class{
TypeID: binaryIDU64ᵖ,
Name: "U64ᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlGetQueryObjectui64vEXT struct{}
func (*GlGetQueryObjectui64vEXT) Class() binary.Class {
return (*binaryClassGlGetQueryObjectui64vEXT)(nil)
}
func doEncodeGlGetQueryObjectui64vEXT(e binary.Encoder, o *GlGetQueryObjectui64vEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Query)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlGetQueryObjectui64vEXT(d binary.Decoder, o *GlGetQueryObjectui64vEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Query = QueryId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = QueryObjectParameter(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlGetQueryObjectui64vEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*U64ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetQueryObjectui64vEXT) ID() binary.ID { return binaryIDGlGetQueryObjectui64vEXT }
func (*binaryClassGlGetQueryObjectui64vEXT) New() binary.Object { return &GlGetQueryObjectui64vEXT{} }
func (*binaryClassGlGetQueryObjectui64vEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetQueryObjectui64vEXT(e, obj.(*GlGetQueryObjectui64vEXT))
}
func (*binaryClassGlGetQueryObjectui64vEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetQueryObjectui64vEXT{}
return obj, doDecodeGlGetQueryObjectui64vEXT(d, obj)
}
func (*binaryClassGlGetQueryObjectui64vEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetQueryObjectui64vEXT(d, obj.(*GlGetQueryObjectui64vEXT))
}
func (*binaryClassGlGetQueryObjectui64vEXT) Skip(d binary.Decoder) error {
return doSkipGlGetQueryObjectui64vEXT(d)
}
func (*binaryClassGlGetQueryObjectui64vEXT) Schema() *schema.Class {
return schemaGlGetQueryObjectui64vEXT
}
var schemaGlGetQueryObjectui64vEXT = &schema.Class{
TypeID: binaryIDGlGetQueryObjectui64vEXT,
Name: "GlGetQueryObjectui64vEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "QueryObjectParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "U64ᵖ"}},
},
}
type binaryClassGlGetQueryObjectuiv struct{}
func (*GlGetQueryObjectuiv) Class() binary.Class {
return (*binaryClassGlGetQueryObjectuiv)(nil)
}
func doEncodeGlGetQueryObjectuiv(e binary.Encoder, o *GlGetQueryObjectuiv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Query)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlGetQueryObjectuiv(d binary.Decoder, o *GlGetQueryObjectuiv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Query = QueryId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = QueryObjectParameter(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlGetQueryObjectuiv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*U32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetQueryObjectuiv) ID() binary.ID { return binaryIDGlGetQueryObjectuiv }
func (*binaryClassGlGetQueryObjectuiv) New() binary.Object { return &GlGetQueryObjectuiv{} }
func (*binaryClassGlGetQueryObjectuiv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetQueryObjectuiv(e, obj.(*GlGetQueryObjectuiv))
}
func (*binaryClassGlGetQueryObjectuiv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetQueryObjectuiv{}
return obj, doDecodeGlGetQueryObjectuiv(d, obj)
}
func (*binaryClassGlGetQueryObjectuiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetQueryObjectuiv(d, obj.(*GlGetQueryObjectuiv))
}
func (*binaryClassGlGetQueryObjectuiv) Skip(d binary.Decoder) error {
return doSkipGlGetQueryObjectuiv(d)
}
func (*binaryClassGlGetQueryObjectuiv) Schema() *schema.Class { return schemaGlGetQueryObjectuiv }
var schemaGlGetQueryObjectuiv = &schema.Class{
TypeID: binaryIDGlGetQueryObjectuiv,
Name: "GlGetQueryObjectuiv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "QueryObjectParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "U32ᵖ"}},
},
}
type binaryClassGlGetQueryObjectuivEXT struct{}
func (*GlGetQueryObjectuivEXT) Class() binary.Class {
return (*binaryClassGlGetQueryObjectuivEXT)(nil)
}
func doEncodeGlGetQueryObjectuivEXT(e binary.Encoder, o *GlGetQueryObjectuivEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Query)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlGetQueryObjectuivEXT(d binary.Decoder, o *GlGetQueryObjectuivEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Query = QueryId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = QueryObjectParameter(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlGetQueryObjectuivEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*U32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetQueryObjectuivEXT) ID() binary.ID { return binaryIDGlGetQueryObjectuivEXT }
func (*binaryClassGlGetQueryObjectuivEXT) New() binary.Object { return &GlGetQueryObjectuivEXT{} }
func (*binaryClassGlGetQueryObjectuivEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetQueryObjectuivEXT(e, obj.(*GlGetQueryObjectuivEXT))
}
func (*binaryClassGlGetQueryObjectuivEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetQueryObjectuivEXT{}
return obj, doDecodeGlGetQueryObjectuivEXT(d, obj)
}
func (*binaryClassGlGetQueryObjectuivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetQueryObjectuivEXT(d, obj.(*GlGetQueryObjectuivEXT))
}
func (*binaryClassGlGetQueryObjectuivEXT) Skip(d binary.Decoder) error {
return doSkipGlGetQueryObjectuivEXT(d)
}
func (*binaryClassGlGetQueryObjectuivEXT) Schema() *schema.Class { return schemaGlGetQueryObjectuivEXT }
var schemaGlGetQueryObjectuivEXT = &schema.Class{
TypeID: binaryIDGlGetQueryObjectuivEXT,
Name: "GlGetQueryObjectuivEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "QueryObjectParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "U32ᵖ"}},
},
}
type binaryClassGlGetQueryiv struct{}
func (*GlGetQueryiv) Class() binary.Class {
return (*binaryClassGlGetQueryiv)(nil)
}
func doEncodeGlGetQueryiv(e binary.Encoder, o *GlGetQueryiv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlGetQueryiv(d binary.Decoder, o *GlGetQueryiv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = QueryTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = QueryParameter(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlGetQueryiv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetQueryiv) ID() binary.ID { return binaryIDGlGetQueryiv }
func (*binaryClassGlGetQueryiv) New() binary.Object { return &GlGetQueryiv{} }
func (*binaryClassGlGetQueryiv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetQueryiv(e, obj.(*GlGetQueryiv))
}
func (*binaryClassGlGetQueryiv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetQueryiv{}
return obj, doDecodeGlGetQueryiv(d, obj)
}
func (*binaryClassGlGetQueryiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetQueryiv(d, obj.(*GlGetQueryiv))
}
func (*binaryClassGlGetQueryiv) Skip(d binary.Decoder) error { return doSkipGlGetQueryiv(d) }
func (*binaryClassGlGetQueryiv) Schema() *schema.Class { return schemaGlGetQueryiv }
var schemaGlGetQueryiv = &schema.Class{
TypeID: binaryIDGlGetQueryiv,
Name: "GlGetQueryiv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "QueryTarget", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "QueryParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlGetQueryivEXT struct{}
func (*GlGetQueryivEXT) Class() binary.Class {
return (*binaryClassGlGetQueryivEXT)(nil)
}
func doEncodeGlGetQueryivEXT(e binary.Encoder, o *GlGetQueryivEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlGetQueryivEXT(d binary.Decoder, o *GlGetQueryivEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = QueryTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = QueryParameter(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlGetQueryivEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetQueryivEXT) ID() binary.ID { return binaryIDGlGetQueryivEXT }
func (*binaryClassGlGetQueryivEXT) New() binary.Object { return &GlGetQueryivEXT{} }
func (*binaryClassGlGetQueryivEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetQueryivEXT(e, obj.(*GlGetQueryivEXT))
}
func (*binaryClassGlGetQueryivEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetQueryivEXT{}
return obj, doDecodeGlGetQueryivEXT(d, obj)
}
func (*binaryClassGlGetQueryivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetQueryivEXT(d, obj.(*GlGetQueryivEXT))
}
func (*binaryClassGlGetQueryivEXT) Skip(d binary.Decoder) error { return doSkipGlGetQueryivEXT(d) }
func (*binaryClassGlGetQueryivEXT) Schema() *schema.Class { return schemaGlGetQueryivEXT }
var schemaGlGetQueryivEXT = &schema.Class{
TypeID: binaryIDGlGetQueryivEXT,
Name: "GlGetQueryivEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "QueryTarget", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "QueryParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlGetRenderbufferParameteriv struct{}
func (*GlGetRenderbufferParameteriv) Class() binary.Class {
return (*binaryClassGlGetRenderbufferParameteriv)(nil)
}
func doEncodeGlGetRenderbufferParameteriv(e binary.Encoder, o *GlGetRenderbufferParameteriv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Values); err != nil {
return err
}
return nil
}
func doDecodeGlGetRenderbufferParameteriv(d binary.Decoder, o *GlGetRenderbufferParameteriv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = RenderbufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = RenderbufferParameter(obj)
}
if err := d.Value(&o.Values); err != nil {
return err
}
return nil
}
func doSkipGlGetRenderbufferParameteriv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetRenderbufferParameteriv) ID() binary.ID {
return binaryIDGlGetRenderbufferParameteriv
}
func (*binaryClassGlGetRenderbufferParameteriv) New() binary.Object {
return &GlGetRenderbufferParameteriv{}
}
func (*binaryClassGlGetRenderbufferParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetRenderbufferParameteriv(e, obj.(*GlGetRenderbufferParameteriv))
}
func (*binaryClassGlGetRenderbufferParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetRenderbufferParameteriv{}
return obj, doDecodeGlGetRenderbufferParameteriv(d, obj)
}
func (*binaryClassGlGetRenderbufferParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetRenderbufferParameteriv(d, obj.(*GlGetRenderbufferParameteriv))
}
func (*binaryClassGlGetRenderbufferParameteriv) Skip(d binary.Decoder) error {
return doSkipGlGetRenderbufferParameteriv(d)
}
func (*binaryClassGlGetRenderbufferParameteriv) Schema() *schema.Class {
return schemaGlGetRenderbufferParameteriv
}
var schemaGlGetRenderbufferParameteriv = &schema.Class{
TypeID: binaryIDGlGetRenderbufferParameteriv,
Name: "GlGetRenderbufferParameteriv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "RenderbufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "RenderbufferParameter", Method: schema.Uint32}},
schema.Field{Declared: "Values", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlGetShaderInfoLog struct{}
func (*GlGetShaderInfoLog) Class() binary.Class {
return (*binaryClassGlGetShaderInfoLog)(nil)
}
func doEncodeGlGetShaderInfoLog(e binary.Encoder, o *GlGetShaderInfoLog) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Shader)); err != nil {
return err
}
if err := e.Int32(o.BufferLength); err != nil {
return err
}
if err := e.Value(&o.StringLengthWritten); err != nil {
return err
}
if err := e.Value(&o.Info); err != nil {
return err
}
return nil
}
func doDecodeGlGetShaderInfoLog(d binary.Decoder, o *GlGetShaderInfoLog) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Shader = ShaderId(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.BufferLength = int32(obj)
}
if err := d.Value(&o.StringLengthWritten); err != nil {
return err
}
if err := d.Value(&o.Info); err != nil {
return err
}
return nil
}
func doSkipGlGetShaderInfoLog(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Charᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetShaderInfoLog) ID() binary.ID { return binaryIDGlGetShaderInfoLog }
func (*binaryClassGlGetShaderInfoLog) New() binary.Object { return &GlGetShaderInfoLog{} }
func (*binaryClassGlGetShaderInfoLog) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetShaderInfoLog(e, obj.(*GlGetShaderInfoLog))
}
func (*binaryClassGlGetShaderInfoLog) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetShaderInfoLog{}
return obj, doDecodeGlGetShaderInfoLog(d, obj)
}
func (*binaryClassGlGetShaderInfoLog) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetShaderInfoLog(d, obj.(*GlGetShaderInfoLog))
}
func (*binaryClassGlGetShaderInfoLog) Skip(d binary.Decoder) error { return doSkipGlGetShaderInfoLog(d) }
func (*binaryClassGlGetShaderInfoLog) Schema() *schema.Class { return schemaGlGetShaderInfoLog }
var schemaGlGetShaderInfoLog = &schema.Class{
TypeID: binaryIDGlGetShaderInfoLog,
Name: "GlGetShaderInfoLog",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
schema.Field{Declared: "BufferLength", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "StringLengthWritten", Type: &schema.Struct{Name: "S32ᵖ"}},
schema.Field{Declared: "Info", Type: &schema.Struct{Name: "Charᵖ"}},
},
}
type binaryClassGlGetShaderPrecisionFormat struct{}
func (*GlGetShaderPrecisionFormat) Class() binary.Class {
return (*binaryClassGlGetShaderPrecisionFormat)(nil)
}
func doEncodeGlGetShaderPrecisionFormat(e binary.Encoder, o *GlGetShaderPrecisionFormat) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.ShaderType)); err != nil {
return err
}
if err := e.Uint32(uint32(o.PrecisionType)); err != nil {
return err
}
if err := e.Value(&o.Range); err != nil {
return err
}
if err := e.Value(&o.Precision); err != nil {
return err
}
return nil
}
func doDecodeGlGetShaderPrecisionFormat(d binary.Decoder, o *GlGetShaderPrecisionFormat) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.ShaderType = ShaderType(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.PrecisionType = PrecisionType(obj)
}
if err := d.Value(&o.Range); err != nil {
return err
}
if err := d.Value(&o.Precision); err != nil {
return err
}
return nil
}
func doSkipGlGetShaderPrecisionFormat(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetShaderPrecisionFormat) ID() binary.ID {
return binaryIDGlGetShaderPrecisionFormat
}
func (*binaryClassGlGetShaderPrecisionFormat) New() binary.Object {
return &GlGetShaderPrecisionFormat{}
}
func (*binaryClassGlGetShaderPrecisionFormat) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetShaderPrecisionFormat(e, obj.(*GlGetShaderPrecisionFormat))
}
func (*binaryClassGlGetShaderPrecisionFormat) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetShaderPrecisionFormat{}
return obj, doDecodeGlGetShaderPrecisionFormat(d, obj)
}
func (*binaryClassGlGetShaderPrecisionFormat) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetShaderPrecisionFormat(d, obj.(*GlGetShaderPrecisionFormat))
}
func (*binaryClassGlGetShaderPrecisionFormat) Skip(d binary.Decoder) error {
return doSkipGlGetShaderPrecisionFormat(d)
}
func (*binaryClassGlGetShaderPrecisionFormat) Schema() *schema.Class {
return schemaGlGetShaderPrecisionFormat
}
var schemaGlGetShaderPrecisionFormat = &schema.Class{
TypeID: binaryIDGlGetShaderPrecisionFormat,
Name: "GlGetShaderPrecisionFormat",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "ShaderType", Type: &schema.Primitive{Name: "ShaderType", Method: schema.Uint32}},
schema.Field{Declared: "PrecisionType", Type: &schema.Primitive{Name: "PrecisionType", Method: schema.Uint32}},
schema.Field{Declared: "Range", Type: &schema.Struct{Name: "S32ᵖ"}},
schema.Field{Declared: "Precision", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlGetShaderSource struct{}
func (*GlGetShaderSource) Class() binary.Class {
return (*binaryClassGlGetShaderSource)(nil)
}
func doEncodeGlGetShaderSource(e binary.Encoder, o *GlGetShaderSource) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Shader)); err != nil {
return err
}
if err := e.Int32(o.BufferLength); err != nil {
return err
}
if err := e.Value(&o.StringLengthWritten); err != nil {
return err
}
if err := e.Value(&o.Source); err != nil {
return err
}
return nil
}
func doDecodeGlGetShaderSource(d binary.Decoder, o *GlGetShaderSource) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Shader = ShaderId(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.BufferLength = int32(obj)
}
if err := d.Value(&o.StringLengthWritten); err != nil {
return err
}
if err := d.Value(&o.Source); err != nil {
return err
}
return nil
}
func doSkipGlGetShaderSource(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Charᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetShaderSource) ID() binary.ID { return binaryIDGlGetShaderSource }
func (*binaryClassGlGetShaderSource) New() binary.Object { return &GlGetShaderSource{} }
func (*binaryClassGlGetShaderSource) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetShaderSource(e, obj.(*GlGetShaderSource))
}
func (*binaryClassGlGetShaderSource) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetShaderSource{}
return obj, doDecodeGlGetShaderSource(d, obj)
}
func (*binaryClassGlGetShaderSource) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetShaderSource(d, obj.(*GlGetShaderSource))
}
func (*binaryClassGlGetShaderSource) Skip(d binary.Decoder) error { return doSkipGlGetShaderSource(d) }
func (*binaryClassGlGetShaderSource) Schema() *schema.Class { return schemaGlGetShaderSource }
var schemaGlGetShaderSource = &schema.Class{
TypeID: binaryIDGlGetShaderSource,
Name: "GlGetShaderSource",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
schema.Field{Declared: "BufferLength", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "StringLengthWritten", Type: &schema.Struct{Name: "S32ᵖ"}},
schema.Field{Declared: "Source", Type: &schema.Struct{Name: "Charᵖ"}},
},
}
type binaryClassGlGetShaderiv struct{}
func (*GlGetShaderiv) Class() binary.Class {
return (*binaryClassGlGetShaderiv)(nil)
}
func doEncodeGlGetShaderiv(e binary.Encoder, o *GlGetShaderiv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Shader)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlGetShaderiv(d binary.Decoder, o *GlGetShaderiv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Shader = ShaderId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = ShaderParameter(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlGetShaderiv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetShaderiv) ID() binary.ID { return binaryIDGlGetShaderiv }
func (*binaryClassGlGetShaderiv) New() binary.Object { return &GlGetShaderiv{} }
func (*binaryClassGlGetShaderiv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetShaderiv(e, obj.(*GlGetShaderiv))
}
func (*binaryClassGlGetShaderiv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetShaderiv{}
return obj, doDecodeGlGetShaderiv(d, obj)
}
func (*binaryClassGlGetShaderiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetShaderiv(d, obj.(*GlGetShaderiv))
}
func (*binaryClassGlGetShaderiv) Skip(d binary.Decoder) error { return doSkipGlGetShaderiv(d) }
func (*binaryClassGlGetShaderiv) Schema() *schema.Class { return schemaGlGetShaderiv }
var schemaGlGetShaderiv = &schema.Class{
TypeID: binaryIDGlGetShaderiv,
Name: "GlGetShaderiv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "ShaderParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlGetString struct{}
func (*GlGetString) Class() binary.Class {
return (*binaryClassGlGetString)(nil)
}
func doEncodeGlGetString(e binary.Encoder, o *GlGetString) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Param)); err != nil {
return err
}
if err := e.Value(&o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlGetString(d binary.Decoder, o *GlGetString) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Param = StringConstant(obj)
}
if err := d.Value(&o.Result); err != nil {
return err
}
return nil
}
func doSkipGlGetString(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*Charᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetString) ID() binary.ID { return binaryIDGlGetString }
func (*binaryClassGlGetString) New() binary.Object { return &GlGetString{} }
func (*binaryClassGlGetString) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetString(e, obj.(*GlGetString))
}
func (*binaryClassGlGetString) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetString{}
return obj, doDecodeGlGetString(d, obj)
}
func (*binaryClassGlGetString) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetString(d, obj.(*GlGetString))
}
func (*binaryClassGlGetString) Skip(d binary.Decoder) error { return doSkipGlGetString(d) }
func (*binaryClassGlGetString) Schema() *schema.Class { return schemaGlGetString }
var schemaGlGetString = &schema.Class{
TypeID: binaryIDGlGetString,
Name: "GlGetString",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Param", Type: &schema.Primitive{Name: "StringConstant", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Struct{Name: "Charᵖ"}},
},
}
type binaryClassGlGetTexParameterfv struct{}
func (*GlGetTexParameterfv) Class() binary.Class {
return (*binaryClassGlGetTexParameterfv)(nil)
}
func doEncodeGlGetTexParameterfv(e binary.Encoder, o *GlGetTexParameterfv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Values); err != nil {
return err
}
return nil
}
func doDecodeGlGetTexParameterfv(d binary.Decoder, o *GlGetTexParameterfv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = TextureParameter(obj)
}
if err := d.Value(&o.Values); err != nil {
return err
}
return nil
}
func doSkipGlGetTexParameterfv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetTexParameterfv) ID() binary.ID { return binaryIDGlGetTexParameterfv }
func (*binaryClassGlGetTexParameterfv) New() binary.Object { return &GlGetTexParameterfv{} }
func (*binaryClassGlGetTexParameterfv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetTexParameterfv(e, obj.(*GlGetTexParameterfv))
}
func (*binaryClassGlGetTexParameterfv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetTexParameterfv{}
return obj, doDecodeGlGetTexParameterfv(d, obj)
}
func (*binaryClassGlGetTexParameterfv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetTexParameterfv(d, obj.(*GlGetTexParameterfv))
}
func (*binaryClassGlGetTexParameterfv) Skip(d binary.Decoder) error {
return doSkipGlGetTexParameterfv(d)
}
func (*binaryClassGlGetTexParameterfv) Schema() *schema.Class { return schemaGlGetTexParameterfv }
var schemaGlGetTexParameterfv = &schema.Class{
TypeID: binaryIDGlGetTexParameterfv,
Name: "GlGetTexParameterfv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureTarget", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "TextureParameter", Method: schema.Uint32}},
schema.Field{Declared: "Values", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlGetTexParameteriv struct{}
func (*GlGetTexParameteriv) Class() binary.Class {
return (*binaryClassGlGetTexParameteriv)(nil)
}
func doEncodeGlGetTexParameteriv(e binary.Encoder, o *GlGetTexParameteriv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Value(&o.Values); err != nil {
return err
}
return nil
}
func doDecodeGlGetTexParameteriv(d binary.Decoder, o *GlGetTexParameteriv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = TextureParameter(obj)
}
if err := d.Value(&o.Values); err != nil {
return err
}
return nil
}
func doSkipGlGetTexParameteriv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetTexParameteriv) ID() binary.ID { return binaryIDGlGetTexParameteriv }
func (*binaryClassGlGetTexParameteriv) New() binary.Object { return &GlGetTexParameteriv{} }
func (*binaryClassGlGetTexParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetTexParameteriv(e, obj.(*GlGetTexParameteriv))
}
func (*binaryClassGlGetTexParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetTexParameteriv{}
return obj, doDecodeGlGetTexParameteriv(d, obj)
}
func (*binaryClassGlGetTexParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetTexParameteriv(d, obj.(*GlGetTexParameteriv))
}
func (*binaryClassGlGetTexParameteriv) Skip(d binary.Decoder) error {
return doSkipGlGetTexParameteriv(d)
}
func (*binaryClassGlGetTexParameteriv) Schema() *schema.Class { return schemaGlGetTexParameteriv }
var schemaGlGetTexParameteriv = &schema.Class{
TypeID: binaryIDGlGetTexParameteriv,
Name: "GlGetTexParameteriv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureTarget", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "TextureParameter", Method: schema.Uint32}},
schema.Field{Declared: "Values", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlGetUniformLocation struct{}
func (*GlGetUniformLocation) Class() binary.Class {
return (*binaryClassGlGetUniformLocation)(nil)
}
func doEncodeGlGetUniformLocation(e binary.Encoder, o *GlGetUniformLocation) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.String(o.Name); err != nil {
return err
}
if err := e.Int32(int32(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeGlGetUniformLocation(d binary.Decoder, o *GlGetUniformLocation) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.String(); err != nil {
return err
} else {
o.Name = string(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Result = UniformLocation(obj)
}
return nil
}
func doSkipGlGetUniformLocation(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipString(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetUniformLocation) ID() binary.ID { return binaryIDGlGetUniformLocation }
func (*binaryClassGlGetUniformLocation) New() binary.Object { return &GlGetUniformLocation{} }
func (*binaryClassGlGetUniformLocation) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetUniformLocation(e, obj.(*GlGetUniformLocation))
}
func (*binaryClassGlGetUniformLocation) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetUniformLocation{}
return obj, doDecodeGlGetUniformLocation(d, obj)
}
func (*binaryClassGlGetUniformLocation) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetUniformLocation(d, obj.(*GlGetUniformLocation))
}
func (*binaryClassGlGetUniformLocation) Skip(d binary.Decoder) error {
return doSkipGlGetUniformLocation(d)
}
func (*binaryClassGlGetUniformLocation) Schema() *schema.Class { return schemaGlGetUniformLocation }
var schemaGlGetUniformLocation = &schema.Class{
TypeID: binaryIDGlGetUniformLocation,
Name: "GlGetUniformLocation",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
},
}
type binaryClassGlGetUniformfv struct{}
func (*GlGetUniformfv) Class() binary.Class {
return (*binaryClassGlGetUniformfv)(nil)
}
func doEncodeGlGetUniformfv(e binary.Encoder, o *GlGetUniformfv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Value(&o.Values); err != nil {
return err
}
return nil
}
func doDecodeGlGetUniformfv(d binary.Decoder, o *GlGetUniformfv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if err := d.Value(&o.Values); err != nil {
return err
}
return nil
}
func doSkipGlGetUniformfv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetUniformfv) ID() binary.ID { return binaryIDGlGetUniformfv }
func (*binaryClassGlGetUniformfv) New() binary.Object { return &GlGetUniformfv{} }
func (*binaryClassGlGetUniformfv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetUniformfv(e, obj.(*GlGetUniformfv))
}
func (*binaryClassGlGetUniformfv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetUniformfv{}
return obj, doDecodeGlGetUniformfv(d, obj)
}
func (*binaryClassGlGetUniformfv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetUniformfv(d, obj.(*GlGetUniformfv))
}
func (*binaryClassGlGetUniformfv) Skip(d binary.Decoder) error { return doSkipGlGetUniformfv(d) }
func (*binaryClassGlGetUniformfv) Schema() *schema.Class { return schemaGlGetUniformfv }
var schemaGlGetUniformfv = &schema.Class{
TypeID: binaryIDGlGetUniformfv,
Name: "GlGetUniformfv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Values", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlGetUniformiv struct{}
func (*GlGetUniformiv) Class() binary.Class {
return (*binaryClassGlGetUniformiv)(nil)
}
func doEncodeGlGetUniformiv(e binary.Encoder, o *GlGetUniformiv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Value(&o.Values); err != nil {
return err
}
return nil
}
func doDecodeGlGetUniformiv(d binary.Decoder, o *GlGetUniformiv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if err := d.Value(&o.Values); err != nil {
return err
}
return nil
}
func doSkipGlGetUniformiv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlGetUniformiv) ID() binary.ID { return binaryIDGlGetUniformiv }
func (*binaryClassGlGetUniformiv) New() binary.Object { return &GlGetUniformiv{} }
func (*binaryClassGlGetUniformiv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlGetUniformiv(e, obj.(*GlGetUniformiv))
}
func (*binaryClassGlGetUniformiv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlGetUniformiv{}
return obj, doDecodeGlGetUniformiv(d, obj)
}
func (*binaryClassGlGetUniformiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlGetUniformiv(d, obj.(*GlGetUniformiv))
}
func (*binaryClassGlGetUniformiv) Skip(d binary.Decoder) error { return doSkipGlGetUniformiv(d) }
func (*binaryClassGlGetUniformiv) Schema() *schema.Class { return schemaGlGetUniformiv }
var schemaGlGetUniformiv = &schema.Class{
TypeID: binaryIDGlGetUniformiv,
Name: "GlGetUniformiv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Values", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlHint struct{}
func (*GlHint) Class() binary.Class {
return (*binaryClassGlHint)(nil)
}
func doEncodeGlHint(e binary.Encoder, o *GlHint) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Mode)); err != nil {
return err
}
return nil
}
func doDecodeGlHint(d binary.Decoder, o *GlHint) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = HintTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Mode = HintMode(obj)
}
return nil
}
func doSkipGlHint(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlHint) ID() binary.ID { return binaryIDGlHint }
func (*binaryClassGlHint) New() binary.Object { return &GlHint{} }
func (*binaryClassGlHint) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlHint(e, obj.(*GlHint))
}
func (*binaryClassGlHint) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlHint{}
return obj, doDecodeGlHint(d, obj)
}
func (*binaryClassGlHint) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlHint(d, obj.(*GlHint))
}
func (*binaryClassGlHint) Skip(d binary.Decoder) error { return doSkipGlHint(d) }
func (*binaryClassGlHint) Schema() *schema.Class { return schemaGlHint }
var schemaGlHint = &schema.Class{
TypeID: binaryIDGlHint,
Name: "GlHint",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "HintTarget", Method: schema.Uint32}},
schema.Field{Declared: "Mode", Type: &schema.Primitive{Name: "HintMode", Method: schema.Uint32}},
},
}
type binaryClassGlInsertEventMarkerEXT struct{}
func (*GlInsertEventMarkerEXT) Class() binary.Class {
return (*binaryClassGlInsertEventMarkerEXT)(nil)
}
func doEncodeGlInsertEventMarkerEXT(e binary.Encoder, o *GlInsertEventMarkerEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Length); err != nil {
return err
}
if err := e.String(o.Marker); err != nil {
return err
}
return nil
}
func doDecodeGlInsertEventMarkerEXT(d binary.Decoder, o *GlInsertEventMarkerEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Length = int32(obj)
}
if obj, err := d.String(); err != nil {
return err
} else {
o.Marker = string(obj)
}
return nil
}
func doSkipGlInsertEventMarkerEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipString(); err != nil {
return err
}
return nil
}
func (*binaryClassGlInsertEventMarkerEXT) ID() binary.ID { return binaryIDGlInsertEventMarkerEXT }
func (*binaryClassGlInsertEventMarkerEXT) New() binary.Object { return &GlInsertEventMarkerEXT{} }
func (*binaryClassGlInsertEventMarkerEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlInsertEventMarkerEXT(e, obj.(*GlInsertEventMarkerEXT))
}
func (*binaryClassGlInsertEventMarkerEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlInsertEventMarkerEXT{}
return obj, doDecodeGlInsertEventMarkerEXT(d, obj)
}
func (*binaryClassGlInsertEventMarkerEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlInsertEventMarkerEXT(d, obj.(*GlInsertEventMarkerEXT))
}
func (*binaryClassGlInsertEventMarkerEXT) Skip(d binary.Decoder) error {
return doSkipGlInsertEventMarkerEXT(d)
}
func (*binaryClassGlInsertEventMarkerEXT) Schema() *schema.Class { return schemaGlInsertEventMarkerEXT }
var schemaGlInsertEventMarkerEXT = &schema.Class{
TypeID: binaryIDGlInsertEventMarkerEXT,
Name: "GlInsertEventMarkerEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Length", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Marker", Type: &schema.Primitive{Name: "string", Method: schema.String}},
},
}
type binaryClassGlInvalidateFramebuffer struct{}
func (*GlInvalidateFramebuffer) Class() binary.Class {
return (*binaryClassGlInvalidateFramebuffer)(nil)
}
func doEncodeGlInvalidateFramebuffer(e binary.Encoder, o *GlInvalidateFramebuffer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Attachments); err != nil {
return err
}
return nil
}
func doDecodeGlInvalidateFramebuffer(d binary.Decoder, o *GlInvalidateFramebuffer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = FramebufferTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Attachments); err != nil {
return err
}
return nil
}
func doSkipGlInvalidateFramebuffer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*FramebufferAttachmentᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlInvalidateFramebuffer) ID() binary.ID { return binaryIDGlInvalidateFramebuffer }
func (*binaryClassGlInvalidateFramebuffer) New() binary.Object { return &GlInvalidateFramebuffer{} }
func (*binaryClassGlInvalidateFramebuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlInvalidateFramebuffer(e, obj.(*GlInvalidateFramebuffer))
}
func (*binaryClassGlInvalidateFramebuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlInvalidateFramebuffer{}
return obj, doDecodeGlInvalidateFramebuffer(d, obj)
}
func (*binaryClassGlInvalidateFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlInvalidateFramebuffer(d, obj.(*GlInvalidateFramebuffer))
}
func (*binaryClassGlInvalidateFramebuffer) Skip(d binary.Decoder) error {
return doSkipGlInvalidateFramebuffer(d)
}
func (*binaryClassGlInvalidateFramebuffer) Schema() *schema.Class {
return schemaGlInvalidateFramebuffer
}
var schemaGlInvalidateFramebuffer = &schema.Class{
TypeID: binaryIDGlInvalidateFramebuffer,
Name: "GlInvalidateFramebuffer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "FramebufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Attachments", Type: &schema.Struct{Name: "FramebufferAttachmentᵖ"}},
},
}
type binaryClassGlIsBuffer struct{}
func (*GlIsBuffer) Class() binary.Class {
return (*binaryClassGlIsBuffer)(nil)
}
func doEncodeGlIsBuffer(e binary.Encoder, o *GlIsBuffer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Buffer)); err != nil {
return err
}
if err := e.Bool(o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlIsBuffer(d binary.Decoder, o *GlIsBuffer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Buffer = BufferId(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Result = bool(obj)
}
return nil
}
func doSkipGlIsBuffer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlIsBuffer) ID() binary.ID { return binaryIDGlIsBuffer }
func (*binaryClassGlIsBuffer) New() binary.Object { return &GlIsBuffer{} }
func (*binaryClassGlIsBuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlIsBuffer(e, obj.(*GlIsBuffer))
}
func (*binaryClassGlIsBuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlIsBuffer{}
return obj, doDecodeGlIsBuffer(d, obj)
}
func (*binaryClassGlIsBuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlIsBuffer(d, obj.(*GlIsBuffer))
}
func (*binaryClassGlIsBuffer) Skip(d binary.Decoder) error { return doSkipGlIsBuffer(d) }
func (*binaryClassGlIsBuffer) Schema() *schema.Class { return schemaGlIsBuffer }
var schemaGlIsBuffer = &schema.Class{
TypeID: binaryIDGlIsBuffer,
Name: "GlIsBuffer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlIsEnabled struct{}
func (*GlIsEnabled) Class() binary.Class {
return (*binaryClassGlIsEnabled)(nil)
}
func doEncodeGlIsEnabled(e binary.Encoder, o *GlIsEnabled) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Capability)); err != nil {
return err
}
if err := e.Bool(o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlIsEnabled(d binary.Decoder, o *GlIsEnabled) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Capability = Capability(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Result = bool(obj)
}
return nil
}
func doSkipGlIsEnabled(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlIsEnabled) ID() binary.ID { return binaryIDGlIsEnabled }
func (*binaryClassGlIsEnabled) New() binary.Object { return &GlIsEnabled{} }
func (*binaryClassGlIsEnabled) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlIsEnabled(e, obj.(*GlIsEnabled))
}
func (*binaryClassGlIsEnabled) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlIsEnabled{}
return obj, doDecodeGlIsEnabled(d, obj)
}
func (*binaryClassGlIsEnabled) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlIsEnabled(d, obj.(*GlIsEnabled))
}
func (*binaryClassGlIsEnabled) Skip(d binary.Decoder) error { return doSkipGlIsEnabled(d) }
func (*binaryClassGlIsEnabled) Schema() *schema.Class { return schemaGlIsEnabled }
var schemaGlIsEnabled = &schema.Class{
TypeID: binaryIDGlIsEnabled,
Name: "GlIsEnabled",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Capability", Type: &schema.Primitive{Name: "Capability", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlIsFramebuffer struct{}
func (*GlIsFramebuffer) Class() binary.Class {
return (*binaryClassGlIsFramebuffer)(nil)
}
func doEncodeGlIsFramebuffer(e binary.Encoder, o *GlIsFramebuffer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Framebuffer)); err != nil {
return err
}
if err := e.Bool(o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlIsFramebuffer(d binary.Decoder, o *GlIsFramebuffer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Framebuffer = FramebufferId(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Result = bool(obj)
}
return nil
}
func doSkipGlIsFramebuffer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlIsFramebuffer) ID() binary.ID { return binaryIDGlIsFramebuffer }
func (*binaryClassGlIsFramebuffer) New() binary.Object { return &GlIsFramebuffer{} }
func (*binaryClassGlIsFramebuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlIsFramebuffer(e, obj.(*GlIsFramebuffer))
}
func (*binaryClassGlIsFramebuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlIsFramebuffer{}
return obj, doDecodeGlIsFramebuffer(d, obj)
}
func (*binaryClassGlIsFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlIsFramebuffer(d, obj.(*GlIsFramebuffer))
}
func (*binaryClassGlIsFramebuffer) Skip(d binary.Decoder) error { return doSkipGlIsFramebuffer(d) }
func (*binaryClassGlIsFramebuffer) Schema() *schema.Class { return schemaGlIsFramebuffer }
var schemaGlIsFramebuffer = &schema.Class{
TypeID: binaryIDGlIsFramebuffer,
Name: "GlIsFramebuffer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Framebuffer", Type: &schema.Primitive{Name: "FramebufferId", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlIsProgram struct{}
func (*GlIsProgram) Class() binary.Class {
return (*binaryClassGlIsProgram)(nil)
}
func doEncodeGlIsProgram(e binary.Encoder, o *GlIsProgram) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Bool(o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlIsProgram(d binary.Decoder, o *GlIsProgram) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Result = bool(obj)
}
return nil
}
func doSkipGlIsProgram(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlIsProgram) ID() binary.ID { return binaryIDGlIsProgram }
func (*binaryClassGlIsProgram) New() binary.Object { return &GlIsProgram{} }
func (*binaryClassGlIsProgram) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlIsProgram(e, obj.(*GlIsProgram))
}
func (*binaryClassGlIsProgram) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlIsProgram{}
return obj, doDecodeGlIsProgram(d, obj)
}
func (*binaryClassGlIsProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlIsProgram(d, obj.(*GlIsProgram))
}
func (*binaryClassGlIsProgram) Skip(d binary.Decoder) error { return doSkipGlIsProgram(d) }
func (*binaryClassGlIsProgram) Schema() *schema.Class { return schemaGlIsProgram }
var schemaGlIsProgram = &schema.Class{
TypeID: binaryIDGlIsProgram,
Name: "GlIsProgram",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlIsQuery struct{}
func (*GlIsQuery) Class() binary.Class {
return (*binaryClassGlIsQuery)(nil)
}
func doEncodeGlIsQuery(e binary.Encoder, o *GlIsQuery) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Query)); err != nil {
return err
}
if err := e.Bool(o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlIsQuery(d binary.Decoder, o *GlIsQuery) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Query = QueryId(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Result = bool(obj)
}
return nil
}
func doSkipGlIsQuery(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlIsQuery) ID() binary.ID { return binaryIDGlIsQuery }
func (*binaryClassGlIsQuery) New() binary.Object { return &GlIsQuery{} }
func (*binaryClassGlIsQuery) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlIsQuery(e, obj.(*GlIsQuery))
}
func (*binaryClassGlIsQuery) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlIsQuery{}
return obj, doDecodeGlIsQuery(d, obj)
}
func (*binaryClassGlIsQuery) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlIsQuery(d, obj.(*GlIsQuery))
}
func (*binaryClassGlIsQuery) Skip(d binary.Decoder) error { return doSkipGlIsQuery(d) }
func (*binaryClassGlIsQuery) Schema() *schema.Class { return schemaGlIsQuery }
var schemaGlIsQuery = &schema.Class{
TypeID: binaryIDGlIsQuery,
Name: "GlIsQuery",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlIsQueryEXT struct{}
func (*GlIsQueryEXT) Class() binary.Class {
return (*binaryClassGlIsQueryEXT)(nil)
}
func doEncodeGlIsQueryEXT(e binary.Encoder, o *GlIsQueryEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Query)); err != nil {
return err
}
if err := e.Bool(o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlIsQueryEXT(d binary.Decoder, o *GlIsQueryEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Query = QueryId(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Result = bool(obj)
}
return nil
}
func doSkipGlIsQueryEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlIsQueryEXT) ID() binary.ID { return binaryIDGlIsQueryEXT }
func (*binaryClassGlIsQueryEXT) New() binary.Object { return &GlIsQueryEXT{} }
func (*binaryClassGlIsQueryEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlIsQueryEXT(e, obj.(*GlIsQueryEXT))
}
func (*binaryClassGlIsQueryEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlIsQueryEXT{}
return obj, doDecodeGlIsQueryEXT(d, obj)
}
func (*binaryClassGlIsQueryEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlIsQueryEXT(d, obj.(*GlIsQueryEXT))
}
func (*binaryClassGlIsQueryEXT) Skip(d binary.Decoder) error { return doSkipGlIsQueryEXT(d) }
func (*binaryClassGlIsQueryEXT) Schema() *schema.Class { return schemaGlIsQueryEXT }
var schemaGlIsQueryEXT = &schema.Class{
TypeID: binaryIDGlIsQueryEXT,
Name: "GlIsQueryEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlIsRenderbuffer struct{}
func (*GlIsRenderbuffer) Class() binary.Class {
return (*binaryClassGlIsRenderbuffer)(nil)
}
func doEncodeGlIsRenderbuffer(e binary.Encoder, o *GlIsRenderbuffer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Renderbuffer)); err != nil {
return err
}
if err := e.Bool(o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlIsRenderbuffer(d binary.Decoder, o *GlIsRenderbuffer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Renderbuffer = RenderbufferId(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Result = bool(obj)
}
return nil
}
func doSkipGlIsRenderbuffer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlIsRenderbuffer) ID() binary.ID { return binaryIDGlIsRenderbuffer }
func (*binaryClassGlIsRenderbuffer) New() binary.Object { return &GlIsRenderbuffer{} }
func (*binaryClassGlIsRenderbuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlIsRenderbuffer(e, obj.(*GlIsRenderbuffer))
}
func (*binaryClassGlIsRenderbuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlIsRenderbuffer{}
return obj, doDecodeGlIsRenderbuffer(d, obj)
}
func (*binaryClassGlIsRenderbuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlIsRenderbuffer(d, obj.(*GlIsRenderbuffer))
}
func (*binaryClassGlIsRenderbuffer) Skip(d binary.Decoder) error { return doSkipGlIsRenderbuffer(d) }
func (*binaryClassGlIsRenderbuffer) Schema() *schema.Class { return schemaGlIsRenderbuffer }
var schemaGlIsRenderbuffer = &schema.Class{
TypeID: binaryIDGlIsRenderbuffer,
Name: "GlIsRenderbuffer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Renderbuffer", Type: &schema.Primitive{Name: "RenderbufferId", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlIsShader struct{}
func (*GlIsShader) Class() binary.Class {
return (*binaryClassGlIsShader)(nil)
}
func doEncodeGlIsShader(e binary.Encoder, o *GlIsShader) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Shader)); err != nil {
return err
}
if err := e.Bool(o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlIsShader(d binary.Decoder, o *GlIsShader) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Shader = ShaderId(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Result = bool(obj)
}
return nil
}
func doSkipGlIsShader(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlIsShader) ID() binary.ID { return binaryIDGlIsShader }
func (*binaryClassGlIsShader) New() binary.Object { return &GlIsShader{} }
func (*binaryClassGlIsShader) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlIsShader(e, obj.(*GlIsShader))
}
func (*binaryClassGlIsShader) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlIsShader{}
return obj, doDecodeGlIsShader(d, obj)
}
func (*binaryClassGlIsShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlIsShader(d, obj.(*GlIsShader))
}
func (*binaryClassGlIsShader) Skip(d binary.Decoder) error { return doSkipGlIsShader(d) }
func (*binaryClassGlIsShader) Schema() *schema.Class { return schemaGlIsShader }
var schemaGlIsShader = &schema.Class{
TypeID: binaryIDGlIsShader,
Name: "GlIsShader",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlIsTexture struct{}
func (*GlIsTexture) Class() binary.Class {
return (*binaryClassGlIsTexture)(nil)
}
func doEncodeGlIsTexture(e binary.Encoder, o *GlIsTexture) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Texture)); err != nil {
return err
}
if err := e.Bool(o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlIsTexture(d binary.Decoder, o *GlIsTexture) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Texture = TextureId(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Result = bool(obj)
}
return nil
}
func doSkipGlIsTexture(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlIsTexture) ID() binary.ID { return binaryIDGlIsTexture }
func (*binaryClassGlIsTexture) New() binary.Object { return &GlIsTexture{} }
func (*binaryClassGlIsTexture) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlIsTexture(e, obj.(*GlIsTexture))
}
func (*binaryClassGlIsTexture) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlIsTexture{}
return obj, doDecodeGlIsTexture(d, obj)
}
func (*binaryClassGlIsTexture) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlIsTexture(d, obj.(*GlIsTexture))
}
func (*binaryClassGlIsTexture) Skip(d binary.Decoder) error { return doSkipGlIsTexture(d) }
func (*binaryClassGlIsTexture) Schema() *schema.Class { return schemaGlIsTexture }
var schemaGlIsTexture = &schema.Class{
TypeID: binaryIDGlIsTexture,
Name: "GlIsTexture",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlIsVertexArrayOES struct{}
func (*GlIsVertexArrayOES) Class() binary.Class {
return (*binaryClassGlIsVertexArrayOES)(nil)
}
func doEncodeGlIsVertexArrayOES(e binary.Encoder, o *GlIsVertexArrayOES) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Array)); err != nil {
return err
}
if err := e.Bool(o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlIsVertexArrayOES(d binary.Decoder, o *GlIsVertexArrayOES) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Array = VertexArrayId(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Result = bool(obj)
}
return nil
}
func doSkipGlIsVertexArrayOES(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlIsVertexArrayOES) ID() binary.ID { return binaryIDGlIsVertexArrayOES }
func (*binaryClassGlIsVertexArrayOES) New() binary.Object { return &GlIsVertexArrayOES{} }
func (*binaryClassGlIsVertexArrayOES) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlIsVertexArrayOES(e, obj.(*GlIsVertexArrayOES))
}
func (*binaryClassGlIsVertexArrayOES) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlIsVertexArrayOES{}
return obj, doDecodeGlIsVertexArrayOES(d, obj)
}
func (*binaryClassGlIsVertexArrayOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlIsVertexArrayOES(d, obj.(*GlIsVertexArrayOES))
}
func (*binaryClassGlIsVertexArrayOES) Skip(d binary.Decoder) error { return doSkipGlIsVertexArrayOES(d) }
func (*binaryClassGlIsVertexArrayOES) Schema() *schema.Class { return schemaGlIsVertexArrayOES }
var schemaGlIsVertexArrayOES = &schema.Class{
TypeID: binaryIDGlIsVertexArrayOES,
Name: "GlIsVertexArrayOES",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Array", Type: &schema.Primitive{Name: "VertexArrayId", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlLineWidth struct{}
func (*GlLineWidth) Class() binary.Class {
return (*binaryClassGlLineWidth)(nil)
}
func doEncodeGlLineWidth(e binary.Encoder, o *GlLineWidth) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Float32(o.Width); err != nil {
return err
}
return nil
}
func doDecodeGlLineWidth(d binary.Decoder, o *GlLineWidth) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Width = float32(obj)
}
return nil
}
func doSkipGlLineWidth(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlLineWidth) ID() binary.ID { return binaryIDGlLineWidth }
func (*binaryClassGlLineWidth) New() binary.Object { return &GlLineWidth{} }
func (*binaryClassGlLineWidth) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlLineWidth(e, obj.(*GlLineWidth))
}
func (*binaryClassGlLineWidth) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlLineWidth{}
return obj, doDecodeGlLineWidth(d, obj)
}
func (*binaryClassGlLineWidth) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlLineWidth(d, obj.(*GlLineWidth))
}
func (*binaryClassGlLineWidth) Skip(d binary.Decoder) error { return doSkipGlLineWidth(d) }
func (*binaryClassGlLineWidth) Schema() *schema.Class { return schemaGlLineWidth }
var schemaGlLineWidth = &schema.Class{
TypeID: binaryIDGlLineWidth,
Name: "GlLineWidth",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlLinkProgram struct{}
func (*GlLinkProgram) Class() binary.Class {
return (*binaryClassGlLinkProgram)(nil)
}
func doEncodeGlLinkProgram(e binary.Encoder, o *GlLinkProgram) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
return nil
}
func doDecodeGlLinkProgram(d binary.Decoder, o *GlLinkProgram) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
return nil
}
func doSkipGlLinkProgram(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlLinkProgram) ID() binary.ID { return binaryIDGlLinkProgram }
func (*binaryClassGlLinkProgram) New() binary.Object { return &GlLinkProgram{} }
func (*binaryClassGlLinkProgram) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlLinkProgram(e, obj.(*GlLinkProgram))
}
func (*binaryClassGlLinkProgram) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlLinkProgram{}
return obj, doDecodeGlLinkProgram(d, obj)
}
func (*binaryClassGlLinkProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlLinkProgram(d, obj.(*GlLinkProgram))
}
func (*binaryClassGlLinkProgram) Skip(d binary.Decoder) error { return doSkipGlLinkProgram(d) }
func (*binaryClassGlLinkProgram) Schema() *schema.Class { return schemaGlLinkProgram }
var schemaGlLinkProgram = &schema.Class{
TypeID: binaryIDGlLinkProgram,
Name: "GlLinkProgram",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
},
}
type binaryClassGlMapBufferRange struct{}
func (*GlMapBufferRange) Class() binary.Class {
return (*binaryClassGlMapBufferRange)(nil)
}
func doEncodeGlMapBufferRange(e binary.Encoder, o *GlMapBufferRange) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Offset); err != nil {
return err
}
if err := e.Int32(o.Length); err != nil {
return err
}
if err := e.Uint32(uint32(o.Access)); err != nil {
return err
}
if err := e.Value(&o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlMapBufferRange(d binary.Decoder, o *GlMapBufferRange) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = BufferTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Offset = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Length = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Access = MapBufferRangeAccess(obj)
}
if err := d.Value(&o.Result); err != nil {
return err
}
return nil
}
func doSkipGlMapBufferRange(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlMapBufferRange) ID() binary.ID { return binaryIDGlMapBufferRange }
func (*binaryClassGlMapBufferRange) New() binary.Object { return &GlMapBufferRange{} }
func (*binaryClassGlMapBufferRange) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlMapBufferRange(e, obj.(*GlMapBufferRange))
}
func (*binaryClassGlMapBufferRange) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlMapBufferRange{}
return obj, doDecodeGlMapBufferRange(d, obj)
}
func (*binaryClassGlMapBufferRange) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlMapBufferRange(d, obj.(*GlMapBufferRange))
}
func (*binaryClassGlMapBufferRange) Skip(d binary.Decoder) error { return doSkipGlMapBufferRange(d) }
func (*binaryClassGlMapBufferRange) Schema() *schema.Class { return schemaGlMapBufferRange }
var schemaGlMapBufferRange = &schema.Class{
TypeID: binaryIDGlMapBufferRange,
Name: "GlMapBufferRange",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "BufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Offset", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Length", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Access", Type: &schema.Primitive{Name: "MapBufferRangeAccess", Method: schema.Uint32}},
schema.Field{Declared: "Result", Type: &schema.Struct{Name: "Voidᵖ"}},
},
}
type binaryClassGlPixelStorei struct{}
func (*GlPixelStorei) Class() binary.Class {
return (*binaryClassGlPixelStorei)(nil)
}
func doEncodeGlPixelStorei(e binary.Encoder, o *GlPixelStorei) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Int32(o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlPixelStorei(d binary.Decoder, o *GlPixelStorei) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = PixelStoreParameter(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Value = int32(obj)
}
return nil
}
func doSkipGlPixelStorei(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlPixelStorei) ID() binary.ID { return binaryIDGlPixelStorei }
func (*binaryClassGlPixelStorei) New() binary.Object { return &GlPixelStorei{} }
func (*binaryClassGlPixelStorei) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlPixelStorei(e, obj.(*GlPixelStorei))
}
func (*binaryClassGlPixelStorei) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlPixelStorei{}
return obj, doDecodeGlPixelStorei(d, obj)
}
func (*binaryClassGlPixelStorei) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlPixelStorei(d, obj.(*GlPixelStorei))
}
func (*binaryClassGlPixelStorei) Skip(d binary.Decoder) error { return doSkipGlPixelStorei(d) }
func (*binaryClassGlPixelStorei) Schema() *schema.Class { return schemaGlPixelStorei }
var schemaGlPixelStorei = &schema.Class{
TypeID: binaryIDGlPixelStorei,
Name: "GlPixelStorei",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "PixelStoreParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlPolygonOffset struct{}
func (*GlPolygonOffset) Class() binary.Class {
return (*binaryClassGlPolygonOffset)(nil)
}
func doEncodeGlPolygonOffset(e binary.Encoder, o *GlPolygonOffset) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Float32(o.ScaleFactor); err != nil {
return err
}
if err := e.Float32(o.Units); err != nil {
return err
}
return nil
}
func doDecodeGlPolygonOffset(d binary.Decoder, o *GlPolygonOffset) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.ScaleFactor = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Units = float32(obj)
}
return nil
}
func doSkipGlPolygonOffset(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlPolygonOffset) ID() binary.ID { return binaryIDGlPolygonOffset }
func (*binaryClassGlPolygonOffset) New() binary.Object { return &GlPolygonOffset{} }
func (*binaryClassGlPolygonOffset) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlPolygonOffset(e, obj.(*GlPolygonOffset))
}
func (*binaryClassGlPolygonOffset) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlPolygonOffset{}
return obj, doDecodeGlPolygonOffset(d, obj)
}
func (*binaryClassGlPolygonOffset) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlPolygonOffset(d, obj.(*GlPolygonOffset))
}
func (*binaryClassGlPolygonOffset) Skip(d binary.Decoder) error { return doSkipGlPolygonOffset(d) }
func (*binaryClassGlPolygonOffset) Schema() *schema.Class { return schemaGlPolygonOffset }
var schemaGlPolygonOffset = &schema.Class{
TypeID: binaryIDGlPolygonOffset,
Name: "GlPolygonOffset",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "ScaleFactor", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Units", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlPopGroupMarkerEXT struct{}
func (*GlPopGroupMarkerEXT) Class() binary.Class {
return (*binaryClassGlPopGroupMarkerEXT)(nil)
}
func doEncodeGlPopGroupMarkerEXT(e binary.Encoder, o *GlPopGroupMarkerEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
return nil
}
func doDecodeGlPopGroupMarkerEXT(d binary.Decoder, o *GlPopGroupMarkerEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
return nil
}
func doSkipGlPopGroupMarkerEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlPopGroupMarkerEXT) ID() binary.ID { return binaryIDGlPopGroupMarkerEXT }
func (*binaryClassGlPopGroupMarkerEXT) New() binary.Object { return &GlPopGroupMarkerEXT{} }
func (*binaryClassGlPopGroupMarkerEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlPopGroupMarkerEXT(e, obj.(*GlPopGroupMarkerEXT))
}
func (*binaryClassGlPopGroupMarkerEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlPopGroupMarkerEXT{}
return obj, doDecodeGlPopGroupMarkerEXT(d, obj)
}
func (*binaryClassGlPopGroupMarkerEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlPopGroupMarkerEXT(d, obj.(*GlPopGroupMarkerEXT))
}
func (*binaryClassGlPopGroupMarkerEXT) Skip(d binary.Decoder) error {
return doSkipGlPopGroupMarkerEXT(d)
}
func (*binaryClassGlPopGroupMarkerEXT) Schema() *schema.Class { return schemaGlPopGroupMarkerEXT }
var schemaGlPopGroupMarkerEXT = &schema.Class{
TypeID: binaryIDGlPopGroupMarkerEXT,
Name: "GlPopGroupMarkerEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
},
}
type binaryClassGlProgramBinaryOES struct{}
func (*GlProgramBinaryOES) Class() binary.Class {
return (*binaryClassGlProgramBinaryOES)(nil)
}
func doEncodeGlProgramBinaryOES(e binary.Encoder, o *GlProgramBinaryOES) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
if err := e.Uint32(o.BinaryFormat); err != nil {
return err
}
if err := e.Value(&o.Binary); err != nil {
return err
}
if err := e.Int32(o.BinarySize); err != nil {
return err
}
return nil
}
func doDecodeGlProgramBinaryOES(d binary.Decoder, o *GlProgramBinaryOES) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.BinaryFormat = uint32(obj)
}
if err := d.Value(&o.Binary); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.BinarySize = int32(obj)
}
return nil
}
func doSkipGlProgramBinaryOES(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlProgramBinaryOES) ID() binary.ID { return binaryIDGlProgramBinaryOES }
func (*binaryClassGlProgramBinaryOES) New() binary.Object { return &GlProgramBinaryOES{} }
func (*binaryClassGlProgramBinaryOES) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlProgramBinaryOES(e, obj.(*GlProgramBinaryOES))
}
func (*binaryClassGlProgramBinaryOES) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlProgramBinaryOES{}
return obj, doDecodeGlProgramBinaryOES(d, obj)
}
func (*binaryClassGlProgramBinaryOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlProgramBinaryOES(d, obj.(*GlProgramBinaryOES))
}
func (*binaryClassGlProgramBinaryOES) Skip(d binary.Decoder) error { return doSkipGlProgramBinaryOES(d) }
func (*binaryClassGlProgramBinaryOES) Schema() *schema.Class { return schemaGlProgramBinaryOES }
var schemaGlProgramBinaryOES = &schema.Class{
TypeID: binaryIDGlProgramBinaryOES,
Name: "GlProgramBinaryOES",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
schema.Field{Declared: "BinaryFormat", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
schema.Field{Declared: "Binary", Type: &schema.Struct{Name: "Voidᵖ"}},
schema.Field{Declared: "BinarySize", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlPushGroupMarkerEXT struct{}
func (*GlPushGroupMarkerEXT) Class() binary.Class {
return (*binaryClassGlPushGroupMarkerEXT)(nil)
}
func doEncodeGlPushGroupMarkerEXT(e binary.Encoder, o *GlPushGroupMarkerEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Length); err != nil {
return err
}
if err := e.String(o.Marker); err != nil {
return err
}
return nil
}
func doDecodeGlPushGroupMarkerEXT(d binary.Decoder, o *GlPushGroupMarkerEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Length = int32(obj)
}
if obj, err := d.String(); err != nil {
return err
} else {
o.Marker = string(obj)
}
return nil
}
func doSkipGlPushGroupMarkerEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipString(); err != nil {
return err
}
return nil
}
func (*binaryClassGlPushGroupMarkerEXT) ID() binary.ID { return binaryIDGlPushGroupMarkerEXT }
func (*binaryClassGlPushGroupMarkerEXT) New() binary.Object { return &GlPushGroupMarkerEXT{} }
func (*binaryClassGlPushGroupMarkerEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlPushGroupMarkerEXT(e, obj.(*GlPushGroupMarkerEXT))
}
func (*binaryClassGlPushGroupMarkerEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlPushGroupMarkerEXT{}
return obj, doDecodeGlPushGroupMarkerEXT(d, obj)
}
func (*binaryClassGlPushGroupMarkerEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlPushGroupMarkerEXT(d, obj.(*GlPushGroupMarkerEXT))
}
func (*binaryClassGlPushGroupMarkerEXT) Skip(d binary.Decoder) error {
return doSkipGlPushGroupMarkerEXT(d)
}
func (*binaryClassGlPushGroupMarkerEXT) Schema() *schema.Class { return schemaGlPushGroupMarkerEXT }
var schemaGlPushGroupMarkerEXT = &schema.Class{
TypeID: binaryIDGlPushGroupMarkerEXT,
Name: "GlPushGroupMarkerEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Length", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Marker", Type: &schema.Primitive{Name: "string", Method: schema.String}},
},
}
type binaryClassGlQueryCounterEXT struct{}
func (*GlQueryCounterEXT) Class() binary.Class {
return (*binaryClassGlQueryCounterEXT)(nil)
}
func doEncodeGlQueryCounterEXT(e binary.Encoder, o *GlQueryCounterEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Query)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
return nil
}
func doDecodeGlQueryCounterEXT(d binary.Decoder, o *GlQueryCounterEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Query = QueryId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = QueryTarget(obj)
}
return nil
}
func doSkipGlQueryCounterEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlQueryCounterEXT) ID() binary.ID { return binaryIDGlQueryCounterEXT }
func (*binaryClassGlQueryCounterEXT) New() binary.Object { return &GlQueryCounterEXT{} }
func (*binaryClassGlQueryCounterEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlQueryCounterEXT(e, obj.(*GlQueryCounterEXT))
}
func (*binaryClassGlQueryCounterEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlQueryCounterEXT{}
return obj, doDecodeGlQueryCounterEXT(d, obj)
}
func (*binaryClassGlQueryCounterEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlQueryCounterEXT(d, obj.(*GlQueryCounterEXT))
}
func (*binaryClassGlQueryCounterEXT) Skip(d binary.Decoder) error { return doSkipGlQueryCounterEXT(d) }
func (*binaryClassGlQueryCounterEXT) Schema() *schema.Class { return schemaGlQueryCounterEXT }
var schemaGlQueryCounterEXT = &schema.Class{
TypeID: binaryIDGlQueryCounterEXT,
Name: "GlQueryCounterEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "QueryTarget", Method: schema.Uint32}},
},
}
type binaryClassGlReadPixels struct{}
func (*GlReadPixels) Class() binary.Class {
return (*binaryClassGlReadPixels)(nil)
}
func doEncodeGlReadPixels(e binary.Encoder, o *GlReadPixels) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.X); err != nil {
return err
}
if err := e.Int32(o.Y); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Type)); err != nil {
return err
}
if err := e.Value(&o.Data); err != nil {
return err
}
return nil
}
func doDecodeGlReadPixels(d binary.Decoder, o *GlReadPixels) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.X = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Y = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = BaseTexelFormat(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = TexelType(obj)
}
if err := d.Value(&o.Data); err != nil {
return err
}
return nil
}
func doSkipGlReadPixels(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlReadPixels) ID() binary.ID { return binaryIDGlReadPixels }
func (*binaryClassGlReadPixels) New() binary.Object { return &GlReadPixels{} }
func (*binaryClassGlReadPixels) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlReadPixels(e, obj.(*GlReadPixels))
}
func (*binaryClassGlReadPixels) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlReadPixels{}
return obj, doDecodeGlReadPixels(d, obj)
}
func (*binaryClassGlReadPixels) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlReadPixels(d, obj.(*GlReadPixels))
}
func (*binaryClassGlReadPixels) Skip(d binary.Decoder) error { return doSkipGlReadPixels(d) }
func (*binaryClassGlReadPixels) Schema() *schema.Class { return schemaGlReadPixels }
var schemaGlReadPixels = &schema.Class{
TypeID: binaryIDGlReadPixels,
Name: "GlReadPixels",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "BaseTexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "TexelType", Method: schema.Uint32}},
schema.Field{Declared: "Data", Type: &schema.Struct{Name: "Voidᵖ"}},
},
}
type binaryClassGlReleaseShaderCompiler struct{}
func (*GlReleaseShaderCompiler) Class() binary.Class {
return (*binaryClassGlReleaseShaderCompiler)(nil)
}
func doEncodeGlReleaseShaderCompiler(e binary.Encoder, o *GlReleaseShaderCompiler) error {
if err := e.Value(&o.observations); err != nil {
return err
}
return nil
}
func doDecodeGlReleaseShaderCompiler(d binary.Decoder, o *GlReleaseShaderCompiler) error {
if err := d.Value(&o.observations); err != nil {
return err
}
return nil
}
func doSkipGlReleaseShaderCompiler(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlReleaseShaderCompiler) ID() binary.ID { return binaryIDGlReleaseShaderCompiler }
func (*binaryClassGlReleaseShaderCompiler) New() binary.Object { return &GlReleaseShaderCompiler{} }
func (*binaryClassGlReleaseShaderCompiler) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlReleaseShaderCompiler(e, obj.(*GlReleaseShaderCompiler))
}
func (*binaryClassGlReleaseShaderCompiler) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlReleaseShaderCompiler{}
return obj, doDecodeGlReleaseShaderCompiler(d, obj)
}
func (*binaryClassGlReleaseShaderCompiler) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlReleaseShaderCompiler(d, obj.(*GlReleaseShaderCompiler))
}
func (*binaryClassGlReleaseShaderCompiler) Skip(d binary.Decoder) error {
return doSkipGlReleaseShaderCompiler(d)
}
func (*binaryClassGlReleaseShaderCompiler) Schema() *schema.Class {
return schemaGlReleaseShaderCompiler
}
var schemaGlReleaseShaderCompiler = &schema.Class{
TypeID: binaryIDGlReleaseShaderCompiler,
Name: "GlReleaseShaderCompiler",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
},
}
type binaryClassGlRenderbufferStorage struct{}
func (*GlRenderbufferStorage) Class() binary.Class {
return (*binaryClassGlRenderbufferStorage)(nil)
}
func doEncodeGlRenderbufferStorage(e binary.Encoder, o *GlRenderbufferStorage) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
return nil
}
func doDecodeGlRenderbufferStorage(d binary.Decoder, o *GlRenderbufferStorage) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = RenderbufferTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = RenderbufferFormat(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
return nil
}
func doSkipGlRenderbufferStorage(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlRenderbufferStorage) ID() binary.ID { return binaryIDGlRenderbufferStorage }
func (*binaryClassGlRenderbufferStorage) New() binary.Object { return &GlRenderbufferStorage{} }
func (*binaryClassGlRenderbufferStorage) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlRenderbufferStorage(e, obj.(*GlRenderbufferStorage))
}
func (*binaryClassGlRenderbufferStorage) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlRenderbufferStorage{}
return obj, doDecodeGlRenderbufferStorage(d, obj)
}
func (*binaryClassGlRenderbufferStorage) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlRenderbufferStorage(d, obj.(*GlRenderbufferStorage))
}
func (*binaryClassGlRenderbufferStorage) Skip(d binary.Decoder) error {
return doSkipGlRenderbufferStorage(d)
}
func (*binaryClassGlRenderbufferStorage) Schema() *schema.Class { return schemaGlRenderbufferStorage }
var schemaGlRenderbufferStorage = &schema.Class{
TypeID: binaryIDGlRenderbufferStorage,
Name: "GlRenderbufferStorage",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "RenderbufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "RenderbufferFormat", Method: schema.Uint32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlRenderbufferStorageMultisample struct{}
func (*GlRenderbufferStorageMultisample) Class() binary.Class {
return (*binaryClassGlRenderbufferStorageMultisample)(nil)
}
func doEncodeGlRenderbufferStorageMultisample(e binary.Encoder, o *GlRenderbufferStorageMultisample) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Samples); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
return nil
}
func doDecodeGlRenderbufferStorageMultisample(d binary.Decoder, o *GlRenderbufferStorageMultisample) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = RenderbufferTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Samples = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = RenderbufferFormat(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
return nil
}
func doSkipGlRenderbufferStorageMultisample(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlRenderbufferStorageMultisample) ID() binary.ID {
return binaryIDGlRenderbufferStorageMultisample
}
func (*binaryClassGlRenderbufferStorageMultisample) New() binary.Object {
return &GlRenderbufferStorageMultisample{}
}
func (*binaryClassGlRenderbufferStorageMultisample) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlRenderbufferStorageMultisample(e, obj.(*GlRenderbufferStorageMultisample))
}
func (*binaryClassGlRenderbufferStorageMultisample) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlRenderbufferStorageMultisample{}
return obj, doDecodeGlRenderbufferStorageMultisample(d, obj)
}
func (*binaryClassGlRenderbufferStorageMultisample) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlRenderbufferStorageMultisample(d, obj.(*GlRenderbufferStorageMultisample))
}
func (*binaryClassGlRenderbufferStorageMultisample) Skip(d binary.Decoder) error {
return doSkipGlRenderbufferStorageMultisample(d)
}
func (*binaryClassGlRenderbufferStorageMultisample) Schema() *schema.Class {
return schemaGlRenderbufferStorageMultisample
}
var schemaGlRenderbufferStorageMultisample = &schema.Class{
TypeID: binaryIDGlRenderbufferStorageMultisample,
Name: "GlRenderbufferStorageMultisample",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "RenderbufferTarget", Method: schema.Uint32}},
schema.Field{Declared: "Samples", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "RenderbufferFormat", Method: schema.Uint32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlSampleCoverage struct{}
func (*GlSampleCoverage) Class() binary.Class {
return (*binaryClassGlSampleCoverage)(nil)
}
func doEncodeGlSampleCoverage(e binary.Encoder, o *GlSampleCoverage) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Float32(o.Value); err != nil {
return err
}
if err := e.Bool(o.Invert); err != nil {
return err
}
return nil
}
func doDecodeGlSampleCoverage(d binary.Decoder, o *GlSampleCoverage) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value = float32(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Invert = bool(obj)
}
return nil
}
func doSkipGlSampleCoverage(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
return nil
}
func (*binaryClassGlSampleCoverage) ID() binary.ID { return binaryIDGlSampleCoverage }
func (*binaryClassGlSampleCoverage) New() binary.Object { return &GlSampleCoverage{} }
func (*binaryClassGlSampleCoverage) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlSampleCoverage(e, obj.(*GlSampleCoverage))
}
func (*binaryClassGlSampleCoverage) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlSampleCoverage{}
return obj, doDecodeGlSampleCoverage(d, obj)
}
func (*binaryClassGlSampleCoverage) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlSampleCoverage(d, obj.(*GlSampleCoverage))
}
func (*binaryClassGlSampleCoverage) Skip(d binary.Decoder) error { return doSkipGlSampleCoverage(d) }
func (*binaryClassGlSampleCoverage) Schema() *schema.Class { return schemaGlSampleCoverage }
var schemaGlSampleCoverage = &schema.Class{
TypeID: binaryIDGlSampleCoverage,
Name: "GlSampleCoverage",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Value", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Invert", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
},
}
type binaryClassGlScissor struct{}
func (*GlScissor) Class() binary.Class {
return (*binaryClassGlScissor)(nil)
}
func doEncodeGlScissor(e binary.Encoder, o *GlScissor) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.X); err != nil {
return err
}
if err := e.Int32(o.Y); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
return nil
}
func doDecodeGlScissor(d binary.Decoder, o *GlScissor) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.X = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Y = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
return nil
}
func doSkipGlScissor(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlScissor) ID() binary.ID { return binaryIDGlScissor }
func (*binaryClassGlScissor) New() binary.Object { return &GlScissor{} }
func (*binaryClassGlScissor) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlScissor(e, obj.(*GlScissor))
}
func (*binaryClassGlScissor) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlScissor{}
return obj, doDecodeGlScissor(d, obj)
}
func (*binaryClassGlScissor) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlScissor(d, obj.(*GlScissor))
}
func (*binaryClassGlScissor) Skip(d binary.Decoder) error { return doSkipGlScissor(d) }
func (*binaryClassGlScissor) Schema() *schema.Class { return schemaGlScissor }
var schemaGlScissor = &schema.Class{
TypeID: binaryIDGlScissor,
Name: "GlScissor",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlShaderBinary struct{}
func (*GlShaderBinary) Class() binary.Class {
return (*binaryClassGlShaderBinary)(nil)
}
func doEncodeGlShaderBinary(e binary.Encoder, o *GlShaderBinary) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Shaders); err != nil {
return err
}
if err := e.Uint32(o.BinaryFormat); err != nil {
return err
}
if err := e.Value(&o.Binary); err != nil {
return err
}
if err := e.Int32(o.BinarySize); err != nil {
return err
}
return nil
}
func doDecodeGlShaderBinary(d binary.Decoder, o *GlShaderBinary) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Shaders); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.BinaryFormat = uint32(obj)
}
if err := d.Value(&o.Binary); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.BinarySize = int32(obj)
}
return nil
}
func doSkipGlShaderBinary(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*ShaderIdᵖ)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlShaderBinary) ID() binary.ID { return binaryIDGlShaderBinary }
func (*binaryClassGlShaderBinary) New() binary.Object { return &GlShaderBinary{} }
func (*binaryClassGlShaderBinary) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlShaderBinary(e, obj.(*GlShaderBinary))
}
func (*binaryClassGlShaderBinary) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlShaderBinary{}
return obj, doDecodeGlShaderBinary(d, obj)
}
func (*binaryClassGlShaderBinary) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlShaderBinary(d, obj.(*GlShaderBinary))
}
func (*binaryClassGlShaderBinary) Skip(d binary.Decoder) error { return doSkipGlShaderBinary(d) }
func (*binaryClassGlShaderBinary) Schema() *schema.Class { return schemaGlShaderBinary }
var schemaGlShaderBinary = &schema.Class{
TypeID: binaryIDGlShaderBinary,
Name: "GlShaderBinary",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Shaders", Type: &schema.Struct{Name: "ShaderIdᵖ"}},
schema.Field{Declared: "BinaryFormat", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
schema.Field{Declared: "Binary", Type: &schema.Struct{Name: "Voidᵖ"}},
schema.Field{Declared: "BinarySize", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlShaderSource struct{}
func (*GlShaderSource) Class() binary.Class {
return (*binaryClassGlShaderSource)(nil)
}
func doEncodeGlShaderSource(e binary.Encoder, o *GlShaderSource) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Shader)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Source); err != nil {
return err
}
if err := e.Value(&o.Length); err != nil {
return err
}
return nil
}
func doDecodeGlShaderSource(d binary.Decoder, o *GlShaderSource) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Shader = ShaderId(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Source); err != nil {
return err
}
if err := d.Value(&o.Length); err != nil {
return err
}
return nil
}
func doSkipGlShaderSource(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*Charᵖᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlShaderSource) ID() binary.ID { return binaryIDGlShaderSource }
func (*binaryClassGlShaderSource) New() binary.Object { return &GlShaderSource{} }
func (*binaryClassGlShaderSource) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlShaderSource(e, obj.(*GlShaderSource))
}
func (*binaryClassGlShaderSource) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlShaderSource{}
return obj, doDecodeGlShaderSource(d, obj)
}
func (*binaryClassGlShaderSource) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlShaderSource(d, obj.(*GlShaderSource))
}
func (*binaryClassGlShaderSource) Skip(d binary.Decoder) error { return doSkipGlShaderSource(d) }
func (*binaryClassGlShaderSource) Schema() *schema.Class { return schemaGlShaderSource }
var schemaGlShaderSource = &schema.Class{
TypeID: binaryIDGlShaderSource,
Name: "GlShaderSource",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Source", Type: &schema.Struct{Name: "Charᵖᵖ"}},
schema.Field{Declared: "Length", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlStartTilingQCOM struct{}
func (*GlStartTilingQCOM) Class() binary.Class {
return (*binaryClassGlStartTilingQCOM)(nil)
}
func doEncodeGlStartTilingQCOM(e binary.Encoder, o *GlStartTilingQCOM) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.X); err != nil {
return err
}
if err := e.Int32(o.Y); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
if err := e.Uint32(uint32(o.PreserveMask)); err != nil {
return err
}
return nil
}
func doDecodeGlStartTilingQCOM(d binary.Decoder, o *GlStartTilingQCOM) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.X = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Y = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.PreserveMask = TilePreserveMaskQCOM(obj)
}
return nil
}
func doSkipGlStartTilingQCOM(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlStartTilingQCOM) ID() binary.ID { return binaryIDGlStartTilingQCOM }
func (*binaryClassGlStartTilingQCOM) New() binary.Object { return &GlStartTilingQCOM{} }
func (*binaryClassGlStartTilingQCOM) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlStartTilingQCOM(e, obj.(*GlStartTilingQCOM))
}
func (*binaryClassGlStartTilingQCOM) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlStartTilingQCOM{}
return obj, doDecodeGlStartTilingQCOM(d, obj)
}
func (*binaryClassGlStartTilingQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlStartTilingQCOM(d, obj.(*GlStartTilingQCOM))
}
func (*binaryClassGlStartTilingQCOM) Skip(d binary.Decoder) error { return doSkipGlStartTilingQCOM(d) }
func (*binaryClassGlStartTilingQCOM) Schema() *schema.Class { return schemaGlStartTilingQCOM }
var schemaGlStartTilingQCOM = &schema.Class{
TypeID: binaryIDGlStartTilingQCOM,
Name: "GlStartTilingQCOM",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "PreserveMask", Type: &schema.Primitive{Name: "TilePreserveMaskQCOM", Method: schema.Uint32}},
},
}
type binaryClassGlStencilFuncSeparate struct{}
func (*GlStencilFuncSeparate) Class() binary.Class {
return (*binaryClassGlStencilFuncSeparate)(nil)
}
func doEncodeGlStencilFuncSeparate(e binary.Encoder, o *GlStencilFuncSeparate) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Face)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Function)); err != nil {
return err
}
if err := e.Int32(o.ReferenceValue); err != nil {
return err
}
if err := e.Int32(o.Mask); err != nil {
return err
}
return nil
}
func doDecodeGlStencilFuncSeparate(d binary.Decoder, o *GlStencilFuncSeparate) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Face = FaceMode(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Function = TestFunction(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.ReferenceValue = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Mask = int32(obj)
}
return nil
}
func doSkipGlStencilFuncSeparate(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlStencilFuncSeparate) ID() binary.ID { return binaryIDGlStencilFuncSeparate }
func (*binaryClassGlStencilFuncSeparate) New() binary.Object { return &GlStencilFuncSeparate{} }
func (*binaryClassGlStencilFuncSeparate) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlStencilFuncSeparate(e, obj.(*GlStencilFuncSeparate))
}
func (*binaryClassGlStencilFuncSeparate) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlStencilFuncSeparate{}
return obj, doDecodeGlStencilFuncSeparate(d, obj)
}
func (*binaryClassGlStencilFuncSeparate) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlStencilFuncSeparate(d, obj.(*GlStencilFuncSeparate))
}
func (*binaryClassGlStencilFuncSeparate) Skip(d binary.Decoder) error {
return doSkipGlStencilFuncSeparate(d)
}
func (*binaryClassGlStencilFuncSeparate) Schema() *schema.Class { return schemaGlStencilFuncSeparate }
var schemaGlStencilFuncSeparate = &schema.Class{
TypeID: binaryIDGlStencilFuncSeparate,
Name: "GlStencilFuncSeparate",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Face", Type: &schema.Primitive{Name: "FaceMode", Method: schema.Uint32}},
schema.Field{Declared: "Function", Type: &schema.Primitive{Name: "TestFunction", Method: schema.Uint32}},
schema.Field{Declared: "ReferenceValue", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Mask", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlStencilMask struct{}
func (*GlStencilMask) Class() binary.Class {
return (*binaryClassGlStencilMask)(nil)
}
func doEncodeGlStencilMask(e binary.Encoder, o *GlStencilMask) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(o.Mask); err != nil {
return err
}
return nil
}
func doDecodeGlStencilMask(d binary.Decoder, o *GlStencilMask) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Mask = uint32(obj)
}
return nil
}
func doSkipGlStencilMask(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlStencilMask) ID() binary.ID { return binaryIDGlStencilMask }
func (*binaryClassGlStencilMask) New() binary.Object { return &GlStencilMask{} }
func (*binaryClassGlStencilMask) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlStencilMask(e, obj.(*GlStencilMask))
}
func (*binaryClassGlStencilMask) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlStencilMask{}
return obj, doDecodeGlStencilMask(d, obj)
}
func (*binaryClassGlStencilMask) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlStencilMask(d, obj.(*GlStencilMask))
}
func (*binaryClassGlStencilMask) Skip(d binary.Decoder) error { return doSkipGlStencilMask(d) }
func (*binaryClassGlStencilMask) Schema() *schema.Class { return schemaGlStencilMask }
var schemaGlStencilMask = &schema.Class{
TypeID: binaryIDGlStencilMask,
Name: "GlStencilMask",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Mask", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
},
}
type binaryClassGlStencilMaskSeparate struct{}
func (*GlStencilMaskSeparate) Class() binary.Class {
return (*binaryClassGlStencilMaskSeparate)(nil)
}
func doEncodeGlStencilMaskSeparate(e binary.Encoder, o *GlStencilMaskSeparate) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Face)); err != nil {
return err
}
if err := e.Uint32(o.Mask); err != nil {
return err
}
return nil
}
func doDecodeGlStencilMaskSeparate(d binary.Decoder, o *GlStencilMaskSeparate) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Face = FaceMode(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Mask = uint32(obj)
}
return nil
}
func doSkipGlStencilMaskSeparate(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlStencilMaskSeparate) ID() binary.ID { return binaryIDGlStencilMaskSeparate }
func (*binaryClassGlStencilMaskSeparate) New() binary.Object { return &GlStencilMaskSeparate{} }
func (*binaryClassGlStencilMaskSeparate) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlStencilMaskSeparate(e, obj.(*GlStencilMaskSeparate))
}
func (*binaryClassGlStencilMaskSeparate) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlStencilMaskSeparate{}
return obj, doDecodeGlStencilMaskSeparate(d, obj)
}
func (*binaryClassGlStencilMaskSeparate) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlStencilMaskSeparate(d, obj.(*GlStencilMaskSeparate))
}
func (*binaryClassGlStencilMaskSeparate) Skip(d binary.Decoder) error {
return doSkipGlStencilMaskSeparate(d)
}
func (*binaryClassGlStencilMaskSeparate) Schema() *schema.Class { return schemaGlStencilMaskSeparate }
var schemaGlStencilMaskSeparate = &schema.Class{
TypeID: binaryIDGlStencilMaskSeparate,
Name: "GlStencilMaskSeparate",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Face", Type: &schema.Primitive{Name: "FaceMode", Method: schema.Uint32}},
schema.Field{Declared: "Mask", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
},
}
type binaryClassGlStencilOpSeparate struct{}
func (*GlStencilOpSeparate) Class() binary.Class {
return (*binaryClassGlStencilOpSeparate)(nil)
}
func doEncodeGlStencilOpSeparate(e binary.Encoder, o *GlStencilOpSeparate) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Face)); err != nil {
return err
}
if err := e.Uint32(uint32(o.StencilFail)); err != nil {
return err
}
if err := e.Uint32(uint32(o.StencilPassDepthFail)); err != nil {
return err
}
if err := e.Uint32(uint32(o.StencilPassDepthPass)); err != nil {
return err
}
return nil
}
func doDecodeGlStencilOpSeparate(d binary.Decoder, o *GlStencilOpSeparate) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Face = FaceMode(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.StencilFail = StencilAction(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.StencilPassDepthFail = StencilAction(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.StencilPassDepthPass = StencilAction(obj)
}
return nil
}
func doSkipGlStencilOpSeparate(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlStencilOpSeparate) ID() binary.ID { return binaryIDGlStencilOpSeparate }
func (*binaryClassGlStencilOpSeparate) New() binary.Object { return &GlStencilOpSeparate{} }
func (*binaryClassGlStencilOpSeparate) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlStencilOpSeparate(e, obj.(*GlStencilOpSeparate))
}
func (*binaryClassGlStencilOpSeparate) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlStencilOpSeparate{}
return obj, doDecodeGlStencilOpSeparate(d, obj)
}
func (*binaryClassGlStencilOpSeparate) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlStencilOpSeparate(d, obj.(*GlStencilOpSeparate))
}
func (*binaryClassGlStencilOpSeparate) Skip(d binary.Decoder) error {
return doSkipGlStencilOpSeparate(d)
}
func (*binaryClassGlStencilOpSeparate) Schema() *schema.Class { return schemaGlStencilOpSeparate }
var schemaGlStencilOpSeparate = &schema.Class{
TypeID: binaryIDGlStencilOpSeparate,
Name: "GlStencilOpSeparate",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Face", Type: &schema.Primitive{Name: "FaceMode", Method: schema.Uint32}},
schema.Field{Declared: "StencilFail", Type: &schema.Primitive{Name: "StencilAction", Method: schema.Uint32}},
schema.Field{Declared: "StencilPassDepthFail", Type: &schema.Primitive{Name: "StencilAction", Method: schema.Uint32}},
schema.Field{Declared: "StencilPassDepthPass", Type: &schema.Primitive{Name: "StencilAction", Method: schema.Uint32}},
},
}
type binaryClassGlTexImage2D struct{}
func (*GlTexImage2D) Class() binary.Class {
return (*binaryClassGlTexImage2D)(nil)
}
func doEncodeGlTexImage2D(e binary.Encoder, o *GlTexImage2D) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Level); err != nil {
return err
}
if err := e.Uint32(uint32(o.InternalFormat)); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
if err := e.Int32(o.Border); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Type)); err != nil {
return err
}
if err := e.Value(&o.Data); err != nil {
return err
}
return nil
}
func doDecodeGlTexImage2D(d binary.Decoder, o *GlTexImage2D) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureImageTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Level = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.InternalFormat = TexelFormat(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Border = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = TexelFormat(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = TexelType(obj)
}
if err := d.Value(&o.Data); err != nil {
return err
}
return nil
}
func doSkipGlTexImage2D(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*TexturePointer)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlTexImage2D) ID() binary.ID { return binaryIDGlTexImage2D }
func (*binaryClassGlTexImage2D) New() binary.Object { return &GlTexImage2D{} }
func (*binaryClassGlTexImage2D) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlTexImage2D(e, obj.(*GlTexImage2D))
}
func (*binaryClassGlTexImage2D) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlTexImage2D{}
return obj, doDecodeGlTexImage2D(d, obj)
}
func (*binaryClassGlTexImage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlTexImage2D(d, obj.(*GlTexImage2D))
}
func (*binaryClassGlTexImage2D) Skip(d binary.Decoder) error { return doSkipGlTexImage2D(d) }
func (*binaryClassGlTexImage2D) Schema() *schema.Class { return schemaGlTexImage2D }
var schemaGlTexImage2D = &schema.Class{
TypeID: binaryIDGlTexImage2D,
Name: "GlTexImage2D",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureImageTarget", Method: schema.Uint32}},
schema.Field{Declared: "Level", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "InternalFormat", Type: &schema.Primitive{Name: "TexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Border", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "TexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "TexelType", Method: schema.Uint32}},
schema.Field{Declared: "Data", Type: &schema.Struct{Name: "TexturePointer"}},
},
}
type binaryClassGlTexParameterf struct{}
func (*GlTexParameterf) Class() binary.Class {
return (*binaryClassGlTexParameterf)(nil)
}
func doEncodeGlTexParameterf(e binary.Encoder, o *GlTexParameterf) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Float32(o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlTexParameterf(d binary.Decoder, o *GlTexParameterf) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = TextureParameter(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value = float32(obj)
}
return nil
}
func doSkipGlTexParameterf(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlTexParameterf) ID() binary.ID { return binaryIDGlTexParameterf }
func (*binaryClassGlTexParameterf) New() binary.Object { return &GlTexParameterf{} }
func (*binaryClassGlTexParameterf) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlTexParameterf(e, obj.(*GlTexParameterf))
}
func (*binaryClassGlTexParameterf) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlTexParameterf{}
return obj, doDecodeGlTexParameterf(d, obj)
}
func (*binaryClassGlTexParameterf) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlTexParameterf(d, obj.(*GlTexParameterf))
}
func (*binaryClassGlTexParameterf) Skip(d binary.Decoder) error { return doSkipGlTexParameterf(d) }
func (*binaryClassGlTexParameterf) Schema() *schema.Class { return schemaGlTexParameterf }
var schemaGlTexParameterf = &schema.Class{
TypeID: binaryIDGlTexParameterf,
Name: "GlTexParameterf",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureTarget", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "TextureParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlTexParameteri struct{}
func (*GlTexParameteri) Class() binary.Class {
return (*binaryClassGlTexParameteri)(nil)
}
func doEncodeGlTexParameteri(e binary.Encoder, o *GlTexParameteri) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Parameter)); err != nil {
return err
}
if err := e.Int32(o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlTexParameteri(d binary.Decoder, o *GlTexParameteri) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureTarget(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Parameter = TextureParameter(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Value = int32(obj)
}
return nil
}
func doSkipGlTexParameteri(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlTexParameteri) ID() binary.ID { return binaryIDGlTexParameteri }
func (*binaryClassGlTexParameteri) New() binary.Object { return &GlTexParameteri{} }
func (*binaryClassGlTexParameteri) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlTexParameteri(e, obj.(*GlTexParameteri))
}
func (*binaryClassGlTexParameteri) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlTexParameteri{}
return obj, doDecodeGlTexParameteri(d, obj)
}
func (*binaryClassGlTexParameteri) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlTexParameteri(d, obj.(*GlTexParameteri))
}
func (*binaryClassGlTexParameteri) Skip(d binary.Decoder) error { return doSkipGlTexParameteri(d) }
func (*binaryClassGlTexParameteri) Schema() *schema.Class { return schemaGlTexParameteri }
var schemaGlTexParameteri = &schema.Class{
TypeID: binaryIDGlTexParameteri,
Name: "GlTexParameteri",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureTarget", Method: schema.Uint32}},
schema.Field{Declared: "Parameter", Type: &schema.Primitive{Name: "TextureParameter", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlTexStorage1DEXT struct{}
func (*GlTexStorage1DEXT) Class() binary.Class {
return (*binaryClassGlTexStorage1DEXT)(nil)
}
func doEncodeGlTexStorage1DEXT(e binary.Encoder, o *GlTexStorage1DEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Levels); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
return nil
}
func doDecodeGlTexStorage1DEXT(d binary.Decoder, o *GlTexStorage1DEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Levels = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = TexelFormat(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
return nil
}
func doSkipGlTexStorage1DEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlTexStorage1DEXT) ID() binary.ID { return binaryIDGlTexStorage1DEXT }
func (*binaryClassGlTexStorage1DEXT) New() binary.Object { return &GlTexStorage1DEXT{} }
func (*binaryClassGlTexStorage1DEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlTexStorage1DEXT(e, obj.(*GlTexStorage1DEXT))
}
func (*binaryClassGlTexStorage1DEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlTexStorage1DEXT{}
return obj, doDecodeGlTexStorage1DEXT(d, obj)
}
func (*binaryClassGlTexStorage1DEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlTexStorage1DEXT(d, obj.(*GlTexStorage1DEXT))
}
func (*binaryClassGlTexStorage1DEXT) Skip(d binary.Decoder) error { return doSkipGlTexStorage1DEXT(d) }
func (*binaryClassGlTexStorage1DEXT) Schema() *schema.Class { return schemaGlTexStorage1DEXT }
var schemaGlTexStorage1DEXT = &schema.Class{
TypeID: binaryIDGlTexStorage1DEXT,
Name: "GlTexStorage1DEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureTarget", Method: schema.Uint32}},
schema.Field{Declared: "Levels", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "TexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlTexStorage2DEXT struct{}
func (*GlTexStorage2DEXT) Class() binary.Class {
return (*binaryClassGlTexStorage2DEXT)(nil)
}
func doEncodeGlTexStorage2DEXT(e binary.Encoder, o *GlTexStorage2DEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Levels); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
return nil
}
func doDecodeGlTexStorage2DEXT(d binary.Decoder, o *GlTexStorage2DEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Levels = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = TexelFormat(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
return nil
}
func doSkipGlTexStorage2DEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlTexStorage2DEXT) ID() binary.ID { return binaryIDGlTexStorage2DEXT }
func (*binaryClassGlTexStorage2DEXT) New() binary.Object { return &GlTexStorage2DEXT{} }
func (*binaryClassGlTexStorage2DEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlTexStorage2DEXT(e, obj.(*GlTexStorage2DEXT))
}
func (*binaryClassGlTexStorage2DEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlTexStorage2DEXT{}
return obj, doDecodeGlTexStorage2DEXT(d, obj)
}
func (*binaryClassGlTexStorage2DEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlTexStorage2DEXT(d, obj.(*GlTexStorage2DEXT))
}
func (*binaryClassGlTexStorage2DEXT) Skip(d binary.Decoder) error { return doSkipGlTexStorage2DEXT(d) }
func (*binaryClassGlTexStorage2DEXT) Schema() *schema.Class { return schemaGlTexStorage2DEXT }
var schemaGlTexStorage2DEXT = &schema.Class{
TypeID: binaryIDGlTexStorage2DEXT,
Name: "GlTexStorage2DEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureTarget", Method: schema.Uint32}},
schema.Field{Declared: "Levels", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "TexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlTexStorage3DEXT struct{}
func (*GlTexStorage3DEXT) Class() binary.Class {
return (*binaryClassGlTexStorage3DEXT)(nil)
}
func doEncodeGlTexStorage3DEXT(e binary.Encoder, o *GlTexStorage3DEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Levels); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
if err := e.Int32(o.Depth); err != nil {
return err
}
return nil
}
func doDecodeGlTexStorage3DEXT(d binary.Decoder, o *GlTexStorage3DEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Levels = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = TexelFormat(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Depth = int32(obj)
}
return nil
}
func doSkipGlTexStorage3DEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlTexStorage3DEXT) ID() binary.ID { return binaryIDGlTexStorage3DEXT }
func (*binaryClassGlTexStorage3DEXT) New() binary.Object { return &GlTexStorage3DEXT{} }
func (*binaryClassGlTexStorage3DEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlTexStorage3DEXT(e, obj.(*GlTexStorage3DEXT))
}
func (*binaryClassGlTexStorage3DEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlTexStorage3DEXT{}
return obj, doDecodeGlTexStorage3DEXT(d, obj)
}
func (*binaryClassGlTexStorage3DEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlTexStorage3DEXT(d, obj.(*GlTexStorage3DEXT))
}
func (*binaryClassGlTexStorage3DEXT) Skip(d binary.Decoder) error { return doSkipGlTexStorage3DEXT(d) }
func (*binaryClassGlTexStorage3DEXT) Schema() *schema.Class { return schemaGlTexStorage3DEXT }
var schemaGlTexStorage3DEXT = &schema.Class{
TypeID: binaryIDGlTexStorage3DEXT,
Name: "GlTexStorage3DEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureTarget", Method: schema.Uint32}},
schema.Field{Declared: "Levels", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "TexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Depth", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlTexSubImage2D struct{}
func (*GlTexSubImage2D) Class() binary.Class {
return (*binaryClassGlTexSubImage2D)(nil)
}
func doEncodeGlTexSubImage2D(e binary.Encoder, o *GlTexSubImage2D) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Level); err != nil {
return err
}
if err := e.Int32(o.Xoffset); err != nil {
return err
}
if err := e.Int32(o.Yoffset); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Type)); err != nil {
return err
}
if err := e.Value(&o.Data); err != nil {
return err
}
return nil
}
func doDecodeGlTexSubImage2D(d binary.Decoder, o *GlTexSubImage2D) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureImageTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Level = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Xoffset = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Yoffset = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = TexelFormat(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = TexelType(obj)
}
if err := d.Value(&o.Data); err != nil {
return err
}
return nil
}
func doSkipGlTexSubImage2D(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*TexturePointer)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlTexSubImage2D) ID() binary.ID { return binaryIDGlTexSubImage2D }
func (*binaryClassGlTexSubImage2D) New() binary.Object { return &GlTexSubImage2D{} }
func (*binaryClassGlTexSubImage2D) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlTexSubImage2D(e, obj.(*GlTexSubImage2D))
}
func (*binaryClassGlTexSubImage2D) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlTexSubImage2D{}
return obj, doDecodeGlTexSubImage2D(d, obj)
}
func (*binaryClassGlTexSubImage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlTexSubImage2D(d, obj.(*GlTexSubImage2D))
}
func (*binaryClassGlTexSubImage2D) Skip(d binary.Decoder) error { return doSkipGlTexSubImage2D(d) }
func (*binaryClassGlTexSubImage2D) Schema() *schema.Class { return schemaGlTexSubImage2D }
var schemaGlTexSubImage2D = &schema.Class{
TypeID: binaryIDGlTexSubImage2D,
Name: "GlTexSubImage2D",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureImageTarget", Method: schema.Uint32}},
schema.Field{Declared: "Level", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Xoffset", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Yoffset", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "TexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "TexelType", Method: schema.Uint32}},
schema.Field{Declared: "Data", Type: &schema.Struct{Name: "TexturePointer"}},
},
}
type binaryClassGlTextureStorage1DEXT struct{}
func (*GlTextureStorage1DEXT) Class() binary.Class {
return (*binaryClassGlTextureStorage1DEXT)(nil)
}
func doEncodeGlTextureStorage1DEXT(e binary.Encoder, o *GlTextureStorage1DEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Texture)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Levels); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
return nil
}
func doDecodeGlTextureStorage1DEXT(d binary.Decoder, o *GlTextureStorage1DEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Texture = TextureId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Levels = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = TexelFormat(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
return nil
}
func doSkipGlTextureStorage1DEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlTextureStorage1DEXT) ID() binary.ID { return binaryIDGlTextureStorage1DEXT }
func (*binaryClassGlTextureStorage1DEXT) New() binary.Object { return &GlTextureStorage1DEXT{} }
func (*binaryClassGlTextureStorage1DEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlTextureStorage1DEXT(e, obj.(*GlTextureStorage1DEXT))
}
func (*binaryClassGlTextureStorage1DEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlTextureStorage1DEXT{}
return obj, doDecodeGlTextureStorage1DEXT(d, obj)
}
func (*binaryClassGlTextureStorage1DEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlTextureStorage1DEXT(d, obj.(*GlTextureStorage1DEXT))
}
func (*binaryClassGlTextureStorage1DEXT) Skip(d binary.Decoder) error {
return doSkipGlTextureStorage1DEXT(d)
}
func (*binaryClassGlTextureStorage1DEXT) Schema() *schema.Class { return schemaGlTextureStorage1DEXT }
var schemaGlTextureStorage1DEXT = &schema.Class{
TypeID: binaryIDGlTextureStorage1DEXT,
Name: "GlTextureStorage1DEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureTarget", Method: schema.Uint32}},
schema.Field{Declared: "Levels", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "TexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlTextureStorage2DEXT struct{}
func (*GlTextureStorage2DEXT) Class() binary.Class {
return (*binaryClassGlTextureStorage2DEXT)(nil)
}
func doEncodeGlTextureStorage2DEXT(e binary.Encoder, o *GlTextureStorage2DEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Texture)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Levels); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
return nil
}
func doDecodeGlTextureStorage2DEXT(d binary.Decoder, o *GlTextureStorage2DEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Texture = TextureId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Levels = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = TexelFormat(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
return nil
}
func doSkipGlTextureStorage2DEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlTextureStorage2DEXT) ID() binary.ID { return binaryIDGlTextureStorage2DEXT }
func (*binaryClassGlTextureStorage2DEXT) New() binary.Object { return &GlTextureStorage2DEXT{} }
func (*binaryClassGlTextureStorage2DEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlTextureStorage2DEXT(e, obj.(*GlTextureStorage2DEXT))
}
func (*binaryClassGlTextureStorage2DEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlTextureStorage2DEXT{}
return obj, doDecodeGlTextureStorage2DEXT(d, obj)
}
func (*binaryClassGlTextureStorage2DEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlTextureStorage2DEXT(d, obj.(*GlTextureStorage2DEXT))
}
func (*binaryClassGlTextureStorage2DEXT) Skip(d binary.Decoder) error {
return doSkipGlTextureStorage2DEXT(d)
}
func (*binaryClassGlTextureStorage2DEXT) Schema() *schema.Class { return schemaGlTextureStorage2DEXT }
var schemaGlTextureStorage2DEXT = &schema.Class{
TypeID: binaryIDGlTextureStorage2DEXT,
Name: "GlTextureStorage2DEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureTarget", Method: schema.Uint32}},
schema.Field{Declared: "Levels", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "TexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlTextureStorage3DEXT struct{}
func (*GlTextureStorage3DEXT) Class() binary.Class {
return (*binaryClassGlTextureStorage3DEXT)(nil)
}
func doEncodeGlTextureStorage3DEXT(e binary.Encoder, o *GlTextureStorage3DEXT) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Texture)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
if err := e.Int32(o.Levels); err != nil {
return err
}
if err := e.Uint32(uint32(o.Format)); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
if err := e.Int32(o.Depth); err != nil {
return err
}
return nil
}
func doDecodeGlTextureStorage3DEXT(d binary.Decoder, o *GlTextureStorage3DEXT) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Texture = TextureId(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = TextureTarget(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Levels = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Format = TexelFormat(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Depth = int32(obj)
}
return nil
}
func doSkipGlTextureStorage3DEXT(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlTextureStorage3DEXT) ID() binary.ID { return binaryIDGlTextureStorage3DEXT }
func (*binaryClassGlTextureStorage3DEXT) New() binary.Object { return &GlTextureStorage3DEXT{} }
func (*binaryClassGlTextureStorage3DEXT) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlTextureStorage3DEXT(e, obj.(*GlTextureStorage3DEXT))
}
func (*binaryClassGlTextureStorage3DEXT) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlTextureStorage3DEXT{}
return obj, doDecodeGlTextureStorage3DEXT(d, obj)
}
func (*binaryClassGlTextureStorage3DEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlTextureStorage3DEXT(d, obj.(*GlTextureStorage3DEXT))
}
func (*binaryClassGlTextureStorage3DEXT) Skip(d binary.Decoder) error {
return doSkipGlTextureStorage3DEXT(d)
}
func (*binaryClassGlTextureStorage3DEXT) Schema() *schema.Class { return schemaGlTextureStorage3DEXT }
var schemaGlTextureStorage3DEXT = &schema.Class{
TypeID: binaryIDGlTextureStorage3DEXT,
Name: "GlTextureStorage3DEXT",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "TextureTarget", Method: schema.Uint32}},
schema.Field{Declared: "Levels", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "TexelFormat", Method: schema.Uint32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Depth", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlUniform1f struct{}
func (*GlUniform1f) Class() binary.Class {
return (*binaryClassGlUniform1f)(nil)
}
func doEncodeGlUniform1f(e binary.Encoder, o *GlUniform1f) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Float32(o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlUniform1f(d binary.Decoder, o *GlUniform1f) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value = float32(obj)
}
return nil
}
func doSkipGlUniform1f(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform1f) ID() binary.ID { return binaryIDGlUniform1f }
func (*binaryClassGlUniform1f) New() binary.Object { return &GlUniform1f{} }
func (*binaryClassGlUniform1f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform1f(e, obj.(*GlUniform1f))
}
func (*binaryClassGlUniform1f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform1f{}
return obj, doDecodeGlUniform1f(d, obj)
}
func (*binaryClassGlUniform1f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform1f(d, obj.(*GlUniform1f))
}
func (*binaryClassGlUniform1f) Skip(d binary.Decoder) error { return doSkipGlUniform1f(d) }
func (*binaryClassGlUniform1f) Schema() *schema.Class { return schemaGlUniform1f }
var schemaGlUniform1f = &schema.Class{
TypeID: binaryIDGlUniform1f,
Name: "GlUniform1f",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Value", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlUniform1fv struct{}
func (*GlUniform1fv) Class() binary.Class {
return (*binaryClassGlUniform1fv)(nil)
}
func doEncodeGlUniform1fv(e binary.Encoder, o *GlUniform1fv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlUniform1fv(d binary.Decoder, o *GlUniform1fv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlUniform1fv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform1fv) ID() binary.ID { return binaryIDGlUniform1fv }
func (*binaryClassGlUniform1fv) New() binary.Object { return &GlUniform1fv{} }
func (*binaryClassGlUniform1fv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform1fv(e, obj.(*GlUniform1fv))
}
func (*binaryClassGlUniform1fv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform1fv{}
return obj, doDecodeGlUniform1fv(d, obj)
}
func (*binaryClassGlUniform1fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform1fv(d, obj.(*GlUniform1fv))
}
func (*binaryClassGlUniform1fv) Skip(d binary.Decoder) error { return doSkipGlUniform1fv(d) }
func (*binaryClassGlUniform1fv) Schema() *schema.Class { return schemaGlUniform1fv }
var schemaGlUniform1fv = &schema.Class{
TypeID: binaryIDGlUniform1fv,
Name: "GlUniform1fv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlUniform1i struct{}
func (*GlUniform1i) Class() binary.Class {
return (*binaryClassGlUniform1i)(nil)
}
func doEncodeGlUniform1i(e binary.Encoder, o *GlUniform1i) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlUniform1i(d binary.Decoder, o *GlUniform1i) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Value = int32(obj)
}
return nil
}
func doSkipGlUniform1i(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform1i) ID() binary.ID { return binaryIDGlUniform1i }
func (*binaryClassGlUniform1i) New() binary.Object { return &GlUniform1i{} }
func (*binaryClassGlUniform1i) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform1i(e, obj.(*GlUniform1i))
}
func (*binaryClassGlUniform1i) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform1i{}
return obj, doDecodeGlUniform1i(d, obj)
}
func (*binaryClassGlUniform1i) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform1i(d, obj.(*GlUniform1i))
}
func (*binaryClassGlUniform1i) Skip(d binary.Decoder) error { return doSkipGlUniform1i(d) }
func (*binaryClassGlUniform1i) Schema() *schema.Class { return schemaGlUniform1i }
var schemaGlUniform1i = &schema.Class{
TypeID: binaryIDGlUniform1i,
Name: "GlUniform1i",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Value", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlUniform1iv struct{}
func (*GlUniform1iv) Class() binary.Class {
return (*binaryClassGlUniform1iv)(nil)
}
func doEncodeGlUniform1iv(e binary.Encoder, o *GlUniform1iv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlUniform1iv(d binary.Decoder, o *GlUniform1iv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlUniform1iv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform1iv) ID() binary.ID { return binaryIDGlUniform1iv }
func (*binaryClassGlUniform1iv) New() binary.Object { return &GlUniform1iv{} }
func (*binaryClassGlUniform1iv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform1iv(e, obj.(*GlUniform1iv))
}
func (*binaryClassGlUniform1iv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform1iv{}
return obj, doDecodeGlUniform1iv(d, obj)
}
func (*binaryClassGlUniform1iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform1iv(d, obj.(*GlUniform1iv))
}
func (*binaryClassGlUniform1iv) Skip(d binary.Decoder) error { return doSkipGlUniform1iv(d) }
func (*binaryClassGlUniform1iv) Schema() *schema.Class { return schemaGlUniform1iv }
var schemaGlUniform1iv = &schema.Class{
TypeID: binaryIDGlUniform1iv,
Name: "GlUniform1iv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlUniform2f struct{}
func (*GlUniform2f) Class() binary.Class {
return (*binaryClassGlUniform2f)(nil)
}
func doEncodeGlUniform2f(e binary.Encoder, o *GlUniform2f) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Float32(o.Value0); err != nil {
return err
}
if err := e.Float32(o.Value1); err != nil {
return err
}
return nil
}
func doDecodeGlUniform2f(d binary.Decoder, o *GlUniform2f) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value0 = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value1 = float32(obj)
}
return nil
}
func doSkipGlUniform2f(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform2f) ID() binary.ID { return binaryIDGlUniform2f }
func (*binaryClassGlUniform2f) New() binary.Object { return &GlUniform2f{} }
func (*binaryClassGlUniform2f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform2f(e, obj.(*GlUniform2f))
}
func (*binaryClassGlUniform2f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform2f{}
return obj, doDecodeGlUniform2f(d, obj)
}
func (*binaryClassGlUniform2f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform2f(d, obj.(*GlUniform2f))
}
func (*binaryClassGlUniform2f) Skip(d binary.Decoder) error { return doSkipGlUniform2f(d) }
func (*binaryClassGlUniform2f) Schema() *schema.Class { return schemaGlUniform2f }
var schemaGlUniform2f = &schema.Class{
TypeID: binaryIDGlUniform2f,
Name: "GlUniform2f",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Value0", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Value1", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlUniform2fv struct{}
func (*GlUniform2fv) Class() binary.Class {
return (*binaryClassGlUniform2fv)(nil)
}
func doEncodeGlUniform2fv(e binary.Encoder, o *GlUniform2fv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlUniform2fv(d binary.Decoder, o *GlUniform2fv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlUniform2fv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform2fv) ID() binary.ID { return binaryIDGlUniform2fv }
func (*binaryClassGlUniform2fv) New() binary.Object { return &GlUniform2fv{} }
func (*binaryClassGlUniform2fv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform2fv(e, obj.(*GlUniform2fv))
}
func (*binaryClassGlUniform2fv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform2fv{}
return obj, doDecodeGlUniform2fv(d, obj)
}
func (*binaryClassGlUniform2fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform2fv(d, obj.(*GlUniform2fv))
}
func (*binaryClassGlUniform2fv) Skip(d binary.Decoder) error { return doSkipGlUniform2fv(d) }
func (*binaryClassGlUniform2fv) Schema() *schema.Class { return schemaGlUniform2fv }
var schemaGlUniform2fv = &schema.Class{
TypeID: binaryIDGlUniform2fv,
Name: "GlUniform2fv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlUniform2i struct{}
func (*GlUniform2i) Class() binary.Class {
return (*binaryClassGlUniform2i)(nil)
}
func doEncodeGlUniform2i(e binary.Encoder, o *GlUniform2i) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Value0); err != nil {
return err
}
if err := e.Int32(o.Value1); err != nil {
return err
}
return nil
}
func doDecodeGlUniform2i(d binary.Decoder, o *GlUniform2i) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Value0 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Value1 = int32(obj)
}
return nil
}
func doSkipGlUniform2i(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform2i) ID() binary.ID { return binaryIDGlUniform2i }
func (*binaryClassGlUniform2i) New() binary.Object { return &GlUniform2i{} }
func (*binaryClassGlUniform2i) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform2i(e, obj.(*GlUniform2i))
}
func (*binaryClassGlUniform2i) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform2i{}
return obj, doDecodeGlUniform2i(d, obj)
}
func (*binaryClassGlUniform2i) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform2i(d, obj.(*GlUniform2i))
}
func (*binaryClassGlUniform2i) Skip(d binary.Decoder) error { return doSkipGlUniform2i(d) }
func (*binaryClassGlUniform2i) Schema() *schema.Class { return schemaGlUniform2i }
var schemaGlUniform2i = &schema.Class{
TypeID: binaryIDGlUniform2i,
Name: "GlUniform2i",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Value0", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value1", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlUniform2iv struct{}
func (*GlUniform2iv) Class() binary.Class {
return (*binaryClassGlUniform2iv)(nil)
}
func doEncodeGlUniform2iv(e binary.Encoder, o *GlUniform2iv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlUniform2iv(d binary.Decoder, o *GlUniform2iv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlUniform2iv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform2iv) ID() binary.ID { return binaryIDGlUniform2iv }
func (*binaryClassGlUniform2iv) New() binary.Object { return &GlUniform2iv{} }
func (*binaryClassGlUniform2iv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform2iv(e, obj.(*GlUniform2iv))
}
func (*binaryClassGlUniform2iv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform2iv{}
return obj, doDecodeGlUniform2iv(d, obj)
}
func (*binaryClassGlUniform2iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform2iv(d, obj.(*GlUniform2iv))
}
func (*binaryClassGlUniform2iv) Skip(d binary.Decoder) error { return doSkipGlUniform2iv(d) }
func (*binaryClassGlUniform2iv) Schema() *schema.Class { return schemaGlUniform2iv }
var schemaGlUniform2iv = &schema.Class{
TypeID: binaryIDGlUniform2iv,
Name: "GlUniform2iv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlUniform3f struct{}
func (*GlUniform3f) Class() binary.Class {
return (*binaryClassGlUniform3f)(nil)
}
func doEncodeGlUniform3f(e binary.Encoder, o *GlUniform3f) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Float32(o.Value0); err != nil {
return err
}
if err := e.Float32(o.Value1); err != nil {
return err
}
if err := e.Float32(o.Value2); err != nil {
return err
}
return nil
}
func doDecodeGlUniform3f(d binary.Decoder, o *GlUniform3f) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value0 = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value1 = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value2 = float32(obj)
}
return nil
}
func doSkipGlUniform3f(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform3f) ID() binary.ID { return binaryIDGlUniform3f }
func (*binaryClassGlUniform3f) New() binary.Object { return &GlUniform3f{} }
func (*binaryClassGlUniform3f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform3f(e, obj.(*GlUniform3f))
}
func (*binaryClassGlUniform3f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform3f{}
return obj, doDecodeGlUniform3f(d, obj)
}
func (*binaryClassGlUniform3f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform3f(d, obj.(*GlUniform3f))
}
func (*binaryClassGlUniform3f) Skip(d binary.Decoder) error { return doSkipGlUniform3f(d) }
func (*binaryClassGlUniform3f) Schema() *schema.Class { return schemaGlUniform3f }
var schemaGlUniform3f = &schema.Class{
TypeID: binaryIDGlUniform3f,
Name: "GlUniform3f",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Value0", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Value1", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Value2", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlUniform3fv struct{}
func (*GlUniform3fv) Class() binary.Class {
return (*binaryClassGlUniform3fv)(nil)
}
func doEncodeGlUniform3fv(e binary.Encoder, o *GlUniform3fv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlUniform3fv(d binary.Decoder, o *GlUniform3fv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlUniform3fv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform3fv) ID() binary.ID { return binaryIDGlUniform3fv }
func (*binaryClassGlUniform3fv) New() binary.Object { return &GlUniform3fv{} }
func (*binaryClassGlUniform3fv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform3fv(e, obj.(*GlUniform3fv))
}
func (*binaryClassGlUniform3fv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform3fv{}
return obj, doDecodeGlUniform3fv(d, obj)
}
func (*binaryClassGlUniform3fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform3fv(d, obj.(*GlUniform3fv))
}
func (*binaryClassGlUniform3fv) Skip(d binary.Decoder) error { return doSkipGlUniform3fv(d) }
func (*binaryClassGlUniform3fv) Schema() *schema.Class { return schemaGlUniform3fv }
var schemaGlUniform3fv = &schema.Class{
TypeID: binaryIDGlUniform3fv,
Name: "GlUniform3fv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlUniform3i struct{}
func (*GlUniform3i) Class() binary.Class {
return (*binaryClassGlUniform3i)(nil)
}
func doEncodeGlUniform3i(e binary.Encoder, o *GlUniform3i) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Value0); err != nil {
return err
}
if err := e.Int32(o.Value1); err != nil {
return err
}
if err := e.Int32(o.Value2); err != nil {
return err
}
return nil
}
func doDecodeGlUniform3i(d binary.Decoder, o *GlUniform3i) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Value0 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Value1 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Value2 = int32(obj)
}
return nil
}
func doSkipGlUniform3i(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform3i) ID() binary.ID { return binaryIDGlUniform3i }
func (*binaryClassGlUniform3i) New() binary.Object { return &GlUniform3i{} }
func (*binaryClassGlUniform3i) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform3i(e, obj.(*GlUniform3i))
}
func (*binaryClassGlUniform3i) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform3i{}
return obj, doDecodeGlUniform3i(d, obj)
}
func (*binaryClassGlUniform3i) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform3i(d, obj.(*GlUniform3i))
}
func (*binaryClassGlUniform3i) Skip(d binary.Decoder) error { return doSkipGlUniform3i(d) }
func (*binaryClassGlUniform3i) Schema() *schema.Class { return schemaGlUniform3i }
var schemaGlUniform3i = &schema.Class{
TypeID: binaryIDGlUniform3i,
Name: "GlUniform3i",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Value0", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value1", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value2", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlUniform3iv struct{}
func (*GlUniform3iv) Class() binary.Class {
return (*binaryClassGlUniform3iv)(nil)
}
func doEncodeGlUniform3iv(e binary.Encoder, o *GlUniform3iv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlUniform3iv(d binary.Decoder, o *GlUniform3iv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlUniform3iv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform3iv) ID() binary.ID { return binaryIDGlUniform3iv }
func (*binaryClassGlUniform3iv) New() binary.Object { return &GlUniform3iv{} }
func (*binaryClassGlUniform3iv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform3iv(e, obj.(*GlUniform3iv))
}
func (*binaryClassGlUniform3iv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform3iv{}
return obj, doDecodeGlUniform3iv(d, obj)
}
func (*binaryClassGlUniform3iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform3iv(d, obj.(*GlUniform3iv))
}
func (*binaryClassGlUniform3iv) Skip(d binary.Decoder) error { return doSkipGlUniform3iv(d) }
func (*binaryClassGlUniform3iv) Schema() *schema.Class { return schemaGlUniform3iv }
var schemaGlUniform3iv = &schema.Class{
TypeID: binaryIDGlUniform3iv,
Name: "GlUniform3iv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlUniform4f struct{}
func (*GlUniform4f) Class() binary.Class {
return (*binaryClassGlUniform4f)(nil)
}
func doEncodeGlUniform4f(e binary.Encoder, o *GlUniform4f) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Float32(o.Value0); err != nil {
return err
}
if err := e.Float32(o.Value1); err != nil {
return err
}
if err := e.Float32(o.Value2); err != nil {
return err
}
if err := e.Float32(o.Value3); err != nil {
return err
}
return nil
}
func doDecodeGlUniform4f(d binary.Decoder, o *GlUniform4f) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value0 = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value1 = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value2 = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value3 = float32(obj)
}
return nil
}
func doSkipGlUniform4f(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform4f) ID() binary.ID { return binaryIDGlUniform4f }
func (*binaryClassGlUniform4f) New() binary.Object { return &GlUniform4f{} }
func (*binaryClassGlUniform4f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform4f(e, obj.(*GlUniform4f))
}
func (*binaryClassGlUniform4f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform4f{}
return obj, doDecodeGlUniform4f(d, obj)
}
func (*binaryClassGlUniform4f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform4f(d, obj.(*GlUniform4f))
}
func (*binaryClassGlUniform4f) Skip(d binary.Decoder) error { return doSkipGlUniform4f(d) }
func (*binaryClassGlUniform4f) Schema() *schema.Class { return schemaGlUniform4f }
var schemaGlUniform4f = &schema.Class{
TypeID: binaryIDGlUniform4f,
Name: "GlUniform4f",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Value0", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Value1", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Value2", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Value3", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlUniform4fv struct{}
func (*GlUniform4fv) Class() binary.Class {
return (*binaryClassGlUniform4fv)(nil)
}
func doEncodeGlUniform4fv(e binary.Encoder, o *GlUniform4fv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlUniform4fv(d binary.Decoder, o *GlUniform4fv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlUniform4fv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform4fv) ID() binary.ID { return binaryIDGlUniform4fv }
func (*binaryClassGlUniform4fv) New() binary.Object { return &GlUniform4fv{} }
func (*binaryClassGlUniform4fv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform4fv(e, obj.(*GlUniform4fv))
}
func (*binaryClassGlUniform4fv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform4fv{}
return obj, doDecodeGlUniform4fv(d, obj)
}
func (*binaryClassGlUniform4fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform4fv(d, obj.(*GlUniform4fv))
}
func (*binaryClassGlUniform4fv) Skip(d binary.Decoder) error { return doSkipGlUniform4fv(d) }
func (*binaryClassGlUniform4fv) Schema() *schema.Class { return schemaGlUniform4fv }
var schemaGlUniform4fv = &schema.Class{
TypeID: binaryIDGlUniform4fv,
Name: "GlUniform4fv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlUniform4i struct{}
func (*GlUniform4i) Class() binary.Class {
return (*binaryClassGlUniform4i)(nil)
}
func doEncodeGlUniform4i(e binary.Encoder, o *GlUniform4i) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Value0); err != nil {
return err
}
if err := e.Int32(o.Value1); err != nil {
return err
}
if err := e.Int32(o.Value2); err != nil {
return err
}
if err := e.Int32(o.Value3); err != nil {
return err
}
return nil
}
func doDecodeGlUniform4i(d binary.Decoder, o *GlUniform4i) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Value0 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Value1 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Value2 = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Value3 = int32(obj)
}
return nil
}
func doSkipGlUniform4i(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform4i) ID() binary.ID { return binaryIDGlUniform4i }
func (*binaryClassGlUniform4i) New() binary.Object { return &GlUniform4i{} }
func (*binaryClassGlUniform4i) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform4i(e, obj.(*GlUniform4i))
}
func (*binaryClassGlUniform4i) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform4i{}
return obj, doDecodeGlUniform4i(d, obj)
}
func (*binaryClassGlUniform4i) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform4i(d, obj.(*GlUniform4i))
}
func (*binaryClassGlUniform4i) Skip(d binary.Decoder) error { return doSkipGlUniform4i(d) }
func (*binaryClassGlUniform4i) Schema() *schema.Class { return schemaGlUniform4i }
var schemaGlUniform4i = &schema.Class{
TypeID: binaryIDGlUniform4i,
Name: "GlUniform4i",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Value0", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value1", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value2", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value3", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlUniform4iv struct{}
func (*GlUniform4iv) Class() binary.Class {
return (*binaryClassGlUniform4iv)(nil)
}
func doEncodeGlUniform4iv(e binary.Encoder, o *GlUniform4iv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlUniform4iv(d binary.Decoder, o *GlUniform4iv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlUniform4iv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniform4iv) ID() binary.ID { return binaryIDGlUniform4iv }
func (*binaryClassGlUniform4iv) New() binary.Object { return &GlUniform4iv{} }
func (*binaryClassGlUniform4iv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniform4iv(e, obj.(*GlUniform4iv))
}
func (*binaryClassGlUniform4iv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniform4iv{}
return obj, doDecodeGlUniform4iv(d, obj)
}
func (*binaryClassGlUniform4iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniform4iv(d, obj.(*GlUniform4iv))
}
func (*binaryClassGlUniform4iv) Skip(d binary.Decoder) error { return doSkipGlUniform4iv(d) }
func (*binaryClassGlUniform4iv) Schema() *schema.Class { return schemaGlUniform4iv }
var schemaGlUniform4iv = &schema.Class{
TypeID: binaryIDGlUniform4iv,
Name: "GlUniform4iv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "S32ᵖ"}},
},
}
type binaryClassGlUniformMatrix2fv struct{}
func (*GlUniformMatrix2fv) Class() binary.Class {
return (*binaryClassGlUniformMatrix2fv)(nil)
}
func doEncodeGlUniformMatrix2fv(e binary.Encoder, o *GlUniformMatrix2fv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Bool(o.Transpose); err != nil {
return err
}
if err := e.Value(&o.Values); err != nil {
return err
}
return nil
}
func doDecodeGlUniformMatrix2fv(d binary.Decoder, o *GlUniformMatrix2fv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Transpose = bool(obj)
}
if err := d.Value(&o.Values); err != nil {
return err
}
return nil
}
func doSkipGlUniformMatrix2fv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniformMatrix2fv) ID() binary.ID { return binaryIDGlUniformMatrix2fv }
func (*binaryClassGlUniformMatrix2fv) New() binary.Object { return &GlUniformMatrix2fv{} }
func (*binaryClassGlUniformMatrix2fv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniformMatrix2fv(e, obj.(*GlUniformMatrix2fv))
}
func (*binaryClassGlUniformMatrix2fv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniformMatrix2fv{}
return obj, doDecodeGlUniformMatrix2fv(d, obj)
}
func (*binaryClassGlUniformMatrix2fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniformMatrix2fv(d, obj.(*GlUniformMatrix2fv))
}
func (*binaryClassGlUniformMatrix2fv) Skip(d binary.Decoder) error { return doSkipGlUniformMatrix2fv(d) }
func (*binaryClassGlUniformMatrix2fv) Schema() *schema.Class { return schemaGlUniformMatrix2fv }
var schemaGlUniformMatrix2fv = &schema.Class{
TypeID: binaryIDGlUniformMatrix2fv,
Name: "GlUniformMatrix2fv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Transpose", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Values", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlUniformMatrix3fv struct{}
func (*GlUniformMatrix3fv) Class() binary.Class {
return (*binaryClassGlUniformMatrix3fv)(nil)
}
func doEncodeGlUniformMatrix3fv(e binary.Encoder, o *GlUniformMatrix3fv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Bool(o.Transpose); err != nil {
return err
}
if err := e.Value(&o.Values); err != nil {
return err
}
return nil
}
func doDecodeGlUniformMatrix3fv(d binary.Decoder, o *GlUniformMatrix3fv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Transpose = bool(obj)
}
if err := d.Value(&o.Values); err != nil {
return err
}
return nil
}
func doSkipGlUniformMatrix3fv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniformMatrix3fv) ID() binary.ID { return binaryIDGlUniformMatrix3fv }
func (*binaryClassGlUniformMatrix3fv) New() binary.Object { return &GlUniformMatrix3fv{} }
func (*binaryClassGlUniformMatrix3fv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniformMatrix3fv(e, obj.(*GlUniformMatrix3fv))
}
func (*binaryClassGlUniformMatrix3fv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniformMatrix3fv{}
return obj, doDecodeGlUniformMatrix3fv(d, obj)
}
func (*binaryClassGlUniformMatrix3fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniformMatrix3fv(d, obj.(*GlUniformMatrix3fv))
}
func (*binaryClassGlUniformMatrix3fv) Skip(d binary.Decoder) error { return doSkipGlUniformMatrix3fv(d) }
func (*binaryClassGlUniformMatrix3fv) Schema() *schema.Class { return schemaGlUniformMatrix3fv }
var schemaGlUniformMatrix3fv = &schema.Class{
TypeID: binaryIDGlUniformMatrix3fv,
Name: "GlUniformMatrix3fv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Transpose", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Values", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlUniformMatrix4fv struct{}
func (*GlUniformMatrix4fv) Class() binary.Class {
return (*binaryClassGlUniformMatrix4fv)(nil)
}
func doEncodeGlUniformMatrix4fv(e binary.Encoder, o *GlUniformMatrix4fv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(int32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Count); err != nil {
return err
}
if err := e.Bool(o.Transpose); err != nil {
return err
}
if err := e.Value(&o.Values); err != nil {
return err
}
return nil
}
func doDecodeGlUniformMatrix4fv(d binary.Decoder, o *GlUniformMatrix4fv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Location = UniformLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Count = int32(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Transpose = bool(obj)
}
if err := d.Value(&o.Values); err != nil {
return err
}
return nil
}
func doSkipGlUniformMatrix4fv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlUniformMatrix4fv) ID() binary.ID { return binaryIDGlUniformMatrix4fv }
func (*binaryClassGlUniformMatrix4fv) New() binary.Object { return &GlUniformMatrix4fv{} }
func (*binaryClassGlUniformMatrix4fv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUniformMatrix4fv(e, obj.(*GlUniformMatrix4fv))
}
func (*binaryClassGlUniformMatrix4fv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUniformMatrix4fv{}
return obj, doDecodeGlUniformMatrix4fv(d, obj)
}
func (*binaryClassGlUniformMatrix4fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUniformMatrix4fv(d, obj.(*GlUniformMatrix4fv))
}
func (*binaryClassGlUniformMatrix4fv) Skip(d binary.Decoder) error { return doSkipGlUniformMatrix4fv(d) }
func (*binaryClassGlUniformMatrix4fv) Schema() *schema.Class { return schemaGlUniformMatrix4fv }
var schemaGlUniformMatrix4fv = &schema.Class{
TypeID: binaryIDGlUniformMatrix4fv,
Name: "GlUniformMatrix4fv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Transpose", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Values", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlUnmapBuffer struct{}
func (*GlUnmapBuffer) Class() binary.Class {
return (*binaryClassGlUnmapBuffer)(nil)
}
func doEncodeGlUnmapBuffer(e binary.Encoder, o *GlUnmapBuffer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Target)); err != nil {
return err
}
return nil
}
func doDecodeGlUnmapBuffer(d binary.Decoder, o *GlUnmapBuffer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Target = BufferTarget(obj)
}
return nil
}
func doSkipGlUnmapBuffer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlUnmapBuffer) ID() binary.ID { return binaryIDGlUnmapBuffer }
func (*binaryClassGlUnmapBuffer) New() binary.Object { return &GlUnmapBuffer{} }
func (*binaryClassGlUnmapBuffer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUnmapBuffer(e, obj.(*GlUnmapBuffer))
}
func (*binaryClassGlUnmapBuffer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUnmapBuffer{}
return obj, doDecodeGlUnmapBuffer(d, obj)
}
func (*binaryClassGlUnmapBuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUnmapBuffer(d, obj.(*GlUnmapBuffer))
}
func (*binaryClassGlUnmapBuffer) Skip(d binary.Decoder) error { return doSkipGlUnmapBuffer(d) }
func (*binaryClassGlUnmapBuffer) Schema() *schema.Class { return schemaGlUnmapBuffer }
var schemaGlUnmapBuffer = &schema.Class{
TypeID: binaryIDGlUnmapBuffer,
Name: "GlUnmapBuffer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Target", Type: &schema.Primitive{Name: "BufferTarget", Method: schema.Uint32}},
},
}
type binaryClassGlUseProgram struct{}
func (*GlUseProgram) Class() binary.Class {
return (*binaryClassGlUseProgram)(nil)
}
func doEncodeGlUseProgram(e binary.Encoder, o *GlUseProgram) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
return nil
}
func doDecodeGlUseProgram(d binary.Decoder, o *GlUseProgram) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
return nil
}
func doSkipGlUseProgram(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlUseProgram) ID() binary.ID { return binaryIDGlUseProgram }
func (*binaryClassGlUseProgram) New() binary.Object { return &GlUseProgram{} }
func (*binaryClassGlUseProgram) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlUseProgram(e, obj.(*GlUseProgram))
}
func (*binaryClassGlUseProgram) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlUseProgram{}
return obj, doDecodeGlUseProgram(d, obj)
}
func (*binaryClassGlUseProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlUseProgram(d, obj.(*GlUseProgram))
}
func (*binaryClassGlUseProgram) Skip(d binary.Decoder) error { return doSkipGlUseProgram(d) }
func (*binaryClassGlUseProgram) Schema() *schema.Class { return schemaGlUseProgram }
var schemaGlUseProgram = &schema.Class{
TypeID: binaryIDGlUseProgram,
Name: "GlUseProgram",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
},
}
type binaryClassGlValidateProgram struct{}
func (*GlValidateProgram) Class() binary.Class {
return (*binaryClassGlValidateProgram)(nil)
}
func doEncodeGlValidateProgram(e binary.Encoder, o *GlValidateProgram) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Program)); err != nil {
return err
}
return nil
}
func doDecodeGlValidateProgram(d binary.Decoder, o *GlValidateProgram) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Program = ProgramId(obj)
}
return nil
}
func doSkipGlValidateProgram(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlValidateProgram) ID() binary.ID { return binaryIDGlValidateProgram }
func (*binaryClassGlValidateProgram) New() binary.Object { return &GlValidateProgram{} }
func (*binaryClassGlValidateProgram) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlValidateProgram(e, obj.(*GlValidateProgram))
}
func (*binaryClassGlValidateProgram) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlValidateProgram{}
return obj, doDecodeGlValidateProgram(d, obj)
}
func (*binaryClassGlValidateProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlValidateProgram(d, obj.(*GlValidateProgram))
}
func (*binaryClassGlValidateProgram) Skip(d binary.Decoder) error { return doSkipGlValidateProgram(d) }
func (*binaryClassGlValidateProgram) Schema() *schema.Class { return schemaGlValidateProgram }
var schemaGlValidateProgram = &schema.Class{
TypeID: binaryIDGlValidateProgram,
Name: "GlValidateProgram",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
},
}
type binaryClassGlVertexAttrib1f struct{}
func (*GlVertexAttrib1f) Class() binary.Class {
return (*binaryClassGlVertexAttrib1f)(nil)
}
func doEncodeGlVertexAttrib1f(e binary.Encoder, o *GlVertexAttrib1f) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
if err := e.Float32(o.Value0); err != nil {
return err
}
return nil
}
func doDecodeGlVertexAttrib1f(d binary.Decoder, o *GlVertexAttrib1f) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value0 = float32(obj)
}
return nil
}
func doSkipGlVertexAttrib1f(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlVertexAttrib1f) ID() binary.ID { return binaryIDGlVertexAttrib1f }
func (*binaryClassGlVertexAttrib1f) New() binary.Object { return &GlVertexAttrib1f{} }
func (*binaryClassGlVertexAttrib1f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlVertexAttrib1f(e, obj.(*GlVertexAttrib1f))
}
func (*binaryClassGlVertexAttrib1f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlVertexAttrib1f{}
return obj, doDecodeGlVertexAttrib1f(d, obj)
}
func (*binaryClassGlVertexAttrib1f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlVertexAttrib1f(d, obj.(*GlVertexAttrib1f))
}
func (*binaryClassGlVertexAttrib1f) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib1f(d) }
func (*binaryClassGlVertexAttrib1f) Schema() *schema.Class { return schemaGlVertexAttrib1f }
var schemaGlVertexAttrib1f = &schema.Class{
TypeID: binaryIDGlVertexAttrib1f,
Name: "GlVertexAttrib1f",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
schema.Field{Declared: "Value0", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlVertexAttrib1fv struct{}
func (*GlVertexAttrib1fv) Class() binary.Class {
return (*binaryClassGlVertexAttrib1fv)(nil)
}
func doEncodeGlVertexAttrib1fv(e binary.Encoder, o *GlVertexAttrib1fv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlVertexAttrib1fv(d binary.Decoder, o *GlVertexAttrib1fv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlVertexAttrib1fv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlVertexAttrib1fv) ID() binary.ID { return binaryIDGlVertexAttrib1fv }
func (*binaryClassGlVertexAttrib1fv) New() binary.Object { return &GlVertexAttrib1fv{} }
func (*binaryClassGlVertexAttrib1fv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlVertexAttrib1fv(e, obj.(*GlVertexAttrib1fv))
}
func (*binaryClassGlVertexAttrib1fv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlVertexAttrib1fv{}
return obj, doDecodeGlVertexAttrib1fv(d, obj)
}
func (*binaryClassGlVertexAttrib1fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlVertexAttrib1fv(d, obj.(*GlVertexAttrib1fv))
}
func (*binaryClassGlVertexAttrib1fv) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib1fv(d) }
func (*binaryClassGlVertexAttrib1fv) Schema() *schema.Class { return schemaGlVertexAttrib1fv }
var schemaGlVertexAttrib1fv = &schema.Class{
TypeID: binaryIDGlVertexAttrib1fv,
Name: "GlVertexAttrib1fv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlVertexAttrib2f struct{}
func (*GlVertexAttrib2f) Class() binary.Class {
return (*binaryClassGlVertexAttrib2f)(nil)
}
func doEncodeGlVertexAttrib2f(e binary.Encoder, o *GlVertexAttrib2f) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
if err := e.Float32(o.Value0); err != nil {
return err
}
if err := e.Float32(o.Value1); err != nil {
return err
}
return nil
}
func doDecodeGlVertexAttrib2f(d binary.Decoder, o *GlVertexAttrib2f) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value0 = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value1 = float32(obj)
}
return nil
}
func doSkipGlVertexAttrib2f(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlVertexAttrib2f) ID() binary.ID { return binaryIDGlVertexAttrib2f }
func (*binaryClassGlVertexAttrib2f) New() binary.Object { return &GlVertexAttrib2f{} }
func (*binaryClassGlVertexAttrib2f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlVertexAttrib2f(e, obj.(*GlVertexAttrib2f))
}
func (*binaryClassGlVertexAttrib2f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlVertexAttrib2f{}
return obj, doDecodeGlVertexAttrib2f(d, obj)
}
func (*binaryClassGlVertexAttrib2f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlVertexAttrib2f(d, obj.(*GlVertexAttrib2f))
}
func (*binaryClassGlVertexAttrib2f) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib2f(d) }
func (*binaryClassGlVertexAttrib2f) Schema() *schema.Class { return schemaGlVertexAttrib2f }
var schemaGlVertexAttrib2f = &schema.Class{
TypeID: binaryIDGlVertexAttrib2f,
Name: "GlVertexAttrib2f",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
schema.Field{Declared: "Value0", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Value1", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlVertexAttrib2fv struct{}
func (*GlVertexAttrib2fv) Class() binary.Class {
return (*binaryClassGlVertexAttrib2fv)(nil)
}
func doEncodeGlVertexAttrib2fv(e binary.Encoder, o *GlVertexAttrib2fv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlVertexAttrib2fv(d binary.Decoder, o *GlVertexAttrib2fv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlVertexAttrib2fv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlVertexAttrib2fv) ID() binary.ID { return binaryIDGlVertexAttrib2fv }
func (*binaryClassGlVertexAttrib2fv) New() binary.Object { return &GlVertexAttrib2fv{} }
func (*binaryClassGlVertexAttrib2fv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlVertexAttrib2fv(e, obj.(*GlVertexAttrib2fv))
}
func (*binaryClassGlVertexAttrib2fv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlVertexAttrib2fv{}
return obj, doDecodeGlVertexAttrib2fv(d, obj)
}
func (*binaryClassGlVertexAttrib2fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlVertexAttrib2fv(d, obj.(*GlVertexAttrib2fv))
}
func (*binaryClassGlVertexAttrib2fv) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib2fv(d) }
func (*binaryClassGlVertexAttrib2fv) Schema() *schema.Class { return schemaGlVertexAttrib2fv }
var schemaGlVertexAttrib2fv = &schema.Class{
TypeID: binaryIDGlVertexAttrib2fv,
Name: "GlVertexAttrib2fv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlVertexAttrib3f struct{}
func (*GlVertexAttrib3f) Class() binary.Class {
return (*binaryClassGlVertexAttrib3f)(nil)
}
func doEncodeGlVertexAttrib3f(e binary.Encoder, o *GlVertexAttrib3f) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
if err := e.Float32(o.Value0); err != nil {
return err
}
if err := e.Float32(o.Value1); err != nil {
return err
}
if err := e.Float32(o.Value2); err != nil {
return err
}
return nil
}
func doDecodeGlVertexAttrib3f(d binary.Decoder, o *GlVertexAttrib3f) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value0 = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value1 = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value2 = float32(obj)
}
return nil
}
func doSkipGlVertexAttrib3f(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlVertexAttrib3f) ID() binary.ID { return binaryIDGlVertexAttrib3f }
func (*binaryClassGlVertexAttrib3f) New() binary.Object { return &GlVertexAttrib3f{} }
func (*binaryClassGlVertexAttrib3f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlVertexAttrib3f(e, obj.(*GlVertexAttrib3f))
}
func (*binaryClassGlVertexAttrib3f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlVertexAttrib3f{}
return obj, doDecodeGlVertexAttrib3f(d, obj)
}
func (*binaryClassGlVertexAttrib3f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlVertexAttrib3f(d, obj.(*GlVertexAttrib3f))
}
func (*binaryClassGlVertexAttrib3f) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib3f(d) }
func (*binaryClassGlVertexAttrib3f) Schema() *schema.Class { return schemaGlVertexAttrib3f }
var schemaGlVertexAttrib3f = &schema.Class{
TypeID: binaryIDGlVertexAttrib3f,
Name: "GlVertexAttrib3f",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
schema.Field{Declared: "Value0", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Value1", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Value2", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlVertexAttrib3fv struct{}
func (*GlVertexAttrib3fv) Class() binary.Class {
return (*binaryClassGlVertexAttrib3fv)(nil)
}
func doEncodeGlVertexAttrib3fv(e binary.Encoder, o *GlVertexAttrib3fv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlVertexAttrib3fv(d binary.Decoder, o *GlVertexAttrib3fv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlVertexAttrib3fv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlVertexAttrib3fv) ID() binary.ID { return binaryIDGlVertexAttrib3fv }
func (*binaryClassGlVertexAttrib3fv) New() binary.Object { return &GlVertexAttrib3fv{} }
func (*binaryClassGlVertexAttrib3fv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlVertexAttrib3fv(e, obj.(*GlVertexAttrib3fv))
}
func (*binaryClassGlVertexAttrib3fv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlVertexAttrib3fv{}
return obj, doDecodeGlVertexAttrib3fv(d, obj)
}
func (*binaryClassGlVertexAttrib3fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlVertexAttrib3fv(d, obj.(*GlVertexAttrib3fv))
}
func (*binaryClassGlVertexAttrib3fv) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib3fv(d) }
func (*binaryClassGlVertexAttrib3fv) Schema() *schema.Class { return schemaGlVertexAttrib3fv }
var schemaGlVertexAttrib3fv = &schema.Class{
TypeID: binaryIDGlVertexAttrib3fv,
Name: "GlVertexAttrib3fv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlVertexAttrib4f struct{}
func (*GlVertexAttrib4f) Class() binary.Class {
return (*binaryClassGlVertexAttrib4f)(nil)
}
func doEncodeGlVertexAttrib4f(e binary.Encoder, o *GlVertexAttrib4f) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
if err := e.Float32(o.Value0); err != nil {
return err
}
if err := e.Float32(o.Value1); err != nil {
return err
}
if err := e.Float32(o.Value2); err != nil {
return err
}
if err := e.Float32(o.Value3); err != nil {
return err
}
return nil
}
func doDecodeGlVertexAttrib4f(d binary.Decoder, o *GlVertexAttrib4f) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value0 = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value1 = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value2 = float32(obj)
}
if obj, err := d.Float32(); err != nil {
return err
} else {
o.Value3 = float32(obj)
}
return nil
}
func doSkipGlVertexAttrib4f(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
if _, err := d.Float32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlVertexAttrib4f) ID() binary.ID { return binaryIDGlVertexAttrib4f }
func (*binaryClassGlVertexAttrib4f) New() binary.Object { return &GlVertexAttrib4f{} }
func (*binaryClassGlVertexAttrib4f) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlVertexAttrib4f(e, obj.(*GlVertexAttrib4f))
}
func (*binaryClassGlVertexAttrib4f) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlVertexAttrib4f{}
return obj, doDecodeGlVertexAttrib4f(d, obj)
}
func (*binaryClassGlVertexAttrib4f) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlVertexAttrib4f(d, obj.(*GlVertexAttrib4f))
}
func (*binaryClassGlVertexAttrib4f) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib4f(d) }
func (*binaryClassGlVertexAttrib4f) Schema() *schema.Class { return schemaGlVertexAttrib4f }
var schemaGlVertexAttrib4f = &schema.Class{
TypeID: binaryIDGlVertexAttrib4f,
Name: "GlVertexAttrib4f",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
schema.Field{Declared: "Value0", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Value1", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Value2", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
schema.Field{Declared: "Value3", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
},
}
type binaryClassGlVertexAttrib4fv struct{}
func (*GlVertexAttrib4fv) Class() binary.Class {
return (*binaryClassGlVertexAttrib4fv)(nil)
}
func doEncodeGlVertexAttrib4fv(e binary.Encoder, o *GlVertexAttrib4fv) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
if err := e.Value(&o.Value); err != nil {
return err
}
return nil
}
func doDecodeGlVertexAttrib4fv(d binary.Decoder, o *GlVertexAttrib4fv) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
if err := d.Value(&o.Value); err != nil {
return err
}
return nil
}
func doSkipGlVertexAttrib4fv(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlVertexAttrib4fv) ID() binary.ID { return binaryIDGlVertexAttrib4fv }
func (*binaryClassGlVertexAttrib4fv) New() binary.Object { return &GlVertexAttrib4fv{} }
func (*binaryClassGlVertexAttrib4fv) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlVertexAttrib4fv(e, obj.(*GlVertexAttrib4fv))
}
func (*binaryClassGlVertexAttrib4fv) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlVertexAttrib4fv{}
return obj, doDecodeGlVertexAttrib4fv(d, obj)
}
func (*binaryClassGlVertexAttrib4fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlVertexAttrib4fv(d, obj.(*GlVertexAttrib4fv))
}
func (*binaryClassGlVertexAttrib4fv) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib4fv(d) }
func (*binaryClassGlVertexAttrib4fv) Schema() *schema.Class { return schemaGlVertexAttrib4fv }
var schemaGlVertexAttrib4fv = &schema.Class{
TypeID: binaryIDGlVertexAttrib4fv,
Name: "GlVertexAttrib4fv",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
schema.Field{Declared: "Value", Type: &schema.Struct{Name: "F32ᵖ"}},
},
}
type binaryClassGlVertexAttribPointer struct{}
func (*GlVertexAttribPointer) Class() binary.Class {
return (*binaryClassGlVertexAttribPointer)(nil)
}
func doEncodeGlVertexAttribPointer(e binary.Encoder, o *GlVertexAttribPointer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(uint32(o.Location)); err != nil {
return err
}
if err := e.Int32(o.Size); err != nil {
return err
}
if err := e.Uint32(uint32(o.Type)); err != nil {
return err
}
if err := e.Bool(o.Normalized); err != nil {
return err
}
if err := e.Int32(o.Stride); err != nil {
return err
}
if err := e.Value(&o.Data); err != nil {
return err
}
return nil
}
func doDecodeGlVertexAttribPointer(d binary.Decoder, o *GlVertexAttribPointer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Location = AttributeLocation(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Size = int32(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = VertexAttribType(obj)
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Normalized = bool(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Stride = int32(obj)
}
if err := d.Value(&o.Data); err != nil {
return err
}
return nil
}
func doSkipGlVertexAttribPointer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if err := d.SkipValue((*VertexPointer)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlVertexAttribPointer) ID() binary.ID { return binaryIDGlVertexAttribPointer }
func (*binaryClassGlVertexAttribPointer) New() binary.Object { return &GlVertexAttribPointer{} }
func (*binaryClassGlVertexAttribPointer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlVertexAttribPointer(e, obj.(*GlVertexAttribPointer))
}
func (*binaryClassGlVertexAttribPointer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlVertexAttribPointer{}
return obj, doDecodeGlVertexAttribPointer(d, obj)
}
func (*binaryClassGlVertexAttribPointer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlVertexAttribPointer(d, obj.(*GlVertexAttribPointer))
}
func (*binaryClassGlVertexAttribPointer) Skip(d binary.Decoder) error {
return doSkipGlVertexAttribPointer(d)
}
func (*binaryClassGlVertexAttribPointer) Schema() *schema.Class { return schemaGlVertexAttribPointer }
var schemaGlVertexAttribPointer = &schema.Class{
TypeID: binaryIDGlVertexAttribPointer,
Name: "GlVertexAttribPointer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
schema.Field{Declared: "Size", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "VertexAttribType", Method: schema.Uint32}},
schema.Field{Declared: "Normalized", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Stride", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Data", Type: &schema.Struct{Name: "VertexPointer"}},
},
}
type binaryClassGlViewport struct{}
func (*GlViewport) Class() binary.Class {
return (*binaryClassGlViewport)(nil)
}
func doEncodeGlViewport(e binary.Encoder, o *GlViewport) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Int32(o.X); err != nil {
return err
}
if err := e.Int32(o.Y); err != nil {
return err
}
if err := e.Int32(o.Width); err != nil {
return err
}
if err := e.Int32(o.Height); err != nil {
return err
}
return nil
}
func doDecodeGlViewport(d binary.Decoder, o *GlViewport) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.X = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Y = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Width = int32(obj)
}
if obj, err := d.Int32(); err != nil {
return err
} else {
o.Height = int32(obj)
}
return nil
}
func doSkipGlViewport(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
if _, err := d.Int32(); err != nil {
return err
}
return nil
}
func (*binaryClassGlViewport) ID() binary.ID { return binaryIDGlViewport }
func (*binaryClassGlViewport) New() binary.Object { return &GlViewport{} }
func (*binaryClassGlViewport) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlViewport(e, obj.(*GlViewport))
}
func (*binaryClassGlViewport) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlViewport{}
return obj, doDecodeGlViewport(d, obj)
}
func (*binaryClassGlViewport) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlViewport(d, obj.(*GlViewport))
}
func (*binaryClassGlViewport) Skip(d binary.Decoder) error { return doSkipGlViewport(d) }
func (*binaryClassGlViewport) Schema() *schema.Class { return schemaGlViewport }
var schemaGlViewport = &schema.Class{
TypeID: binaryIDGlViewport,
Name: "GlViewport",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "X", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Y", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
},
}
type binaryClassGlXCreateContext struct{}
func (*GlXCreateContext) Class() binary.Class {
return (*binaryClassGlXCreateContext)(nil)
}
func doEncodeGlXCreateContext(e binary.Encoder, o *GlXCreateContext) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Dpy); err != nil {
return err
}
if err := e.Value(&o.Vis); err != nil {
return err
}
if err := e.Value(&o.ShareList); err != nil {
return err
}
if err := e.Bool(o.Direct); err != nil {
return err
}
if err := e.Value(&o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlXCreateContext(d binary.Decoder, o *GlXCreateContext) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Dpy); err != nil {
return err
}
if err := d.Value(&o.Vis); err != nil {
return err
}
if err := d.Value(&o.ShareList); err != nil {
return err
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Direct = bool(obj)
}
if err := d.Value(&o.Result); err != nil {
return err
}
return nil
}
func doSkipGlXCreateContext(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*GLXContext)(nil)); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if err := d.SkipValue((*GLXContext)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlXCreateContext) ID() binary.ID { return binaryIDGlXCreateContext }
func (*binaryClassGlXCreateContext) New() binary.Object { return &GlXCreateContext{} }
func (*binaryClassGlXCreateContext) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlXCreateContext(e, obj.(*GlXCreateContext))
}
func (*binaryClassGlXCreateContext) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlXCreateContext{}
return obj, doDecodeGlXCreateContext(d, obj)
}
func (*binaryClassGlXCreateContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlXCreateContext(d, obj.(*GlXCreateContext))
}
func (*binaryClassGlXCreateContext) Skip(d binary.Decoder) error { return doSkipGlXCreateContext(d) }
func (*binaryClassGlXCreateContext) Schema() *schema.Class { return schemaGlXCreateContext }
var schemaGlXCreateContext = &schema.Class{
TypeID: binaryIDGlXCreateContext,
Name: "GlXCreateContext",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Dpy", Type: &schema.Struct{Name: "Voidᵖ"}},
schema.Field{Declared: "Vis", Type: &schema.Struct{Name: "Voidᵖ"}},
schema.Field{Declared: "ShareList", Type: &schema.Struct{Name: "GLXContext"}},
schema.Field{Declared: "Direct", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Result", Type: &schema.Struct{Name: "GLXContext"}},
},
}
type binaryClassGlXCreateNewContext struct{}
func (*GlXCreateNewContext) Class() binary.Class {
return (*binaryClassGlXCreateNewContext)(nil)
}
func doEncodeGlXCreateNewContext(e binary.Encoder, o *GlXCreateNewContext) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Display); err != nil {
return err
}
if err := e.Value(&o.Fbconfig); err != nil {
return err
}
if err := e.Uint32(o.Type); err != nil {
return err
}
if err := e.Value(&o.Shared); err != nil {
return err
}
if err := e.Bool(o.Direct); err != nil {
return err
}
if err := e.Value(&o.Result); err != nil {
return err
}
return nil
}
func doDecodeGlXCreateNewContext(d binary.Decoder, o *GlXCreateNewContext) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Display); err != nil {
return err
}
if err := d.Value(&o.Fbconfig); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Type = uint32(obj)
}
if err := d.Value(&o.Shared); err != nil {
return err
}
if obj, err := d.Bool(); err != nil {
return err
} else {
o.Direct = bool(obj)
}
if err := d.Value(&o.Result); err != nil {
return err
}
return nil
}
func doSkipGlXCreateNewContext(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if err := d.SkipValue((*GLXContext)(nil)); err != nil {
return err
}
if _, err := d.Bool(); err != nil {
return err
}
if err := d.SkipValue((*GLXContext)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlXCreateNewContext) ID() binary.ID { return binaryIDGlXCreateNewContext }
func (*binaryClassGlXCreateNewContext) New() binary.Object { return &GlXCreateNewContext{} }
func (*binaryClassGlXCreateNewContext) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlXCreateNewContext(e, obj.(*GlXCreateNewContext))
}
func (*binaryClassGlXCreateNewContext) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlXCreateNewContext{}
return obj, doDecodeGlXCreateNewContext(d, obj)
}
func (*binaryClassGlXCreateNewContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlXCreateNewContext(d, obj.(*GlXCreateNewContext))
}
func (*binaryClassGlXCreateNewContext) Skip(d binary.Decoder) error {
return doSkipGlXCreateNewContext(d)
}
func (*binaryClassGlXCreateNewContext) Schema() *schema.Class { return schemaGlXCreateNewContext }
var schemaGlXCreateNewContext = &schema.Class{
TypeID: binaryIDGlXCreateNewContext,
Name: "GlXCreateNewContext",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Display", Type: &schema.Struct{Name: "Voidᵖ"}},
schema.Field{Declared: "Fbconfig", Type: &schema.Struct{Name: "Voidᵖ"}},
schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
schema.Field{Declared: "Shared", Type: &schema.Struct{Name: "GLXContext"}},
schema.Field{Declared: "Direct", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
schema.Field{Declared: "Result", Type: &schema.Struct{Name: "GLXContext"}},
},
}
type binaryClassGlXMakeContextCurrent struct{}
func (*GlXMakeContextCurrent) Class() binary.Class {
return (*binaryClassGlXMakeContextCurrent)(nil)
}
func doEncodeGlXMakeContextCurrent(e binary.Encoder, o *GlXMakeContextCurrent) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Display); err != nil {
return err
}
if err := e.Value(&o.Draw); err != nil {
return err
}
if err := e.Value(&o.Read); err != nil {
return err
}
if err := e.Value(&o.Ctx); err != nil {
return err
}
return nil
}
func doDecodeGlXMakeContextCurrent(d binary.Decoder, o *GlXMakeContextCurrent) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Display); err != nil {
return err
}
if err := d.Value(&o.Draw); err != nil {
return err
}
if err := d.Value(&o.Read); err != nil {
return err
}
if err := d.Value(&o.Ctx); err != nil {
return err
}
return nil
}
func doSkipGlXMakeContextCurrent(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*GLXDrawable)(nil)); err != nil {
return err
}
if err := d.SkipValue((*GLXDrawable)(nil)); err != nil {
return err
}
if err := d.SkipValue((*GLXContext)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlXMakeContextCurrent) ID() binary.ID { return binaryIDGlXMakeContextCurrent }
func (*binaryClassGlXMakeContextCurrent) New() binary.Object { return &GlXMakeContextCurrent{} }
func (*binaryClassGlXMakeContextCurrent) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlXMakeContextCurrent(e, obj.(*GlXMakeContextCurrent))
}
func (*binaryClassGlXMakeContextCurrent) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlXMakeContextCurrent{}
return obj, doDecodeGlXMakeContextCurrent(d, obj)
}
func (*binaryClassGlXMakeContextCurrent) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlXMakeContextCurrent(d, obj.(*GlXMakeContextCurrent))
}
func (*binaryClassGlXMakeContextCurrent) Skip(d binary.Decoder) error {
return doSkipGlXMakeContextCurrent(d)
}
func (*binaryClassGlXMakeContextCurrent) Schema() *schema.Class { return schemaGlXMakeContextCurrent }
var schemaGlXMakeContextCurrent = &schema.Class{
TypeID: binaryIDGlXMakeContextCurrent,
Name: "GlXMakeContextCurrent",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Display", Type: &schema.Struct{Name: "Voidᵖ"}},
schema.Field{Declared: "Draw", Type: &schema.Struct{Name: "GLXDrawable"}},
schema.Field{Declared: "Read", Type: &schema.Struct{Name: "GLXDrawable"}},
schema.Field{Declared: "Ctx", Type: &schema.Struct{Name: "GLXContext"}},
},
}
type binaryClassGlXSwapBuffers struct{}
func (*GlXSwapBuffers) Class() binary.Class {
return (*binaryClassGlXSwapBuffers)(nil)
}
func doEncodeGlXSwapBuffers(e binary.Encoder, o *GlXSwapBuffers) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Display); err != nil {
return err
}
if err := e.Value(&o.Drawable); err != nil {
return err
}
return nil
}
func doDecodeGlXSwapBuffers(d binary.Decoder, o *GlXSwapBuffers) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Display); err != nil {
return err
}
if err := d.Value(&o.Drawable); err != nil {
return err
}
return nil
}
func doSkipGlXSwapBuffers(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*GLXDrawable)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassGlXSwapBuffers) ID() binary.ID { return binaryIDGlXSwapBuffers }
func (*binaryClassGlXSwapBuffers) New() binary.Object { return &GlXSwapBuffers{} }
func (*binaryClassGlXSwapBuffers) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlXSwapBuffers(e, obj.(*GlXSwapBuffers))
}
func (*binaryClassGlXSwapBuffers) Decode(d binary.Decoder) (binary.Object, error) {
obj := &GlXSwapBuffers{}
return obj, doDecodeGlXSwapBuffers(d, obj)
}
func (*binaryClassGlXSwapBuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlXSwapBuffers(d, obj.(*GlXSwapBuffers))
}
func (*binaryClassGlXSwapBuffers) Skip(d binary.Decoder) error { return doSkipGlXSwapBuffers(d) }
func (*binaryClassGlXSwapBuffers) Schema() *schema.Class { return schemaGlXSwapBuffers }
var schemaGlXSwapBuffers = &schema.Class{
TypeID: binaryIDGlXSwapBuffers,
Name: "GlXSwapBuffers",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Display", Type: &schema.Struct{Name: "Voidᵖ"}},
schema.Field{Declared: "Drawable", Type: &schema.Struct{Name: "GLXDrawable"}},
},
}
type binaryClassHGLRC struct{}
func (*HGLRC) Class() binary.Class {
return (*binaryClassHGLRC)(nil)
}
func doEncodeHGLRC(e binary.Encoder, o *HGLRC) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeHGLRC(d binary.Decoder, o *HGLRC) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipHGLRC(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassHGLRC) ID() binary.ID { return binaryIDHGLRC }
func (*binaryClassHGLRC) New() binary.Object { return &HGLRC{} }
func (*binaryClassHGLRC) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeHGLRC(e, obj.(*HGLRC))
}
func (*binaryClassHGLRC) Decode(d binary.Decoder) (binary.Object, error) {
obj := &HGLRC{}
return obj, doDecodeHGLRC(d, obj)
}
func (*binaryClassHGLRC) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeHGLRC(d, obj.(*HGLRC))
}
func (*binaryClassHGLRC) Skip(d binary.Decoder) error { return doSkipHGLRC(d) }
func (*binaryClassHGLRC) Schema() *schema.Class { return schemaHGLRC }
var schemaHGLRC = &schema.Class{
TypeID: binaryIDHGLRC,
Name: "HGLRC",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassGlobals struct{}
func (*Globals) Class() binary.Class {
return (*binaryClassGlobals)(nil)
}
func doEncodeGlobals(e binary.Encoder, o *Globals) error {
if err := e.Uint32(uint32(o.NextContextID)); err != nil {
return err
}
if err := e.Uint32(uint32(o.CurrentThread)); err != nil {
return err
}
if err := e.Uint32(uint32(len(o.Contexts))); err != nil {
return err
}
for k, v := range o.Contexts {
if err := e.Uint32(uint32(k)); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.EGLContexts))); err != nil {
return err
}
for k, v := range o.EGLContexts {
if err := e.Value(&k); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.GLXContexts))); err != nil {
return err
}
for k, v := range o.GLXContexts {
if err := e.Value(&k); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.WGLContexts))); err != nil {
return err
}
for k, v := range o.WGLContexts {
if err := e.Value(&k); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
if err := e.Uint32(uint32(len(o.CGLContexts))); err != nil {
return err
}
for k, v := range o.CGLContexts {
if err := e.Value(&k); err != nil {
return err
}
if v != nil {
if err := e.Object(v); err != nil {
return err
}
} else if err := e.Object(nil); err != nil {
return err
}
}
return nil
}
func doDecodeGlobals(d binary.Decoder, o *Globals) error {
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.NextContextID = ContextID(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.CurrentThread = ThreadID(obj)
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.Contexts = make(ThreadIDːContextʳᵐ, count)
m := o.Contexts
for i := uint32(0); i < count; i++ {
var k ThreadID
var v *Context
if obj, err := d.Uint32(); err != nil {
return err
} else {
k = ThreadID(obj)
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*Context)
} else {
v = nil
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.EGLContexts = make(EGLContextːContextʳᵐ, count)
m := o.EGLContexts
for i := uint32(0); i < count; i++ {
var k EGLContext
var v *Context
if err := d.Value(&k); err != nil {
return err
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*Context)
} else {
v = nil
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.GLXContexts = make(GLXContextːContextʳᵐ, count)
m := o.GLXContexts
for i := uint32(0); i < count; i++ {
var k GLXContext
var v *Context
if err := d.Value(&k); err != nil {
return err
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*Context)
} else {
v = nil
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.WGLContexts = make(HGLRCːContextʳᵐ, count)
m := o.WGLContexts
for i := uint32(0); i < count; i++ {
var k HGLRC
var v *Context
if err := d.Value(&k); err != nil {
return err
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*Context)
} else {
v = nil
}
m[k] = v
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
o.CGLContexts = make(CGLContextObjːContextʳᵐ, count)
m := o.CGLContexts
for i := uint32(0); i < count; i++ {
var k CGLContextObj
var v *Context
if err := d.Value(&k); err != nil {
return err
}
if obj, err := d.Object(); err != nil {
return err
} else if obj != nil {
v = obj.(*Context)
} else {
v = nil
}
m[k] = v
}
}
return nil
}
func doSkipGlobals(d binary.Decoder) error {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if _, err := d.Uint32(); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if err := d.SkipValue((*EGLContext)(nil)); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if err := d.SkipValue((*GLXContext)(nil)); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if err := d.SkipValue((*HGLRC)(nil)); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
if count, err := d.Uint32(); err != nil {
return err
} else {
for i := uint32(0); i < count; i++ {
if err := d.SkipValue((*CGLContextObj)(nil)); err != nil {
return err
}
if _, err := d.SkipObject(); err != nil {
return err
}
}
}
return nil
}
func (*binaryClassGlobals) ID() binary.ID { return binaryIDGlobals }
func (*binaryClassGlobals) New() binary.Object { return &Globals{} }
func (*binaryClassGlobals) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeGlobals(e, obj.(*Globals))
}
func (*binaryClassGlobals) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Globals{}
return obj, doDecodeGlobals(d, obj)
}
func (*binaryClassGlobals) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeGlobals(d, obj.(*Globals))
}
func (*binaryClassGlobals) Skip(d binary.Decoder) error { return doSkipGlobals(d) }
func (*binaryClassGlobals) Schema() *schema.Class { return schemaGlobals }
var schemaGlobals = &schema.Class{
TypeID: binaryIDGlobals,
Name: "Globals",
Fields: []schema.Field{
schema.Field{Declared: "NextContextID", Type: &schema.Primitive{Name: "ContextID", Method: schema.Uint32}},
schema.Field{Declared: "CurrentThread", Type: &schema.Primitive{Name: "ThreadID", Method: schema.Uint32}},
schema.Field{Declared: "Contexts", Type: &schema.Map{Alias: "ThreadIDːContextʳᵐ", KeyType: &schema.Primitive{Name: "ThreadID", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Context"}}}},
schema.Field{Declared: "EGLContexts", Type: &schema.Map{Alias: "EGLContextːContextʳᵐ", KeyType: &schema.Struct{Name: "EGLContext"}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Context"}}}},
schema.Field{Declared: "GLXContexts", Type: &schema.Map{Alias: "GLXContextːContextʳᵐ", KeyType: &schema.Struct{Name: "GLXContext"}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Context"}}}},
schema.Field{Declared: "WGLContexts", Type: &schema.Map{Alias: "HGLRCːContextʳᵐ", KeyType: &schema.Struct{Name: "HGLRC"}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Context"}}}},
schema.Field{Declared: "CGLContexts", Type: &schema.Map{Alias: "CGLContextObjːContextʳᵐ", KeyType: &schema.Struct{Name: "CGLContextObj"}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Context"}}}},
},
}
type binaryClassHDC struct{}
func (*HDC) Class() binary.Class {
return (*binaryClassHDC)(nil)
}
func doEncodeHDC(e binary.Encoder, o *HDC) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeHDC(d binary.Decoder, o *HDC) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipHDC(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassHDC) ID() binary.ID { return binaryIDHDC }
func (*binaryClassHDC) New() binary.Object { return &HDC{} }
func (*binaryClassHDC) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeHDC(e, obj.(*HDC))
}
func (*binaryClassHDC) Decode(d binary.Decoder) (binary.Object, error) {
obj := &HDC{}
return obj, doDecodeHDC(d, obj)
}
func (*binaryClassHDC) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeHDC(d, obj.(*HDC))
}
func (*binaryClassHDC) Skip(d binary.Decoder) error { return doSkipHDC(d) }
func (*binaryClassHDC) Schema() *schema.Class { return schemaHDC }
var schemaHDC = &schema.Class{
TypeID: binaryIDHDC,
Name: "HDC",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassIntˢ struct{}
func (*Intˢ) Class() binary.Class {
return (*binaryClassIntˢ)(nil)
}
func doEncodeIntˢ(e binary.Encoder, o *Intˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeIntˢ(d binary.Decoder, o *Intˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipIntˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassIntˢ) ID() binary.ID { return binaryIDIntˢ }
func (*binaryClassIntˢ) New() binary.Object { return &Intˢ{} }
func (*binaryClassIntˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeIntˢ(e, obj.(*Intˢ))
}
func (*binaryClassIntˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Intˢ{}
return obj, doDecodeIntˢ(d, obj)
}
func (*binaryClassIntˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeIntˢ(d, obj.(*Intˢ))
}
func (*binaryClassIntˢ) Skip(d binary.Decoder) error { return doSkipIntˢ(d) }
func (*binaryClassIntˢ) Schema() *schema.Class { return schemaIntˢ }
var schemaIntˢ = &schema.Class{
TypeID: binaryIDIntˢ,
Name: "Intˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassIntᵖ struct{}
func (*Intᵖ) Class() binary.Class {
return (*binaryClassIntᵖ)(nil)
}
func doEncodeIntᵖ(e binary.Encoder, o *Intᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeIntᵖ(d binary.Decoder, o *Intᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipIntᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassIntᵖ) ID() binary.ID { return binaryIDIntᵖ }
func (*binaryClassIntᵖ) New() binary.Object { return &Intᵖ{} }
func (*binaryClassIntᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeIntᵖ(e, obj.(*Intᵖ))
}
func (*binaryClassIntᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Intᵖ{}
return obj, doDecodeIntᵖ(d, obj)
}
func (*binaryClassIntᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeIntᵖ(d, obj.(*Intᵖ))
}
func (*binaryClassIntᵖ) Skip(d binary.Decoder) error { return doSkipIntᵖ(d) }
func (*binaryClassIntᵖ) Schema() *schema.Class { return schemaIntᵖ }
var schemaIntᵖ = &schema.Class{
TypeID: binaryIDIntᵖ,
Name: "Intᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassQueryIdˢ struct{}
func (*QueryIdˢ) Class() binary.Class {
return (*binaryClassQueryIdˢ)(nil)
}
func doEncodeQueryIdˢ(e binary.Encoder, o *QueryIdˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeQueryIdˢ(d binary.Decoder, o *QueryIdˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipQueryIdˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassQueryIdˢ) ID() binary.ID { return binaryIDQueryIdˢ }
func (*binaryClassQueryIdˢ) New() binary.Object { return &QueryIdˢ{} }
func (*binaryClassQueryIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeQueryIdˢ(e, obj.(*QueryIdˢ))
}
func (*binaryClassQueryIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &QueryIdˢ{}
return obj, doDecodeQueryIdˢ(d, obj)
}
func (*binaryClassQueryIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeQueryIdˢ(d, obj.(*QueryIdˢ))
}
func (*binaryClassQueryIdˢ) Skip(d binary.Decoder) error { return doSkipQueryIdˢ(d) }
func (*binaryClassQueryIdˢ) Schema() *schema.Class { return schemaQueryIdˢ }
var schemaQueryIdˢ = &schema.Class{
TypeID: binaryIDQueryIdˢ,
Name: "QueryIdˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassRenderbufferIdˢ struct{}
func (*RenderbufferIdˢ) Class() binary.Class {
return (*binaryClassRenderbufferIdˢ)(nil)
}
func doEncodeRenderbufferIdˢ(e binary.Encoder, o *RenderbufferIdˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeRenderbufferIdˢ(d binary.Decoder, o *RenderbufferIdˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipRenderbufferIdˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassRenderbufferIdˢ) ID() binary.ID { return binaryIDRenderbufferIdˢ }
func (*binaryClassRenderbufferIdˢ) New() binary.Object { return &RenderbufferIdˢ{} }
func (*binaryClassRenderbufferIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeRenderbufferIdˢ(e, obj.(*RenderbufferIdˢ))
}
func (*binaryClassRenderbufferIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &RenderbufferIdˢ{}
return obj, doDecodeRenderbufferIdˢ(d, obj)
}
func (*binaryClassRenderbufferIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeRenderbufferIdˢ(d, obj.(*RenderbufferIdˢ))
}
func (*binaryClassRenderbufferIdˢ) Skip(d binary.Decoder) error { return doSkipRenderbufferIdˢ(d) }
func (*binaryClassRenderbufferIdˢ) Schema() *schema.Class { return schemaRenderbufferIdˢ }
var schemaRenderbufferIdˢ = &schema.Class{
TypeID: binaryIDRenderbufferIdˢ,
Name: "RenderbufferIdˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassReplayBindRenderer struct{}
func (*ReplayBindRenderer) Class() binary.Class {
return (*binaryClassReplayBindRenderer)(nil)
}
func doEncodeReplayBindRenderer(e binary.Encoder, o *ReplayBindRenderer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(o.Id); err != nil {
return err
}
return nil
}
func doDecodeReplayBindRenderer(d binary.Decoder, o *ReplayBindRenderer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Id = uint32(obj)
}
return nil
}
func doSkipReplayBindRenderer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassReplayBindRenderer) ID() binary.ID { return binaryIDReplayBindRenderer }
func (*binaryClassReplayBindRenderer) New() binary.Object { return &ReplayBindRenderer{} }
func (*binaryClassReplayBindRenderer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeReplayBindRenderer(e, obj.(*ReplayBindRenderer))
}
func (*binaryClassReplayBindRenderer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &ReplayBindRenderer{}
return obj, doDecodeReplayBindRenderer(d, obj)
}
func (*binaryClassReplayBindRenderer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeReplayBindRenderer(d, obj.(*ReplayBindRenderer))
}
func (*binaryClassReplayBindRenderer) Skip(d binary.Decoder) error { return doSkipReplayBindRenderer(d) }
func (*binaryClassReplayBindRenderer) Schema() *schema.Class { return schemaReplayBindRenderer }
var schemaReplayBindRenderer = &schema.Class{
TypeID: binaryIDReplayBindRenderer,
Name: "ReplayBindRenderer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Id", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
},
}
type binaryClassReplayCreateRenderer struct{}
func (*ReplayCreateRenderer) Class() binary.Class {
return (*binaryClassReplayCreateRenderer)(nil)
}
func doEncodeReplayCreateRenderer(e binary.Encoder, o *ReplayCreateRenderer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint32(o.Id); err != nil {
return err
}
return nil
}
func doDecodeReplayCreateRenderer(d binary.Decoder, o *ReplayCreateRenderer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Id = uint32(obj)
}
return nil
}
func doSkipReplayCreateRenderer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassReplayCreateRenderer) ID() binary.ID { return binaryIDReplayCreateRenderer }
func (*binaryClassReplayCreateRenderer) New() binary.Object { return &ReplayCreateRenderer{} }
func (*binaryClassReplayCreateRenderer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeReplayCreateRenderer(e, obj.(*ReplayCreateRenderer))
}
func (*binaryClassReplayCreateRenderer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &ReplayCreateRenderer{}
return obj, doDecodeReplayCreateRenderer(d, obj)
}
func (*binaryClassReplayCreateRenderer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeReplayCreateRenderer(d, obj.(*ReplayCreateRenderer))
}
func (*binaryClassReplayCreateRenderer) Skip(d binary.Decoder) error {
return doSkipReplayCreateRenderer(d)
}
func (*binaryClassReplayCreateRenderer) Schema() *schema.Class { return schemaReplayCreateRenderer }
var schemaReplayCreateRenderer = &schema.Class{
TypeID: binaryIDReplayCreateRenderer,
Name: "ReplayCreateRenderer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Id", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
},
}
type binaryClassS32ˢ struct{}
func (*S32ˢ) Class() binary.Class {
return (*binaryClassS32ˢ)(nil)
}
func doEncodeS32ˢ(e binary.Encoder, o *S32ˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeS32ˢ(d binary.Decoder, o *S32ˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipS32ˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassS32ˢ) ID() binary.ID { return binaryIDS32ˢ }
func (*binaryClassS32ˢ) New() binary.Object { return &S32ˢ{} }
func (*binaryClassS32ˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeS32ˢ(e, obj.(*S32ˢ))
}
func (*binaryClassS32ˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &S32ˢ{}
return obj, doDecodeS32ˢ(d, obj)
}
func (*binaryClassS32ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeS32ˢ(d, obj.(*S32ˢ))
}
func (*binaryClassS32ˢ) Skip(d binary.Decoder) error { return doSkipS32ˢ(d) }
func (*binaryClassS32ˢ) Schema() *schema.Class { return schemaS32ˢ }
var schemaS32ˢ = &schema.Class{
TypeID: binaryIDS32ˢ,
Name: "S32ˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassS64ˢ struct{}
func (*S64ˢ) Class() binary.Class {
return (*binaryClassS64ˢ)(nil)
}
func doEncodeS64ˢ(e binary.Encoder, o *S64ˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeS64ˢ(d binary.Decoder, o *S64ˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipS64ˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassS64ˢ) ID() binary.ID { return binaryIDS64ˢ }
func (*binaryClassS64ˢ) New() binary.Object { return &S64ˢ{} }
func (*binaryClassS64ˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeS64ˢ(e, obj.(*S64ˢ))
}
func (*binaryClassS64ˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &S64ˢ{}
return obj, doDecodeS64ˢ(d, obj)
}
func (*binaryClassS64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeS64ˢ(d, obj.(*S64ˢ))
}
func (*binaryClassS64ˢ) Skip(d binary.Decoder) error { return doSkipS64ˢ(d) }
func (*binaryClassS64ˢ) Schema() *schema.Class { return schemaS64ˢ }
var schemaS64ˢ = &schema.Class{
TypeID: binaryIDS64ˢ,
Name: "S64ˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassShaderAttribTypeˢ struct{}
func (*ShaderAttribTypeˢ) Class() binary.Class {
return (*binaryClassShaderAttribTypeˢ)(nil)
}
func doEncodeShaderAttribTypeˢ(e binary.Encoder, o *ShaderAttribTypeˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeShaderAttribTypeˢ(d binary.Decoder, o *ShaderAttribTypeˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipShaderAttribTypeˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassShaderAttribTypeˢ) ID() binary.ID { return binaryIDShaderAttribTypeˢ }
func (*binaryClassShaderAttribTypeˢ) New() binary.Object { return &ShaderAttribTypeˢ{} }
func (*binaryClassShaderAttribTypeˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeShaderAttribTypeˢ(e, obj.(*ShaderAttribTypeˢ))
}
func (*binaryClassShaderAttribTypeˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &ShaderAttribTypeˢ{}
return obj, doDecodeShaderAttribTypeˢ(d, obj)
}
func (*binaryClassShaderAttribTypeˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeShaderAttribTypeˢ(d, obj.(*ShaderAttribTypeˢ))
}
func (*binaryClassShaderAttribTypeˢ) Skip(d binary.Decoder) error { return doSkipShaderAttribTypeˢ(d) }
func (*binaryClassShaderAttribTypeˢ) Schema() *schema.Class { return schemaShaderAttribTypeˢ }
var schemaShaderAttribTypeˢ = &schema.Class{
TypeID: binaryIDShaderAttribTypeˢ,
Name: "ShaderAttribTypeˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassShaderIdˢ struct{}
func (*ShaderIdˢ) Class() binary.Class {
return (*binaryClassShaderIdˢ)(nil)
}
func doEncodeShaderIdˢ(e binary.Encoder, o *ShaderIdˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeShaderIdˢ(d binary.Decoder, o *ShaderIdˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipShaderIdˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassShaderIdˢ) ID() binary.ID { return binaryIDShaderIdˢ }
func (*binaryClassShaderIdˢ) New() binary.Object { return &ShaderIdˢ{} }
func (*binaryClassShaderIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeShaderIdˢ(e, obj.(*ShaderIdˢ))
}
func (*binaryClassShaderIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &ShaderIdˢ{}
return obj, doDecodeShaderIdˢ(d, obj)
}
func (*binaryClassShaderIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeShaderIdˢ(d, obj.(*ShaderIdˢ))
}
func (*binaryClassShaderIdˢ) Skip(d binary.Decoder) error { return doSkipShaderIdˢ(d) }
func (*binaryClassShaderIdˢ) Schema() *schema.Class { return schemaShaderIdˢ }
var schemaShaderIdˢ = &schema.Class{
TypeID: binaryIDShaderIdˢ,
Name: "ShaderIdˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassShaderUniformTypeˢ struct{}
func (*ShaderUniformTypeˢ) Class() binary.Class {
return (*binaryClassShaderUniformTypeˢ)(nil)
}
func doEncodeShaderUniformTypeˢ(e binary.Encoder, o *ShaderUniformTypeˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeShaderUniformTypeˢ(d binary.Decoder, o *ShaderUniformTypeˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipShaderUniformTypeˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassShaderUniformTypeˢ) ID() binary.ID { return binaryIDShaderUniformTypeˢ }
func (*binaryClassShaderUniformTypeˢ) New() binary.Object { return &ShaderUniformTypeˢ{} }
func (*binaryClassShaderUniformTypeˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeShaderUniformTypeˢ(e, obj.(*ShaderUniformTypeˢ))
}
func (*binaryClassShaderUniformTypeˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &ShaderUniformTypeˢ{}
return obj, doDecodeShaderUniformTypeˢ(d, obj)
}
func (*binaryClassShaderUniformTypeˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeShaderUniformTypeˢ(d, obj.(*ShaderUniformTypeˢ))
}
func (*binaryClassShaderUniformTypeˢ) Skip(d binary.Decoder) error {
return doSkipShaderUniformTypeˢ(d)
}
func (*binaryClassShaderUniformTypeˢ) Schema() *schema.Class { return schemaShaderUniformTypeˢ }
var schemaShaderUniformTypeˢ = &schema.Class{
TypeID: binaryIDShaderUniformTypeˢ,
Name: "ShaderUniformTypeˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassStartTimer struct{}
func (*StartTimer) Class() binary.Class {
return (*binaryClassStartTimer)(nil)
}
func doEncodeStartTimer(e binary.Encoder, o *StartTimer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint8(o.Index); err != nil {
return err
}
return nil
}
func doDecodeStartTimer(d binary.Decoder, o *StartTimer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint8(); err != nil {
return err
} else {
o.Index = uint8(obj)
}
return nil
}
func doSkipStartTimer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint8(); err != nil {
return err
}
return nil
}
func (*binaryClassStartTimer) ID() binary.ID { return binaryIDStartTimer }
func (*binaryClassStartTimer) New() binary.Object { return &StartTimer{} }
func (*binaryClassStartTimer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeStartTimer(e, obj.(*StartTimer))
}
func (*binaryClassStartTimer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &StartTimer{}
return obj, doDecodeStartTimer(d, obj)
}
func (*binaryClassStartTimer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeStartTimer(d, obj.(*StartTimer))
}
func (*binaryClassStartTimer) Skip(d binary.Decoder) error { return doSkipStartTimer(d) }
func (*binaryClassStartTimer) Schema() *schema.Class { return schemaStartTimer }
var schemaStartTimer = &schema.Class{
TypeID: binaryIDStartTimer,
Name: "StartTimer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Index", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}},
},
}
type binaryClassStopTimer struct{}
func (*StopTimer) Class() binary.Class {
return (*binaryClassStopTimer)(nil)
}
func doEncodeStopTimer(e binary.Encoder, o *StopTimer) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Uint8(o.Index); err != nil {
return err
}
if err := e.Uint64(o.Result); err != nil {
return err
}
return nil
}
func doDecodeStopTimer(d binary.Decoder, o *StopTimer) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if obj, err := d.Uint8(); err != nil {
return err
} else {
o.Index = uint8(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Result = uint64(obj)
}
return nil
}
func doSkipStopTimer(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if _, err := d.Uint8(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
return nil
}
func (*binaryClassStopTimer) ID() binary.ID { return binaryIDStopTimer }
func (*binaryClassStopTimer) New() binary.Object { return &StopTimer{} }
func (*binaryClassStopTimer) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeStopTimer(e, obj.(*StopTimer))
}
func (*binaryClassStopTimer) Decode(d binary.Decoder) (binary.Object, error) {
obj := &StopTimer{}
return obj, doDecodeStopTimer(d, obj)
}
func (*binaryClassStopTimer) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeStopTimer(d, obj.(*StopTimer))
}
func (*binaryClassStopTimer) Skip(d binary.Decoder) error { return doSkipStopTimer(d) }
func (*binaryClassStopTimer) Schema() *schema.Class { return schemaStopTimer }
var schemaStopTimer = &schema.Class{
TypeID: binaryIDStopTimer,
Name: "StopTimer",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Index", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
},
}
type binaryClassTextureIdˢ struct{}
func (*TextureIdˢ) Class() binary.Class {
return (*binaryClassTextureIdˢ)(nil)
}
func doEncodeTextureIdˢ(e binary.Encoder, o *TextureIdˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeTextureIdˢ(d binary.Decoder, o *TextureIdˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipTextureIdˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassTextureIdˢ) ID() binary.ID { return binaryIDTextureIdˢ }
func (*binaryClassTextureIdˢ) New() binary.Object { return &TextureIdˢ{} }
func (*binaryClassTextureIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeTextureIdˢ(e, obj.(*TextureIdˢ))
}
func (*binaryClassTextureIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &TextureIdˢ{}
return obj, doDecodeTextureIdˢ(d, obj)
}
func (*binaryClassTextureIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeTextureIdˢ(d, obj.(*TextureIdˢ))
}
func (*binaryClassTextureIdˢ) Skip(d binary.Decoder) error { return doSkipTextureIdˢ(d) }
func (*binaryClassTextureIdˢ) Schema() *schema.Class { return schemaTextureIdˢ }
var schemaTextureIdˢ = &schema.Class{
TypeID: binaryIDTextureIdˢ,
Name: "TextureIdˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassU32ˢ struct{}
func (*U32ˢ) Class() binary.Class {
return (*binaryClassU32ˢ)(nil)
}
func doEncodeU32ˢ(e binary.Encoder, o *U32ˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeU32ˢ(d binary.Decoder, o *U32ˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipU32ˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassU32ˢ) ID() binary.ID { return binaryIDU32ˢ }
func (*binaryClassU32ˢ) New() binary.Object { return &U32ˢ{} }
func (*binaryClassU32ˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeU32ˢ(e, obj.(*U32ˢ))
}
func (*binaryClassU32ˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &U32ˢ{}
return obj, doDecodeU32ˢ(d, obj)
}
func (*binaryClassU32ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeU32ˢ(d, obj.(*U32ˢ))
}
func (*binaryClassU32ˢ) Skip(d binary.Decoder) error { return doSkipU32ˢ(d) }
func (*binaryClassU32ˢ) Schema() *schema.Class { return schemaU32ˢ }
var schemaU32ˢ = &schema.Class{
TypeID: binaryIDU32ˢ,
Name: "U32ˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassU64ˢ struct{}
func (*U64ˢ) Class() binary.Class {
return (*binaryClassU64ˢ)(nil)
}
func doEncodeU64ˢ(e binary.Encoder, o *U64ˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeU64ˢ(d binary.Decoder, o *U64ˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipU64ˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassU64ˢ) ID() binary.ID { return binaryIDU64ˢ }
func (*binaryClassU64ˢ) New() binary.Object { return &U64ˢ{} }
func (*binaryClassU64ˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeU64ˢ(e, obj.(*U64ˢ))
}
func (*binaryClassU64ˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &U64ˢ{}
return obj, doDecodeU64ˢ(d, obj)
}
func (*binaryClassU64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeU64ˢ(d, obj.(*U64ˢ))
}
func (*binaryClassU64ˢ) Skip(d binary.Decoder) error { return doSkipU64ˢ(d) }
func (*binaryClassU64ˢ) Schema() *schema.Class { return schemaU64ˢ }
var schemaU64ˢ = &schema.Class{
TypeID: binaryIDU64ˢ,
Name: "U64ˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassU8ᵖ struct{}
func (*U8ᵖ) Class() binary.Class {
return (*binaryClassU8ᵖ)(nil)
}
func doEncodeU8ᵖ(e binary.Encoder, o *U8ᵖ) error {
if err := e.Uint64(uint64(o.Address)); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeU8ᵖ(d binary.Decoder, o *U8ᵖ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Address = memory.Pointer(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipU8ᵖ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassU8ᵖ) ID() binary.ID { return binaryIDU8ᵖ }
func (*binaryClassU8ᵖ) New() binary.Object { return &U8ᵖ{} }
func (*binaryClassU8ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeU8ᵖ(e, obj.(*U8ᵖ))
}
func (*binaryClassU8ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &U8ᵖ{}
return obj, doDecodeU8ᵖ(d, obj)
}
func (*binaryClassU8ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeU8ᵖ(d, obj.(*U8ᵖ))
}
func (*binaryClassU8ᵖ) Skip(d binary.Decoder) error { return doSkipU8ᵖ(d) }
func (*binaryClassU8ᵖ) Schema() *schema.Class { return schemaU8ᵖ }
var schemaU8ᵖ = &schema.Class{
TypeID: binaryIDU8ᵖ,
Name: "U8ᵖ",
Fields: []schema.Field{
schema.Field{Declared: "Address", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassVertexArrayIdˢ struct{}
func (*VertexArrayIdˢ) Class() binary.Class {
return (*binaryClassVertexArrayIdˢ)(nil)
}
func doEncodeVertexArrayIdˢ(e binary.Encoder, o *VertexArrayIdˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeVertexArrayIdˢ(d binary.Decoder, o *VertexArrayIdˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipVertexArrayIdˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassVertexArrayIdˢ) ID() binary.ID { return binaryIDVertexArrayIdˢ }
func (*binaryClassVertexArrayIdˢ) New() binary.Object { return &VertexArrayIdˢ{} }
func (*binaryClassVertexArrayIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVertexArrayIdˢ(e, obj.(*VertexArrayIdˢ))
}
func (*binaryClassVertexArrayIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &VertexArrayIdˢ{}
return obj, doDecodeVertexArrayIdˢ(d, obj)
}
func (*binaryClassVertexArrayIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVertexArrayIdˢ(d, obj.(*VertexArrayIdˢ))
}
func (*binaryClassVertexArrayIdˢ) Skip(d binary.Decoder) error { return doSkipVertexArrayIdˢ(d) }
func (*binaryClassVertexArrayIdˢ) Schema() *schema.Class { return schemaVertexArrayIdˢ }
var schemaVertexArrayIdˢ = &schema.Class{
TypeID: binaryIDVertexArrayIdˢ,
Name: "VertexArrayIdˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassVoidˢ struct{}
func (*Voidˢ) Class() binary.Class {
return (*binaryClassVoidˢ)(nil)
}
func doEncodeVoidˢ(e binary.Encoder, o *Voidˢ) error {
if err := e.Uint64(uint64(o.Root)); err != nil {
return err
}
if err := e.Uint64(uint64(o.Base)); err != nil {
return err
}
if err := e.Uint64(o.Count); err != nil {
return err
}
if err := e.Uint32(uint32(o.Pool)); err != nil {
return err
}
return nil
}
func doDecodeVoidˢ(d binary.Decoder, o *Voidˢ) error {
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Root = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Base = memory.Pointer(obj)
}
if obj, err := d.Uint64(); err != nil {
return err
} else {
o.Count = uint64(obj)
}
if obj, err := d.Uint32(); err != nil {
return err
} else {
o.Pool = memory.PoolID(obj)
}
return nil
}
func doSkipVoidˢ(d binary.Decoder) error {
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint64(); err != nil {
return err
}
if _, err := d.Uint32(); err != nil {
return err
}
return nil
}
func (*binaryClassVoidˢ) ID() binary.ID { return binaryIDVoidˢ }
func (*binaryClassVoidˢ) New() binary.Object { return &Voidˢ{} }
func (*binaryClassVoidˢ) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeVoidˢ(e, obj.(*Voidˢ))
}
func (*binaryClassVoidˢ) Decode(d binary.Decoder) (binary.Object, error) {
obj := &Voidˢ{}
return obj, doDecodeVoidˢ(d, obj)
}
func (*binaryClassVoidˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeVoidˢ(d, obj.(*Voidˢ))
}
func (*binaryClassVoidˢ) Skip(d binary.Decoder) error { return doSkipVoidˢ(d) }
func (*binaryClassVoidˢ) Schema() *schema.Class { return schemaVoidˢ }
var schemaVoidˢ = &schema.Class{
TypeID: binaryIDVoidˢ,
Name: "Voidˢ",
Fields: []schema.Field{
schema.Field{Declared: "Root", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "memory.Pointer", Method: schema.Uint64}},
schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
schema.Field{Declared: "Pool", Type: &schema.Primitive{Name: "memory.PoolID", Method: schema.Uint32}},
},
}
type binaryClassWglCreateContext struct{}
func (*WglCreateContext) Class() binary.Class {
return (*binaryClassWglCreateContext)(nil)
}
func doEncodeWglCreateContext(e binary.Encoder, o *WglCreateContext) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Hdc); err != nil {
return err
}
if err := e.Value(&o.Result); err != nil {
return err
}
return nil
}
func doDecodeWglCreateContext(d binary.Decoder, o *WglCreateContext) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Hdc); err != nil {
return err
}
if err := d.Value(&o.Result); err != nil {
return err
}
return nil
}
func doSkipWglCreateContext(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*HDC)(nil)); err != nil {
return err
}
if err := d.SkipValue((*HGLRC)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassWglCreateContext) ID() binary.ID { return binaryIDWglCreateContext }
func (*binaryClassWglCreateContext) New() binary.Object { return &WglCreateContext{} }
func (*binaryClassWglCreateContext) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeWglCreateContext(e, obj.(*WglCreateContext))
}
func (*binaryClassWglCreateContext) Decode(d binary.Decoder) (binary.Object, error) {
obj := &WglCreateContext{}
return obj, doDecodeWglCreateContext(d, obj)
}
func (*binaryClassWglCreateContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeWglCreateContext(d, obj.(*WglCreateContext))
}
func (*binaryClassWglCreateContext) Skip(d binary.Decoder) error { return doSkipWglCreateContext(d) }
func (*binaryClassWglCreateContext) Schema() *schema.Class { return schemaWglCreateContext }
var schemaWglCreateContext = &schema.Class{
TypeID: binaryIDWglCreateContext,
Name: "WglCreateContext",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Hdc", Type: &schema.Struct{Name: "HDC"}},
schema.Field{Declared: "Result", Type: &schema.Struct{Name: "HGLRC"}},
},
}
type binaryClassWglCreateContextAttribsARB struct{}
func (*WglCreateContextAttribsARB) Class() binary.Class {
return (*binaryClassWglCreateContextAttribsARB)(nil)
}
func doEncodeWglCreateContextAttribsARB(e binary.Encoder, o *WglCreateContextAttribsARB) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Hdc); err != nil {
return err
}
if err := e.Value(&o.HShareContext); err != nil {
return err
}
if err := e.Value(&o.AttribList); err != nil {
return err
}
if err := e.Value(&o.Result); err != nil {
return err
}
return nil
}
func doDecodeWglCreateContextAttribsARB(d binary.Decoder, o *WglCreateContextAttribsARB) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Hdc); err != nil {
return err
}
if err := d.Value(&o.HShareContext); err != nil {
return err
}
if err := d.Value(&o.AttribList); err != nil {
return err
}
if err := d.Value(&o.Result); err != nil {
return err
}
return nil
}
func doSkipWglCreateContextAttribsARB(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*HDC)(nil)); err != nil {
return err
}
if err := d.SkipValue((*HGLRC)(nil)); err != nil {
return err
}
if err := d.SkipValue((*Intᵖ)(nil)); err != nil {
return err
}
if err := d.SkipValue((*HGLRC)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassWglCreateContextAttribsARB) ID() binary.ID {
return binaryIDWglCreateContextAttribsARB
}
func (*binaryClassWglCreateContextAttribsARB) New() binary.Object {
return &WglCreateContextAttribsARB{}
}
func (*binaryClassWglCreateContextAttribsARB) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeWglCreateContextAttribsARB(e, obj.(*WglCreateContextAttribsARB))
}
func (*binaryClassWglCreateContextAttribsARB) Decode(d binary.Decoder) (binary.Object, error) {
obj := &WglCreateContextAttribsARB{}
return obj, doDecodeWglCreateContextAttribsARB(d, obj)
}
func (*binaryClassWglCreateContextAttribsARB) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeWglCreateContextAttribsARB(d, obj.(*WglCreateContextAttribsARB))
}
func (*binaryClassWglCreateContextAttribsARB) Skip(d binary.Decoder) error {
return doSkipWglCreateContextAttribsARB(d)
}
func (*binaryClassWglCreateContextAttribsARB) Schema() *schema.Class {
return schemaWglCreateContextAttribsARB
}
var schemaWglCreateContextAttribsARB = &schema.Class{
TypeID: binaryIDWglCreateContextAttribsARB,
Name: "WglCreateContextAttribsARB",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Hdc", Type: &schema.Struct{Name: "HDC"}},
schema.Field{Declared: "HShareContext", Type: &schema.Struct{Name: "HGLRC"}},
schema.Field{Declared: "AttribList", Type: &schema.Struct{Name: "Intᵖ"}},
schema.Field{Declared: "Result", Type: &schema.Struct{Name: "HGLRC"}},
},
}
type binaryClassWglMakeCurrent struct{}
func (*WglMakeCurrent) Class() binary.Class {
return (*binaryClassWglMakeCurrent)(nil)
}
func doEncodeWglMakeCurrent(e binary.Encoder, o *WglMakeCurrent) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Hdc); err != nil {
return err
}
if err := e.Value(&o.Hglrc); err != nil {
return err
}
if err := e.Int64(int64(o.Result)); err != nil {
return err
}
return nil
}
func doDecodeWglMakeCurrent(d binary.Decoder, o *WglMakeCurrent) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Hdc); err != nil {
return err
}
if err := d.Value(&o.Hglrc); err != nil {
return err
}
if obj, err := d.Int64(); err != nil {
return err
} else {
o.Result = BOOL(obj)
}
return nil
}
func doSkipWglMakeCurrent(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*HDC)(nil)); err != nil {
return err
}
if err := d.SkipValue((*HGLRC)(nil)); err != nil {
return err
}
if _, err := d.Int64(); err != nil {
return err
}
return nil
}
func (*binaryClassWglMakeCurrent) ID() binary.ID { return binaryIDWglMakeCurrent }
func (*binaryClassWglMakeCurrent) New() binary.Object { return &WglMakeCurrent{} }
func (*binaryClassWglMakeCurrent) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeWglMakeCurrent(e, obj.(*WglMakeCurrent))
}
func (*binaryClassWglMakeCurrent) Decode(d binary.Decoder) (binary.Object, error) {
obj := &WglMakeCurrent{}
return obj, doDecodeWglMakeCurrent(d, obj)
}
func (*binaryClassWglMakeCurrent) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeWglMakeCurrent(d, obj.(*WglMakeCurrent))
}
func (*binaryClassWglMakeCurrent) Skip(d binary.Decoder) error { return doSkipWglMakeCurrent(d) }
func (*binaryClassWglMakeCurrent) Schema() *schema.Class { return schemaWglMakeCurrent }
var schemaWglMakeCurrent = &schema.Class{
TypeID: binaryIDWglMakeCurrent,
Name: "WglMakeCurrent",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Hdc", Type: &schema.Struct{Name: "HDC"}},
schema.Field{Declared: "Hglrc", Type: &schema.Struct{Name: "HGLRC"}},
schema.Field{Declared: "Result", Type: &schema.Primitive{Name: "BOOL", Method: schema.Int64}},
},
}
type binaryClassWglSwapBuffers struct{}
func (*WglSwapBuffers) Class() binary.Class {
return (*binaryClassWglSwapBuffers)(nil)
}
func doEncodeWglSwapBuffers(e binary.Encoder, o *WglSwapBuffers) error {
if err := e.Value(&o.observations); err != nil {
return err
}
if err := e.Value(&o.Hdc); err != nil {
return err
}
return nil
}
func doDecodeWglSwapBuffers(d binary.Decoder, o *WglSwapBuffers) error {
if err := d.Value(&o.observations); err != nil {
return err
}
if err := d.Value(&o.Hdc); err != nil {
return err
}
return nil
}
func doSkipWglSwapBuffers(d binary.Decoder) error {
if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
return err
}
if err := d.SkipValue((*HDC)(nil)); err != nil {
return err
}
return nil
}
func (*binaryClassWglSwapBuffers) ID() binary.ID { return binaryIDWglSwapBuffers }
func (*binaryClassWglSwapBuffers) New() binary.Object { return &WglSwapBuffers{} }
func (*binaryClassWglSwapBuffers) Encode(e binary.Encoder, obj binary.Object) error {
return doEncodeWglSwapBuffers(e, obj.(*WglSwapBuffers))
}
func (*binaryClassWglSwapBuffers) Decode(d binary.Decoder) (binary.Object, error) {
obj := &WglSwapBuffers{}
return obj, doDecodeWglSwapBuffers(d, obj)
}
func (*binaryClassWglSwapBuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
return doDecodeWglSwapBuffers(d, obj.(*WglSwapBuffers))
}
func (*binaryClassWglSwapBuffers) Skip(d binary.Decoder) error { return doSkipWglSwapBuffers(d) }
func (*binaryClassWglSwapBuffers) Schema() *schema.Class { return schemaWglSwapBuffers }
var schemaWglSwapBuffers = &schema.Class{
TypeID: binaryIDWglSwapBuffers,
Name: "WglSwapBuffers",
Fields: []schema.Field{
schema.Field{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations"}},
schema.Field{Declared: "Hdc", Type: &schema.Struct{Name: "HDC"}},
},
}
const _ArrayType_GLES_1_1_name = "GL_VERTEX_ARRAYGL_NORMAL_ARRAYGL_COLOR_ARRAYGL_TEXTURE_COORD_ARRAY"
var _ArrayType_GLES_1_1_map = map[ArrayType_GLES_1_1]string{
32884: _ArrayType_GLES_1_1_name[0:15],
32885: _ArrayType_GLES_1_1_name[15:30],
32886: _ArrayType_GLES_1_1_name[30:44],
32888: _ArrayType_GLES_1_1_name[44:66],
}
func (v ArrayType_GLES_1_1) String() string {
if s, ok := _ArrayType_GLES_1_1_map[v]; ok {
return s
}
return fmt.Sprintf("ArrayType_GLES_1_1(%d)", v)
}
func (v *ArrayType_GLES_1_1) Parse(s string) error {
for k, t := range _ArrayType_GLES_1_1_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ArrayType_GLES_1_1", s)
}
const _ArrayType_name = "GL_VERTEX_ARRAYGL_NORMAL_ARRAYGL_COLOR_ARRAYGL_TEXTURE_COORD_ARRAYGL_POINT_SIZE_ARRAY_OES"
var _ArrayType_map = map[ArrayType]string{
32884: _ArrayType_name[0:15],
32885: _ArrayType_name[15:30],
32886: _ArrayType_name[30:44],
32888: _ArrayType_name[44:66],
35740: _ArrayType_name[66:89],
}
func (v ArrayType) String() string {
if s, ok := _ArrayType_map[v]; ok {
return s
}
return fmt.Sprintf("ArrayType(%d)", v)
}
func (v *ArrayType) Parse(s string) error {
for k, t := range _ArrayType_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ArrayType", s)
}
const _ArrayType_OES_point_size_array_name = "GL_POINT_SIZE_ARRAY_OES"
var _ArrayType_OES_point_size_array_map = map[ArrayType_OES_point_size_array]string{
35740: _ArrayType_OES_point_size_array_name[0:23],
}
func (v ArrayType_OES_point_size_array) String() string {
if s, ok := _ArrayType_OES_point_size_array_map[v]; ok {
return s
}
return fmt.Sprintf("ArrayType_OES_point_size_array(%d)", v)
}
func (v *ArrayType_OES_point_size_array) Parse(s string) error {
for k, t := range _ArrayType_OES_point_size_array_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ArrayType_OES_point_size_array", s)
}
const _BaseTexelFormat_name = "GL_ALPHAGL_RGBGL_RGBA"
var _BaseTexelFormat_map = map[BaseTexelFormat]string{
6406: _BaseTexelFormat_name[0:8],
6407: _BaseTexelFormat_name[8:14],
6408: _BaseTexelFormat_name[14:21],
}
func (v BaseTexelFormat) String() string {
if s, ok := _BaseTexelFormat_map[v]; ok {
return s
}
return fmt.Sprintf("BaseTexelFormat(%d)", v)
}
func (v *BaseTexelFormat) Parse(s string) error {
for k, t := range _BaseTexelFormat_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in BaseTexelFormat", s)
}
const _BlendEquation_name = "GL_FUNC_ADDGL_FUNC_SUBTRACTGL_FUNC_REVERSE_SUBTRACT"
var _BlendEquation_map = map[BlendEquation]string{
32774: _BlendEquation_name[0:11],
32778: _BlendEquation_name[11:27],
32779: _BlendEquation_name[27:51],
}
func (v BlendEquation) String() string {
if s, ok := _BlendEquation_map[v]; ok {
return s
}
return fmt.Sprintf("BlendEquation(%d)", v)
}
func (v *BlendEquation) Parse(s string) error {
for k, t := range _BlendEquation_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in BlendEquation", s)
}
const _BlendFactor_name = "GL_ZEROGL_ONEGL_SRC_COLORGL_ONE_MINUS_SRC_COLORGL_SRC_ALPHAGL_ONE_MINUS_SRC_ALPHAGL_DST_ALPHAGL_ONE_MINUS_DST_ALPHAGL_DST_COLORGL_ONE_MINUS_DST_COLORGL_SRC_ALPHA_SATURATEGL_CONSTANT_COLORGL_ONE_MINUS_CONSTANT_COLORGL_CONSTANT_ALPHAGL_ONE_MINUS_CONSTANT_ALPHA"
var _BlendFactor_map = map[BlendFactor]string{
0: _BlendFactor_name[0:7],
1: _BlendFactor_name[7:13],
768: _BlendFactor_name[13:25],
769: _BlendFactor_name[25:47],
770: _BlendFactor_name[47:59],
771: _BlendFactor_name[59:81],
772: _BlendFactor_name[81:93],
773: _BlendFactor_name[93:115],
774: _BlendFactor_name[115:127],
775: _BlendFactor_name[127:149],
776: _BlendFactor_name[149:170],
32769: _BlendFactor_name[170:187],
32770: _BlendFactor_name[187:214],
32771: _BlendFactor_name[214:231],
32772: _BlendFactor_name[231:258],
}
func (v BlendFactor) String() string {
if s, ok := _BlendFactor_map[v]; ok {
return s
}
return fmt.Sprintf("BlendFactor(%d)", v)
}
func (v *BlendFactor) Parse(s string) error {
for k, t := range _BlendFactor_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in BlendFactor", s)
}
const _BufferParameter_name = "GL_BUFFER_SIZEGL_BUFFER_USAGE"
var _BufferParameter_map = map[BufferParameter]string{
34660: _BufferParameter_name[0:14],
34661: _BufferParameter_name[14:29],
}
func (v BufferParameter) String() string {
if s, ok := _BufferParameter_map[v]; ok {
return s
}
return fmt.Sprintf("BufferParameter(%d)", v)
}
func (v *BufferParameter) Parse(s string) error {
for k, t := range _BufferParameter_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in BufferParameter", s)
}
const _BufferTarget_name = "GL_ARRAY_BUFFERGL_ELEMENT_ARRAY_BUFFERGL_PIXEL_PACK_BUFFERGL_PIXEL_UNPACK_BUFFERGL_UNIFORM_BUFFERGL_TRANSFORM_FEEDBACK_BUFFERGL_COPY_READ_BUFFERGL_COPY_WRITE_BUFFER"
var _BufferTarget_map = map[BufferTarget]string{
34962: _BufferTarget_name[0:15],
34963: _BufferTarget_name[15:38],
35051: _BufferTarget_name[38:58],
35052: _BufferTarget_name[58:80],
35345: _BufferTarget_name[80:97],
35982: _BufferTarget_name[97:125],
36662: _BufferTarget_name[125:144],
36663: _BufferTarget_name[144:164],
}
func (v BufferTarget) String() string {
if s, ok := _BufferTarget_map[v]; ok {
return s
}
return fmt.Sprintf("BufferTarget(%d)", v)
}
func (v *BufferTarget) Parse(s string) error {
for k, t := range _BufferTarget_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in BufferTarget", s)
}
const _BufferUsage_name = "GL_STREAM_DRAWGL_STATIC_DRAWGL_DYNAMIC_DRAW"
var _BufferUsage_map = map[BufferUsage]string{
35040: _BufferUsage_name[0:14],
35044: _BufferUsage_name[14:28],
35048: _BufferUsage_name[28:43],
}
func (v BufferUsage) String() string {
if s, ok := _BufferUsage_map[v]; ok {
return s
}
return fmt.Sprintf("BufferUsage(%d)", v)
}
func (v *BufferUsage) Parse(s string) error {
for k, t := range _BufferUsage_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in BufferUsage", s)
}
const _Capability_name = "GL_CULL_FACEGL_DEPTH_TESTGL_STENCIL_TESTGL_DITHERGL_BLENDGL_SCISSOR_TESTGL_POLYGON_OFFSET_FILLGL_VERTEX_ARRAYGL_NORMAL_ARRAYGL_COLOR_ARRAYGL_TEXTURE_COORD_ARRAYGL_SAMPLE_ALPHA_TO_COVERAGEGL_SAMPLE_COVERAGEGL_POINT_SIZE_ARRAY_OES"
var _Capability_map = map[Capability]string{
2884: _Capability_name[0:12],
2929: _Capability_name[12:25],
2960: _Capability_name[25:40],
3024: _Capability_name[40:49],
3042: _Capability_name[49:57],
3089: _Capability_name[57:72],
32823: _Capability_name[72:94],
32884: _Capability_name[94:109],
32885: _Capability_name[109:124],
32886: _Capability_name[124:138],
32888: _Capability_name[138:160],
32926: _Capability_name[160:187],
32928: _Capability_name[187:205],
35740: _Capability_name[205:228],
}
func (v Capability) String() string {
if s, ok := _Capability_map[v]; ok {
return s
}
return fmt.Sprintf("Capability(%d)", v)
}
func (v *Capability) Parse(s string) error {
for k, t := range _Capability_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in Capability", s)
}
const _ClearMask_name = "GL_DEPTH_BUFFER_BITGL_STENCIL_BUFFER_BITGL_COLOR_BUFFER_BIT"
var _ClearMask_map = map[ClearMask]string{
256: _ClearMask_name[0:19],
1024: _ClearMask_name[19:40],
16384: _ClearMask_name[40:59],
}
func (v ClearMask) String() string {
if s, ok := _ClearMask_map[v]; ok {
return s
}
return fmt.Sprintf("ClearMask(%d)", v)
}
func (v *ClearMask) Parse(s string) error {
for k, t := range _ClearMask_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ClearMask", s)
}
const _CompressedTexelFormat_AMD_compressed_ATC_texture_name = "GL_ATC_RGBA_INTERPOLATED_ALPHA_AMDGL_ATC_RGB_AMDGL_ATC_RGBA_EXPLICIT_ALPHA_AMD"
var _CompressedTexelFormat_AMD_compressed_ATC_texture_map = map[CompressedTexelFormat_AMD_compressed_ATC_texture]string{
34798: _CompressedTexelFormat_AMD_compressed_ATC_texture_name[0:34],
35986: _CompressedTexelFormat_AMD_compressed_ATC_texture_name[34:48],
35987: _CompressedTexelFormat_AMD_compressed_ATC_texture_name[48:78],
}
func (v CompressedTexelFormat_AMD_compressed_ATC_texture) String() string {
if s, ok := _CompressedTexelFormat_AMD_compressed_ATC_texture_map[v]; ok {
return s
}
return fmt.Sprintf("CompressedTexelFormat_AMD_compressed_ATC_texture(%d)", v)
}
func (v *CompressedTexelFormat_AMD_compressed_ATC_texture) Parse(s string) error {
for k, t := range _CompressedTexelFormat_AMD_compressed_ATC_texture_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in CompressedTexelFormat_AMD_compressed_ATC_texture", s)
}
const _CompressedTexelFormat_name = "GL_ATC_RGBA_INTERPOLATED_ALPHA_AMDGL_ATC_RGB_AMDGL_ATC_RGBA_EXPLICIT_ALPHA_AMDGL_ETC1_RGB8_OES"
var _CompressedTexelFormat_map = map[CompressedTexelFormat]string{
34798: _CompressedTexelFormat_name[0:34],
35986: _CompressedTexelFormat_name[34:48],
35987: _CompressedTexelFormat_name[48:78],
36196: _CompressedTexelFormat_name[78:94],
}
func (v CompressedTexelFormat) String() string {
if s, ok := _CompressedTexelFormat_map[v]; ok {
return s
}
return fmt.Sprintf("CompressedTexelFormat(%d)", v)
}
func (v *CompressedTexelFormat) Parse(s string) error {
for k, t := range _CompressedTexelFormat_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in CompressedTexelFormat", s)
}
const _CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture_name = "GL_ETC1_RGB8_OES"
var _CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture_map = map[CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture]string{
36196: _CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture_name[0:16],
}
func (v CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture) String() string {
if s, ok := _CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture_map[v]; ok {
return s
}
return fmt.Sprintf("CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture(%d)", v)
}
func (v *CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture) Parse(s string) error {
for k, t := range _CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in CompressedTexelFormat_OES_compressed_ETC1_RGB8_texture", s)
}
const _CubeMapImageTarget_name = "GL_TEXTURE_CUBE_MAP_POSITIVE_XGL_TEXTURE_CUBE_MAP_NEGATIVE_XGL_TEXTURE_CUBE_MAP_POSITIVE_YGL_TEXTURE_CUBE_MAP_NEGATIVE_YGL_TEXTURE_CUBE_MAP_POSITIVE_ZGL_TEXTURE_CUBE_MAP_NEGATIVE_Z"
var _CubeMapImageTarget_map = map[CubeMapImageTarget]string{
34069: _CubeMapImageTarget_name[0:30],
34070: _CubeMapImageTarget_name[30:60],
34071: _CubeMapImageTarget_name[60:90],
34072: _CubeMapImageTarget_name[90:120],
34073: _CubeMapImageTarget_name[120:150],
34074: _CubeMapImageTarget_name[150:180],
}
func (v CubeMapImageTarget) String() string {
if s, ok := _CubeMapImageTarget_map[v]; ok {
return s
}
return fmt.Sprintf("CubeMapImageTarget(%d)", v)
}
func (v *CubeMapImageTarget) Parse(s string) error {
for k, t := range _CubeMapImageTarget_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in CubeMapImageTarget", s)
}
const _DiscardFramebufferAttachment_name = "GL_COLOR_EXTGL_DEPTH_EXTGL_STENCIL_EXT"
var _DiscardFramebufferAttachment_map = map[DiscardFramebufferAttachment]string{
6144: _DiscardFramebufferAttachment_name[0:12],
6145: _DiscardFramebufferAttachment_name[12:24],
6146: _DiscardFramebufferAttachment_name[24:38],
}
func (v DiscardFramebufferAttachment) String() string {
if s, ok := _DiscardFramebufferAttachment_map[v]; ok {
return s
}
return fmt.Sprintf("DiscardFramebufferAttachment(%d)", v)
}
func (v *DiscardFramebufferAttachment) Parse(s string) error {
for k, t := range _DiscardFramebufferAttachment_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in DiscardFramebufferAttachment", s)
}
const _DrawMode_name = "GL_POINTSGL_LINESGL_LINE_LOOPGL_LINE_STRIPGL_TRIANGLESGL_TRIANGLE_STRIPGL_TRIANGLE_FAN"
var _DrawMode_map = map[DrawMode]string{
0: _DrawMode_name[0:9],
1: _DrawMode_name[9:17],
2: _DrawMode_name[17:29],
3: _DrawMode_name[29:42],
4: _DrawMode_name[42:54],
5: _DrawMode_name[54:71],
6: _DrawMode_name[71:86],
}
func (v DrawMode) String() string {
if s, ok := _DrawMode_map[v]; ok {
return s
}
return fmt.Sprintf("DrawMode(%d)", v)
}
func (v *DrawMode) Parse(s string) error {
for k, t := range _DrawMode_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in DrawMode", s)
}
const _Error_name = "GL_NO_ERRORGL_INVALID_ENUMGL_INVALID_VALUEGL_INVALID_OPERATIONGL_OUT_OF_MEMORYGL_INVALID_FRAMEBUFFER_OPERATION"
var _Error_map = map[Error]string{
0: _Error_name[0:11],
1280: _Error_name[11:26],
1281: _Error_name[26:42],
1282: _Error_name[42:62],
1285: _Error_name[62:78],
1286: _Error_name[78:110],
}
func (v Error) String() string {
if s, ok := _Error_map[v]; ok {
return s
}
return fmt.Sprintf("Error(%d)", v)
}
func (v *Error) Parse(s string) error {
for k, t := range _Error_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in Error", s)
}
const _FaceMode_name = "GL_FRONTGL_BACKGL_FRONT_AND_BACK"
var _FaceMode_map = map[FaceMode]string{
1028: _FaceMode_name[0:8],
1029: _FaceMode_name[8:15],
1032: _FaceMode_name[15:32],
}
func (v FaceMode) String() string {
if s, ok := _FaceMode_map[v]; ok {
return s
}
return fmt.Sprintf("FaceMode(%d)", v)
}
func (v *FaceMode) Parse(s string) error {
for k, t := range _FaceMode_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in FaceMode", s)
}
const _FaceOrientation_name = "GL_CWGL_CCW"
var _FaceOrientation_map = map[FaceOrientation]string{
2304: _FaceOrientation_name[0:5],
2305: _FaceOrientation_name[5:11],
}
func (v FaceOrientation) String() string {
if s, ok := _FaceOrientation_map[v]; ok {
return s
}
return fmt.Sprintf("FaceOrientation(%d)", v)
}
func (v *FaceOrientation) Parse(s string) error {
for k, t := range _FaceOrientation_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in FaceOrientation", s)
}
const _FramebufferAttachmentParameter_name = "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPEGL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAMEGL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVELGL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"
var _FramebufferAttachmentParameter_map = map[FramebufferAttachmentParameter]string{
36048: _FramebufferAttachmentParameter_name[0:37],
36049: _FramebufferAttachmentParameter_name[37:74],
36050: _FramebufferAttachmentParameter_name[74:113],
36051: _FramebufferAttachmentParameter_name[113:160],
}
func (v FramebufferAttachmentParameter) String() string {
if s, ok := _FramebufferAttachmentParameter_map[v]; ok {
return s
}
return fmt.Sprintf("FramebufferAttachmentParameter(%d)", v)
}
func (v *FramebufferAttachmentParameter) Parse(s string) error {
for k, t := range _FramebufferAttachmentParameter_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in FramebufferAttachmentParameter", s)
}
const _FramebufferAttachmentType_name = "GL_NONEGL_TEXTUREGL_RENDERBUFFER"
var _FramebufferAttachmentType_map = map[FramebufferAttachmentType]string{
0: _FramebufferAttachmentType_name[0:7],
5890: _FramebufferAttachmentType_name[7:17],
36161: _FramebufferAttachmentType_name[17:32],
}
func (v FramebufferAttachmentType) String() string {
if s, ok := _FramebufferAttachmentType_map[v]; ok {
return s
}
return fmt.Sprintf("FramebufferAttachmentType(%d)", v)
}
func (v *FramebufferAttachmentType) Parse(s string) error {
for k, t := range _FramebufferAttachmentType_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in FramebufferAttachmentType", s)
}
const _FramebufferAttachment_name = "GL_COLOR_ATTACHMENT0GL_DEPTH_ATTACHMENTGL_STENCIL_ATTACHMENT"
var _FramebufferAttachment_map = map[FramebufferAttachment]string{
36064: _FramebufferAttachment_name[0:20],
36096: _FramebufferAttachment_name[20:39],
36128: _FramebufferAttachment_name[39:60],
}
func (v FramebufferAttachment) String() string {
if s, ok := _FramebufferAttachment_map[v]; ok {
return s
}
return fmt.Sprintf("FramebufferAttachment(%d)", v)
}
func (v *FramebufferAttachment) Parse(s string) error {
for k, t := range _FramebufferAttachment_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in FramebufferAttachment", s)
}
const _FramebufferStatus_name = "GL_FRAMEBUFFER_COMPLETEGL_FRAMEBUFFER_INCOMPLETE_ATTACHMENTGL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENTGL_FRAMEBUFFER_INCOMPLETE_DIMENSIONSGL_FRAMEBUFFER_UNSUPPORTED"
var _FramebufferStatus_map = map[FramebufferStatus]string{
36053: _FramebufferStatus_name[0:23],
36054: _FramebufferStatus_name[23:59],
36055: _FramebufferStatus_name[59:103],
36057: _FramebufferStatus_name[103:139],
36061: _FramebufferStatus_name[139:165],
}
func (v FramebufferStatus) String() string {
if s, ok := _FramebufferStatus_map[v]; ok {
return s
}
return fmt.Sprintf("FramebufferStatus(%d)", v)
}
func (v *FramebufferStatus) Parse(s string) error {
for k, t := range _FramebufferStatus_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in FramebufferStatus", s)
}
const _FramebufferTarget_GLES_2_0_name = "GL_FRAMEBUFFER"
var _FramebufferTarget_GLES_2_0_map = map[FramebufferTarget_GLES_2_0]string{
36160: _FramebufferTarget_GLES_2_0_name[0:14],
}
func (v FramebufferTarget_GLES_2_0) String() string {
if s, ok := _FramebufferTarget_GLES_2_0_map[v]; ok {
return s
}
return fmt.Sprintf("FramebufferTarget_GLES_2_0(%d)", v)
}
func (v *FramebufferTarget_GLES_2_0) Parse(s string) error {
for k, t := range _FramebufferTarget_GLES_2_0_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in FramebufferTarget_GLES_2_0", s)
}
const _FramebufferTarget_GLES_3_1_name = "GL_READ_FRAMEBUFFERGL_DRAW_FRAMEBUFFER"
var _FramebufferTarget_GLES_3_1_map = map[FramebufferTarget_GLES_3_1]string{
36008: _FramebufferTarget_GLES_3_1_name[0:19],
36009: _FramebufferTarget_GLES_3_1_name[19:38],
}
func (v FramebufferTarget_GLES_3_1) String() string {
if s, ok := _FramebufferTarget_GLES_3_1_map[v]; ok {
return s
}
return fmt.Sprintf("FramebufferTarget_GLES_3_1(%d)", v)
}
func (v *FramebufferTarget_GLES_3_1) Parse(s string) error {
for k, t := range _FramebufferTarget_GLES_3_1_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in FramebufferTarget_GLES_3_1", s)
}
const _FramebufferTarget_name = "GL_READ_FRAMEBUFFERGL_DRAW_FRAMEBUFFERGL_FRAMEBUFFER"
var _FramebufferTarget_map = map[FramebufferTarget]string{
36008: _FramebufferTarget_name[0:19],
36009: _FramebufferTarget_name[19:38],
36160: _FramebufferTarget_name[38:52],
}
func (v FramebufferTarget) String() string {
if s, ok := _FramebufferTarget_map[v]; ok {
return s
}
return fmt.Sprintf("FramebufferTarget(%d)", v)
}
func (v *FramebufferTarget) Parse(s string) error {
for k, t := range _FramebufferTarget_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in FramebufferTarget", s)
}
const _HintMode_name = "GL_DONT_CAREGL_FASTESTGL_NICEST"
var _HintMode_map = map[HintMode]string{
4352: _HintMode_name[0:12],
4353: _HintMode_name[12:22],
4354: _HintMode_name[22:31],
}
func (v HintMode) String() string {
if s, ok := _HintMode_map[v]; ok {
return s
}
return fmt.Sprintf("HintMode(%d)", v)
}
func (v *HintMode) Parse(s string) error {
for k, t := range _HintMode_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in HintMode", s)
}
const _HintTarget_name = "GL_GENERATE_MIPMAP_HINT"
var _HintTarget_map = map[HintTarget]string{
33170: _HintTarget_name[0:23],
}
func (v HintTarget) String() string {
if s, ok := _HintTarget_map[v]; ok {
return s
}
return fmt.Sprintf("HintTarget(%d)", v)
}
func (v *HintTarget) Parse(s string) error {
for k, t := range _HintTarget_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in HintTarget", s)
}
const _ImageTargetRenderbufferStorage_name = "GL_RENDERBUFFER_OES"
var _ImageTargetRenderbufferStorage_map = map[ImageTargetRenderbufferStorage]string{
36161: _ImageTargetRenderbufferStorage_name[0:19],
}
func (v ImageTargetRenderbufferStorage) String() string {
if s, ok := _ImageTargetRenderbufferStorage_map[v]; ok {
return s
}
return fmt.Sprintf("ImageTargetRenderbufferStorage(%d)", v)
}
func (v *ImageTargetRenderbufferStorage) Parse(s string) error {
for k, t := range _ImageTargetRenderbufferStorage_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ImageTargetRenderbufferStorage", s)
}
const _ImageTargetTexture_name = "GL_TEXTURE_2DGL_TEXTURE_EXTERNAL_OES"
var _ImageTargetTexture_map = map[ImageTargetTexture]string{
3553: _ImageTargetTexture_name[0:13],
36197: _ImageTargetTexture_name[13:36],
}
func (v ImageTargetTexture) String() string {
if s, ok := _ImageTargetTexture_map[v]; ok {
return s
}
return fmt.Sprintf("ImageTargetTexture(%d)", v)
}
func (v *ImageTargetTexture) Parse(s string) error {
for k, t := range _ImageTargetTexture_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ImageTargetTexture", s)
}
const _ImageTargetTexture_OES_EGL_image_name = "GL_TEXTURE_2D"
var _ImageTargetTexture_OES_EGL_image_map = map[ImageTargetTexture_OES_EGL_image]string{
3553: _ImageTargetTexture_OES_EGL_image_name[0:13],
}
func (v ImageTargetTexture_OES_EGL_image) String() string {
if s, ok := _ImageTargetTexture_OES_EGL_image_map[v]; ok {
return s
}
return fmt.Sprintf("ImageTargetTexture_OES_EGL_image(%d)", v)
}
func (v *ImageTargetTexture_OES_EGL_image) Parse(s string) error {
for k, t := range _ImageTargetTexture_OES_EGL_image_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ImageTargetTexture_OES_EGL_image", s)
}
const _ImageTargetTexture_OES_EGL_image_external_name = "GL_TEXTURE_EXTERNAL_OES"
var _ImageTargetTexture_OES_EGL_image_external_map = map[ImageTargetTexture_OES_EGL_image_external]string{
36197: _ImageTargetTexture_OES_EGL_image_external_name[0:23],
}
func (v ImageTargetTexture_OES_EGL_image_external) String() string {
if s, ok := _ImageTargetTexture_OES_EGL_image_external_map[v]; ok {
return s
}
return fmt.Sprintf("ImageTargetTexture_OES_EGL_image_external(%d)", v)
}
func (v *ImageTargetTexture_OES_EGL_image_external) Parse(s string) error {
for k, t := range _ImageTargetTexture_OES_EGL_image_external_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ImageTargetTexture_OES_EGL_image_external", s)
}
const _ImageTexelFormat_name = "GL_DEPTH_COMPONENTGL_REDGL_ALPHAGL_RGBGL_RGBAGL_LUMINANCEGL_LUMINANCE_ALPHAGL_DEPTH_COMPONENT16GL_RGGL_RG_INTEGERGL_DEPTH_STENCILGL_ATC_RGBA_INTERPOLATED_ALPHA_AMDGL_DEPTH24_STENCIL8GL_ATC_RGB_AMDGL_ATC_RGBA_EXPLICIT_ALPHA_AMDGL_ETC1_RGB8_OESGL_RED_INTEGERGL_RGB_INTEGERGL_RGBA_INTEGER"
var _ImageTexelFormat_map = map[ImageTexelFormat]string{
6402: _ImageTexelFormat_name[0:18],
6403: _ImageTexelFormat_name[18:24],
6406: _ImageTexelFormat_name[24:32],
6407: _ImageTexelFormat_name[32:38],
6408: _ImageTexelFormat_name[38:45],
6409: _ImageTexelFormat_name[45:57],
6410: _ImageTexelFormat_name[57:75],
33189: _ImageTexelFormat_name[75:95],
33319: _ImageTexelFormat_name[95:100],
33320: _ImageTexelFormat_name[100:113],
34041: _ImageTexelFormat_name[113:129],
34798: _ImageTexelFormat_name[129:163],
35056: _ImageTexelFormat_name[163:182],
35986: _ImageTexelFormat_name[182:196],
35987: _ImageTexelFormat_name[196:226],
36196: _ImageTexelFormat_name[226:242],
36244: _ImageTexelFormat_name[242:256],
36248: _ImageTexelFormat_name[256:270],
36249: _ImageTexelFormat_name[270:285],
}
func (v ImageTexelFormat) String() string {
if s, ok := _ImageTexelFormat_map[v]; ok {
return s
}
return fmt.Sprintf("ImageTexelFormat(%d)", v)
}
func (v *ImageTexelFormat) Parse(s string) error {
for k, t := range _ImageTexelFormat_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ImageTexelFormat", s)
}
const _IndicesType_name = "GL_UNSIGNED_BYTEGL_UNSIGNED_SHORTGL_UNSIGNED_INT"
var _IndicesType_map = map[IndicesType]string{
5121: _IndicesType_name[0:16],
5123: _IndicesType_name[16:33],
5125: _IndicesType_name[33:48],
}
func (v IndicesType) String() string {
if s, ok := _IndicesType_map[v]; ok {
return s
}
return fmt.Sprintf("IndicesType(%d)", v)
}
func (v *IndicesType) Parse(s string) error {
for k, t := range _IndicesType_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in IndicesType", s)
}
const _MapBufferRangeAccess_name = "GL_MAP_READ_BITGL_MAP_WRITE_BITGL_MAP_INVALIDATE_RANGE_BITGL_MAP_INVALIDATE_BUFFER_BITGL_MAP_FLUSH_EXPLICIT_BITGL_MAP_UNSYNCHRONIZED_BIT"
var _MapBufferRangeAccess_map = map[MapBufferRangeAccess]string{
1: _MapBufferRangeAccess_name[0:15],
2: _MapBufferRangeAccess_name[15:31],
4: _MapBufferRangeAccess_name[31:58],
8: _MapBufferRangeAccess_name[58:86],
16: _MapBufferRangeAccess_name[86:111],
32: _MapBufferRangeAccess_name[111:136],
}
func (v MapBufferRangeAccess) String() string {
if s, ok := _MapBufferRangeAccess_map[v]; ok {
return s
}
return fmt.Sprintf("MapBufferRangeAccess(%d)", v)
}
func (v *MapBufferRangeAccess) Parse(s string) error {
for k, t := range _MapBufferRangeAccess_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in MapBufferRangeAccess", s)
}
const _PixelStoreParameter_name = "GL_UNPACK_ALIGNMENTGL_PACK_ALIGNMENT"
var _PixelStoreParameter_map = map[PixelStoreParameter]string{
3317: _PixelStoreParameter_name[0:19],
3333: _PixelStoreParameter_name[19:36],
}
func (v PixelStoreParameter) String() string {
if s, ok := _PixelStoreParameter_map[v]; ok {
return s
}
return fmt.Sprintf("PixelStoreParameter(%d)", v)
}
func (v *PixelStoreParameter) Parse(s string) error {
for k, t := range _PixelStoreParameter_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in PixelStoreParameter", s)
}
const _PrecisionType_name = "GL_LOW_FLOATGL_MEDIUM_FLOATGL_HIGH_FLOATGL_LOW_INTGL_MEDIUM_INTGL_HIGH_INT"
var _PrecisionType_map = map[PrecisionType]string{
36336: _PrecisionType_name[0:12],
36337: _PrecisionType_name[12:27],
36338: _PrecisionType_name[27:40],
36339: _PrecisionType_name[40:50],
36340: _PrecisionType_name[50:63],
36341: _PrecisionType_name[63:74],
}
func (v PrecisionType) String() string {
if s, ok := _PrecisionType_map[v]; ok {
return s
}
return fmt.Sprintf("PrecisionType(%d)", v)
}
func (v *PrecisionType) Parse(s string) error {
for k, t := range _PrecisionType_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in PrecisionType", s)
}
const _ProgramParameter_name = "GL_DELETE_STATUSGL_LINK_STATUSGL_VALIDATE_STATUSGL_INFO_LOG_LENGTHGL_ATTACHED_SHADERSGL_ACTIVE_UNIFORMSGL_ACTIVE_UNIFORM_MAX_LENGTHGL_ACTIVE_ATTRIBUTESGL_ACTIVE_ATTRIBUTE_MAX_LENGTH"
var _ProgramParameter_map = map[ProgramParameter]string{
35712: _ProgramParameter_name[0:16],
35714: _ProgramParameter_name[16:30],
35715: _ProgramParameter_name[30:48],
35716: _ProgramParameter_name[48:66],
35717: _ProgramParameter_name[66:85],
35718: _ProgramParameter_name[85:103],
35719: _ProgramParameter_name[103:131],
35721: _ProgramParameter_name[131:151],
35722: _ProgramParameter_name[151:181],
}
func (v ProgramParameter) String() string {
if s, ok := _ProgramParameter_map[v]; ok {
return s
}
return fmt.Sprintf("ProgramParameter(%d)", v)
}
func (v *ProgramParameter) Parse(s string) error {
for k, t := range _ProgramParameter_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ProgramParameter", s)
}
const _QueryObjectParameter_GLES_3_name = "GL_QUERY_RESULTGL_QUERY_RESULT_AVAILABLE"
var _QueryObjectParameter_GLES_3_map = map[QueryObjectParameter_GLES_3]string{
34918: _QueryObjectParameter_GLES_3_name[0:15],
34919: _QueryObjectParameter_GLES_3_name[15:40],
}
func (v QueryObjectParameter_GLES_3) String() string {
if s, ok := _QueryObjectParameter_GLES_3_map[v]; ok {
return s
}
return fmt.Sprintf("QueryObjectParameter_GLES_3(%d)", v)
}
func (v *QueryObjectParameter_GLES_3) Parse(s string) error {
for k, t := range _QueryObjectParameter_GLES_3_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in QueryObjectParameter_GLES_3", s)
}
const _QueryObjectParameter_name = "GL_QUERY_RESULTGL_QUERY_RESULT_AVAILABLE"
var _QueryObjectParameter_map = map[QueryObjectParameter]string{
34918: _QueryObjectParameter_name[0:15],
34919: _QueryObjectParameter_name[15:40],
}
func (v QueryObjectParameter) String() string {
if s, ok := _QueryObjectParameter_map[v]; ok {
return s
}
return fmt.Sprintf("QueryObjectParameter(%d)", v)
}
func (v *QueryObjectParameter) Parse(s string) error {
for k, t := range _QueryObjectParameter_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in QueryObjectParameter", s)
}
const _QueryParameter_EXT_disjoint_timer_query_name = "GL_QUERY_COUNTER_BITS_EXT"
var _QueryParameter_EXT_disjoint_timer_query_map = map[QueryParameter_EXT_disjoint_timer_query]string{
34916: _QueryParameter_EXT_disjoint_timer_query_name[0:25],
}
func (v QueryParameter_EXT_disjoint_timer_query) String() string {
if s, ok := _QueryParameter_EXT_disjoint_timer_query_map[v]; ok {
return s
}
return fmt.Sprintf("QueryParameter_EXT_disjoint_timer_query(%d)", v)
}
func (v *QueryParameter_EXT_disjoint_timer_query) Parse(s string) error {
for k, t := range _QueryParameter_EXT_disjoint_timer_query_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in QueryParameter_EXT_disjoint_timer_query", s)
}
const _QueryParameter_GLES_3_name = "GL_CURRENT_QUERY"
var _QueryParameter_GLES_3_map = map[QueryParameter_GLES_3]string{
34917: _QueryParameter_GLES_3_name[0:16],
}
func (v QueryParameter_GLES_3) String() string {
if s, ok := _QueryParameter_GLES_3_map[v]; ok {
return s
}
return fmt.Sprintf("QueryParameter_GLES_3(%d)", v)
}
func (v *QueryParameter_GLES_3) Parse(s string) error {
for k, t := range _QueryParameter_GLES_3_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in QueryParameter_GLES_3", s)
}
const _QueryParameter_name = "GL_QUERY_COUNTER_BITS_EXTGL_CURRENT_QUERY"
var _QueryParameter_map = map[QueryParameter]string{
34916: _QueryParameter_name[0:25],
34917: _QueryParameter_name[25:41],
}
func (v QueryParameter) String() string {
if s, ok := _QueryParameter_map[v]; ok {
return s
}
return fmt.Sprintf("QueryParameter(%d)", v)
}
func (v *QueryParameter) Parse(s string) error {
for k, t := range _QueryParameter_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in QueryParameter", s)
}
const _QueryTarget_EXT_disjoint_timer_query_name = "GL_TIME_ELAPSED_EXTGL_TIMESTAMP_EXT"
var _QueryTarget_EXT_disjoint_timer_query_map = map[QueryTarget_EXT_disjoint_timer_query]string{
35007: _QueryTarget_EXT_disjoint_timer_query_name[0:19],
36392: _QueryTarget_EXT_disjoint_timer_query_name[19:35],
}
func (v QueryTarget_EXT_disjoint_timer_query) String() string {
if s, ok := _QueryTarget_EXT_disjoint_timer_query_map[v]; ok {
return s
}
return fmt.Sprintf("QueryTarget_EXT_disjoint_timer_query(%d)", v)
}
func (v *QueryTarget_EXT_disjoint_timer_query) Parse(s string) error {
for k, t := range _QueryTarget_EXT_disjoint_timer_query_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in QueryTarget_EXT_disjoint_timer_query", s)
}
const _QueryTarget_GLES_3_name = "GL_ANY_SAMPLES_PASSEDGL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTENGL_ANY_SAMPLES_PASSED_CONSERVATIVE"
var _QueryTarget_GLES_3_map = map[QueryTarget_GLES_3]string{
35887: _QueryTarget_GLES_3_name[0:21],
35976: _QueryTarget_GLES_3_name[21:61],
36202: _QueryTarget_GLES_3_name[61:95],
}
func (v QueryTarget_GLES_3) String() string {
if s, ok := _QueryTarget_GLES_3_map[v]; ok {
return s
}
return fmt.Sprintf("QueryTarget_GLES_3(%d)", v)
}
func (v *QueryTarget_GLES_3) Parse(s string) error {
for k, t := range _QueryTarget_GLES_3_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in QueryTarget_GLES_3", s)
}
const _QueryTarget_name = "GL_TIME_ELAPSED_EXTGL_ANY_SAMPLES_PASSEDGL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTENGL_ANY_SAMPLES_PASSED_CONSERVATIVEGL_TIMESTAMP_EXT"
var _QueryTarget_map = map[QueryTarget]string{
35007: _QueryTarget_name[0:19],
35887: _QueryTarget_name[19:40],
35976: _QueryTarget_name[40:80],
36202: _QueryTarget_name[80:114],
36392: _QueryTarget_name[114:130],
}
func (v QueryTarget) String() string {
if s, ok := _QueryTarget_map[v]; ok {
return s
}
return fmt.Sprintf("QueryTarget(%d)", v)
}
func (v *QueryTarget) Parse(s string) error {
for k, t := range _QueryTarget_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in QueryTarget", s)
}
const _RenderbufferFormat_name = "GL_RGBA4GL_RGB5_A1GL_RGBA8GL_DEPTH_COMPONENT16GL_STENCIL_INDEX8GL_RGB565"
var _RenderbufferFormat_map = map[RenderbufferFormat]string{
32854: _RenderbufferFormat_name[0:8],
32855: _RenderbufferFormat_name[8:18],
32856: _RenderbufferFormat_name[18:26],
33189: _RenderbufferFormat_name[26:46],
36168: _RenderbufferFormat_name[46:63],
36194: _RenderbufferFormat_name[63:72],
}
func (v RenderbufferFormat) String() string {
if s, ok := _RenderbufferFormat_map[v]; ok {
return s
}
return fmt.Sprintf("RenderbufferFormat(%d)", v)
}
func (v *RenderbufferFormat) Parse(s string) error {
for k, t := range _RenderbufferFormat_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in RenderbufferFormat", s)
}
const _RenderbufferParameter_name = "GL_RENDERBUFFER_WIDTHGL_RENDERBUFFER_HEIGHTGL_RENDERBUFFER_INTERNAL_FORMATGL_RENDERBUFFER_RED_SIZEGL_RENDERBUFFER_GREEN_SIZEGL_RENDERBUFFER_BLUE_SIZEGL_RENDERBUFFER_ALPHA_SIZEGL_RENDERBUFFER_DEPTH_SIZEGL_RENDERBUFFER_STENCIL_SIZE"
var _RenderbufferParameter_map = map[RenderbufferParameter]string{
36162: _RenderbufferParameter_name[0:21],
36163: _RenderbufferParameter_name[21:43],
36164: _RenderbufferParameter_name[43:74],
36176: _RenderbufferParameter_name[74:98],
36177: _RenderbufferParameter_name[98:124],
36178: _RenderbufferParameter_name[124:149],
36179: _RenderbufferParameter_name[149:175],
36180: _RenderbufferParameter_name[175:201],
36181: _RenderbufferParameter_name[201:229],
}
func (v RenderbufferParameter) String() string {
if s, ok := _RenderbufferParameter_map[v]; ok {
return s
}
return fmt.Sprintf("RenderbufferParameter(%d)", v)
}
func (v *RenderbufferParameter) Parse(s string) error {
for k, t := range _RenderbufferParameter_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in RenderbufferParameter", s)
}
const _RenderbufferTarget_name = "GL_RENDERBUFFER"
var _RenderbufferTarget_map = map[RenderbufferTarget]string{
36161: _RenderbufferTarget_name[0:15],
}
func (v RenderbufferTarget) String() string {
if s, ok := _RenderbufferTarget_map[v]; ok {
return s
}
return fmt.Sprintf("RenderbufferTarget(%d)", v)
}
func (v *RenderbufferTarget) Parse(s string) error {
for k, t := range _RenderbufferTarget_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in RenderbufferTarget", s)
}
const _ResetStatus_name = "GL_NO_ERRORGL_GUILTY_CONTEXT_RESET_EXTGL_INNOCENT_CONTEXT_RESET_EXTGL_UNKNOWN_CONTEXT_RESET_EXT"
var _ResetStatus_map = map[ResetStatus]string{
0: _ResetStatus_name[0:11],
33363: _ResetStatus_name[11:38],
33364: _ResetStatus_name[38:67],
33365: _ResetStatus_name[67:95],
}
func (v ResetStatus) String() string {
if s, ok := _ResetStatus_map[v]; ok {
return s
}
return fmt.Sprintf("ResetStatus(%d)", v)
}
func (v *ResetStatus) Parse(s string) error {
for k, t := range _ResetStatus_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ResetStatus", s)
}
const _ShaderAttribType_name = "GL_FLOATGL_FLOAT_VEC2GL_FLOAT_VEC3GL_FLOAT_VEC4GL_FLOAT_MAT2GL_FLOAT_MAT3GL_FLOAT_MAT4"
var _ShaderAttribType_map = map[ShaderAttribType]string{
5126: _ShaderAttribType_name[0:8],
35664: _ShaderAttribType_name[8:21],
35665: _ShaderAttribType_name[21:34],
35666: _ShaderAttribType_name[34:47],
35674: _ShaderAttribType_name[47:60],
35675: _ShaderAttribType_name[60:73],
35676: _ShaderAttribType_name[73:86],
}
func (v ShaderAttribType) String() string {
if s, ok := _ShaderAttribType_map[v]; ok {
return s
}
return fmt.Sprintf("ShaderAttribType(%d)", v)
}
func (v *ShaderAttribType) Parse(s string) error {
for k, t := range _ShaderAttribType_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ShaderAttribType", s)
}
const _ShaderParameter_name = "GL_SHADER_TYPEGL_DELETE_STATUSGL_COMPILE_STATUSGL_INFO_LOG_LENGTHGL_SHADER_SOURCE_LENGTH"
var _ShaderParameter_map = map[ShaderParameter]string{
35663: _ShaderParameter_name[0:14],
35712: _ShaderParameter_name[14:30],
35713: _ShaderParameter_name[30:47],
35716: _ShaderParameter_name[47:65],
35720: _ShaderParameter_name[65:88],
}
func (v ShaderParameter) String() string {
if s, ok := _ShaderParameter_map[v]; ok {
return s
}
return fmt.Sprintf("ShaderParameter(%d)", v)
}
func (v *ShaderParameter) Parse(s string) error {
for k, t := range _ShaderParameter_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ShaderParameter", s)
}
const _ShaderType_name = "GL_FRAGMENT_SHADERGL_VERTEX_SHADER"
var _ShaderType_map = map[ShaderType]string{
35632: _ShaderType_name[0:18],
35633: _ShaderType_name[18:34],
}
func (v ShaderType) String() string {
if s, ok := _ShaderType_map[v]; ok {
return s
}
return fmt.Sprintf("ShaderType(%d)", v)
}
func (v *ShaderType) Parse(s string) error {
for k, t := range _ShaderType_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ShaderType", s)
}
const _ShaderUniformType_name = "GL_INTGL_FLOATGL_FLOAT_VEC2GL_FLOAT_VEC3GL_FLOAT_VEC4GL_INT_VEC2GL_INT_VEC3GL_INT_VEC4GL_BOOLGL_BOOL_VEC2GL_BOOL_VEC3GL_BOOL_VEC4GL_FLOAT_MAT2GL_FLOAT_MAT3GL_FLOAT_MAT4GL_SAMPLER_2DGL_SAMPLER_CUBE"
var _ShaderUniformType_map = map[ShaderUniformType]string{
5124: _ShaderUniformType_name[0:6],
5126: _ShaderUniformType_name[6:14],
35664: _ShaderUniformType_name[14:27],
35665: _ShaderUniformType_name[27:40],
35666: _ShaderUniformType_name[40:53],
35667: _ShaderUniformType_name[53:64],
35668: _ShaderUniformType_name[64:75],
35669: _ShaderUniformType_name[75:86],
35670: _ShaderUniformType_name[86:93],
35671: _ShaderUniformType_name[93:105],
35672: _ShaderUniformType_name[105:117],
35673: _ShaderUniformType_name[117:129],
35674: _ShaderUniformType_name[129:142],
35675: _ShaderUniformType_name[142:155],
35676: _ShaderUniformType_name[155:168],
35678: _ShaderUniformType_name[168:181],
35680: _ShaderUniformType_name[181:196],
}
func (v ShaderUniformType) String() string {
if s, ok := _ShaderUniformType_map[v]; ok {
return s
}
return fmt.Sprintf("ShaderUniformType(%d)", v)
}
func (v *ShaderUniformType) Parse(s string) error {
for k, t := range _ShaderUniformType_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in ShaderUniformType", s)
}
const _StateVariable_EXT_disjoint_timer_query_name = "GL_GPU_DISJOINT_EXT"
var _StateVariable_EXT_disjoint_timer_query_map = map[StateVariable_EXT_disjoint_timer_query]string{
36795: _StateVariable_EXT_disjoint_timer_query_name[0:19],
}
func (v StateVariable_EXT_disjoint_timer_query) String() string {
if s, ok := _StateVariable_EXT_disjoint_timer_query_map[v]; ok {
return s
}
return fmt.Sprintf("StateVariable_EXT_disjoint_timer_query(%d)", v)
}
func (v *StateVariable_EXT_disjoint_timer_query) Parse(s string) error {
for k, t := range _StateVariable_EXT_disjoint_timer_query_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in StateVariable_EXT_disjoint_timer_query", s)
}
const _StateVariable_EXT_texture_filter_anisotropic_name = "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT"
var _StateVariable_EXT_texture_filter_anisotropic_map = map[StateVariable_EXT_texture_filter_anisotropic]string{
34047: _StateVariable_EXT_texture_filter_anisotropic_name[0:33],
}
func (v StateVariable_EXT_texture_filter_anisotropic) String() string {
if s, ok := _StateVariable_EXT_texture_filter_anisotropic_map[v]; ok {
return s
}
return fmt.Sprintf("StateVariable_EXT_texture_filter_anisotropic(%d)", v)
}
func (v *StateVariable_EXT_texture_filter_anisotropic) Parse(s string) error {
for k, t := range _StateVariable_EXT_texture_filter_anisotropic_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in StateVariable_EXT_texture_filter_anisotropic", s)
}
const _StateVariable_GLES_2_0_name = "GL_LINE_WIDTHGL_CULL_FACEGL_CULL_FACE_MODEGL_FRONT_FACEGL_DEPTH_RANGEGL_DEPTH_TESTGL_DEPTH_WRITEMASKGL_DEPTH_CLEAR_VALUEGL_DEPTH_FUNCGL_STENCIL_TESTGL_STENCIL_CLEAR_VALUEGL_STENCIL_FUNCGL_STENCIL_VALUE_MASKGL_STENCIL_FAILGL_STENCIL_PASS_DEPTH_FAILGL_STENCIL_PASS_DEPTH_PASSGL_STENCIL_REFGL_STENCIL_WRITEMASKGL_VIEWPORTGL_DITHERGL_BLENDGL_SCISSOR_BOXGL_SCISSOR_TESTGL_COLOR_CLEAR_VALUEGL_COLOR_WRITEMASKGL_UNPACK_ALIGNMENTGL_PACK_ALIGNMENTGL_MAX_TEXTURE_SIZEGL_MAX_VIEWPORT_DIMSGL_SUBPIXEL_BITSGL_RED_BITSGL_GREEN_BITSGL_BLUE_BITSGL_ALPHA_BITSGL_DEPTH_BITSGL_STENCIL_BITSGL_POLYGON_OFFSET_UNITSGL_BLEND_COLORGL_BLEND_EQUATION_RGBGL_POLYGON_OFFSET_FILLGL_POLYGON_OFFSET_FACTORGL_TEXTURE_BINDING_2DGL_SAMPLE_ALPHA_TO_COVERAGEGL_SAMPLE_COVERAGEGL_SAMPLE_BUFFERSGL_SAMPLESGL_SAMPLE_COVERAGE_VALUEGL_SAMPLE_COVERAGE_INVERTGL_BLEND_DST_RGBGL_BLEND_SRC_RGBGL_BLEND_DST_ALPHAGL_BLEND_SRC_ALPHAGL_GENERATE_MIPMAP_HINTGL_ALIASED_POINT_SIZE_RANGEGL_ALIASED_LINE_WIDTH_RANGEGL_ACTIVE_TEXTUREGL_MAX_RENDERBUFFER_SIZEGL_TEXTURE_BINDING_CUBE_MAPGL_MAX_CUBE_MAP_TEXTURE_SIZEGL_NUM_COMPRESSED_TEXTURE_FORMATSGL_COMPRESSED_TEXTURE_FORMATSGL_STENCIL_BACK_FUNCGL_STENCIL_BACK_FAILGL_STENCIL_BACK_PASS_DEPTH_FAILGL_STENCIL_BACK_PASS_DEPTH_PASSGL_BLEND_EQUATION_ALPHAGL_MAX_VERTEX_ATTRIBSGL_MAX_TEXTURE_IMAGE_UNITSGL_ARRAY_BUFFER_BINDINGGL_ELEMENT_ARRAY_BUFFER_BINDINGGL_MAX_VERTEX_TEXTURE_IMAGE_UNITSGL_MAX_COMBINED_TEXTURE_IMAGE_UNITSGL_CURRENT_PROGRAMGL_IMPLEMENTATION_COLOR_READ_TYPEGL_IMPLEMENTATION_COLOR_READ_FORMATGL_STENCIL_BACK_REFGL_STENCIL_BACK_VALUE_MASKGL_STENCIL_BACK_WRITEMASKGL_FRAMEBUFFER_BINDINGGL_RENDERBUFFER_BINDINGGL_SHADER_BINARY_FORMATSGL_NUM_SHADER_BINARY_FORMATSGL_SHADER_COMPILERGL_MAX_VERTEX_UNIFORM_VECTORSGL_MAX_VARYING_VECTORSGL_MAX_FRAGMENT_UNIFORM_VECTORS"
var _StateVariable_GLES_2_0_map = map[StateVariable_GLES_2_0]string{
2849: _StateVariable_GLES_2_0_name[0:13],
2884: _StateVariable_GLES_2_0_name[13:25],
2885: _StateVariable_GLES_2_0_name[25:42],
2886: _StateVariable_GLES_2_0_name[42:55],
2928: _StateVariable_GLES_2_0_name[55:69],
2929: _StateVariable_GLES_2_0_name[69:82],
2930: _StateVariable_GLES_2_0_name[82:100],
2931: _StateVariable_GLES_2_0_name[100:120],
2932: _StateVariable_GLES_2_0_name[120:133],
2960: _StateVariable_GLES_2_0_name[133:148],
2961: _StateVariable_GLES_2_0_name[148:170],
2962: _StateVariable_GLES_2_0_name[170:185],
2963: _StateVariable_GLES_2_0_name[185:206],
2964: _StateVariable_GLES_2_0_name[206:221],
2965: _StateVariable_GLES_2_0_name[221:247],
2966: _StateVariable_GLES_2_0_name[247:273],
2967: _StateVariable_GLES_2_0_name[273:287],
2968: _StateVariable_GLES_2_0_name[287:307],
2978: _StateVariable_GLES_2_0_name[307:318],
3024: _StateVariable_GLES_2_0_name[318:327],
3042: _StateVariable_GLES_2_0_name[327:335],
3088: _StateVariable_GLES_2_0_name[335:349],
3089: _StateVariable_GLES_2_0_name[349:364],
3106: _StateVariable_GLES_2_0_name[364:384],
3107: _StateVariable_GLES_2_0_name[384:402],
3317: _StateVariable_GLES_2_0_name[402:421],
3333: _StateVariable_GLES_2_0_name[421:438],
3379: _StateVariable_GLES_2_0_name[438:457],
3386: _StateVariable_GLES_2_0_name[457:477],
3408: _StateVariable_GLES_2_0_name[477:493],
3410: _StateVariable_GLES_2_0_name[493:504],
3411: _StateVariable_GLES_2_0_name[504:517],
3412: _StateVariable_GLES_2_0_name[517:529],
3413: _StateVariable_GLES_2_0_name[529:542],
3414: _StateVariable_GLES_2_0_name[542:555],
3415: _StateVariable_GLES_2_0_name[555:570],
10752: _StateVariable_GLES_2_0_name[570:593],
32773: _StateVariable_GLES_2_0_name[593:607],
32777: _StateVariable_GLES_2_0_name[607:628],
32823: _StateVariable_GLES_2_0_name[628:650],
32824: _StateVariable_GLES_2_0_name[650:674],
32873: _StateVariable_GLES_2_0_name[674:695],
32926: _StateVariable_GLES_2_0_name[695:722],
32928: _StateVariable_GLES_2_0_name[722:740],
32936: _StateVariable_GLES_2_0_name[740:757],
32937: _StateVariable_GLES_2_0_name[757:767],
32938: _StateVariable_GLES_2_0_name[767:791],
32939: _StateVariable_GLES_2_0_name[791:816],
32968: _StateVariable_GLES_2_0_name[816:832],
32969: _StateVariable_GLES_2_0_name[832:848],
32970: _StateVariable_GLES_2_0_name[848:866],
32971: _StateVariable_GLES_2_0_name[866:884],
33170: _StateVariable_GLES_2_0_name[884:907],
33901: _StateVariable_GLES_2_0_name[907:934],
33902: _StateVariable_GLES_2_0_name[934:961],
34016: _StateVariable_GLES_2_0_name[961:978],
34024: _StateVariable_GLES_2_0_name[978:1002],
34068: _StateVariable_GLES_2_0_name[1002:1029],
34076: _StateVariable_GLES_2_0_name[1029:1057],
34466: _StateVariable_GLES_2_0_name[1057:1090],
34467: _StateVariable_GLES_2_0_name[1090:1119],
34816: _StateVariable_GLES_2_0_name[1119:1139],
34817: _StateVariable_GLES_2_0_name[1139:1159],
34818: _StateVariable_GLES_2_0_name[1159:1190],
34819: _StateVariable_GLES_2_0_name[1190:1221],
34877: _StateVariable_GLES_2_0_name[1221:1244],
34921: _StateVariable_GLES_2_0_name[1244:1265],
34930: _StateVariable_GLES_2_0_name[1265:1291],
34964: _StateVariable_GLES_2_0_name[1291:1314],
34965: _StateVariable_GLES_2_0_name[1314:1345],
35660: _StateVariable_GLES_2_0_name[1345:1378],
35661: _StateVariable_GLES_2_0_name[1378:1413],
35725: _StateVariable_GLES_2_0_name[1413:1431],
35738: _StateVariable_GLES_2_0_name[1431:1464],
35739: _StateVariable_GLES_2_0_name[1464:1499],
36003: _StateVariable_GLES_2_0_name[1499:1518],
36004: _StateVariable_GLES_2_0_name[1518:1544],
36005: _StateVariable_GLES_2_0_name[1544:1569],
36006: _StateVariable_GLES_2_0_name[1569:1591],
36007: _StateVariable_GLES_2_0_name[1591:1614],
36344: _StateVariable_GLES_2_0_name[1614:1638],
36345: _StateVariable_GLES_2_0_name[1638:1666],
36346: _StateVariable_GLES_2_0_name[1666:1684],
36347: _StateVariable_GLES_2_0_name[1684:1713],
36348: _StateVariable_GLES_2_0_name[1713:1735],
36349: _StateVariable_GLES_2_0_name[1735:1766],
}
func (v StateVariable_GLES_2_0) String() string {
if s, ok := _StateVariable_GLES_2_0_map[v]; ok {
return s
}
return fmt.Sprintf("StateVariable_GLES_2_0(%d)", v)
}
func (v *StateVariable_GLES_2_0) Parse(s string) error {
for k, t := range _StateVariable_GLES_2_0_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in StateVariable_GLES_2_0", s)
}
const _StateVariable_GLES_3_1_name = "GL_READ_FRAMEBUFFER_BINDING"
var _StateVariable_GLES_3_1_map = map[StateVariable_GLES_3_1]string{
36010: _StateVariable_GLES_3_1_name[0:27],
}
func (v StateVariable_GLES_3_1) String() string {
if s, ok := _StateVariable_GLES_3_1_map[v]; ok {
return s
}
return fmt.Sprintf("StateVariable_GLES_3_1(%d)", v)
}
func (v *StateVariable_GLES_3_1) Parse(s string) error {
for k, t := range _StateVariable_GLES_3_1_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in StateVariable_GLES_3_1", s)
}
const _StateVariable_name = "GL_LINE_WIDTHGL_CULL_FACEGL_CULL_FACE_MODEGL_FRONT_FACEGL_DEPTH_RANGEGL_DEPTH_TESTGL_DEPTH_WRITEMASKGL_DEPTH_CLEAR_VALUEGL_DEPTH_FUNCGL_STENCIL_TESTGL_STENCIL_CLEAR_VALUEGL_STENCIL_FUNCGL_STENCIL_VALUE_MASKGL_STENCIL_FAILGL_STENCIL_PASS_DEPTH_FAILGL_STENCIL_PASS_DEPTH_PASSGL_STENCIL_REFGL_STENCIL_WRITEMASKGL_VIEWPORTGL_DITHERGL_BLENDGL_SCISSOR_BOXGL_SCISSOR_TESTGL_COLOR_CLEAR_VALUEGL_COLOR_WRITEMASKGL_UNPACK_ALIGNMENTGL_PACK_ALIGNMENTGL_MAX_TEXTURE_SIZEGL_MAX_VIEWPORT_DIMSGL_SUBPIXEL_BITSGL_RED_BITSGL_GREEN_BITSGL_BLUE_BITSGL_ALPHA_BITSGL_DEPTH_BITSGL_STENCIL_BITSGL_POLYGON_OFFSET_UNITSGL_BLEND_COLORGL_BLEND_EQUATION_RGBGL_POLYGON_OFFSET_FILLGL_POLYGON_OFFSET_FACTORGL_TEXTURE_BINDING_2DGL_SAMPLE_ALPHA_TO_COVERAGEGL_SAMPLE_COVERAGEGL_SAMPLE_BUFFERSGL_SAMPLESGL_SAMPLE_COVERAGE_VALUEGL_SAMPLE_COVERAGE_INVERTGL_BLEND_DST_RGBGL_BLEND_SRC_RGBGL_BLEND_DST_ALPHAGL_BLEND_SRC_ALPHAGL_GENERATE_MIPMAP_HINTGL_ALIASED_POINT_SIZE_RANGEGL_ALIASED_LINE_WIDTH_RANGEGL_ACTIVE_TEXTUREGL_MAX_RENDERBUFFER_SIZEGL_MAX_TEXTURE_MAX_ANISOTROPY_EXTGL_TEXTURE_BINDING_CUBE_MAPGL_MAX_CUBE_MAP_TEXTURE_SIZEGL_NUM_COMPRESSED_TEXTURE_FORMATSGL_COMPRESSED_TEXTURE_FORMATSGL_STENCIL_BACK_FUNCGL_STENCIL_BACK_FAILGL_STENCIL_BACK_PASS_DEPTH_FAILGL_STENCIL_BACK_PASS_DEPTH_PASSGL_BLEND_EQUATION_ALPHAGL_MAX_VERTEX_ATTRIBSGL_MAX_TEXTURE_IMAGE_UNITSGL_ARRAY_BUFFER_BINDINGGL_ELEMENT_ARRAY_BUFFER_BINDINGGL_MAX_VERTEX_TEXTURE_IMAGE_UNITSGL_MAX_COMBINED_TEXTURE_IMAGE_UNITSGL_CURRENT_PROGRAMGL_IMPLEMENTATION_COLOR_READ_TYPEGL_IMPLEMENTATION_COLOR_READ_FORMATGL_STENCIL_BACK_REFGL_STENCIL_BACK_VALUE_MASKGL_STENCIL_BACK_WRITEMASKGL_FRAMEBUFFER_BINDINGGL_RENDERBUFFER_BINDINGGL_READ_FRAMEBUFFER_BINDINGGL_SHADER_BINARY_FORMATSGL_NUM_SHADER_BINARY_FORMATSGL_SHADER_COMPILERGL_MAX_VERTEX_UNIFORM_VECTORSGL_MAX_VARYING_VECTORSGL_MAX_FRAGMENT_UNIFORM_VECTORSGL_GPU_DISJOINT_EXT"
var _StateVariable_map = map[StateVariable]string{
2849: _StateVariable_name[0:13],
2884: _StateVariable_name[13:25],
2885: _StateVariable_name[25:42],
2886: _StateVariable_name[42:55],
2928: _StateVariable_name[55:69],
2929: _StateVariable_name[69:82],
2930: _StateVariable_name[82:100],
2931: _StateVariable_name[100:120],
2932: _StateVariable_name[120:133],
2960: _StateVariable_name[133:148],
2961: _StateVariable_name[148:170],
2962: _StateVariable_name[170:185],
2963: _StateVariable_name[185:206],
2964: _StateVariable_name[206:221],
2965: _StateVariable_name[221:247],
2966: _StateVariable_name[247:273],
2967: _StateVariable_name[273:287],
2968: _StateVariable_name[287:307],
2978: _StateVariable_name[307:318],
3024: _StateVariable_name[318:327],
3042: _StateVariable_name[327:335],
3088: _StateVariable_name[335:349],
3089: _StateVariable_name[349:364],
3106: _StateVariable_name[364:384],
3107: _StateVariable_name[384:402],
3317: _StateVariable_name[402:421],
3333: _StateVariable_name[421:438],
3379: _StateVariable_name[438:457],
3386: _StateVariable_name[457:477],
3408: _StateVariable_name[477:493],
3410: _StateVariable_name[493:504],
3411: _StateVariable_name[504:517],
3412: _StateVariable_name[517:529],
3413: _StateVariable_name[529:542],
3414: _StateVariable_name[542:555],
3415: _StateVariable_name[555:570],
10752: _StateVariable_name[570:593],
32773: _StateVariable_name[593:607],
32777: _StateVariable_name[607:628],
32823: _StateVariable_name[628:650],
32824: _StateVariable_name[650:674],
32873: _StateVariable_name[674:695],
32926: _StateVariable_name[695:722],
32928: _StateVariable_name[722:740],
32936: _StateVariable_name[740:757],
32937: _StateVariable_name[757:767],
32938: _StateVariable_name[767:791],
32939: _StateVariable_name[791:816],
32968: _StateVariable_name[816:832],
32969: _StateVariable_name[832:848],
32970: _StateVariable_name[848:866],
32971: _StateVariable_name[866:884],
33170: _StateVariable_name[884:907],
33901: _StateVariable_name[907:934],
33902: _StateVariable_name[934:961],
34016: _StateVariable_name[961:978],
34024: _StateVariable_name[978:1002],
34047: _StateVariable_name[1002:1035],
34068: _StateVariable_name[1035:1062],
34076: _StateVariable_name[1062:1090],
34466: _StateVariable_name[1090:1123],
34467: _StateVariable_name[1123:1152],
34816: _StateVariable_name[1152:1172],
34817: _StateVariable_name[1172:1192],
34818: _StateVariable_name[1192:1223],
34819: _StateVariable_name[1223:1254],
34877: _StateVariable_name[1254:1277],
34921: _StateVariable_name[1277:1298],
34930: _StateVariable_name[1298:1324],
34964: _StateVariable_name[1324:1347],
34965: _StateVariable_name[1347:1378],
35660: _StateVariable_name[1378:1411],
35661: _StateVariable_name[1411:1446],
35725: _StateVariable_name[1446:1464],
35738: _StateVariable_name[1464:1497],
35739: _StateVariable_name[1497:1532],
36003: _StateVariable_name[1532:1551],
36004: _StateVariable_name[1551:1577],
36005: _StateVariable_name[1577:1602],
36006: _StateVariable_name[1602:1624],
36007: _StateVariable_name[1624:1647],
36010: _StateVariable_name[1647:1674],
36344: _StateVariable_name[1674:1698],
36345: _StateVariable_name[1698:1726],
36346: _StateVariable_name[1726:1744],
36347: _StateVariable_name[1744:1773],
36348: _StateVariable_name[1773:1795],
36349: _StateVariable_name[1795:1826],
36795: _StateVariable_name[1826:1845],
}
func (v StateVariable) String() string {
if s, ok := _StateVariable_map[v]; ok {
return s
}
return fmt.Sprintf("StateVariable(%d)", v)
}
func (v *StateVariable) Parse(s string) error {
for k, t := range _StateVariable_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in StateVariable", s)
}
const _StencilAction_name = "GL_ZEROGL_INVERTGL_KEEPGL_REPLACEGL_INCRGL_DECRGL_INCR_WRAPGL_DECR_WRAP"
var _StencilAction_map = map[StencilAction]string{
0: _StencilAction_name[0:7],
5386: _StencilAction_name[7:16],
7680: _StencilAction_name[16:23],
7681: _StencilAction_name[23:33],
7682: _StencilAction_name[33:40],
7683: _StencilAction_name[40:47],
34055: _StencilAction_name[47:59],
34056: _StencilAction_name[59:71],
}
func (v StencilAction) String() string {
if s, ok := _StencilAction_map[v]; ok {
return s
}
return fmt.Sprintf("StencilAction(%d)", v)
}
func (v *StencilAction) Parse(s string) error {
for k, t := range _StencilAction_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in StencilAction", s)
}
const _StringConstant_name = "GL_VENDORGL_RENDERERGL_VERSIONGL_EXTENSIONS"
var _StringConstant_map = map[StringConstant]string{
7936: _StringConstant_name[0:9],
7937: _StringConstant_name[9:20],
7938: _StringConstant_name[20:30],
7939: _StringConstant_name[30:43],
}
func (v StringConstant) String() string {
if s, ok := _StringConstant_map[v]; ok {
return s
}
return fmt.Sprintf("StringConstant(%d)", v)
}
func (v *StringConstant) Parse(s string) error {
for k, t := range _StringConstant_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in StringConstant", s)
}
const _TestFunction_name = "GL_NEVERGL_LESSGL_EQUALGL_LEQUALGL_GREATERGL_NOTEQUALGL_GEQUALGL_ALWAYS"
var _TestFunction_map = map[TestFunction]string{
512: _TestFunction_name[0:8],
513: _TestFunction_name[8:15],
514: _TestFunction_name[15:23],
515: _TestFunction_name[23:32],
516: _TestFunction_name[32:42],
517: _TestFunction_name[42:53],
518: _TestFunction_name[53:62],
519: _TestFunction_name[62:71],
}
func (v TestFunction) String() string {
if s, ok := _TestFunction_map[v]; ok {
return s
}
return fmt.Sprintf("TestFunction(%d)", v)
}
func (v *TestFunction) Parse(s string) error {
for k, t := range _TestFunction_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TestFunction", s)
}
const _TexelComponent_name = "GL_REDGL_GREENGL_BLUEGL_ALPHA"
var _TexelComponent_map = map[TexelComponent]string{
6403: _TexelComponent_name[0:6],
6404: _TexelComponent_name[6:14],
6405: _TexelComponent_name[14:21],
6406: _TexelComponent_name[21:29],
}
func (v TexelComponent) String() string {
if s, ok := _TexelComponent_map[v]; ok {
return s
}
return fmt.Sprintf("TexelComponent(%d)", v)
}
func (v *TexelComponent) Parse(s string) error {
for k, t := range _TexelComponent_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TexelComponent", s)
}
const _TexelFormat_GLES_1_1_name = "GL_ALPHAGL_RGBGL_RGBAGL_LUMINANCEGL_LUMINANCE_ALPHA"
var _TexelFormat_GLES_1_1_map = map[TexelFormat_GLES_1_1]string{
6406: _TexelFormat_GLES_1_1_name[0:8],
6407: _TexelFormat_GLES_1_1_name[8:14],
6408: _TexelFormat_GLES_1_1_name[14:21],
6409: _TexelFormat_GLES_1_1_name[21:33],
6410: _TexelFormat_GLES_1_1_name[33:51],
}
func (v TexelFormat_GLES_1_1) String() string {
if s, ok := _TexelFormat_GLES_1_1_map[v]; ok {
return s
}
return fmt.Sprintf("TexelFormat_GLES_1_1(%d)", v)
}
func (v *TexelFormat_GLES_1_1) Parse(s string) error {
for k, t := range _TexelFormat_GLES_1_1_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TexelFormat_GLES_1_1", s)
}
const _TexelFormat_GLES_3_0_name = "GL_DEPTH_COMPONENTGL_REDGL_DEPTH_COMPONENT16GL_RGGL_RG_INTEGERGL_DEPTH_STENCILGL_DEPTH24_STENCIL8GL_RED_INTEGERGL_RGB_INTEGERGL_RGBA_INTEGER"
var _TexelFormat_GLES_3_0_map = map[TexelFormat_GLES_3_0]string{
6402: _TexelFormat_GLES_3_0_name[0:18],
6403: _TexelFormat_GLES_3_0_name[18:24],
33189: _TexelFormat_GLES_3_0_name[24:44],
33319: _TexelFormat_GLES_3_0_name[44:49],
33320: _TexelFormat_GLES_3_0_name[49:62],
34041: _TexelFormat_GLES_3_0_name[62:78],
35056: _TexelFormat_GLES_3_0_name[78:97],
36244: _TexelFormat_GLES_3_0_name[97:111],
36248: _TexelFormat_GLES_3_0_name[111:125],
36249: _TexelFormat_GLES_3_0_name[125:140],
}
func (v TexelFormat_GLES_3_0) String() string {
if s, ok := _TexelFormat_GLES_3_0_map[v]; ok {
return s
}
return fmt.Sprintf("TexelFormat_GLES_3_0(%d)", v)
}
func (v *TexelFormat_GLES_3_0) Parse(s string) error {
for k, t := range _TexelFormat_GLES_3_0_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TexelFormat_GLES_3_0", s)
}
const _TexelFormat_name = "GL_DEPTH_COMPONENTGL_REDGL_ALPHAGL_RGBGL_RGBAGL_LUMINANCEGL_LUMINANCE_ALPHAGL_DEPTH_COMPONENT16GL_RGGL_RG_INTEGERGL_DEPTH_STENCILGL_DEPTH24_STENCIL8GL_RED_INTEGERGL_RGB_INTEGERGL_RGBA_INTEGER"
var _TexelFormat_map = map[TexelFormat]string{
6402: _TexelFormat_name[0:18],
6403: _TexelFormat_name[18:24],
6406: _TexelFormat_name[24:32],
6407: _TexelFormat_name[32:38],
6408: _TexelFormat_name[38:45],
6409: _TexelFormat_name[45:57],
6410: _TexelFormat_name[57:75],
33189: _TexelFormat_name[75:95],
33319: _TexelFormat_name[95:100],
33320: _TexelFormat_name[100:113],
34041: _TexelFormat_name[113:129],
35056: _TexelFormat_name[129:148],
36244: _TexelFormat_name[148:162],
36248: _TexelFormat_name[162:176],
36249: _TexelFormat_name[176:191],
}
func (v TexelFormat) String() string {
if s, ok := _TexelFormat_map[v]; ok {
return s
}
return fmt.Sprintf("TexelFormat(%d)", v)
}
func (v *TexelFormat) Parse(s string) error {
for k, t := range _TexelFormat_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TexelFormat", s)
}
const _TexelType_name = "GL_UNSIGNED_BYTEGL_UNSIGNED_SHORTGL_UNSIGNED_INTGL_FLOATGL_UNSIGNED_SHORT_4_4_4_4GL_UNSIGNED_SHORT_5_5_5_1GL_UNSIGNED_SHORT_5_6_5GL_UNSIGNED_INT_24_8"
var _TexelType_map = map[TexelType]string{
5121: _TexelType_name[0:16],
5123: _TexelType_name[16:33],
5125: _TexelType_name[33:48],
5126: _TexelType_name[48:56],
32819: _TexelType_name[56:81],
32820: _TexelType_name[81:106],
33635: _TexelType_name[106:129],
34042: _TexelType_name[129:149],
}
func (v TexelType) String() string {
if s, ok := _TexelType_map[v]; ok {
return s
}
return fmt.Sprintf("TexelType(%d)", v)
}
func (v *TexelType) Parse(s string) error {
for k, t := range _TexelType_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TexelType", s)
}
const _Texture2DImageTarget_name = "GL_TEXTURE_2D"
var _Texture2DImageTarget_map = map[Texture2DImageTarget]string{
3553: _Texture2DImageTarget_name[0:13],
}
func (v Texture2DImageTarget) String() string {
if s, ok := _Texture2DImageTarget_map[v]; ok {
return s
}
return fmt.Sprintf("Texture2DImageTarget(%d)", v)
}
func (v *Texture2DImageTarget) Parse(s string) error {
for k, t := range _Texture2DImageTarget_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in Texture2DImageTarget", s)
}
const _TextureFilterMode_name = "GL_NEARESTGL_LINEARGL_NEAREST_MIPMAP_NEARESTGL_LINEAR_MIPMAP_NEARESTGL_NEAREST_MIPMAP_LINEARGL_LINEAR_MIPMAP_LINEAR"
var _TextureFilterMode_map = map[TextureFilterMode]string{
9728: _TextureFilterMode_name[0:10],
9729: _TextureFilterMode_name[10:19],
9984: _TextureFilterMode_name[19:44],
9985: _TextureFilterMode_name[44:68],
9986: _TextureFilterMode_name[68:92],
9987: _TextureFilterMode_name[92:115],
}
func (v TextureFilterMode) String() string {
if s, ok := _TextureFilterMode_map[v]; ok {
return s
}
return fmt.Sprintf("TextureFilterMode(%d)", v)
}
func (v *TextureFilterMode) Parse(s string) error {
for k, t := range _TextureFilterMode_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureFilterMode", s)
}
const _TextureImageTarget_name = "GL_TEXTURE_2DGL_TEXTURE_CUBE_MAP_POSITIVE_XGL_TEXTURE_CUBE_MAP_NEGATIVE_XGL_TEXTURE_CUBE_MAP_POSITIVE_YGL_TEXTURE_CUBE_MAP_NEGATIVE_YGL_TEXTURE_CUBE_MAP_POSITIVE_ZGL_TEXTURE_CUBE_MAP_NEGATIVE_Z"
var _TextureImageTarget_map = map[TextureImageTarget]string{
3553: _TextureImageTarget_name[0:13],
34069: _TextureImageTarget_name[13:43],
34070: _TextureImageTarget_name[43:73],
34071: _TextureImageTarget_name[73:103],
34072: _TextureImageTarget_name[103:133],
34073: _TextureImageTarget_name[133:163],
34074: _TextureImageTarget_name[163:193],
}
func (v TextureImageTarget) String() string {
if s, ok := _TextureImageTarget_map[v]; ok {
return s
}
return fmt.Sprintf("TextureImageTarget(%d)", v)
}
func (v *TextureImageTarget) Parse(s string) error {
for k, t := range _TextureImageTarget_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureImageTarget", s)
}
const _TextureKind_name = "UNDEFINEDTEXTURE2DCUBEMAP"
var _TextureKind_map = map[TextureKind]string{
0: _TextureKind_name[0:9],
1: _TextureKind_name[9:18],
2: _TextureKind_name[18:25],
}
func (v TextureKind) String() string {
if s, ok := _TextureKind_map[v]; ok {
return s
}
return fmt.Sprintf("TextureKind(%d)", v)
}
func (v *TextureKind) Parse(s string) error {
for k, t := range _TextureKind_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureKind", s)
}
const _TextureParameter_EXT_texture_filter_anisotropic_name = "GL_TEXTURE_MAX_ANISOTROPY_EXT"
var _TextureParameter_EXT_texture_filter_anisotropic_map = map[TextureParameter_EXT_texture_filter_anisotropic]string{
34046: _TextureParameter_EXT_texture_filter_anisotropic_name[0:29],
}
func (v TextureParameter_EXT_texture_filter_anisotropic) String() string {
if s, ok := _TextureParameter_EXT_texture_filter_anisotropic_map[v]; ok {
return s
}
return fmt.Sprintf("TextureParameter_EXT_texture_filter_anisotropic(%d)", v)
}
func (v *TextureParameter_EXT_texture_filter_anisotropic) Parse(s string) error {
for k, t := range _TextureParameter_EXT_texture_filter_anisotropic_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureParameter_EXT_texture_filter_anisotropic", s)
}
const _TextureParameter_FilterMode_name = "GL_TEXTURE_MAG_FILTERGL_TEXTURE_MIN_FILTER"
var _TextureParameter_FilterMode_map = map[TextureParameter_FilterMode]string{
10240: _TextureParameter_FilterMode_name[0:21],
10241: _TextureParameter_FilterMode_name[21:42],
}
func (v TextureParameter_FilterMode) String() string {
if s, ok := _TextureParameter_FilterMode_map[v]; ok {
return s
}
return fmt.Sprintf("TextureParameter_FilterMode(%d)", v)
}
func (v *TextureParameter_FilterMode) Parse(s string) error {
for k, t := range _TextureParameter_FilterMode_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureParameter_FilterMode", s)
}
const _TextureParameter_name = "GL_TEXTURE_MAG_FILTERGL_TEXTURE_MIN_FILTERGL_TEXTURE_WRAP_SGL_TEXTURE_WRAP_TGL_TEXTURE_MAX_ANISOTROPY_EXTGL_TEXTURE_SWIZZLE_RGL_TEXTURE_SWIZZLE_GGL_TEXTURE_SWIZZLE_BGL_TEXTURE_SWIZZLE_A"
var _TextureParameter_map = map[TextureParameter]string{
10240: _TextureParameter_name[0:21],
10241: _TextureParameter_name[21:42],
10242: _TextureParameter_name[42:59],
10243: _TextureParameter_name[59:76],
34046: _TextureParameter_name[76:105],
36418: _TextureParameter_name[105:125],
36419: _TextureParameter_name[125:145],
36420: _TextureParameter_name[145:165],
36421: _TextureParameter_name[165:185],
}
func (v TextureParameter) String() string {
if s, ok := _TextureParameter_map[v]; ok {
return s
}
return fmt.Sprintf("TextureParameter(%d)", v)
}
func (v *TextureParameter) Parse(s string) error {
for k, t := range _TextureParameter_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureParameter", s)
}
const _TextureParameter_SwizzleMode_name = "GL_TEXTURE_SWIZZLE_RGL_TEXTURE_SWIZZLE_GGL_TEXTURE_SWIZZLE_BGL_TEXTURE_SWIZZLE_A"
var _TextureParameter_SwizzleMode_map = map[TextureParameter_SwizzleMode]string{
36418: _TextureParameter_SwizzleMode_name[0:20],
36419: _TextureParameter_SwizzleMode_name[20:40],
36420: _TextureParameter_SwizzleMode_name[40:60],
36421: _TextureParameter_SwizzleMode_name[60:80],
}
func (v TextureParameter_SwizzleMode) String() string {
if s, ok := _TextureParameter_SwizzleMode_map[v]; ok {
return s
}
return fmt.Sprintf("TextureParameter_SwizzleMode(%d)", v)
}
func (v *TextureParameter_SwizzleMode) Parse(s string) error {
for k, t := range _TextureParameter_SwizzleMode_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureParameter_SwizzleMode", s)
}
const _TextureParameter_WrapMode_name = "GL_TEXTURE_WRAP_SGL_TEXTURE_WRAP_T"
var _TextureParameter_WrapMode_map = map[TextureParameter_WrapMode]string{
10242: _TextureParameter_WrapMode_name[0:17],
10243: _TextureParameter_WrapMode_name[17:34],
}
func (v TextureParameter_WrapMode) String() string {
if s, ok := _TextureParameter_WrapMode_map[v]; ok {
return s
}
return fmt.Sprintf("TextureParameter_WrapMode(%d)", v)
}
func (v *TextureParameter_WrapMode) Parse(s string) error {
for k, t := range _TextureParameter_WrapMode_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureParameter_WrapMode", s)
}
const _TextureTarget_GLES_1_1_name = "GL_TEXTURE_2D"
var _TextureTarget_GLES_1_1_map = map[TextureTarget_GLES_1_1]string{
3553: _TextureTarget_GLES_1_1_name[0:13],
}
func (v TextureTarget_GLES_1_1) String() string {
if s, ok := _TextureTarget_GLES_1_1_map[v]; ok {
return s
}
return fmt.Sprintf("TextureTarget_GLES_1_1(%d)", v)
}
func (v *TextureTarget_GLES_1_1) Parse(s string) error {
for k, t := range _TextureTarget_GLES_1_1_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureTarget_GLES_1_1", s)
}
const _TextureTarget_GLES_2_0_name = "GL_TEXTURE_CUBE_MAP"
var _TextureTarget_GLES_2_0_map = map[TextureTarget_GLES_2_0]string{
34067: _TextureTarget_GLES_2_0_name[0:19],
}
func (v TextureTarget_GLES_2_0) String() string {
if s, ok := _TextureTarget_GLES_2_0_map[v]; ok {
return s
}
return fmt.Sprintf("TextureTarget_GLES_2_0(%d)", v)
}
func (v *TextureTarget_GLES_2_0) Parse(s string) error {
for k, t := range _TextureTarget_GLES_2_0_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureTarget_GLES_2_0", s)
}
const _TextureTarget_name = "GL_TEXTURE_2DGL_TEXTURE_CUBE_MAPGL_TEXTURE_EXTERNAL_OES"
var _TextureTarget_map = map[TextureTarget]string{
3553: _TextureTarget_name[0:13],
34067: _TextureTarget_name[13:32],
36197: _TextureTarget_name[32:55],
}
func (v TextureTarget) String() string {
if s, ok := _TextureTarget_map[v]; ok {
return s
}
return fmt.Sprintf("TextureTarget(%d)", v)
}
func (v *TextureTarget) Parse(s string) error {
for k, t := range _TextureTarget_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureTarget", s)
}
const _TextureTarget_OES_EGL_image_external_name = "GL_TEXTURE_EXTERNAL_OES"
var _TextureTarget_OES_EGL_image_external_map = map[TextureTarget_OES_EGL_image_external]string{
36197: _TextureTarget_OES_EGL_image_external_name[0:23],
}
func (v TextureTarget_OES_EGL_image_external) String() string {
if s, ok := _TextureTarget_OES_EGL_image_external_map[v]; ok {
return s
}
return fmt.Sprintf("TextureTarget_OES_EGL_image_external(%d)", v)
}
func (v *TextureTarget_OES_EGL_image_external) Parse(s string) error {
for k, t := range _TextureTarget_OES_EGL_image_external_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureTarget_OES_EGL_image_external", s)
}
const _TextureUnit_name = "GL_TEXTURE0GL_TEXTURE1GL_TEXTURE2GL_TEXTURE3GL_TEXTURE4GL_TEXTURE5GL_TEXTURE6GL_TEXTURE7GL_TEXTURE8GL_TEXTURE9GL_TEXTURE10GL_TEXTURE11GL_TEXTURE12GL_TEXTURE13GL_TEXTURE14GL_TEXTURE15GL_TEXTURE16GL_TEXTURE17GL_TEXTURE18GL_TEXTURE19GL_TEXTURE20GL_TEXTURE21GL_TEXTURE22GL_TEXTURE23GL_TEXTURE24GL_TEXTURE25GL_TEXTURE26GL_TEXTURE27GL_TEXTURE28GL_TEXTURE29GL_TEXTURE30GL_TEXTURE31"
var _TextureUnit_map = map[TextureUnit]string{
33984: _TextureUnit_name[0:11],
33985: _TextureUnit_name[11:22],
33986: _TextureUnit_name[22:33],
33987: _TextureUnit_name[33:44],
33988: _TextureUnit_name[44:55],
33989: _TextureUnit_name[55:66],
33990: _TextureUnit_name[66:77],
33991: _TextureUnit_name[77:88],
33992: _TextureUnit_name[88:99],
33993: _TextureUnit_name[99:110],
33994: _TextureUnit_name[110:122],
33995: _TextureUnit_name[122:134],
33996: _TextureUnit_name[134:146],
33997: _TextureUnit_name[146:158],
33998: _TextureUnit_name[158:170],
33999: _TextureUnit_name[170:182],
34000: _TextureUnit_name[182:194],
34001: _TextureUnit_name[194:206],
34002: _TextureUnit_name[206:218],
34003: _TextureUnit_name[218:230],
34004: _TextureUnit_name[230:242],
34005: _TextureUnit_name[242:254],
34006: _TextureUnit_name[254:266],
34007: _TextureUnit_name[266:278],
34008: _TextureUnit_name[278:290],
34009: _TextureUnit_name[290:302],
34010: _TextureUnit_name[302:314],
34011: _TextureUnit_name[314:326],
34012: _TextureUnit_name[326:338],
34013: _TextureUnit_name[338:350],
34014: _TextureUnit_name[350:362],
34015: _TextureUnit_name[362:374],
}
func (v TextureUnit) String() string {
if s, ok := _TextureUnit_map[v]; ok {
return s
}
return fmt.Sprintf("TextureUnit(%d)", v)
}
func (v *TextureUnit) Parse(s string) error {
for k, t := range _TextureUnit_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureUnit", s)
}
const _TextureWrapMode_name = "GL_REPEATGL_CLAMP_TO_EDGEGL_MIRRORED_REPEAT"
var _TextureWrapMode_map = map[TextureWrapMode]string{
10497: _TextureWrapMode_name[0:9],
33071: _TextureWrapMode_name[9:25],
33648: _TextureWrapMode_name[25:43],
}
func (v TextureWrapMode) String() string {
if s, ok := _TextureWrapMode_map[v]; ok {
return s
}
return fmt.Sprintf("TextureWrapMode(%d)", v)
}
func (v *TextureWrapMode) Parse(s string) error {
for k, t := range _TextureWrapMode_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TextureWrapMode", s)
}
const _TilePreserveMaskQCOM_name = "GL_COLOR_BUFFER_BIT0_QCOMGL_COLOR_BUFFER_BIT1_QCOMGL_COLOR_BUFFER_BIT2_QCOMGL_COLOR_BUFFER_BIT3_QCOMGL_COLOR_BUFFER_BIT4_QCOMGL_COLOR_BUFFER_BIT5_QCOMGL_COLOR_BUFFER_BIT6_QCOMGL_COLOR_BUFFER_BIT7_QCOMGL_DEPTH_BUFFER_BIT0_QCOMGL_DEPTH_BUFFER_BIT1_QCOMGL_DEPTH_BUFFER_BIT2_QCOMGL_DEPTH_BUFFER_BIT3_QCOMGL_DEPTH_BUFFER_BIT4_QCOMGL_DEPTH_BUFFER_BIT5_QCOMGL_DEPTH_BUFFER_BIT6_QCOMGL_DEPTH_BUFFER_BIT7_QCOMGL_STENCIL_BUFFER_BIT0_QCOMGL_STENCIL_BUFFER_BIT1_QCOMGL_STENCIL_BUFFER_BIT2_QCOMGL_STENCIL_BUFFER_BIT3_QCOMGL_STENCIL_BUFFER_BIT4_QCOMGL_STENCIL_BUFFER_BIT5_QCOMGL_STENCIL_BUFFER_BIT6_QCOMGL_STENCIL_BUFFER_BIT7_QCOMGL_MULTISAMPLE_BUFFER_BIT0_QCOMGL_MULTISAMPLE_BUFFER_BIT1_QCOMGL_MULTISAMPLE_BUFFER_BIT2_QCOMGL_MULTISAMPLE_BUFFER_BIT3_QCOMGL_MULTISAMPLE_BUFFER_BIT4_QCOMGL_MULTISAMPLE_BUFFER_BIT5_QCOMGL_MULTISAMPLE_BUFFER_BIT6_QCOMGL_MULTISAMPLE_BUFFER_BIT7_QCOM"
var _TilePreserveMaskQCOM_map = map[TilePreserveMaskQCOM]string{
1: _TilePreserveMaskQCOM_name[0:25],
2: _TilePreserveMaskQCOM_name[25:50],
4: _TilePreserveMaskQCOM_name[50:75],
8: _TilePreserveMaskQCOM_name[75:100],
16: _TilePreserveMaskQCOM_name[100:125],
32: _TilePreserveMaskQCOM_name[125:150],
64: _TilePreserveMaskQCOM_name[150:175],
128: _TilePreserveMaskQCOM_name[175:200],
256: _TilePreserveMaskQCOM_name[200:225],
512: _TilePreserveMaskQCOM_name[225:250],
1024: _TilePreserveMaskQCOM_name[250:275],
2048: _TilePreserveMaskQCOM_name[275:300],
4096: _TilePreserveMaskQCOM_name[300:325],
8192: _TilePreserveMaskQCOM_name[325:350],
16384: _TilePreserveMaskQCOM_name[350:375],
32768: _TilePreserveMaskQCOM_name[375:400],
65536: _TilePreserveMaskQCOM_name[400:427],
131072: _TilePreserveMaskQCOM_name[427:454],
262144: _TilePreserveMaskQCOM_name[454:481],
524288: _TilePreserveMaskQCOM_name[481:508],
1048576: _TilePreserveMaskQCOM_name[508:535],
2097152: _TilePreserveMaskQCOM_name[535:562],
4194304: _TilePreserveMaskQCOM_name[562:589],
8388608: _TilePreserveMaskQCOM_name[589:616],
16777216: _TilePreserveMaskQCOM_name[616:647],
33554432: _TilePreserveMaskQCOM_name[647:678],
67108864: _TilePreserveMaskQCOM_name[678:709],
134217728: _TilePreserveMaskQCOM_name[709:740],
268435456: _TilePreserveMaskQCOM_name[740:771],
536870912: _TilePreserveMaskQCOM_name[771:802],
1073741824: _TilePreserveMaskQCOM_name[802:833],
2147483648: _TilePreserveMaskQCOM_name[833:864],
}
func (v TilePreserveMaskQCOM) String() string {
if s, ok := _TilePreserveMaskQCOM_map[v]; ok {
return s
}
return fmt.Sprintf("TilePreserveMaskQCOM(%d)", v)
}
func (v *TilePreserveMaskQCOM) Parse(s string) error {
for k, t := range _TilePreserveMaskQCOM_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in TilePreserveMaskQCOM", s)
}
const _Type_ARB_half_float_vertex_name = "GL_ARB_half_float_vertex"
var _Type_ARB_half_float_vertex_map = map[Type_ARB_half_float_vertex]string{
5131: _Type_ARB_half_float_vertex_name[0:24],
}
func (v Type_ARB_half_float_vertex) String() string {
if s, ok := _Type_ARB_half_float_vertex_map[v]; ok {
return s
}
return fmt.Sprintf("Type_ARB_half_float_vertex(%d)", v)
}
func (v *Type_ARB_half_float_vertex) Parse(s string) error {
for k, t := range _Type_ARB_half_float_vertex_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in Type_ARB_half_float_vertex", s)
}
const _Type_OES_vertex_half_float_name = "GL_HALF_FLOAT_OES"
var _Type_OES_vertex_half_float_map = map[Type_OES_vertex_half_float]string{
36193: _Type_OES_vertex_half_float_name[0:17],
}
func (v Type_OES_vertex_half_float) String() string {
if s, ok := _Type_OES_vertex_half_float_map[v]; ok {
return s
}
return fmt.Sprintf("Type_OES_vertex_half_float(%d)", v)
}
func (v *Type_OES_vertex_half_float) Parse(s string) error {
for k, t := range _Type_OES_vertex_half_float_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in Type_OES_vertex_half_float", s)
}
const _VertexAttribType_name = "GL_BYTEGL_UNSIGNED_BYTEGL_SHORTGL_UNSIGNED_SHORTGL_FLOATGL_ARB_half_float_vertexGL_FIXEDGL_HALF_FLOAT_OES"
var _VertexAttribType_map = map[VertexAttribType]string{
5120: _VertexAttribType_name[0:7],
5121: _VertexAttribType_name[7:23],
5122: _VertexAttribType_name[23:31],
5123: _VertexAttribType_name[31:48],
5126: _VertexAttribType_name[48:56],
5131: _VertexAttribType_name[56:80],
5132: _VertexAttribType_name[80:88],
36193: _VertexAttribType_name[88:105],
}
func (v VertexAttribType) String() string {
if s, ok := _VertexAttribType_map[v]; ok {
return s
}
return fmt.Sprintf("VertexAttribType(%d)", v)
}
func (v *VertexAttribType) Parse(s string) error {
for k, t := range _VertexAttribType_map {
if s == t {
*v = k
return nil
}
}
return fmt.Errorf("%s not in VertexAttribType", s)
}